@qidao/sdk 5.0.10 → 5.1.2

package/dist/entities/MultiRouter.d.ts

@@ -1,59 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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;
-}

package/dist/entities/Route.d.ts

@@ -1,14 +0,0 @@
-import { Currency } from './Currency';
-import { Pair } from './Pair';
-import { Price } from './Price';
-import { Token } from './Token';
-export declare class Route<TInput extends Currency, TOutput extends Currency> {
-    readonly pairs: Pair[];
-    readonly path: Token[];
-    readonly input: TInput;
-    readonly output: TOutput;
-    constructor(pairs: Pair[], input: TInput, output: TOutput);
-    private _midPrice;
-    get midPrice(): Price<TInput, TOutput>;
-    get chainId(): number;
-}

package/dist/entities/Trade.d.ts

@@ -1,107 +0,0 @@
-import { Currency } from './Currency';
-import { CurrencyAmount } from './CurrencyAmount';
-import { Pair } from './Pair';
-import { Percent } from './Percent';
-import { Price } from './Price';
-import { Route } from './Route';
-import { TradeType } from '../enums';
-interface InputOutput<TInput extends Currency, TOutput extends Currency> {
-    readonly inputAmount: CurrencyAmount<TInput>;
-    readonly outputAmount: CurrencyAmount<TOutput>;
-}
-export declare function inputOutputComparator<TInput extends Currency, TOutput extends Currency>(a: InputOutput<TInput, TOutput>, b: InputOutput<TInput, TOutput>): number;
-export declare function tradeComparator<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(a: Trade<TInput, TOutput, TTradeType>, b: Trade<TInput, TOutput, TTradeType>): number;
-export interface BestTradeOptions {
-    maxNumResults?: number;
-    maxHops?: number;
-}
-/**
- * Represents a trade executed against a list of pairs.
- * Does not account for slippage, i.e. trades that front run this trade and move the price.
- */
-export declare class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
-    /**
-     * The route of the trade, i.e. which pairs the trade goes through and the input/output currencies.
-     */
-    readonly route: Route<TInput, TOutput>;
-    /**
-     * The type of the trade, either exact in or exact out.
-     */
-    readonly tradeType: TTradeType;
-    /**
-     * The input amount for the trade assuming no slippage.
-     */
-    readonly inputAmount: CurrencyAmount<TInput>;
-    /**
-     * The output amount for the trade assuming no slippage.
-     */
-    readonly outputAmount: CurrencyAmount<TOutput>;
-    /**
-     * The price expressed in terms of output amount/input amount.
-     */
-    readonly executionPrice: Price<TInput, TOutput>;
-    /**
-     * The percent difference between the mid price before the trade and the trade execution price.
-     */
-    readonly priceImpact: Percent;
-    /**
-     * Constructs an exact in trade with the given amount in and route
-     * @param route route of the exact in trade
-     * @param amountIn the amount being passed in
-     */
-    static exactIn<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountIn: CurrencyAmount<TInput>): Trade<TInput, TOutput, TradeType.EXACT_INPUT>;
-    /**
-     * Constructs an exact out trade with the given amount out and route
-     * @param route route of the exact out trade
-     * @param amountOut the amount returned by the trade
-     */
-    static exactOut<TInput extends Currency, TOutput extends Currency>(route: Route<TInput, TOutput>, amountOut: CurrencyAmount<TOutput>): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>;
-    constructor(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType);
-    /**
-     * Get the minimum amount that must be received from this trade for the given slippage tolerance
-     * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
-     */
-    minimumAmountOut(slippageTolerance: Percent): CurrencyAmount<TOutput>;
-    /**
-     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
-     * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
-     */
-    maximumAmountIn(slippageTolerance: Percent): CurrencyAmount<TInput>;
-    /**
-     * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
-     * amount to an output token, making at most `maxHops` hops.
-     * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
-     * the amount in among multiple routes.
-     * @param pairs the pairs to consider in finding the best trade
-     * @param nextAmountIn exact amount of input currency to spend
-     * @param currencyOut the desired currency out
-     * @param maxNumResults maximum number of results to return
-     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
-     * @param currentPairs used in recursion; the current list of pairs
-     * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
-     * @param bestTrades used in recursion; the current list of best trades
-     */
-    static bestTradeExactIn<TInput extends Currency, TOutput extends Currency>(pairs: Pair[], currencyAmountIn: CurrencyAmount<TInput>, currencyOut: TOutput, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], nextAmountIn?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]): Trade<TInput, TOutput, TradeType.EXACT_INPUT>[];
-    /**
-     * Return the execution price after accounting for slippage tolerance
-     * @param slippageTolerance the allowed tolerated slippage
-     */
-    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
-    /**
-     * similar to the above method but instead targets a fixed output amount
-     * given a list of pairs, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
-     * to an output token amount, making at most `maxHops` hops
-     * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
-     * the amount in among multiple routes.
-     * @param pairs the pairs to consider in finding the best trade
-     * @param currencyIn the currency to spend
-     * @param nextAmountOut the exact amount of currency out
-     * @param maxNumResults maximum number of results to return
-     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
-     * @param currentPairs used in recursion; the current list of pairs
-     * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter
-     * @param bestTrades used in recursion; the current list of best trades
-     */
-    static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(pairs: Pair[], currencyIn: TInput, currencyAmountOut: CurrencyAmount<TOutput>, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], nextAmountOut?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]): Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[];
-}
-export {};

