@qidao/sdk 5.1.1 → 5.1.2

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

@@ -1,33 +0,0 @@
-import { AbstractCurrency } from './AbstractCurrency';
-import { ChainId } from '../enums';
-import { Currency } from './Currency';
-/**
- * Represents an ERC20 token with a unique address and some metadata.
- */
-export declare class Token extends AbstractCurrency {
-    readonly chainId: ChainId;
-    readonly address: string;
-    readonly isNative: false;
-    readonly isToken: true;
-    constructor(chainId: ChainId, address: string, decimals: number, symbol?: string, name?: 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;
-}
-/**
- * Compares two currencies for equality
- */
-export declare function currencyEquals(currencyA: Currency, currencyB: Currency): boolean;

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

@@ -1,16 +0,0 @@
-/**
- * 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.
- */
-export 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.
- */
-export declare class InsufficientInputAmountError extends Error {
-    readonly isInsufficientInputAmountError: true;
-    constructor();
-}

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;

package/dist/functions/computeConstantProductPoolAddress.d.ts

@@ -1,9 +0,0 @@
-import { Fee } from '../enums';
-import { Token } from '../entities';
-export declare const computeConstantProductPoolAddress: ({ factoryAddress, tokenA, tokenB, fee, twap }: {
-    factoryAddress: string;
-    tokenA: Token;
-    tokenB: Token;
-    fee: Fee;
-    twap: boolean;
-}) => string;

package/dist/functions/computePairAddress.d.ts

@@ -1,6 +0,0 @@
-import { Token } from '../entities';
-export declare const computePairAddress: ({ factoryAddress, tokenA, tokenB }: {
-    factoryAddress: string;
-    tokenA: Token;
-    tokenB: Token;
-}) => string;

package/dist/functions/computePoolInitCodeHash.d.ts

@@ -1,5 +0,0 @@
-export declare const computePoolInitCodeHash: ({ creationCode, deployData, masterDeployerAddress }: {
-    creationCode: string;
-    deployData: string;
-    masterDeployerAddress: string;
-}) => string;

package/dist/functions/computePriceImpact.d.ts

@@ -1,11 +0,0 @@
-import { Currency } from '../entities/Currency';
-import { CurrencyAmount } from '../entities/CurrencyAmount';
-import { Percent } from '../entities/Percent';
-import { Price } from '../entities/Price';
-/**
- * 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
- */
-export declare function computePriceImpact<TBase extends Currency, TQuote extends Currency>(midPrice: Price<TBase, TQuote>, inputAmount: CurrencyAmount<TBase>, outputAmount: CurrencyAmount<TQuote>): Percent;

package/dist/functions/index.d.ts

@@ -1,8 +0,0 @@
-export { computePairAddress } from './computePairAddress';
-export { computePriceImpact } from './computePriceImpact';
-export { computeConstantProductPoolAddress } from './computeConstantProductPoolAddress';
-export { computePoolInitCodeHash } from './computePoolInitCodeHash';
-export { sortedInsert } from './sortedInsert';
-export { sqrt } from './sqrt';
-export { validateAndParseAddress } from './validateAndParseAddress';
-export { validateSolidityTypeInstance } from './validateSolidityTypeInstance';

package/dist/functions/kashi.d.ts

@@ -1,9 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber';
-export declare function accrue(pair: any, amount: BigNumber, includePrincipal?: boolean): BigNumber;
-export declare function accrueTotalAssetWithFee(pair: any): {
-    elastic: BigNumber;
-    base: BigNumber;
-};
-export declare function interestAccrue(pair: any, interest: BigNumber): BigNumber;
-export declare function takeFee(amount: BigNumber): BigNumber;
-export declare function addBorrowFee(amount: BigNumber): BigNumber;

package/dist/functions/rebase.d.ts

@@ -1,4 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber';
-import { Rebase } from '../interfaces';
-export declare function rebase(value: BigNumber, from: BigNumber, to: BigNumber): BigNumber;
-export declare function toElastic(total: Rebase, base: BigNumber, roundUp: boolean): BigNumber;

package/dist/functions/sortedInsert.d.ts

@@ -1 +0,0 @@
-export declare function sortedInsert<T>(items: T[], add: T, maxSize: number, comparator: (a: T, b: T) => number): T | null;

package/dist/functions/sqrt.d.ts

@@ -1,7 +0,0 @@
-import JSBI from 'jsbi';
-export declare const MAX_SAFE_INTEGER: JSBI;
-/**
- * Computes floor(sqrt(value))
- * @param value the value for which to compute the square root, rounded down
- */
-export declare function sqrt(value: JSBI): JSBI;

package/dist/functions/validateAndParseAddress.d.ts

@@ -1 +0,0 @@
-export declare function validateAndParseAddress(address: string): string;

package/dist/functions/validateSolidityTypeInstance.d.ts

@@ -1,3 +0,0 @@
-import { SolidityType } from '../constants';
-import JSBI from 'jsbi';
-export declare function validateSolidityTypeInstance(value: JSBI, solidityType: SolidityType): void;

package/dist/index.d.ts

@@ -1,12 +0,0 @@
-import JSBI from 'jsbi';
-export { JSBI };
-export * from './constants';
-export * from './errors';
-export * from './entities';
-export * from './functions';
-export * from './router';
-export * from './enums';
-export * from './router';
-export * from './types';
-export * from './utils/MultiRouterMath';
-export * from './limitorder';

package/dist/interfaces/AccrueInfo.d.ts

@@ -1,6 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber';
-export interface AccrueInfo {
-    interestPerSecond: BigNumber;
-    lastAccrued: BigNumber;
-    feesEarnedFraction: BigNumber;
-}

package/dist/interfaces/Rebase.d.ts

@@ -1,5 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber';
-export interface Rebase {
-    base: BigNumber;
-    elastic: BigNumber;
-}

package/dist/interfaces/index.d.ts

@@ -1,2 +0,0 @@
-export { AccrueInfo } from './AccrueInfo';
-export { Rebase } from './Rebase';

package/dist/limitorder.d.ts

@@ -1,115 +0,0 @@
-import { CurrencyAmount, Price, Token } from './entities';
-import { Message } from './entities';
-import { BigNumber } from '@ethersproject/bignumber';
-import { ChainId } from './enums';
-import { NonceManager } from '@ethersproject/experimental';
-import { Signer } from '@ethersproject/abstract-signer';
-import { Transaction } from '@ethersproject/transactions';
-import { Web3Provider } from '@ethersproject/providers';
-export interface ILimitOrderData {
-    maker: string;
-    tokenIn: string;
-    tokenOut: string;
-    tokenInDecimals: number;
-    tokenOutDecimals: number;
-    tokenInSymbol: string;
-    tokenOutSymbol: string;
-    amountIn: string;
-    amountOut: string;
-    recipient: string;
-    startTime: string | number;
-    endTime: string | number;
-    stopPrice?: string;
-    oracleAddress?: string;
-    oracleData?: string;
-    v: number;
-    r: string;
-    s: string;
-    chainId: ChainId;
-    orderTypeHash?: string;
-}
-export declare class LimitOrder {
-    readonly maker: string;
-    readonly amountIn: CurrencyAmount<Token>;
-    readonly amountOut: CurrencyAmount<Token>;
-    readonly recipient: string;
-    readonly startTime: string;
-    readonly endTime: string;
-    readonly stopPrice: string;
-    readonly oracleAddress: string;
-    readonly oracleData: string;
-    v: number;
-    r: string;
-    s: string;
-    static getLimitOrder(data: ILimitOrderData): LimitOrder;
-    constructor(maker: string, amountIn: CurrencyAmount<Token>, amountOut: CurrencyAmount<Token>, recipient: string, startTime: string | number, endTime: string | number, stopPrice?: string, oracleAddress?: string, oracleData?: string, v?: number, r?: string, s?: string);
-    get amountInRaw(): string;
-    get amountOutRaw(): string;
-    get tokenInAddress(): string;
-    get tokenOutAddress(): string;
-    get tokenInDecimals(): number;
-    get tokenOutDecimals(): number;
-    get tokenInSymbol(): string;
-    get tokenOutSymbol(): string;
-    get chainId(): ChainId;
-    usePrice(price: Price<Token, Token>): LimitOrder;
-    signdOrderWithPrivatekey(chainId: ChainId, privateKey: string): {
-        v: number;
-        r: string;
-        s: string;
-    };
-    signOrderWithProvider(chainId: ChainId, provider: Web3Provider): Promise<{
-        v: number;
-        r: string;
-        s: string;
-    }>;
-    getTypedData(): {
-        types: {
-            EIP712Domain: {
-                name: string;
-                type: string;
-            }[];
-            LimitOrder: {
-                name: string;
-                type: string;
-            }[];
-        };
-        primaryType: string;
-        domain: import("./entities").Domain;
-        message: Message;
-    };
-    getTypeHash(): string;
-    send(): Promise<any>;
-}
-export declare class FillLimitOrder {
-    readonly order: LimitOrder;
-    readonly path: string[];
-    readonly amountExternal: BigNumber;
-    readonly amountToFill: BigNumber;
-    readonly limitOrderReceiver: string;
-    readonly to: string;
-    readonly tokenIn: string;
-    readonly tokenOut: string;
-    readonly limitOrderReceiverData: string;
-    constructor(order: LimitOrder, path: string[], amountExternal: BigNumber, amountToFill: BigNumber, limitOrderReceiver: string, to: string, keepTokenIn?: boolean);
-    fillOrderOpen(signer: Signer, extra: {
-        forceExecution?: boolean;
-        gasPrice?: BigNumber;
-        nonce?: number;
-        debug?: boolean;
-        open?: boolean;
-    }): Promise<{
-        executed: boolean;
-        transaction?: Transaction | undefined;
-    }>;
-    fillOrder(signer: Signer | NonceManager, extra: {
-        debug?: boolean;
-        forceExecution?: boolean;
-        gasPrice?: BigNumber;
-        open?: boolean;
-        nonce?: number;
-    }): Promise<{
-        executed: boolean;
-        transaction?: Transaction;
-    }>;
-}