@qidao/sdk 5.0.6 → 5.0.9

package/dist/constants/addresses.d.ts

@@ -0,0 +1,31 @@
+import { AddressMap } from '../types';
+export declare const USDC_ADDRESS: AddressMap;
+export declare const USD_ADDRESS: AddressMap;
+export declare const FACTORY_ADDRESS: AddressMap;
+export declare const ROUTER_ADDRESS: AddressMap;
+export declare const SUSHI_ADDRESS: AddressMap;
+export declare const MASTERCHEF_ADDRESS: AddressMap;
+export declare const BAR_ADDRESS: AddressMap;
+export declare const MAKER_ADDRESS: AddressMap;
+export declare const TIMELOCK_ADDRESS: AddressMap;
+export declare const BENTOBOX_ADDRESS: AddressMap;
+export declare const KASHI_ADDRESS: AddressMap;
+export declare const SUSHISWAP_SWAPPER_ADDRESS: AddressMap;
+export declare const SUSHISWAP_MULTISWAPPER_ADDRESS: AddressMap;
+export declare const SUSHISWAP_MULTI_EXACT_SWAPPER_ADDRESS: AddressMap;
+export declare const PEGGED_ORACLE_ADDRESS = "0x6cbfbB38498Df0E1e7A4506593cDB02db9001564";
+export declare const SUSHISWAP_TWAP_0_ORACLE_ADDRESS = "0x66F03B0d30838A3fee971928627ea6F59B236065";
+export declare const SUSHISWAP_TWAP_1_ORACLE_ADDRESS = "0x0D51b575591F8f74a2763Ade75D3CDCf6789266f";
+export declare const CHAINLINK_ORACLE_ADDRESS: AddressMap;
+export declare const BORING_HELPER_ADDRESS: AddressMap;
+export declare const STOP_LIMIT_ORDER_ADDRESS: AddressMap;
+export declare const ARCHER_ROUTER_ADDRESS: AddressMap;
+export declare const MINICHEF_ADDRESS: AddressMap;
+export declare const OLD_FARMS: AddressMap;
+export declare const WETH9_ADDRESS: AddressMap;
+export declare const WNATIVE_ADDRESS: AddressMap;
+export declare const MASTERCHEF_V2_ADDRESS: AddressMap;
+export declare const ENS_REGISTRAR_ADDRESS: AddressMap;
+export declare const ZAPPER_ADDRESS: AddressMap;
+export declare const MERKLE_DISTRIBUTOR_ADDRESS: AddressMap;
+export declare const MULTICALL2_ADDRESS: AddressMap;

package/dist/constants/index.d.ts

@@ -0,0 +1,20 @@
+import JSBI from 'jsbi';
+export * from './addresses';
+export * from './kashi';
+export * from './natives';
+export * from './numbers';
+export * from './tokens';
+export declare const INIT_CODE_HASH: {
+    [chainId: number]: string;
+};
+export declare const MINIMUM_LIQUIDITY: JSBI;
+export declare enum SolidityType {
+    uint8 = "uint8",
+    uint256 = "uint256"
+}
+export declare const SOLIDITY_TYPE_MAXIMA: {
+    uint8: JSBI;
+    uint256: JSBI;
+};
+export declare const LAMBDA_URL = "https://9epjsvomc4.execute-api.us-east-1.amazonaws.com/dev";
+export declare const SOCKET_URL = "wss://hfimt374ge.execute-api.us-east-1.amazonaws.com/dev";

package/dist/constants/kashi.d.ts

