@pancakeswap/swap-sdk-core 0.0.1 → 1.0.0

package/dist/index.mjs

@@ -1,8 +1,9 @@
-// src/index.ts
-import JSBI7 from "jsbi";
+import invariant6 from 'tiny-invariant';
+import _Decimal from 'decimal.js-light';
+import _Big from 'big.js';
+import toFormat from 'toformat';
 
 // 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";
@@ -14,46 +15,43 @@ var Rounding = /* @__PURE__ */ ((Rounding2) => {
   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;
+var MINIMUM_LIQUIDITY = 1000n;
+var ZERO = 0n;
+var ONE = 1n;
+var TWO = 2n;
+var THREE = 3n;
+var FIVE = 5n;
+var TEN = 10n;
+var _100 = 100n;
+var _9975 = 9975n;
+var _10000 = 10000n;
+var MaxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+var VMType = /* @__PURE__ */ ((VMType3) => {
+  VMType3["uint8"] = "uint8";
+  VMType3["uint256"] = "uint256";
+  return VMType3;
 })(VMType || {});
 var VM_TYPE_MAXIMA = {
-  ["uint8" /* uint8 */]: JSBI.BigInt("0xff"),
-  ["uint256" /* uint256 */]: JSBI.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+  ["uint8" /* uint8 */]: BigInt("0xff"),
+  ["uint256" /* uint256 */]: BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
 };
-
-// src/baseCurrency.ts
-import invariant from "tiny-invariant";
 var BaseCurrency = class {
+  /**
+   * 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
+   */
   constructor(chainId, decimals, symbol, name) {
-    invariant(Number.isSafeInteger(chainId), "CHAIN_ID");
-    invariant(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
+    invariant6(Number.isSafeInteger(chainId), "CHAIN_ID");
+    invariant6(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 = {
@@ -67,88 +65,101 @@ var toFixedRounding = {
   [2 /* ROUND_UP */]: 3 /* RoundUp */
 };
 var Fraction = class {
-  constructor(numerator, denominator = JSBI2.BigInt(1)) {
-    this.numerator = JSBI2.BigInt(numerator);
-    this.denominator = JSBI2.BigInt(denominator);
+  constructor(numerator, denominator = 1n) {
+    this.numerator = BigInt(numerator);
+    this.denominator = BigInt(denominator);
   }
   static tryParseFraction(fractionish) {
-    if (fractionish instanceof JSBI2 || typeof fractionish === "number" || typeof fractionish === "string")
+    if (typeof fractionish === "bigint" || 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");
   }
+  // performs floor division
   get quotient() {
-    return JSBI2.divide(this.numerator, this.denominator);
+    return this.numerator / this.denominator;
   }
+  // remainder after floor division
   get remainder() {
-    return new Fraction(JSBI2.remainder(this.numerator, this.denominator), this.denominator);
+    return new Fraction(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);
+    if (this.denominator === otherParsed.denominator) {
+      return new Fraction(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));
+    return new Fraction(
+      this.numerator * otherParsed.denominator + otherParsed.numerator * this.denominator,
+      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);
+    if (this.denominator === otherParsed.denominator) {
+      return new Fraction(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));
+    return new Fraction(
+      this.numerator * otherParsed.denominator - otherParsed.numerator * this.denominator,
+      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));
+    return this.numerator * otherParsed.denominator < 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));
+    return this.numerator * otherParsed.denominator === 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));
+    return this.numerator * otherParsed.denominator > 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));
+    return new Fraction(this.numerator * otherParsed.numerator, 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));
+    return new Fraction(this.numerator * otherParsed.denominator, 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.`);
+    invariant6(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
+    invariant6(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.`);
+    invariant6(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
+    invariant6(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);
   }
+  /**
+   * Helper method for converting any super class back to a fraction
+   */
   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));
+var ONE_HUNDRED = new Fraction(100n);
 function toPercent(fraction) {
   return new Percent(fraction.numerator, fraction.denominator);
 }
 var Percent = class extends Fraction {
   constructor() {
     super(...arguments);
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
     this.isPercent = true;
   }
   add(other) {
@@ -170,33 +181,38 @@ var Percent = class extends Fraction {
     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 Big2 = toFormat(_Big);
 var CurrencyAmount = class extends Fraction {
   constructor(currency, numerator, denominator) {
     super(numerator, denominator);
-    invariant3(JSBI4.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT");
+    invariant6(this.quotient <= MaxUint256, "AMOUNT");
     this.currency = currency;
-    this.decimalScale = JSBI4.exponentiate(JSBI4.BigInt(10), JSBI4.BigInt(currency.decimals));
+    this.decimalScale = 10n ** BigInt(currency.decimals);
   }
+  /**
+   * 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(currency, rawAmount) {
     return new CurrencyAmount(currency, rawAmount);
   }
+  /**
+   * 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(currency, numerator, denominator) {
     return new CurrencyAmount(currency, numerator, denominator);
   }
   add(other) {
-    invariant3(this.currency.equals(other.currency), "CURRENCY");
+    invariant6(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");
+    invariant6(this.currency.equals(other.currency), "CURRENCY");
     const subtracted = super.subtract(other);
     return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
   }
@@ -212,7 +228,7 @@ var CurrencyAmount = class extends Fraction {
     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");
+    invariant6(decimalPlaces <= this.currency.decimals, "DECIMALS");
     return super.divide(this.decimalScale).toFixed(decimalPlaces, format, rounding);
   }
   toExact(format = { groupSeparator: "" }) {
@@ -225,18 +241,18 @@ var CurrencyAmount = class extends Fraction {
     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 {
+  // used to adjust the raw fraction w/r/t the decimals of the {base,quote}Token
+  /**
+   * Construct a price, either with the base and quote currency amount, or the
+   * @param args
+   */
   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);
@@ -250,21 +266,36 @@ var Price = class extends Fraction {
     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)));
+    this.scalar = new Fraction(10n ** BigInt(baseCurrency.decimals), 10n ** BigInt(quoteCurrency.decimals));
   }
+  /**
+   * Flip the price, switching the base and quote currency
+   */
   invert() {
     return new Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
   }
+  /**
+   * 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(other) {
-    invariant4(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
+    invariant6(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
     const fraction = super.multiply(other);
     return new Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
   }
+  /**
+   * 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) {
-    invariant4(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+    invariant6(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
     const result = super.multiply(currencyAmount);
     return CurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
   }
+  /**
+   * Get the value scaled by decimals for formatting
+   * @private
+   */
   get adjustedForDecimals() {
     return super.multiply(this.scalar);
   }
@@ -284,9 +315,6 @@ var NativeCurrency = class extends BaseCurrency {
     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);
@@ -295,14 +323,27 @@ var Token = class extends BaseCurrency {
     this.address = address;
     this.projectLink = projectLink;
   }
+  /**
+   * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+   * @param other other token to compare
+   */
   equals(other) {
     return other.isToken && this.chainId === other.chainId && this.address === other.address;
   }
+  /**
+   * 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) {
-    invariant5(this.chainId === other.chainId, "CHAIN_IDS");
-    invariant5(this.address !== other.address, "ADDRESSES");
+    invariant6(this.chainId === other.chainId, "CHAIN_IDS");
+    invariant6(this.address !== other.address, "ADDRESSES");
     return this.address.toLowerCase() < other.address.toLowerCase();
   }
+  /**
+   * Return this token, which does not need to be wrapped
+   */
   get wrapped() {
     return this;
   }
@@ -338,26 +379,22 @@ var InsufficientInputAmountError = class extends Error {
       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}.`);
+  invariant6(value >= ZERO, `${value} is not a ${vmType}.`);
+  invariant6(value <= VM_TYPE_MAXIMA[vmType], `${value} is not a ${vmType}.`);
 }
 function sqrt(y) {
-  validateVMTypeInstance(y, "uint256" /* uint256 */);
+  invariant6(y >= ZERO, "NEGATIVE");
   let z = ZERO;
   let x;
-  if (JSBI6.greaterThan(y, THREE)) {
+  if (y > THREE) {
     z = y;
-    x = JSBI6.add(JSBI6.divide(y, TWO), ONE);
-    while (JSBI6.lessThan(x, z)) {
+    x = y / TWO + ONE;
+    while (x < z) {
       z = x;
-      x = JSBI6.divide(JSBI6.add(JSBI6.divide(y, x), x), TWO);
+      x = (y / x + x) / TWO;
     }
-  } else if (JSBI6.notEqual(y, ZERO)) {
+  } else if (y !== ZERO) {
     z = ONE;
   }
   return z;
@@ -391,34 +428,30 @@ function computePriceImpact(midPrice, inputAmount, outputAmount) {
   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
-};
+function balanceComparator(balanceA, balanceB) {
+  if (balanceA && balanceB) {
+    return balanceA.greaterThan(balanceB) ? -1 : balanceA.equalTo(balanceB) ? 0 : 1;
+  }
+  if (balanceA && balanceA.greaterThan("0")) {
+    return -1;
+  }
+  if (balanceB && balanceB.greaterThan("0")) {
+    return 1;
+  }
+  return 0;
+}
+function getTokenComparator(balances) {
+  return function sortTokens(tokenA, tokenB) {
+    const balanceA = balances[tokenA.address];
+    const balanceB = balances[tokenB.address];
+    const balanceComp = balanceComparator(balanceA, balanceB);
+    if (balanceComp !== 0)
+      return balanceComp;
+    if (tokenA.symbol && tokenB.symbol) {
+      return tokenA.symbol.toLowerCase() < tokenB.symbol.toLowerCase() ? -1 : 1;
+    }
+    return tokenA.symbol ? -1 : tokenB.symbol ? -1 : 0;
+  };
+}
+
+export { BaseCurrency, CurrencyAmount, FIVE, Fraction, InsufficientInputAmountError, InsufficientReservesError, MINIMUM_LIQUIDITY, MaxUint256, NativeCurrency, ONE, Percent, Price, Rounding, TEN, THREE, TWO, Token, TradeType, VMType, VM_TYPE_MAXIMA, ZERO, _100, _10000, _9975, computePriceImpact, getTokenComparator, sortedInsert, sqrt, validateVMTypeInstance };

package/dist/nativeCurrency.d.ts

@@ -0,0 +1,9 @@
+import { BaseCurrency } from './baseCurrency';
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+export declare abstract class NativeCurrency extends BaseCurrency {
+    readonly isNative: true;
+    readonly isToken: false;
+}
+//# sourceMappingURL=nativeCurrency.d.ts.map

package/dist/nativeCurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeCurrency.d.ts","sourceRoot":"","sources":["../src/nativeCurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C;;GAEG;AACH,8BAAsB,cAAe,SAAQ,YAAY;IACvD,SAAgB,QAAQ,OAAgB;IAExC,SAAgB,OAAO,QAAiB;CACzC"}

package/dist/token.d.ts

@@ -0,0 +1,41 @@
+import { BaseCurrency } from './baseCurrency';
+import { Currency } from './currency';
+export 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.
+ */
+export 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;
+}
+//# sourceMappingURL=token.d.ts.map

package/dist/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,qBAAa,KAAM,SAAQ,YAAY;IACrC,SAAgB,QAAQ,EAAE,KAAK,CAAiB;IAEhD,SAAgB,OAAO,EAAE,IAAI,CAAgB;IAE7C;;OAEG;IACH,SAAgB,OAAO,EAAE,MAAM,CAAA;IAE/B,SAAgB,WAAW,CAAC,EAAE,MAAM,CAAA;gBAGlC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM;IAOtB;;;OAGG;IACI,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAIvC;;;;;OAKG;IACI,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAMzC;;OAEG;IACH,IAAW,OAAO,IAAI,KAAK,CAE1B;IAED,IAAW,SAAS,IAAI,eAAe,CAStC;CACF"}

package/dist/utils.d.ts

@@ -0,0 +1,18 @@
+import { VMType } from './constants';
+import { Currency } from './currency';
+import { CurrencyAmount, Percent, Price } from './fractions';
+import { Token } from './token';
+export declare function validateVMTypeInstance(value: bigint, vmType: VMType): void;
+export declare function sqrt(y: bigint): bigint;
+export 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
+ */
+export declare function computePriceImpact<TBase extends Currency, TQuote extends Currency>(midPrice: Price<TBase, TQuote>, inputAmount: CurrencyAmount<TBase>, outputAmount: CurrencyAmount<TQuote>): Percent;
+export declare function getTokenComparator(balances: {
+    [tokenAddress: string]: CurrencyAmount<Token> | undefined;
+}): (tokenA: Token, tokenB: Token) => number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,MAAM,EAAkB,MAAM,aAAa,CAAA;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAG1E;AAGD,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBtC;AAKD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,GAAG,IAAI,CA8BjH;AAGD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,QAAQ,EAAE,MAAM,SAAS,QAAQ,EAChF,QAAQ,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,EAC9B,WAAW,EAAE,cAAc,CAAC,KAAK,CAAC,EAClC,YAAY,EAAE,cAAc,CAAC,MAAM,CAAC,GACnC,OAAO,CAKT;AAgBD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG,SAAS,CAAA;CAC1D,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,KAAK,MAAM,CAkB3C"}

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "@pancakeswap/swap-sdk-core",
   "license": "MIT",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "🛠 An SDK for building applications on top of Pancakeswap.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
+  "module": "dist/index.mjs",
   "files": [
     "dist"
   ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/pancakeswap/pancake-frontend.git",
@@ -16,31 +25,21 @@
   "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": {
+    "vitest": "^0.27.2",
     "@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"
+    "tsup": "^6.7.0"
   },
   "engines": {
     "node": ">=10"
@@ -49,5 +48,12 @@
     "printWidth": 120,
     "semi": false,
     "singleQuote": true
+  },
+  "scripts": {
+    "lint": "eslint src test",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest --globals --run",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
   }
-}
+}