@pancakeswap/swap-sdk-core 1.4.0 → 1.5.1

package/dist/index.d.ts

@@ -1,9 +1,363 @@
-export * from './constants';
-export * from './baseCurrency';
-export * from './currency';
-export * from './fractions';
-export * from './nativeCurrency';
-export * from './token';
-export * from './errors';
-export * from './utils';
-//# sourceMappingURL=index.d.ts.map
+type BigintIsh = bigint | 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 = 1000n;
+declare const ZERO = 0n;
+declare const ONE = 1n;
+declare const TWO = 2n;
+declare const THREE = 3n;
+declare const FIVE = 5n;
+declare const TEN = 10n;
+declare const _100 = 100n;
+declare const _9975 = 9975n;
+declare const _10000 = 10000n;
+declare const MaxUint256: bigint;
+declare enum VMType {
+    uint8 = "uint8",
+    uint256 = "uint256"
+}
+declare const VM_TYPE_MAXIMA: {
+    uint8: bigint;
+    uint256: bigint;
+};
+declare const ZERO_ADDRESS: "0x0000000000000000000000000000000000000000";
+
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+declare abstract class BaseCurrency<T extends BaseCurrency<any> = BaseCurrency<any>> {
+    /**
+     * 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: BaseCurrency<any>): 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(): T;
+    get asToken(): T;
+}
+
+interface SerializedToken {
+    chainId: number;
+    address: `0x${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<Token> {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: `0x${string}`;
+    readonly projectLink?: string;
+    constructor(chainId: number, address: `0x${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: BaseCurrency): 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;
+}
+
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+declare abstract class NativeCurrency extends BaseCurrency<Token> {
+    readonly isNative: true;
+    readonly isToken: false;
+    get asToken(): Token;
+}
+
+interface SerializedSPLToken {
+    chainId: number;
+    address: string;
+    programId: string;
+    decimals: number;
+    symbol: string;
+    name?: string;
+    projectLink?: string;
+}
+/**
+ * Represents an SPL token on Solana or other non-EVM chains.
+ */
+declare class SPLToken extends BaseCurrency<SPLToken> {
+    readonly isNative: false;
+    readonly isToken: true;
+    readonly address: string;
+    readonly programId: string;
+    readonly logoURI: string;
+    readonly projectLink?: string;
+    static isSPLToken(token?: UnifiedCurrency): boolean;
+    constructor({ chainId, programId, address, decimals, symbol, logoURI, name, projectLink, }: {
+        chainId: number;
+        programId: string;
+        address: string;
+        decimals: number;
+        symbol: string;
+        logoURI: string;
+        name?: string;
+        projectLink?: string;
+        isNative?: boolean;
+    });
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and programId.
+     * @param other other token to compare
+     */
+    equals(other: BaseCurrency): boolean;
+    sortsBefore(other: SPLToken): boolean;
+    get wrapped(): SPLToken;
+    get serialize(): SerializedSPLToken;
+}
+
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+declare abstract class SPLNativeCurrency extends BaseCurrency<SPLToken> {
+    readonly isNative: true;
+    readonly isToken: false;
+    readonly address: string;
+}
+
+type Currency = NativeCurrency | Token;
+type UnifiedNativeCurrency = NativeCurrency | SPLNativeCurrency;
+type UnifiedCurrency = SPLToken | SPLNativeCurrency | Currency;
+type UnifiedToken = SPLToken | Token;
+
+declare class Fraction {
+    readonly numerator: bigint;
+    readonly denominator: bigint;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    private static tryParseFraction;
+    get quotient(): bigint;
+    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;
+}
+
+/**
+ * Converts a fraction to a percent
+ * @param fraction the fraction to convert
+ */
+declare function toPercent(fraction: Fraction): Percent;
+declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    static toPercent: typeof toPercent;
+    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: bigint;
+    /**
+     * 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(value: bigint): 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>;
+    info(): string;
+}
+
+declare class UnifiedCurrencyAmount<T extends UnifiedCurrency> extends Fraction {
+    readonly currency: T;
+    readonly decimalScale: bigint;
+    /**
+     * 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 UnifiedCurrency>(currency: T, rawAmount: BigintIsh): UnifiedCurrencyAmount<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 UnifiedCurrency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): UnifiedCurrencyAmount<T>;
+    protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: UnifiedCurrencyAmount<T>): UnifiedCurrencyAmount<T>;
+    subtract(value: bigint): UnifiedCurrencyAmount<T>;
+    subtract(other: UnifiedCurrencyAmount<T>): UnifiedCurrencyAmount<T>;
+    multiply(other: Fraction | BigintIsh): UnifiedCurrencyAmount<T>;
+    divide(other: Fraction | BigintIsh): UnifiedCurrencyAmount<T>;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+    get wrapped(): UnifiedCurrencyAmount<UnifiedToken>;
+    info(): string;
+}
+
+declare class Price<TBase extends UnifiedCurrency, TQuote extends UnifiedCurrency> 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: UnifiedCurrencyAmount<TBase>;
+        quoteAmount: UnifiedCurrencyAmount<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 UnifiedCurrency>(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: UnifiedCurrencyAmount<TBase>): UnifiedCurrencyAmount<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;
+    get wrapped(): Price<TBase['wrapped'], TQuote['wrapped']>;
+    /**
+     * Create a price from base and quote currency and a decimal string
+     * @param base
+     * @param quote
+     * @param value
+     * @returns Price<TBase, TQuote> | undefined
+     */
+    static fromDecimal<TBase extends UnifiedCurrency, TQuote extends UnifiedCurrency>(base: TBase, quote: TQuote, value: string): Price<TBase, TQuote> | undefined;
+}
+
+/**
+ * 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: bigint, vmType: VMType): void;
+declare function sqrt(y: bigint): bigint;
+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;
+declare function getTokenComparator(balances: {
+    [tokenAddress: string]: CurrencyAmount<Token> | undefined;
+}): (tokenA: Token, tokenB: Token) => number;
+declare function sortCurrencies<T extends Currency>(currencies: T[]): T[];
+declare const isCurrencySorted: (currencyA: Currency, currencyB: Currency) => boolean;
+declare function getCurrencyAddress(currency: Currency): `0x${string}`;
+declare function getMatchedCurrency(currency: Currency, list: Currency[], matchWrappedCurrency?: boolean): Currency | undefined;
+
+export { BaseCurrency, BigintIsh, Currency, CurrencyAmount, FIVE, Fraction, InsufficientInputAmountError, InsufficientReservesError, MINIMUM_LIQUIDITY, MaxUint256, NativeCurrency, ONE, Percent, Price, Rounding, SPLNativeCurrency, SPLToken, SerializedSPLToken, SerializedToken, TEN, THREE, TWO, Token, TradeType, UnifiedCurrency, UnifiedCurrencyAmount, UnifiedNativeCurrency, UnifiedToken, VMType, VM_TYPE_MAXIMA, ZERO, ZERO_ADDRESS, _100, _10000, _9975, computePriceImpact, getCurrencyAddress, getMatchedCurrency, getTokenComparator, isCurrencySorted, sortCurrencies, sortedInsert, sqrt, validateVMTypeInstance };

package/dist/index.js

@@ -1,13 +1,13 @@
 'use strict';
 
-var invariant6 = require('tiny-invariant');
+var invariant8 = require('tiny-invariant');
 var _Decimal = require('decimal.js-light');
 var _Big = require('big.js');
 var toFormat = require('toformat');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var invariant6__default = /*#__PURE__*/_interopDefault(invariant6);