package/dist/entities/eip712.d.ts

@@ -1,78 +0,0 @@
-import { ChainId } from '../enums';
-import { Web3Provider } from '@ethersproject/providers';
-export interface Domain {
-    name: string;
-    chainId: ChainId;
-    verifyingContract: string;
-}
-export interface Message {
-    maker: string;
-    tokenIn: string;
-    tokenOut: string;
-    amountIn: string;
-    amountOut: string;
-    recipient: string;
-    startTime: string;
-    endTime: string;
-    stopPrice: string;
-    oracleAddress: string;
-    oracleData: string;
-}
-export interface BentoApprovalMessage {
-    warning: string;
-    user: string;
-    masterContract: string;
-    approved: boolean;
-    nonce: number;
-}
-export declare const getSignature: (message: Message, chainId: ChainId, privateKey: string) => {
-    v: number;
-    r: string;
-    s: string;
-};
-export declare const getTypedData: (message: Message, chainId: ChainId) => {
-    types: {
-        EIP712Domain: {
-            name: string;
-            type: string;
-        }[];
-        LimitOrder: {
-            name: string;
-            type: string;
-        }[];
-    };
-    primaryType: string;
-    domain: Domain;
-    message: Message;
-};
-export declare const getTypedDataBento: (message: BentoApprovalMessage, chainId: ChainId) => {
-    types: {
-        EIP712Domain: {
-            name: string;
-            type: string;
-        }[];
-        SetMasterContractApproval: {
-            name: string;
-            type: string;
-        }[];
-    };
-    primaryType: string;
-    domain: Domain;
-    message: BentoApprovalMessage;
-};
-export declare const getTypeHash: (typedData: any) => string;
-export declare const getSignatureWithProvider: (message: Message, chainId: ChainId, provider: Web3Provider) => Promise<{
-    v: number;
-    r: string;
-    s: string;
-}>;
-export declare const getSignatureWithProviderBentobox: (message: BentoApprovalMessage, chainId: ChainId, provider: Web3Provider) => Promise<{
-    v: number;
-    r: string;
-    s: string;
-}>;
-export declare const getSignatureBento: (bentoApproval: BentoApprovalMessage, chainId: ChainId, privateKey: string) => Promise<{
-    v: number;
-    r: string;
-    s: string;
-}>;

package/dist/entities/index.d.ts

