@pancakeswap/sdk 3.1.0 → 3.1.2

package/README.md

@@ -1,4 +1,4 @@
-# Pancakeswap SDK
+# PancakeSwap SDK
 
 Forked from the [Uniswap SDK](https://github.com/Uniswap/uniswap-v2-sdk/commit/a88048e9c4198a5bdaea00883ca00c8c8e582605).
 

package/dist/index.d.ts

@@ -1,316 +1,78 @@
-import JSBI from 'jsbi';
 export { default as JSBI } from 'jsbi';
+import { Token, CurrencyAmount, Price, BigintIsh, Currency, TradeType, Percent, NativeCurrency } from '@pancakeswap/swap-sdk-core';
+export * from '@pancakeswap/swap-sdk-core';
 
-/**
- * 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;
-}
-
-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;
-}
-
-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;
+declare class ERC20Token extends Token {
     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 BigintIsh = JSBI | number | string;
 declare enum ChainId {
     ETHEREUM = 1,
-    RINKEBY = 4,
     GOERLI = 5,
     BSC = 56,
     BSC_TESTNET = 97
 }
-declare enum TradeType {
-    EXACT_INPUT = 0,
-    EXACT_OUTPUT = 1
-}
-declare enum Rounding {
-    ROUND_DOWN = 0,
-    ROUND_HALF_UP = 1,
-    ROUND_UP = 2
-}
 declare const FACTORY_ADDRESS = "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73";
 declare const FACTORY_ADDRESS_MAP: Record<number, string>;
 declare const INIT_CODE_HASH = "0x00fb7f630766e6a796048ea87d01acd3068e8ff67d078148a3fa3f4a84f69bd5";
 declare const INIT_CODE_HASH_MAP: Record<number, string>;
-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 SolidityType {
-    uint8 = "uint8",
-    uint256 = "uint256"
-}
-declare const SOLIDITY_TYPE_MAXIMA: {
-    uint8: JSBI;
-    uint256: JSBI;
-};
 declare const WETH9: {
-    1: Token;
-    4: Token;
-    5: Token;
+    1: ERC20Token;
+    5: ERC20Token;
 };
 declare const WBNB: {
-    1: Token;
-    56: Token;
-    97: Token;
+    1: ERC20Token;
+    56: ERC20Token;
+    97: ERC20Token;
 };
-declare const WNATIVE: Record<number, Token>;
+declare const WNATIVE: Record<number, ERC20Token>;
 declare const NATIVE: Record<number, {
     name: string;
     symbol: string;
     decimals: number;
 }>;
 
-/**
- * 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 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 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;
-}
-
-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 const computePairAddress: ({ factoryAddress, tokenA, tokenB, }: {
     factoryAddress: string;
-    tokenA: Token;
-    tokenB: Token;
+    tokenA: ERC20Token;
+    tokenB: ERC20Token;
 }) => string;
 declare class Pair {
-    readonly liquidityToken: Token;
+    readonly liquidityToken: ERC20Token;
     private readonly tokenAmounts;
-    static getAddress(tokenA: Token, tokenB: Token): string;
-    constructor(currencyAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>);
+    static getAddress(tokenA: ERC20Token, tokenB: ERC20Token): string;
+    constructor(currencyAmountA: CurrencyAmount<ERC20Token>, tokenAmountB: CurrencyAmount<ERC20Token>);
     /**
      * Returns true if the token is either token0 or token1
      * @param token to check
      */
-    involvesToken(token: Token): boolean;
+    involvesToken(token: ERC20Token): boolean;
     /**
      * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
      */
-    get token0Price(): Price<Token, Token>;
+    get token0Price(): Price<ERC20Token, ERC20Token>;
     /**
      * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
      */
-    get token1Price(): Price<Token, Token>;
+    get token1Price(): Price<ERC20Token, ERC20Token>;
     /**
      * Return the price of the given token in terms of the other token in the pair.
      * @param token token to return price of
      */
-    priceOf(token: Token): Price<Token, Token>;
+    priceOf(token: ERC20Token): Price<ERC20Token, ERC20Token>;
     /**
      * Returns the chain ID of the tokens in the pair.
      */
     get chainId(): number;
-    get token0(): Token;
-    get token1(): Token;
-    get reserve0(): CurrencyAmount<Token>;
-    get reserve1(): CurrencyAmount<Token>;
-    reserveOf(token: Token): CurrencyAmount<Token>;
-    getOutputAmount(inputAmount: CurrencyAmount<Token>): [CurrencyAmount<Token>, Pair];
-    getInputAmount(outputAmount: CurrencyAmount<Token>): [CurrencyAmount<Token>, Pair];
-    getLiquidityMinted(totalSupply: CurrencyAmount<Token>, tokenAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>): CurrencyAmount<Token>;
-    getLiquidityValue(token: Token, totalSupply: CurrencyAmount<Token>, liquidity: CurrencyAmount<Token>, feeOn?: boolean, kLast?: BigintIsh): CurrencyAmount<Token>;
+    get token0(): ERC20Token;
+    get token1(): ERC20Token;
+    get reserve0(): CurrencyAmount<ERC20Token>;
+    get reserve1(): CurrencyAmount<ERC20Token>;
+    reserveOf(token: ERC20Token): CurrencyAmount<ERC20Token>;
+    getOutputAmount(inputAmount: CurrencyAmount<ERC20Token>): [CurrencyAmount<ERC20Token>, Pair];
+    getInputAmount(outputAmount: CurrencyAmount<ERC20Token>): [CurrencyAmount<ERC20Token>, Pair];
+    getLiquidityMinted(totalSupply: CurrencyAmount<ERC20Token>, tokenAmountA: CurrencyAmount<ERC20Token>, tokenAmountB: CurrencyAmount<ERC20Token>): CurrencyAmount<ERC20Token>;
+    getLiquidityValue(token: ERC20Token, totalSupply: CurrencyAmount<ERC20Token>, liquidity: CurrencyAmount<ERC20Token>, feeOn?: boolean, kLast?: BigintIsh): CurrencyAmount<ERC20Token>;
 }
 
 declare class Route<TInput extends Currency, TOutput extends Currency> {
@@ -504,12 +266,4 @@ declare abstract class Router {
     static swapCallParameters(trade: Trade<Currency, Currency, TradeType>, options: TradeOptions | TradeOptionsDeadline): SwapParameters;
 }
 
-/**
- * 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, BestTradeOptions, BigintIsh, ChainId, Currency, CurrencyAmount, FACTORY_ADDRESS, FACTORY_ADDRESS_MAP, FIVE, Fraction, INIT_CODE_HASH, INIT_CODE_HASH_MAP, InsufficientInputAmountError, InsufficientReservesError, MINIMUM_LIQUIDITY, MaxUint256, NATIVE, Native, NativeCurrency, ONE, Pair, Percent, Price, Rounding, Route, Router, SOLIDITY_TYPE_MAXIMA, SerializedToken, SolidityType, SwapParameters, TEN, THREE, TWO, Token, Trade, TradeOptions, TradeOptionsDeadline, TradeType, WBNB, WETH9, WNATIVE, ZERO, _100, _10000, _9975, computePairAddress, computePriceImpact, inputOutputComparator, tradeComparator };
+export { BestTradeOptions, ChainId, ERC20Token, FACTORY_ADDRESS, FACTORY_ADDRESS_MAP, INIT_CODE_HASH, INIT_CODE_HASH_MAP, NATIVE, Native, Pair, Route, Router, SwapParameters, Trade, TradeOptions, TradeOptionsDeadline, WBNB, WETH9, WNATIVE, computePairAddress, inputOutputComparator, tradeComparator };