@@ -0,0 +1,29 @@
+import { BigNumber } from '@ethersproject/bignumber';
+export declare const ACTION_ADD_ASSET = 1;
+export declare const ACTION_REPAY = 2;
+export declare const ACTION_REMOVE_ASSET = 3;
+export declare const ACTION_REMOVE_COLLATERAL = 4;
+export declare const ACTION_BORROW = 5;
+export declare const ACTION_GET_REPAY_SHARE = 6;
+export declare const ACTION_GET_REPAY_PART = 7;
+export declare const ACTION_ACCRUE = 8;
+export declare const ACTION_ADD_COLLATERAL = 10;
+export declare const ACTION_UPDATE_EXCHANGE_RATE = 11;
+export declare const ACTION_BENTO_DEPOSIT = 20;
+export declare const ACTION_BENTO_WITHDRAW = 21;
+export declare const ACTION_BENTO_TRANSFER = 22;
+export declare const ACTION_BENTO_TRANSFER_MULTIPLE = 23;
+export declare const ACTION_BENTO_SETAPPROVAL = 24;
+export declare const ACTION_CALL = 30;
+export declare const MINIMUM_TARGET_UTILIZATION: BigNumber;
+export declare const MAXIMUM_TARGET_UTILIZATION: BigNumber;
+export declare const UTILIZATION_PRECISION: BigNumber;
+export declare const FULL_UTILIZATION: BigNumber;
+export declare const FULL_UTILIZATION_MINUS_MAX: BigNumber;
+export declare const STARTING_INTEREST_PER_YEAR: BigNumber;
+export declare const MINIMUM_INTEREST_PER_YEAR: BigNumber;
+export declare const MAXIMUM_INTEREST_PER_YEAR: BigNumber;
+export declare const INTEREST_ELASTICITY: BigNumber;
+export declare const FACTOR_PRECISION: BigNumber;
+export declare const PROTOCOL_FEE: BigNumber;
+export declare const PROTOCOL_FEE_DIVISOR: BigNumber;

package/dist/constants/natives.d.ts

@@ -0,0 +1,30 @@
+import { Avalanche, Binance, Celo, Ether, Fantom, Fuse, Harmony, Heco, Matic, Movr, Okex, Palm, xDai, Telos } from '../entities/Native';
+import { ChainId } from '../enums';
+export declare const NATIVE: {
+    1: Ether;
+    3: Ether;
+    4: Ether;
+    5: Ether;
+    42: Ether;
+    250: Fantom;
+    4002: Fantom;
+    137: Matic;
+    80001: Matic;
+    100: xDai;
+    56: Binance;
+    97: Binance;
+    42161: Ether;
+    43114: Avalanche;
+    43113: Avalanche;
+    128: Heco;
+    256: Heco;
+    1666600000: Harmony;
+    1666700000: Harmony;
+    66: Okex;
+    65: Okex;
+    42220: Celo;
+    11297108109: Palm;
+    1285: Movr;
+    122: Fuse;
+    40: Telos;
+};

package/dist/constants/numbers.d.ts

@@ -0,0 +1,11 @@
+import JSBI from 'jsbi';
+export declare const MaxUint256: JSBI;
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const TWO: JSBI;
+export declare const THREE: JSBI;
+export declare const FIVE: JSBI;
+export declare const TEN: JSBI;
+export declare const _100: JSBI;
+export declare const _997: JSBI;
+export declare const _1000: JSBI;

package/dist/constants/tokens.d.ts

@@ -0,0 +1,5 @@
+import { TokenMap } from '../types/TokenMap';
+export declare const USDC: TokenMap;
+export declare const USD: TokenMap;
+export declare const WETH9: TokenMap;
+export declare const WNATIVE: TokenMap;

package/dist/entities/AbstractCurrency.d.ts

@@ -0,0 +1,53 @@
+import { Currency } from './Currency';
+import { Token } from './Token';
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export declare abstract class AbstractCurrency {
+    /**
+     * 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 Uniswap 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 Uniswap contracts. Currencies must
+     * implement this to be used in Uniswap
+     */
+    abstract get wrapped(): Token;
+    /**
+     * Returns token address. Useful in cases where a dependency is needed to detect changes (e.g. useEffect).
+     */
+    serialize(): string;
+}

package/dist/entities/ConstantProductPool.d.ts