@@ -1,14 +0,0 @@
-export * from './AbstractCurrency';
-export * from './Currency';
-export * from './CurrencyAmount';
-export * from './ConstantProductPool';
-export * from './Fraction';
-export * from './NativeCurrency';
-export * from './Pair';
-export * from './Percent';
-export * from './Price';
-export * from './Route';
-export * from './Token';
-export * from './Trade';
-export * from './Native';
-export * from './eip712';

package/dist/enums/ChainId.d.ts

@@ -1,32 +0,0 @@
-export declare enum ChainId {
-    MAINNET = 1,
-    ROPSTEN = 3,
-    RINKEBY = 4,
-    GÖRLI = 5,
-    KOVAN = 42,
-    MATIC = 137,
-    MATIC_TESTNET = 80001,
-    FANTOM = 250,
-    FANTOM_TESTNET = 4002,
-    XDAI = 100,
-    BSC = 56,
-    BSC_TESTNET = 97,
-    ARBITRUM = 42161,
-    ARBITRUM_TESTNET = 79377087078960,
-    MOONBEAM_TESTNET = 1287,
-    MOONBEAM = 1284,
-    AVALANCHE = 43114,
-    AVALANCHE_TESTNET = 43113,
-    HECO = 128,
-    HECO_TESTNET = 256,
-    HARMONY = 1666600000,
-    HARMONY_TESTNET = 1666700000,
-    OKEX = 66,
-    OKEX_TESTNET = 65,
-    CELO = 42220,
-    PALM = 11297108109,
-    PALM_TESTNET = 11297108099,
-    MOONRIVER = 1285,
-    FUSE = 122,
-    TELOS = 40
-}

package/dist/enums/Fee.d.ts

@@ -1,3 +0,0 @@
-export declare enum Fee {
-    DEFAULT = 30
-}

package/dist/enums/KashiAction.d.ts

@@ -1,18 +0,0 @@
-export declare enum KashiAction {
-    ADD_ASSET = 1,
-    REPAY = 2,
-    REMOVE_ASSET = 3,
-    REMOVE_COLLATERAL = 4,
-    BORROW = 5,
-    GET_REPAY_SHARE = 6,
-    GET_REPAY_PART = 7,
-    ACCRUE = 8,
-    ADD_COLLATERAL = 10,
-    UPDATE_EXCHANGE_RATE = 11,
-    BENTO_DEPOSIT = 20,
-    BENTO_WITHDRAW = 21,
-    BENTO_TRANSFER = 22,
-    BENTO_TRANSFER_MULTIPLE = 23,
-    BENTO_SETAPPROVAL = 24,
-    CALL = 30
-}

package/dist/enums/OrderStatus.d.ts

@@ -1,6 +0,0 @@
-export declare enum OrderStatus {
-    FILLED = "FILLED",
-    CANCELLED = "CANCELLED",
-    EXPIRED = "EXPIRED",
-    PENDING = "PENDING"
-}

package/dist/enums/Rounding.d.ts

@@ -1,5 +0,0 @@
-export declare enum Rounding {
-    ROUND_DOWN = 0,
-    ROUND_HALF_UP = 1,
-    ROUND_UP = 2
-}

package/dist/enums/TradeType.d.ts

@@ -1,4 +0,0 @@
-export declare enum TradeType {
-    EXACT_INPUT = 0,
-    EXACT_OUTPUT = 1
-}

package/dist/enums/index.d.ts

@@ -1,6 +0,0 @@
-export { ChainId } from './ChainId';
-export { Rounding } from './Rounding';
-export { TradeType } from './TradeType';
-export { KashiAction } from './KashiAction';
-export { Fee } from './Fee';
-export { OrderStatus } from './OrderStatus';

package/dist/functions/bentobox.d.ts

@@ -1,3 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber';
-export declare function toAmount(token: any, shares: BigNumber): BigNumber;
-export declare function toShare(token: any, amount: BigNumber): BigNumber;