@pancakeswap/swap-sdk-core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Noah Zinsmeister
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,257 @@
+import JSBI from 'jsbi';
+export { default as JSBI } from 'jsbi';
+
+declare type BigintIsh = JSBI | number | string;
+declare enum TradeType {
+    EXACT_INPUT = 0,
+    EXACT_OUTPUT = 1
+}
+declare enum Rounding {
+    ROUND_DOWN = 0,
+    ROUND_HALF_UP = 1,
+    ROUND_UP = 2
+}
+declare const MINIMUM_LIQUIDITY: JSBI;
+declare const ZERO: JSBI;
+declare const ONE: JSBI;
+declare const TWO: JSBI;
+declare const THREE: JSBI;
+declare const FIVE: JSBI;
+declare const TEN: JSBI;
+declare const _100: JSBI;
+declare const _9975: JSBI;
+declare const _10000: JSBI;
+declare const MaxUint256: JSBI;
+declare enum VMType {
+    uint8 = "uint8",
+    uint256 = "uint256"
+}
+declare const VM_TYPE_MAXIMA: {
+    uint8: JSBI;
+    uint256: JSBI;
+};
+
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+declare abstract class NativeCurrency extends BaseCurrency {
+    readonly isNative: true;
+    readonly isToken: false;
+}
+
+interface SerializedToken {
+    chainId: number;
+    address: string;
+    decimals: number;
+    symbol: string;
+    name?: string;
+    projectLink?: string;
+}
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+declare class Token extends BaseCurrency {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    readonly projectLink?: string;
+    constructor(chainId: number, address: string, decimals: number, symbol: string, name?: string, projectLink?: string);
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: Currency): boolean;
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @throws if the tokens have the same address
+     * @throws if the tokens are on different chains
+     */
+    sortsBefore(other: Token): boolean;
+    /**
+     * Return this token, which does not need to be wrapped
+     */
+    get wrapped(): Token;
+    get serialize(): SerializedToken;
+}
+
+declare type Currency = NativeCurrency | Token;
+
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+declare abstract class BaseCurrency {
+    /**
+     * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     */
+    abstract readonly isNative: boolean;
+    /**
+     * Returns whether the currency is a token that is usable in PancakeSwap without wrapping
+     */
+    abstract readonly isToken: boolean;
+    /**
+     * The chain ID on which this currency resides
+     */
+    readonly chainId: number;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The symbol of the currency, i.e. a short textual non-unique identifier
+     */
+    readonly symbol: string;
+    /**
+     * The name of the currency, i.e. a descriptive textual non-unique identifier
+     */
+    readonly name?: string;
+    /**
+     * Constructs an instance of the base class `BaseCurrency`.
+     * @param chainId the chain ID on which this currency resides
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    protected constructor(chainId: number, decimals: number, symbol: string, name?: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    abstract equals(other: Currency): boolean;
+    /**
+     * Return the wrapped version of this currency that can be used with the PancakeSwap contracts. Currencies must
+     * implement this to be used in PancakeSwap
+     */
+    abstract get wrapped(): Token;
+}
+
+declare class Fraction {
+    readonly numerator: JSBI;
+    readonly denominator: JSBI;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    private static tryParseFraction;
+    get quotient(): JSBI;
+    get remainder(): Fraction;
+    invert(): Fraction;
+    add(other: Fraction | BigintIsh): Fraction;
+    subtract(other: Fraction | BigintIsh): Fraction;
+    lessThan(other: Fraction | BigintIsh): boolean;
+    equalTo(other: Fraction | BigintIsh): boolean;
+    greaterThan(other: Fraction | BigintIsh): boolean;
+    multiply(other: Fraction | BigintIsh): Fraction;
+    divide(other: Fraction | BigintIsh): Fraction;
+    toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
+    /**
+     * Helper method for converting any super class back to a fraction
+     */
+    get asFraction(): Fraction;
+}
+
+declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    add(other: Fraction | BigintIsh): Percent;
+    subtract(other: Fraction | BigintIsh): Percent;
+    multiply(other: Fraction | BigintIsh): Percent;
+    divide(other: Fraction | BigintIsh): Percent;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}
+
+declare class CurrencyAmount<T extends Currency> extends Fraction {
+    readonly currency: T;
+    readonly decimalScale: JSBI;
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount<T extends Currency>(currency: T, rawAmount: BigintIsh): CurrencyAmount<T>;
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount<T extends Currency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount<T>;
+    protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    subtract(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    divide(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+    get wrapped(): CurrencyAmount<Token>;
+}
+
+declare class Price<TBase extends Currency, TQuote extends Currency> extends Fraction {
+    readonly baseCurrency: TBase;
+    readonly quoteCurrency: TQuote;
+    readonly scalar: Fraction;
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args: [TBase, TQuote, BigintIsh, BigintIsh] | [{
+        baseAmount: CurrencyAmount<TBase>;
+        quoteAmount: CurrencyAmount<TQuote>;
+    }]);
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert(): Price<TQuote, TBase>;
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply<TOtherQuote extends Currency>(other: Price<TQuote, TOtherQuote>): Price<TBase, TOtherQuote>;
+    /**
+     * Return the amount of quote currency corresponding to a given amount of the base currency
+     * @param currencyAmount the amount of base currency to quote against the price
+     */
+    quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote>;
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    private get adjustedForDecimals();
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}
+
+/**
+ * Indicates that the pair has insufficient reserves for a desired output amount. I.e. the amount of output cannot be
+ * obtained by sending any amount of input.
+ */
+declare class InsufficientReservesError extends Error {
+    readonly isInsufficientReservesError: true;
+    constructor();
+}
+/**
+ * Indicates that the input amount is too small to produce any amount of output. I.e. the amount of input sent is less
+ * than the price of a single unit of output after fees.
+ */
+declare class InsufficientInputAmountError extends Error {
+    readonly isInsufficientInputAmountError: true;
+    constructor();
+}
+
+declare function validateVMTypeInstance(value: JSBI, vmType: VMType): void;
+declare function sqrt(y: JSBI): JSBI;
+declare function sortedInsert<T>(items: T[], add: T, maxSize: number, comparator: (a: T, b: T) => number): T | null;
+/**
+ * Returns the percent difference between the mid price and the execution price, i.e. price impact.
+ * @param midPrice mid price before the trade
+ * @param inputAmount the input amount of the trade
+ * @param outputAmount the output amount of the trade
+ */
+declare function computePriceImpact<TBase extends Currency, TQuote extends Currency>(midPrice: Price<TBase, TQuote>, inputAmount: CurrencyAmount<TBase>, outputAmount: CurrencyAmount<TQuote>): Percent;
+
+export { BaseCurrency, BigintIsh, Currency, CurrencyAmount, FIVE, Fraction, InsufficientInputAmountError, InsufficientReservesError, MINIMUM_LIQUIDITY, MaxUint256, NativeCurrency, ONE, Percent, Price, Rounding, SerializedToken, TEN, THREE, TWO, Token, TradeType, VMType, VM_TYPE_MAXIMA, ZERO, _100, _10000, _9975, computePriceImpact, sortedInsert, sqrt, validateVMTypeInstance };

package/dist/index.js

@@ -0,0 +1,480 @@
+"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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BaseCurrency: () => BaseCurrency,
+  CurrencyAmount: () => CurrencyAmount,
+  FIVE: () => FIVE,
+  Fraction: () => Fraction,
+  InsufficientInputAmountError: () => InsufficientInputAmountError,
+  InsufficientReservesError: () => InsufficientReservesError,
+  JSBI: () => import_jsbi7.default,
+  MINIMUM_LIQUIDITY: () => MINIMUM_LIQUIDITY,
+  MaxUint256: () => MaxUint256,
+  NativeCurrency: () => NativeCurrency,
+  ONE: () => ONE,
+  Percent: () => Percent,
+  Price: () => Price,
+  Rounding: () => Rounding,
+  TEN: () => TEN,
+  THREE: () => THREE,
+  TWO: () => TWO,
+  Token: () => Token,
+  TradeType: () => TradeType,
+  VMType: () => VMType,
+  VM_TYPE_MAXIMA: () => VM_TYPE_MAXIMA,
+  ZERO: () => ZERO,
+  _100: () => _100,
+  _10000: () => _10000,
+  _9975: () => _9975,
+  computePriceImpact: () => computePriceImpact,
+  sortedInsert: () => sortedInsert,
+  sqrt: () => sqrt,
+  validateVMTypeInstance: () => validateVMTypeInstance
+});
+module.exports = __toCommonJS(src_exports);
+var import_jsbi7 = __toESM(require("jsbi"));
+
+// src/constants.ts
+var import_jsbi = __toESM(require("jsbi"));
+var TradeType = /* @__PURE__ */ ((TradeType2) => {
+  TradeType2[TradeType2["EXACT_INPUT"] = 0] = "EXACT_INPUT";
+  TradeType2[TradeType2["EXACT_OUTPUT"] = 1] = "EXACT_OUTPUT";
+  return TradeType2;
+})(TradeType || {});
+var Rounding = /* @__PURE__ */ ((Rounding2) => {
+  Rounding2[Rounding2["ROUND_DOWN"] = 0] = "ROUND_DOWN";
+  Rounding2[Rounding2["ROUND_HALF_UP"] = 1] = "ROUND_HALF_UP";
+  Rounding2[Rounding2["ROUND_UP"] = 2] = "ROUND_UP";
+  return Rounding2;
+})(Rounding || {});
+var MINIMUM_LIQUIDITY = import_jsbi.default.BigInt(1e3);
+var ZERO = import_jsbi.default.BigInt(0);
+var ONE = import_jsbi.default.BigInt(1);
+var TWO = import_jsbi.default.BigInt(2);
+var THREE = import_jsbi.default.BigInt(3);
+var FIVE = import_jsbi.default.BigInt(5);
+var TEN = import_jsbi.default.BigInt(10);
+var _100 = import_jsbi.default.BigInt(100);
+var _9975 = import_jsbi.default.BigInt(9975);
+var _10000 = import_jsbi.default.BigInt(1e4);
+var MaxUint256 = import_jsbi.default.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+var VMType = /* @__PURE__ */ ((VMType2) => {
+  VMType2["uint8"] = "uint8";
+  VMType2["uint256"] = "uint256";
+  return VMType2;
+})(VMType || {});
+var VM_TYPE_MAXIMA = {
+  ["uint8" /* uint8 */]: import_jsbi.default.BigInt("0xff"),
+  ["uint256" /* uint256 */]: import_jsbi.default.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+};
+
+// src/baseCurrency.ts
+var import_tiny_invariant = __toESM(require("tiny-invariant"));
+var BaseCurrency = class {
+  constructor(chainId, decimals, symbol, name) {
+    (0, import_tiny_invariant.default)(Number.isSafeInteger(chainId), "CHAIN_ID");
+    (0, import_tiny_invariant.default)(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
+    this.chainId = chainId;
+    this.decimals = decimals;
+    this.symbol = symbol;
+    this.name = name;
+  }
+};
+
+// src/fractions/fraction.ts
+var import_jsbi2 = __toESM(require("jsbi"));
+var import_tiny_invariant2 = __toESM(require("tiny-invariant"));
+var import_decimal = __toESM(require("decimal.js-light"));
+var import_big = __toESM(require("big.js"));
+var import_toformat = __toESM(require("toformat"));
+var Decimal = (0, import_toformat.default)(import_decimal.default);
+var Big = (0, import_toformat.default)(import_big.default);
+var toSignificantRounding = {
+  [0 /* ROUND_DOWN */]: Decimal.ROUND_DOWN,
+  [1 /* ROUND_HALF_UP */]: Decimal.ROUND_HALF_UP,
+  [2 /* ROUND_UP */]: Decimal.ROUND_UP
+};
+var toFixedRounding = {
+  [0 /* ROUND_DOWN */]: 0 /* RoundDown */,
+  [1 /* ROUND_HALF_UP */]: 1 /* RoundHalfUp */,
+  [2 /* ROUND_UP */]: 3 /* RoundUp */
+};
+var Fraction = class {
+  constructor(numerator, denominator = import_jsbi2.default.BigInt(1)) {
+    this.numerator = import_jsbi2.default.BigInt(numerator);
+    this.denominator = import_jsbi2.default.BigInt(denominator);
+  }
+  static tryParseFraction(fractionish) {
+    if (fractionish instanceof import_jsbi2.default || typeof fractionish === "number" || typeof fractionish === "string")
+      return new Fraction(fractionish);
+    if ("numerator" in fractionish && "denominator" in fractionish)
+      return fractionish;
+    throw new Error("Could not parse fraction");
+  }
+  get quotient() {
+    return import_jsbi2.default.divide(this.numerator, this.denominator);
+  }
+  get remainder() {
+    return new Fraction(import_jsbi2.default.remainder(this.numerator, this.denominator), this.denominator);
+  }
+  invert() {
+    return new Fraction(this.denominator, this.numerator);
+  }
+  add(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    if (import_jsbi2.default.equal(this.denominator, otherParsed.denominator)) {
+      return new Fraction(import_jsbi2.default.add(this.numerator, otherParsed.numerator), this.denominator);
+    }
+    return new Fraction(import_jsbi2.default.add(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator)), import_jsbi2.default.multiply(this.denominator, otherParsed.denominator));
+  }
+  subtract(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    if (import_jsbi2.default.equal(this.denominator, otherParsed.denominator)) {
+      return new Fraction(import_jsbi2.default.subtract(this.numerator, otherParsed.numerator), this.denominator);
+    }
+    return new Fraction(import_jsbi2.default.subtract(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator)), import_jsbi2.default.multiply(this.denominator, otherParsed.denominator));
+  }
+  lessThan(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return import_jsbi2.default.lessThan(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator));
+  }
+  equalTo(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return import_jsbi2.default.equal(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator));
+  }
+  greaterThan(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return import_jsbi2.default.greaterThan(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator));
+  }
+  multiply(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return new Fraction(import_jsbi2.default.multiply(this.numerator, otherParsed.numerator), import_jsbi2.default.multiply(this.denominator, otherParsed.denominator));
+  }
+  divide(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return new Fraction(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(this.denominator, otherParsed.numerator));
+  }
+  toSignificant(significantDigits, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
+    (0, import_tiny_invariant2.default)(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
+    (0, import_tiny_invariant2.default)(significantDigits > 0, `${significantDigits} is not positive.`);
+    Decimal.set({ precision: significantDigits + 1, rounding: toSignificantRounding[rounding] });
+    const quotient = new Decimal(this.numerator.toString()).div(this.denominator.toString()).toSignificantDigits(significantDigits);
+    return quotient.toFormat(quotient.decimalPlaces(), format);
+  }
+  toFixed(decimalPlaces, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
+    (0, import_tiny_invariant2.default)(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
+    (0, import_tiny_invariant2.default)(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
+    Big.DP = decimalPlaces;
+    Big.RM = toFixedRounding[rounding];
+    return new Big(this.numerator.toString()).div(this.denominator.toString()).toFormat(decimalPlaces, format);
+  }
+  get asFraction() {
+    return new Fraction(this.numerator, this.denominator);
+  }
+};
+
+// src/fractions/percent.ts
+var import_jsbi3 = __toESM(require("jsbi"));
+var ONE_HUNDRED = new Fraction(import_jsbi3.default.BigInt(100));
+function toPercent(fraction) {
+  return new Percent(fraction.numerator, fraction.denominator);
+}
+var Percent = class extends Fraction {
+  constructor() {
+    super(...arguments);
+    this.isPercent = true;
+  }
+  add(other) {
+    return toPercent(super.add(other));
+  }
+  subtract(other) {
+    return toPercent(super.subtract(other));
+  }
+  multiply(other) {
+    return toPercent(super.multiply(other));
+  }
+  divide(other) {
+    return toPercent(super.divide(other));
+  }
+  toSignificant(significantDigits = 5, format, rounding) {
+    return super.multiply(ONE_HUNDRED).toSignificant(significantDigits, format, rounding);
+  }
+  toFixed(decimalPlaces = 2, format, rounding) {
+    return super.multiply(ONE_HUNDRED).toFixed(decimalPlaces, format, rounding);
+  }
+};
+
+// src/fractions/currencyAmount.ts
+var import_tiny_invariant3 = __toESM(require("tiny-invariant"));
+var import_jsbi4 = __toESM(require("jsbi"));
+var import_big2 = __toESM(require("big.js"));
+var import_toformat2 = __toESM(require("toformat"));
+var Big2 = (0, import_toformat2.default)(import_big2.default);
+var CurrencyAmount = class extends Fraction {
+  constructor(currency, numerator, denominator) {
+    super(numerator, denominator);
+    (0, import_tiny_invariant3.default)(import_jsbi4.default.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT");
+    this.currency = currency;
+    this.decimalScale = import_jsbi4.default.exponentiate(import_jsbi4.default.BigInt(10), import_jsbi4.default.BigInt(currency.decimals));
+  }
+  static fromRawAmount(currency, rawAmount) {
+    return new CurrencyAmount(currency, rawAmount);
+  }
+  static fromFractionalAmount(currency, numerator, denominator) {
+    return new CurrencyAmount(currency, numerator, denominator);
+  }
+  add(other) {
+    (0, import_tiny_invariant3.default)(this.currency.equals(other.currency), "CURRENCY");
+    const added = super.add(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
+  }
+  subtract(other) {
+    (0, import_tiny_invariant3.default)(this.currency.equals(other.currency), "CURRENCY");
+    const subtracted = super.subtract(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
+  }
+  multiply(other) {
+    const multiplied = super.multiply(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
+  }
+  divide(other) {
+    const divided = super.divide(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
+  }
+  toSignificant(significantDigits = 6, format, rounding = 0 /* ROUND_DOWN */) {
+    return super.divide(this.decimalScale).toSignificant(significantDigits, format, rounding);
+  }
+  toFixed(decimalPlaces = this.currency.decimals, format, rounding = 0 /* ROUND_DOWN */) {
+    (0, import_tiny_invariant3.default)(decimalPlaces <= this.currency.decimals, "DECIMALS");
+    return super.divide(this.decimalScale).toFixed(decimalPlaces, format, rounding);
+  }
+  toExact(format = { groupSeparator: "" }) {
+    Big2.DP = this.currency.decimals;
+    return new Big2(this.quotient.toString()).div(this.decimalScale.toString()).toFormat(format);
+  }
+  get wrapped() {
+    if (this.currency.isToken)
+      return this;
+    return CurrencyAmount.fromFractionalAmount(this.currency.wrapped, this.numerator, this.denominator);
+  }
+};
+
+// src/fractions/price.ts
+var import_jsbi5 = __toESM(require("jsbi"));
+var import_tiny_invariant4 = __toESM(require("tiny-invariant"));
+var Price = class extends Fraction {
+  constructor(...args) {
+    let baseCurrency;
+    let quoteCurrency;
+    let denominator;
+    let numerator;
+    if (args.length === 4) {
+      ;
+      [baseCurrency, quoteCurrency, denominator, numerator] = args;
+    } else {
+      const result = args[0].quoteAmount.divide(args[0].baseAmount);
+      [baseCurrency, quoteCurrency, denominator, numerator] = [
+        args[0].baseAmount.currency,
+        args[0].quoteAmount.currency,
+        result.denominator,
+        result.numerator
+      ];
+    }
+    super(numerator, denominator);
+    this.baseCurrency = baseCurrency;
+    this.quoteCurrency = quoteCurrency;
+    this.scalar = new Fraction(import_jsbi5.default.exponentiate(import_jsbi5.default.BigInt(10), import_jsbi5.default.BigInt(baseCurrency.decimals)), import_jsbi5.default.exponentiate(import_jsbi5.default.BigInt(10), import_jsbi5.default.BigInt(quoteCurrency.decimals)));
+  }
+  invert() {
+    return new Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
+  }
+  multiply(other) {
+    (0, import_tiny_invariant4.default)(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
+    const fraction = super.multiply(other);
+    return new Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
+  }
+  quote(currencyAmount) {
+    (0, import_tiny_invariant4.default)(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+    const result = super.multiply(currencyAmount);
+    return CurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
+  }
+  get adjustedForDecimals() {
+    return super.multiply(this.scalar);
+  }
+  toSignificant(significantDigits = 6, format, rounding) {
+    return this.adjustedForDecimals.toSignificant(significantDigits, format, rounding);
+  }
+  toFixed(decimalPlaces = 4, format, rounding) {
+    return this.adjustedForDecimals.toFixed(decimalPlaces, format, rounding);
+  }
+};
+
+// src/nativeCurrency.ts
+var NativeCurrency = class extends BaseCurrency {
+  constructor() {
+    super(...arguments);
+    this.isNative = true;
+    this.isToken = false;
+  }
+};
+
+// src/token.ts
+var import_tiny_invariant5 = __toESM(require("tiny-invariant"));
+var Token = class extends BaseCurrency {
+  constructor(chainId, address, decimals, symbol, name, projectLink) {
+    super(chainId, decimals, symbol, name);
+    this.isNative = false;
+    this.isToken = true;
+    this.address = address;
+    this.projectLink = projectLink;
+  }
+  equals(other) {
+    return other.isToken && this.chainId === other.chainId && this.address === other.address;
+  }
+  sortsBefore(other) {
+    (0, import_tiny_invariant5.default)(this.chainId === other.chainId, "CHAIN_IDS");
+    (0, import_tiny_invariant5.default)(this.address !== other.address, "ADDRESSES");
+    return this.address.toLowerCase() < other.address.toLowerCase();
+  }
+  get wrapped() {
+    return this;
+  }
+  get serialize() {
+    return {
+      address: this.address,
+      chainId: this.chainId,
+      decimals: this.decimals,
+      symbol: this.symbol,
+      name: this.name,
+      projectLink: this.projectLink
+    };
+  }
+};
+
+// src/errors.ts
+var CAN_SET_PROTOTYPE = "setPrototypeOf" in Object;
+var InsufficientReservesError = class extends Error {
+  constructor() {
+    super();
+    this.isInsufficientReservesError = true;
+    this.name = this.constructor.name;
+    if (CAN_SET_PROTOTYPE)
+      Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InsufficientInputAmountError = class extends Error {
+  constructor() {
+    super();
+    this.isInsufficientInputAmountError = true;
+    this.name = this.constructor.name;
+    if (CAN_SET_PROTOTYPE)
+      Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/utils.ts
+var import_jsbi6 = __toESM(require("jsbi"));
+var import_tiny_invariant6 = __toESM(require("tiny-invariant"));
+function validateVMTypeInstance(value, vmType) {
+  (0, import_tiny_invariant6.default)(import_jsbi6.default.greaterThanOrEqual(value, ZERO), `${value} is not a ${vmType}.`);
+  (0, import_tiny_invariant6.default)(import_jsbi6.default.lessThanOrEqual(value, VM_TYPE_MAXIMA[vmType]), `${value} is not a ${vmType}.`);
+}
+function sqrt(y) {
+  validateVMTypeInstance(y, "uint256" /* uint256 */);
+  let z = ZERO;
+  let x;
+  if (import_jsbi6.default.greaterThan(y, THREE)) {
+    z = y;
+    x = import_jsbi6.default.add(import_jsbi6.default.divide(y, TWO), ONE);
+    while (import_jsbi6.default.lessThan(x, z)) {
+      z = x;
+      x = import_jsbi6.default.divide(import_jsbi6.default.add(import_jsbi6.default.divide(y, x), x), TWO);
+    }
+  } else if (import_jsbi6.default.notEqual(y, ZERO)) {
+    z = ONE;
+  }
+  return z;
+}
+function sortedInsert(items, add, maxSize, comparator) {
+  (0, import_tiny_invariant6.default)(maxSize > 0, "MAX_SIZE_ZERO");
+  (0, import_tiny_invariant6.default)(items.length <= maxSize, "ITEMS_SIZE");
+  if (items.length === 0) {
+    items.push(add);
+    return null;
+  } else {
+    const isFull = items.length === maxSize;
+    if (isFull && comparator(items[items.length - 1], add) <= 0) {
+      return add;
+    }
+    let lo = 0, hi = items.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (comparator(items[mid], add) <= 0) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    items.splice(lo, 0, add);
+    return isFull ? items.pop() : null;
+  }
+}
+function computePriceImpact(midPrice, inputAmount, outputAmount) {
+  const quotedOutputAmount = midPrice.quote(inputAmount);
+  const priceImpact = quotedOutputAmount.subtract(outputAmount).divide(quotedOutputAmount);
+  return new Percent(priceImpact.numerator, priceImpact.denominator);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseCurrency,
+  CurrencyAmount,
+  FIVE,
+  Fraction,
+  InsufficientInputAmountError,
+  InsufficientReservesError,
+  JSBI,
+  MINIMUM_LIQUIDITY,
+  MaxUint256,
+  NativeCurrency,
+  ONE,
+  Percent,
+  Price,
+  Rounding,
+  TEN,
+  THREE,
+  TWO,
+  Token,
+  TradeType,
+  VMType,
+  VM_TYPE_MAXIMA,
+  ZERO,
+  _100,
+  _10000,
+  _9975,
+  computePriceImpact,
+  sortedInsert,
+  sqrt,
+  validateVMTypeInstance
+});

package/dist/index.mjs

@@ -0,0 +1,424 @@
+// src/index.ts
+import JSBI7 from "jsbi";
+
+// src/constants.ts
+import JSBI from "jsbi";
+var TradeType = /* @__PURE__ */ ((TradeType2) => {
+  TradeType2[TradeType2["EXACT_INPUT"] = 0] = "EXACT_INPUT";
+  TradeType2[TradeType2["EXACT_OUTPUT"] = 1] = "EXACT_OUTPUT";
+  return TradeType2;
+})(TradeType || {});
+var Rounding = /* @__PURE__ */ ((Rounding2) => {
+  Rounding2[Rounding2["ROUND_DOWN"] = 0] = "ROUND_DOWN";
+  Rounding2[Rounding2["ROUND_HALF_UP"] = 1] = "ROUND_HALF_UP";
+  Rounding2[Rounding2["ROUND_UP"] = 2] = "ROUND_UP";
+  return Rounding2;
+})(Rounding || {});
+var MINIMUM_LIQUIDITY = JSBI.BigInt(1e3);
+var ZERO = JSBI.BigInt(0);
+var ONE = JSBI.BigInt(1);
+var TWO = JSBI.BigInt(2);
+var THREE = JSBI.BigInt(3);
+var FIVE = JSBI.BigInt(5);
+var TEN = JSBI.BigInt(10);
+var _100 = JSBI.BigInt(100);
+var _9975 = JSBI.BigInt(9975);
+var _10000 = JSBI.BigInt(1e4);
+var MaxUint256 = JSBI.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+var VMType = /* @__PURE__ */ ((VMType2) => {
+  VMType2["uint8"] = "uint8";
+  VMType2["uint256"] = "uint256";
+  return VMType2;
+})(VMType || {});
+var VM_TYPE_MAXIMA = {
+  ["uint8" /* uint8 */]: JSBI.BigInt("0xff"),
+  ["uint256" /* uint256 */]: JSBI.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+};
+
+// src/baseCurrency.ts
+import invariant from "tiny-invariant";
+var BaseCurrency = class {
+  constructor(chainId, decimals, symbol, name) {
+    invariant(Number.isSafeInteger(chainId), "CHAIN_ID");
+    invariant(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
+    this.chainId = chainId;
+    this.decimals = decimals;
+    this.symbol = symbol;
+    this.name = name;
+  }
+};
+
+// src/fractions/fraction.ts
+import JSBI2 from "jsbi";
+import invariant2 from "tiny-invariant";
+import _Decimal from "decimal.js-light";
+import _Big from "big.js";
+import toFormat from "toformat";
+var Decimal = toFormat(_Decimal);
+var Big = toFormat(_Big);
+var toSignificantRounding = {
+  [0 /* ROUND_DOWN */]: Decimal.ROUND_DOWN,
+  [1 /* ROUND_HALF_UP */]: Decimal.ROUND_HALF_UP,
+  [2 /* ROUND_UP */]: Decimal.ROUND_UP
+};
+var toFixedRounding = {
+  [0 /* ROUND_DOWN */]: 0 /* RoundDown */,
+  [1 /* ROUND_HALF_UP */]: 1 /* RoundHalfUp */,
+  [2 /* ROUND_UP */]: 3 /* RoundUp */
+};
+var Fraction = class {
+  constructor(numerator, denominator = JSBI2.BigInt(1)) {
+    this.numerator = JSBI2.BigInt(numerator);
+    this.denominator = JSBI2.BigInt(denominator);
+  }
+  static tryParseFraction(fractionish) {
+    if (fractionish instanceof JSBI2 || typeof fractionish === "number" || typeof fractionish === "string")
+      return new Fraction(fractionish);
+    if ("numerator" in fractionish && "denominator" in fractionish)
+      return fractionish;
+    throw new Error("Could not parse fraction");
+  }
+  get quotient() {
+    return JSBI2.divide(this.numerator, this.denominator);
+  }
+  get remainder() {
+    return new Fraction(JSBI2.remainder(this.numerator, this.denominator), this.denominator);
+  }
+  invert() {
+    return new Fraction(this.denominator, this.numerator);
+  }
+  add(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    if (JSBI2.equal(this.denominator, otherParsed.denominator)) {
+      return new Fraction(JSBI2.add(this.numerator, otherParsed.numerator), this.denominator);
+    }
+    return new Fraction(JSBI2.add(JSBI2.multiply(this.numerator, otherParsed.denominator), JSBI2.multiply(otherParsed.numerator, this.denominator)), JSBI2.multiply(this.denominator, otherParsed.denominator));
+  }
+  subtract(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    if (JSBI2.equal(this.denominator, otherParsed.denominator)) {
+      return new Fraction(JSBI2.subtract(this.numerator, otherParsed.numerator), this.denominator);
+    }
+    return new Fraction(JSBI2.subtract(JSBI2.multiply(this.numerator, otherParsed.denominator), JSBI2.multiply(otherParsed.numerator, this.denominator)), JSBI2.multiply(this.denominator, otherParsed.denominator));
+  }
+  lessThan(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return JSBI2.lessThan(JSBI2.multiply(this.numerator, otherParsed.denominator), JSBI2.multiply(otherParsed.numerator, this.denominator));
+  }
+  equalTo(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return JSBI2.equal(JSBI2.multiply(this.numerator, otherParsed.denominator), JSBI2.multiply(otherParsed.numerator, this.denominator));
+  }
+  greaterThan(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return JSBI2.greaterThan(JSBI2.multiply(this.numerator, otherParsed.denominator), JSBI2.multiply(otherParsed.numerator, this.denominator));
+  }
+  multiply(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return new Fraction(JSBI2.multiply(this.numerator, otherParsed.numerator), JSBI2.multiply(this.denominator, otherParsed.denominator));
+  }
+  divide(other) {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return new Fraction(JSBI2.multiply(this.numerator, otherParsed.denominator), JSBI2.multiply(this.denominator, otherParsed.numerator));
+  }
+  toSignificant(significantDigits, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
+    invariant2(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
+    invariant2(significantDigits > 0, `${significantDigits} is not positive.`);
+    Decimal.set({ precision: significantDigits + 1, rounding: toSignificantRounding[rounding] });
+    const quotient = new Decimal(this.numerator.toString()).div(this.denominator.toString()).toSignificantDigits(significantDigits);
+    return quotient.toFormat(quotient.decimalPlaces(), format);
+  }
+  toFixed(decimalPlaces, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
+    invariant2(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
+    invariant2(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
+    Big.DP = decimalPlaces;
+    Big.RM = toFixedRounding[rounding];
+    return new Big(this.numerator.toString()).div(this.denominator.toString()).toFormat(decimalPlaces, format);
+  }
+  get asFraction() {
+    return new Fraction(this.numerator, this.denominator);
+  }
+};
+
+// src/fractions/percent.ts
+import JSBI3 from "jsbi";
+var ONE_HUNDRED = new Fraction(JSBI3.BigInt(100));
+function toPercent(fraction) {
+  return new Percent(fraction.numerator, fraction.denominator);
+}
+var Percent = class extends Fraction {
+  constructor() {
+    super(...arguments);
+    this.isPercent = true;
+  }
+  add(other) {
+    return toPercent(super.add(other));
+  }
+  subtract(other) {
+    return toPercent(super.subtract(other));
+  }
+  multiply(other) {
+    return toPercent(super.multiply(other));
+  }
+  divide(other) {
+    return toPercent(super.divide(other));
+  }
+  toSignificant(significantDigits = 5, format, rounding) {
+    return super.multiply(ONE_HUNDRED).toSignificant(significantDigits, format, rounding);
+  }
+  toFixed(decimalPlaces = 2, format, rounding) {
+    return super.multiply(ONE_HUNDRED).toFixed(decimalPlaces, format, rounding);
+  }
+};
+
+// src/fractions/currencyAmount.ts
+import invariant3 from "tiny-invariant";
+import JSBI4 from "jsbi";
+import _Big2 from "big.js";
+import toFormat2 from "toformat";
+var Big2 = toFormat2(_Big2);
+var CurrencyAmount = class extends Fraction {
+  constructor(currency, numerator, denominator) {
+    super(numerator, denominator);
+    invariant3(JSBI4.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT");
+    this.currency = currency;
+    this.decimalScale = JSBI4.exponentiate(JSBI4.BigInt(10), JSBI4.BigInt(currency.decimals));
+  }
+  static fromRawAmount(currency, rawAmount) {
+    return new CurrencyAmount(currency, rawAmount);
+  }
+  static fromFractionalAmount(currency, numerator, denominator) {
+    return new CurrencyAmount(currency, numerator, denominator);
+  }
+  add(other) {
+    invariant3(this.currency.equals(other.currency), "CURRENCY");
+    const added = super.add(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
+  }
+  subtract(other) {
+    invariant3(this.currency.equals(other.currency), "CURRENCY");
+    const subtracted = super.subtract(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
+  }
+  multiply(other) {
+    const multiplied = super.multiply(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
+  }
+  divide(other) {
+    const divided = super.divide(other);
+    return CurrencyAmount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
+  }
+  toSignificant(significantDigits = 6, format, rounding = 0 /* ROUND_DOWN */) {
+    return super.divide(this.decimalScale).toSignificant(significantDigits, format, rounding);
+  }
+  toFixed(decimalPlaces = this.currency.decimals, format, rounding = 0 /* ROUND_DOWN */) {
+    invariant3(decimalPlaces <= this.currency.decimals, "DECIMALS");
+    return super.divide(this.decimalScale).toFixed(decimalPlaces, format, rounding);
+  }
+  toExact(format = { groupSeparator: "" }) {
+    Big2.DP = this.currency.decimals;
+    return new Big2(this.quotient.toString()).div(this.decimalScale.toString()).toFormat(format);
+  }
+  get wrapped() {
+    if (this.currency.isToken)
+      return this;
+    return CurrencyAmount.fromFractionalAmount(this.currency.wrapped, this.numerator, this.denominator);
+  }
+};
+
+// src/fractions/price.ts
+import JSBI5 from "jsbi";
+import invariant4 from "tiny-invariant";
+var Price = class extends Fraction {
+  constructor(...args) {
+    let baseCurrency;
+    let quoteCurrency;
+    let denominator;
+    let numerator;
+    if (args.length === 4) {
+      ;
+      [baseCurrency, quoteCurrency, denominator, numerator] = args;
+    } else {
+      const result = args[0].quoteAmount.divide(args[0].baseAmount);
+      [baseCurrency, quoteCurrency, denominator, numerator] = [
+        args[0].baseAmount.currency,
+        args[0].quoteAmount.currency,
+        result.denominator,
+        result.numerator
+      ];
+    }
+    super(numerator, denominator);
+    this.baseCurrency = baseCurrency;
+    this.quoteCurrency = quoteCurrency;
+    this.scalar = new Fraction(JSBI5.exponentiate(JSBI5.BigInt(10), JSBI5.BigInt(baseCurrency.decimals)), JSBI5.exponentiate(JSBI5.BigInt(10), JSBI5.BigInt(quoteCurrency.decimals)));
+  }
+  invert() {
+    return new Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
+  }
+  multiply(other) {
+    invariant4(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
+    const fraction = super.multiply(other);
+    return new Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
+  }
+  quote(currencyAmount) {
+    invariant4(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+    const result = super.multiply(currencyAmount);
+    return CurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
+  }
+  get adjustedForDecimals() {
+    return super.multiply(this.scalar);
+  }
+  toSignificant(significantDigits = 6, format, rounding) {
+    return this.adjustedForDecimals.toSignificant(significantDigits, format, rounding);
+  }
+  toFixed(decimalPlaces = 4, format, rounding) {
+    return this.adjustedForDecimals.toFixed(decimalPlaces, format, rounding);
+  }
+};
+
+// src/nativeCurrency.ts
+var NativeCurrency = class extends BaseCurrency {
+  constructor() {
+    super(...arguments);
+    this.isNative = true;
+    this.isToken = false;
+  }
+};
+
+// src/token.ts
+import invariant5 from "tiny-invariant";
+var Token = class extends BaseCurrency {
+  constructor(chainId, address, decimals, symbol, name, projectLink) {
+    super(chainId, decimals, symbol, name);
+    this.isNative = false;
+    this.isToken = true;
+    this.address = address;
+    this.projectLink = projectLink;
+  }
+  equals(other) {
+    return other.isToken && this.chainId === other.chainId && this.address === other.address;
+  }
+  sortsBefore(other) {
+    invariant5(this.chainId === other.chainId, "CHAIN_IDS");
+    invariant5(this.address !== other.address, "ADDRESSES");
+    return this.address.toLowerCase() < other.address.toLowerCase();
+  }
+  get wrapped() {
+    return this;
+  }
+  get serialize() {
+    return {
+      address: this.address,
+      chainId: this.chainId,
+      decimals: this.decimals,
+      symbol: this.symbol,
+      name: this.name,
+      projectLink: this.projectLink
+    };
+  }
+};
+
+// src/errors.ts
+var CAN_SET_PROTOTYPE = "setPrototypeOf" in Object;
+var InsufficientReservesError = class extends Error {
+  constructor() {
+    super();
+    this.isInsufficientReservesError = true;
+    this.name = this.constructor.name;
+    if (CAN_SET_PROTOTYPE)
+      Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InsufficientInputAmountError = class extends Error {
+  constructor() {
+    super();
+    this.isInsufficientInputAmountError = true;
+    this.name = this.constructor.name;
+    if (CAN_SET_PROTOTYPE)
+      Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/utils.ts
+import JSBI6 from "jsbi";
+import invariant6 from "tiny-invariant";
+function validateVMTypeInstance(value, vmType) {
+  invariant6(JSBI6.greaterThanOrEqual(value, ZERO), `${value} is not a ${vmType}.`);
+  invariant6(JSBI6.lessThanOrEqual(value, VM_TYPE_MAXIMA[vmType]), `${value} is not a ${vmType}.`);
+}
+function sqrt(y) {
+  validateVMTypeInstance(y, "uint256" /* uint256 */);
+  let z = ZERO;
+  let x;
+  if (JSBI6.greaterThan(y, THREE)) {
+    z = y;
+    x = JSBI6.add(JSBI6.divide(y, TWO), ONE);
+    while (JSBI6.lessThan(x, z)) {
+      z = x;
+      x = JSBI6.divide(JSBI6.add(JSBI6.divide(y, x), x), TWO);
+    }
+  } else if (JSBI6.notEqual(y, ZERO)) {
+    z = ONE;
+  }
+  return z;
+}
+function sortedInsert(items, add, maxSize, comparator) {
+  invariant6(maxSize > 0, "MAX_SIZE_ZERO");
+  invariant6(items.length <= maxSize, "ITEMS_SIZE");
+  if (items.length === 0) {
+    items.push(add);
+    return null;
+  } else {
+    const isFull = items.length === maxSize;
+    if (isFull && comparator(items[items.length - 1], add) <= 0) {
+      return add;
+    }
+    let lo = 0, hi = items.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (comparator(items[mid], add) <= 0) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    items.splice(lo, 0, add);
+    return isFull ? items.pop() : null;
+  }
+}
+function computePriceImpact(midPrice, inputAmount, outputAmount) {
+  const quotedOutputAmount = midPrice.quote(inputAmount);
+  const priceImpact = quotedOutputAmount.subtract(outputAmount).divide(quotedOutputAmount);
+  return new Percent(priceImpact.numerator, priceImpact.denominator);
+}
+export {
+  BaseCurrency,
+  CurrencyAmount,
+  FIVE,
+  Fraction,
+  InsufficientInputAmountError,
+  InsufficientReservesError,
+  JSBI7 as JSBI,
+  MINIMUM_LIQUIDITY,
+  MaxUint256,
+  NativeCurrency,
+  ONE,
+  Percent,
+  Price,
+  Rounding,
+  TEN,
+  THREE,
+  TWO,
+  Token,
+  TradeType,
+  VMType,
+  VM_TYPE_MAXIMA,
+  ZERO,
+  _100,
+  _10000,
+  _9975,
+  computePriceImpact,
+  sortedInsert,
+  sqrt,
+  validateVMTypeInstance
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@pancakeswap/swap-sdk-core",
+  "license": "MIT",
+  "version": "0.0.1",
+  "description": "🛠 An SDK for building applications on top of Pancakeswap.",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pancakeswap/pancake-frontend.git",
+    "directory": "packages/swap-sdk"
+  },
+  "keywords": [
+    "pancakeswap"
+  ],
+  "module": "dist/index.mjs",
+  "scripts": {
+    "lint": "eslint src test",
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "test": "jest",
+    "prepublishOnly": "yarn run build",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "dependencies": {
+    "big.js": "^5.2.2",
+    "decimal.js-light": "^2.5.0",
+    "jsbi": "^3.1.4",
+    "tiny-invariant": "^1.1.0",
+    "tiny-warning": "^1.0.3",
+    "toformat": "^2.0.0"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "@swc/core": "^1.2.215",
+    "@swc/jest": "^0.2.21",
+    "@types/big.js": "^4.0.5",
+    "@types/jest": "^24.0.25",
+    "babel-plugin-transform-jsbi-to-bigint": "^1.3.1",
+    "tsup": "^5.10.1"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "prettier": {
+    "printWidth": 120,
+    "semi": false,
+    "singleQuote": true
+  }
+}