import { AsyncOrSync } from 'ts-essentials';
import { Address, SimpleExchangeParam, AdapterExchangeParam, DexExchangeParam, TxInfo, NumberAsString, Token, ExchangePrices, PoolPrices, PoolLiquidity, OptimalSwapExchange, ExchangeTxInfo, PreprocessTransactionOptions, TransferFeeParams, Config } from '../types';
import { SwapSide, Network } from '../constants';
import { IDexHelper } from '../dex-helper/idex-helper';
import { OptimalRate, OptimalSwap } from '@paraswap/core';
export type Context = {
    isGlobalSrcToken: boolean;
    isGlobalDestToken: boolean;
};
export type NeedWrapNativeFunc = (priceRoute: OptimalRate, swap: OptimalSwap, se: OptimalSwapExchange<any>) => boolean;
export interface IDexTxBuilderV5<ExchangeData, DirectParam = null> {
    getAdapterParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, // required for buy case
    data: ExchangeData, side: SwapSide): AdapterExchangeParam;
    getSimpleParam?(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, data: ExchangeData, side: SwapSide): AsyncOrSync<SimpleExchangeParam>;
    getDirectParam?(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, expectedAmount: NumberAsString, data: ExchangeData, side: SwapSide, permit: string, uuid: string, feePercent: NumberAsString, deadline: NumberAsString, partner: string, beneficiary: string, contractMethod: string): TxInfo<DirectParam>;
}
export interface IDexTxBuilderV6<ExchangeData, DirectParam = null> {
    getDexParam?(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: ExchangeData, side: SwapSide, context: Context, executorAddress: Address): AsyncOrSync<DexExchangeParam>;
    getDirectParamV6?(srcToken: Address, destToken: Address, fromAmount: NumberAsString, toAmount: NumberAsString, quotedAmount: NumberAsString, data: ExchangeData, side: SwapSide, permit: string, uuid: string, partnerAndFee: string, beneficiary: string, blockNumber: number, contractMethod: string): TxInfo<DirectParam>;
}
export interface IDexTxBuilder<ExchangeData, DirectParam = null> extends IDexTxBuilderV5<ExchangeData, DirectParam>, IDexTxBuilderV6<ExchangeData, DirectParam> {
    needWrapNative: boolean | NeedWrapNativeFunc;
    needsSequentialPreprocessing?: boolean;
    getNetworkFee?(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, data: ExchangeData, side: SwapSide): NumberAsString;
    preProcessTransaction?(optimalSwapExchange: OptimalSwapExchange<ExchangeData>, srcToken: Token, destToken: Token, side: SwapSide, options: PreprocessTransactionOptions): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
}
export interface IDexWithBlacklist {
    hasBlacklist(): this is IDexWithBlacklist;
    isBlacklisted(address: string): Promise<boolean>;
    getBlacklistedCacheKey(address: string): string;
}
export interface IDexWithRestriction {
    hasDexRestriction(): this is IDexWithRestriction;
    isRestricted(): Promise<boolean>;
    getRestrictedCacheKey(): string;
}
export interface IDexWithPairRestriction {
    hasPairRestriction(): this is IDexWithPairRestriction;
    isRestrictedPair(token0: string, token1: string): Promise<boolean>;
    getRestrictedPairCacheKey(token0: string, token1: string): string;
}
export interface IDexPricing<ExchangeData> {
    readonly dexKey: string;
    readonly hasConstantPriceLargeAmounts: boolean;
    readonly isFeeOnTransferSupported: boolean;
    readonly cacheStateKey: string;
    readonly isStatePollingDex?: boolean;
    getPoolIdentifiers(srcToken: Token, destToken: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
    getPricesVolume(srcToken: Token, destToken: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams, isFirstSwap?: boolean): Promise<ExchangePrices<ExchangeData> | null>;
    getCalldataGasCost(poolPrices: PoolPrices<ExchangeData>): number | number[];
    initializePricing?(blockNumber: number): AsyncOrSync<void>;
    getAdapters(side: SwapSide): {
        name: string;
        index: number;
    }[] | null;
    releaseResources?(): AsyncOrSync<void>;
    addMasterPool?(poolKey: string, blockNumber: number): AsyncOrSync<boolean>;
    hasDexRestriction?(): this is IDexWithRestriction;
    hasPairRestriction?(): this is IDexWithPairRestriction;
    hasBlacklist?(): this is IDexWithBlacklist;
    minUsdTradeValue?(): number | null;
}
export interface IDexPooltracker {
    updatePoolState?(): AsyncOrSync<void>;
    getTopPoolsForToken(tokenAddress: Address, limit: number): AsyncOrSync<PoolLiquidity[]>;
}
export interface IDex<ExchangeData, DirectParam = null, OptimizedExchangeData = ExchangeData> extends IDexTxBuilder<OptimizedExchangeData, DirectParam>, IDexPricing<ExchangeData>, IDexPooltracker {
}
export interface DexConstructor<ExchangeData, DirectParam = null, OptimizedExchangeData = ExchangeData> {
    new (network: Network, dexKey: string, dexHelper: IDexHelper): IDex<ExchangeData, DirectParam, OptimizedExchangeData>;
    dexKeysWithNetwork?: {
        key: string;
        networks: Network[];
    }[];
    builderDexKeysWithNetwork?(dexHelper: Config): void;
}
export type IRouteOptimizer<T> = (formaterRate: T) => T;