@qidao/sdk 5.0.0-canary.117

package/LICENSE

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

package/README.md

@@ -0,0 +1,53 @@
+# Sushiswap SDK
+
+In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).
+
+This modifies uniswap-sdk's UniswapV2Factory address. The new address for sushiswap is  `0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac`.
+
+## Running tests
+
+To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.
+
+First clone the repository:
+
+```sh
+git clone https://github.com/sushiswap/sushiswap-sdk.git
+```
+
+Move into the sushiswap-sdk working directory
+
+```sh
+cd sushiswap-sdk/
+```
+
+Install dependencies
+
+```sh
+yarn install
+```
+
+Run tests
+
+```sh
+yarn test
+```
+
+You should see output like the following:
+
+```sh
+yarn run v1.22.4
+$ tsdx test
+ PASS  test/constants.test.ts
+ PASS  test/pair.test.ts
+ PASS  test/fraction.test.ts
+ PASS  test/miscellaneous.test.ts
+ PASS  test/entities.test.ts
+ PASS  test/trade.test.ts
+
+Test Suites: 1 skipped, 6 passed, 6 of 7 total
+Tests:       3 skipped, 82 passed, 85 total
+Snapshots:   0 total
+Time:        5.091s
+Ran all test suites.
+✨  Done in 6.61s.
+```

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/Fraction.d.ts

@@ -0,0 +1,25 @@
+import { BigintIsh } from '../types';
+import JSBI from 'jsbi';
+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;
+    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;
+}

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;
+}