@@ -0,0 +1,43 @@
+import { CurrencyAmount } from './CurrencyAmount';
+import { Fee } from '../enums';
+import { Price } from './Price';
+import { Token } from './Token';
+export declare class ConstantProductPool {
+    readonly liquidityToken: Token;
+    readonly fee: Fee;
+    readonly twap: boolean;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token, fee?: Fee, twap?: boolean): string;
+    constructor(currencyAmountA: CurrencyAmount<Token>, currencyAmountB: CurrencyAmount<Token>, fee?: Fee, twap?: boolean);
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token to check
+     */
+    involvesToken(token: Token): 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>, ConstantProductPool];
+    getInputAmount(outputAmount: CurrencyAmount<Token>): [CurrencyAmount<Token>, ConstantProductPool];
+    getLiquidityMinted(totalSupply: CurrencyAmount<Token>, tokenAmountA: CurrencyAmount<Token>, tokenAmountB: CurrencyAmount<Token>): CurrencyAmount<Token>;
+    getLiquidityValue(token: Token, totalSupply: CurrencyAmount<Token>, liquidity: CurrencyAmount<Token>): CurrencyAmount<Token>;
+}

package/dist/entities/Currency.d.ts

@@ -0,0 +1,3 @@
+import { NativeCurrency } from './NativeCurrency';
+import { Token } from './Token';
+export declare type Currency = NativeCurrency | Token;

package/dist/entities/CurrencyAmount.d.ts

@@ -0,0 +1,38 @@
+import { BigintIsh } from '../types';
+import { Currency } from './Currency';
+import { Fraction } from './Fraction';
+import JSBI from 'jsbi';
+import { Rounding } from '../enums';
+import { Token } from './Token';
+export 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>;
+    /**
+     * Returns a string representation of the address and currency amount.
+     * Useful in cases where a dependency is needed to detect changes (e.g. useEffect).
+     * @return string [0x6B3595068778DD592e39A122f4f5a5cF09C90fE2 - 1323.94]
+     */
+    serialize(): string;
+}

package/dist/entities/{fractions/fraction.d.ts → Fraction.d.ts}

@@ -1,9 +1,11 @@
+import { BigintIsh } from '../types';
 import JSBI from 'jsbi';
-import { BigintIsh, Rounding } from '../../constants';
+import { Rounding } from '../enums';
 export 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;
@@ -16,4 +18,8 @@ export declare class 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;
 }

package/dist/entities/MultiRouter.d.ts

@@ -0,0 +1,59 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { Pool, RToken, RouteLeg, MultiRoute } from '../types/MultiRouterTypes';
+export declare class Edge {
+    readonly GasConsumption = 40000;
+    readonly MINIMUM_LIQUIDITY = 1000;
+    pool: Pool;
+    vert0: Vertice;
+    vert1: Vertice;
+    canBeUsed: boolean;
+    direction: boolean;
+    amountInPrevious: number;
+    amountOutPrevious: number;
+    bestEdgeIncome: number;
+    constructor(p: Pool, v0: Vertice, v1: Vertice);
+    reserve(v: Vertice): BigNumber;
+    calcOutput(v: Vertice, amountIn: number): number[];
+    checkMinimalLiquidityExceededAfterSwap(from: Vertice, amountOut: number): boolean;
+    testApply(from: Vertice, amountIn: number, amountOut: number): boolean;
+    applySwap(from: Vertice): void;
+}
+export declare class Vertice {
+    token: RToken;
+    edges: Edge[];
+    price: number;
+    gasPrice: number;
+    bestIncome: number;
+    gasSpent: number;
+    bestTotal: number;
+    bestSource?: Edge;
+    checkLine: number;
+    constructor(t: RToken);
+    getNeibour(e?: Edge): Vertice | undefined;
+}
+export declare class Graph {
+    vertices: Vertice[];
+    edges: Edge[];
+    tokens: Map<RToken, Vertice>;
+    constructor(pools: Pool[], baseToken: RToken, gasPrice: number);
+    setPrices(from: Vertice, price: number, gasPrice: number): void;
+    getOrCreateVertice(token: RToken): Vertice;
+    findBestPath(from: RToken, to: RToken, amountIn: number): {
+        path: Edge[];
+        output: number;
+        gasSpent: number;
+        totalOutput: number;
+    } | undefined;
+    addPath(from: Vertice | undefined, to: Vertice | undefined, path: Edge[]): void;
+    findBestRoute(from: RToken, to: RToken, amountIn: number, mode: number | number[]): MultiRoute;
+    getRouteLegs(from: Vertice, to: Vertice): [RouteLeg[], number, boolean];
+    edgeFrom(e: Edge): [Vertice, number] | undefined;
+    getOutputEdges(v: Vertice): Edge[];
+    getInputEdges(v: Vertice): Edge[];
+    calcLegsAmountOut(legs: RouteLeg[], amountIn: number, to: RToken): number;
+    cleanTopology(from: Vertice, to: Vertice): [Vertice[], boolean];
+    removeDeadEnds(verts: Vertice[]): void;
+    removeWeakestEdge(verts: Vertice[]): void;
+    topologySort(from: Vertice, to: Vertice): [number, Vertice[]];
+}
+export declare function findMultiRouting(from: RToken, to: RToken, amountIn: number, pools: Pool[], baseToken: RToken, gasPrice: number, steps?: number | number[]): MultiRoute;