+var invariant8__default = /*#__PURE__*/_interopDefault(invariant8);
 var _Decimal__default = /*#__PURE__*/_interopDefault(_Decimal);
 var _Big__default = /*#__PURE__*/_interopDefault(_Big);
 var toFormat__default = /*#__PURE__*/_interopDefault(toFormat);
@@ -54,8 +54,7 @@ var BaseCurrency = class {
    * @param name of the currency
    */
   constructor(chainId, decimals, symbol, name) {
-    invariant6__default.default(Number.isSafeInteger(chainId), "CHAIN_ID");
-    invariant6__default.default(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
+    invariant8__default.default(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
     this.chainId = chainId;
     this.decimals = decimals;
     this.symbol = symbol;
@@ -141,15 +140,15 @@ var Fraction = class {
     return new Fraction(this.numerator * otherParsed.denominator, this.denominator * otherParsed.numerator);
   }
   toSignificant(significantDigits, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
-    invariant6__default.default(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
-    invariant6__default.default(significantDigits > 0, `${significantDigits} is not positive.`);
+    invariant8__default.default(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
+    invariant8__default.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 */) {
-    invariant6__default.default(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
-    invariant6__default.default(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
+    invariant8__default.default(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
+    invariant8__default.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);
@@ -199,7 +198,7 @@ var Big2 = toFormat__default.default(_Big__default.default);
 var CurrencyAmount = class extends Fraction {
   constructor(currency, numerator, denominator) {
     super(numerator, denominator);
-    invariant6__default.default(this.quotient <= MaxUint256, "AMOUNT");
+    invariant8__default.default(this.quotient <= MaxUint256, "AMOUNT");
     this.currency = currency;
     this.decimalScale = 10n ** BigInt(currency.decimals);
   }
@@ -221,7 +220,7 @@ var CurrencyAmount = class extends Fraction {
     return new CurrencyAmount(currency, numerator, denominator);
   }
   add(other) {
-    invariant6__default.default(this.currency.equals(other.currency), "CURRENCY");
+    invariant8__default.default(this.currency.equals(other.currency), "CURRENCY");
     const added = super.add(other);
     return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
   }
@@ -233,7 +232,7 @@ var CurrencyAmount = class extends Fraction {
         this.denominator
       );
     }
-    invariant6__default.default(this.currency.equals(value.currency), "CURRENCY");
+    invariant8__default.default(this.currency.equals(value.currency), "CURRENCY");
     const subtracted = super.subtract(value);
     return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
   }
@@ -249,7 +248,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 */) {
-    invariant6__default.default(decimalPlaces <= this.currency.decimals, "DECIMALS");
+    invariant8__default.default(decimalPlaces <= this.currency.decimals, "DECIMALS");
     return super.divide(this.decimalScale).toFixed(decimalPlaces, format, rounding);
   }
   toExact(format = { groupSeparator: "" }) {
@@ -265,6 +264,76 @@ var CurrencyAmount = class extends Fraction {
     return `${this.toExact()}${this.currency.symbol}`;
   }
 };
+var Big3 = toFormat__default.default(_Big__default.default);
+var UnifiedCurrencyAmount = class extends Fraction {
+  constructor(currency, numerator, denominator) {
+    super(numerator, denominator);
+    invariant8__default.default(this.quotient <= MaxUint256, "AMOUNT");
+    this.currency = currency;
+    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 UnifiedCurrencyAmount(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 UnifiedCurrencyAmount(currency, numerator, denominator);
+  }
+  add(other) {
+    invariant8__default.default(this.currency.equals(other.currency), "CURRENCY");
+    const added = super.add(other);
+    return UnifiedCurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
+  }
+  subtract(value) {
+    if (typeof value === "bigint") {
+      return UnifiedCurrencyAmount.fromFractionalAmount(
+        this.currency,
+        this.numerator - value * this.denominator,
+        this.denominator
+      );
+    }
+    invariant8__default.default(this.currency.equals(value.currency), "CURRENCY");
+    const subtracted = super.subtract(value);
+    return UnifiedCurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
+  }
+  multiply(other) {
+    const multiplied = super.multiply(other);
+    return UnifiedCurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
+  }
+  divide(other) {
+    const divided = super.divide(other);
+    return UnifiedCurrencyAmount.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 */) {
+    invariant8__default.default(decimalPlaces <= this.currency.decimals, "DECIMALS");
+    return super.divide(this.decimalScale).toFixed(decimalPlaces, format, rounding);
+  }
+  toExact(format = { groupSeparator: "" }) {
+    Big3.DP = this.currency.decimals;
+    return new Big3(this.quotient.toString()).div(this.decimalScale.toString()).toFormat(format);
+  }
+  get wrapped() {
+    if (this.currency.isToken)
+      return this;
+    return UnifiedCurrencyAmount.fromFractionalAmount(this.currency.wrapped, this.numerator, this.denominator);
+  }
+  info() {
+    return `${this.toExact()}${this.currency.symbol}`;
+  }
+};
 var Price = class extends Fraction {
   // used to adjust the raw fraction w/r/t the decimals of the {base,quote}Token
   /**
@@ -303,7 +372,7 @@ var Price = class extends Fraction {
    * @param other the other price
    */
   multiply(other) {
-    invariant6__default.default(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
+    invariant8__default.default(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
     const fraction = super.multiply(other);
     return new Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
   }
@@ -312,9 +381,9 @@ var Price = class extends Fraction {
    * @param currencyAmount the amount of base currency to quote against the price
    */
   quote(currencyAmount) {
-    invariant6__default.default(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+    invariant8__default.default(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
     const result = super.multiply(currencyAmount);
-    return CurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
+    return UnifiedCurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
   }
   /**
    * Get the value scaled by decimals for formatting
@@ -376,8 +445,8 @@ var Token = class extends BaseCurrency {
    * @throws if the tokens are on different chains
    */
   sortsBefore(other) {
-    invariant6__default.default(this.chainId === other.chainId, "CHAIN_IDS");
-    invariant6__default.default(this.address !== other.address, "ADDRESSES");
+    invariant8__default.default(this.chainId === other.chainId, "CHAIN_IDS");
+    invariant8__default.default(this.address !== other.address, "ADDRESSES");
     return this.address.toLowerCase() < other.address.toLowerCase();
   }
   /**
@@ -410,6 +479,68 @@ var NativeCurrency = class extends BaseCurrency {
   }
 };
 
+// src/splNativeCurrency.ts
+var SPLNativeCurrency = class extends BaseCurrency {
+  constructor() {
+    super(...arguments);
+    this.isNative = true;
+    this.isToken = false;
+    this.address = "";
+  }
+};
+var SPLToken = class extends BaseCurrency {
+  constructor({
+    chainId,
+    programId,
+    address,
+    decimals,
+    symbol,
+    logoURI,
+    name,
+    projectLink
+  }) {
+    super(chainId, decimals, symbol, name);
+    this.isNative = false;
+    this.isToken = true;
+    this.address = address;
+    this.programId = programId;
+    this.logoURI = logoURI;
+    this.projectLink = projectLink;
+  }
+  static isSPLToken(token) {
+    if (!token)
+      return false;
+    return "programId" in token || token.wrapped instanceof SPLToken;
+  }
+  /**
+   * Returns true if the two tokens are equivalent, i.e. have the same chainId and programId.
+   * @param other other token to compare
+   */
+  equals(other) {
+    return this.chainId === other.chainId && this.address === other.address;
+  }
+  sortsBefore(other) {
+    invariant8__default.default(this.chainId === other.chainId, "CHAIN_IDS");
+    invariant8__default.default(this.programId !== other.programId, "ADDRESSES");
+    return this.programId.toLowerCase() < other.programId.toLowerCase();
+  }
+  /* For compatibility */
+  get wrapped() {
+    return this;
+  }
+  get serialize() {
+    return {
+      address: this.address,
+      programId: this.programId,
+      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 {
@@ -431,11 +562,11 @@ var InsufficientInputAmountError = class extends Error {
   }
 };
 function validateVMTypeInstance(value, vmType) {
-  invariant6__default.default(value >= ZERO, `${value} is not a ${vmType}.`);
-  invariant6__default.default(value <= VM_TYPE_MAXIMA[vmType], `${value} is not a ${vmType}.`);
+  invariant8__default.default(value >= ZERO, `${value} is not a ${vmType}.`);
+  invariant8__default.default(value <= VM_TYPE_MAXIMA[vmType], `${value} is not a ${vmType}.`);
 }
 function sqrt(y) {
-  invariant6__default.default(y >= ZERO, "NEGATIVE");
+  invariant8__default.default(y >= ZERO, "NEGATIVE");
   let z = ZERO;
   let x;
   if (y > THREE) {
@@ -451,8 +582,8 @@ function sqrt(y) {
   return z;
 }
 function sortedInsert(items, add, maxSize, comparator) {
-  invariant6__default.default(maxSize > 0, "MAX_SIZE_ZERO");
-  invariant6__default.default(items.length <= maxSize, "ITEMS_SIZE");
+  invariant8__default.default(maxSize > 0, "MAX_SIZE_ZERO");
+  invariant8__default.default(items.length <= maxSize, "ITEMS_SIZE");
   if (items.length === 0) {
     items.push(add);
     return null;
@@ -549,11 +680,14 @@ exports.ONE = ONE;
 exports.Percent = Percent;
 exports.Price = Price;
 exports.Rounding = Rounding;
+exports.SPLNativeCurrency = SPLNativeCurrency;
+exports.SPLToken = SPLToken;
 exports.TEN = TEN;
 exports.THREE = THREE;
 exports.TWO = TWO;
 exports.Token = Token;
 exports.TradeType = TradeType;
+exports.UnifiedCurrencyAmount = UnifiedCurrencyAmount;
 exports.VMType = VMType;
 exports.VM_TYPE_MAXIMA = VM_TYPE_MAXIMA;
 exports.ZERO = ZERO;