package/dist/entities/Native/Avalanche.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Avalanche extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Avalanche;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Binance.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Binance extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Binance;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Celo.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Celo extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Celo;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Ether.d.ts

@@ -0,0 +1,13 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+/**
+ * Ether is the main usage of a 'native' currency, i.e. for Ethereum mainnet and all testnets
+ */
+export declare class Ether extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _etherCache;
+    static onChain(chainId: number): Ether;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Fantom.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Fantom extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Fantom;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Fuse.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Fuse extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Fuse;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Harmony.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Harmony extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Harmony;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Heco.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Heco extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Heco;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Matic.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Matic extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Matic;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Movr.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Movr extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Movr;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Okex.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Okex extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Okex;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Palm.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Palm extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Palm;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/Telos.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class Telos extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): Telos;
+    equals(other: Currency): boolean;
+}

package/dist/entities/Native/index.d.ts

@@ -0,0 +1,14 @@
+export { Avalanche } from './Avalanche';
+export { Binance } from './Binance';
+export { Celo } from './Celo';
+export { Ether } from './Ether';
+export { Fantom } from './Fantom';
+export { Harmony } from './Harmony';
+export { Heco } from './Heco';
+export { Matic } from './Matic';
+export { Movr } from './Movr';
+export { Okex } from './Okex';
+export { xDai } from './xDai';
+export { Palm } from './Palm';
+export { Fuse } from './Fuse';
+export { Telos } from './Telos';

package/dist/entities/Native/xDai.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '../Currency';
+import { NativeCurrency } from '../NativeCurrency';
+import { Token } from '../Token';
+export declare class xDai extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _cache;
+    static onChain(chainId: number): xDai;
+    equals(other: Currency): boolean;
+}

package/dist/entities/NativeCurrency.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCurrency } from './AbstractCurrency';
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+export declare abstract class NativeCurrency extends AbstractCurrency {
+    readonly isNative: true;
+    readonly isToken: false;
+}

package/dist/entities/Pair.d.ts

@@ -0,0 +1,41 @@
+import { BigintIsh } from '../types';
+import { CurrencyAmount } from './CurrencyAmount';
+import { Price } from './Price';
+import { Token } from './Token';
+export declare class Pair {
+    readonly liquidityToken: Token;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token): string;
+    constructor(currencyAmountA: CurrencyAmount<Token>, currencyAmountB: CurrencyAmount<Token>);
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token to check
+     */
+    involvesToken(token: Token): 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+}

package/dist/entities/Percent.d.ts

@@ -0,0 +1,15 @@
+import { BigintIsh } from '../types';
+import { Fraction } from './Fraction';
+import { Rounding } from '../enums';
+export 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;
+}

package/dist/entities/Price.d.ts

@@ -0,0 +1,39 @@
+import { BigintIsh } from '../types';
+import { Currency } from './Currency';
+import { CurrencyAmount } from './CurrencyAmount';
+import { Fraction } from './Fraction';
+import { Rounding } from '../enums';
+export 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;
+}