import { Interface } from '@ethersproject/abi';
import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
import { AdapterExchangeParam, Address, ExchangePrices, PoolPrices, Log, Logger, PoolLiquidity, SimpleExchangeParam, Token, TxInfo, TransferFeeParams, DexExchangeParam } from '../../types';
import { UniswapData, UniswapParam, UniswapV2Data, UniswapV2Functions, UniswapV2FunctionsV6, UniswapV2ParamsDirect, UniswapV2PoolOrderedParams } from './types';
import { IDex } from '../idex';
import { Network } from '../../constants';
import { SimpleExchange } from '../simple-exchange';
import { NumberAsString, SwapSide } from '@paraswap/core';
import { IDexHelper } from '../../dex-helper';
import { Contract } from 'web3-eth-contract';
export declare const RESERVE_LIMIT: bigint;
interface UniswapV2PoolState {
    reserves0: string;
    reserves1: string;
    feeCode: number;
}
export declare const directUniswapFunctionName: UniswapV2Functions[];
export declare const directUniswapFunctionNameV6: UniswapV2FunctionsV6[];
export interface UniswapV2Pair {
    token0: Token;
    token1: Token;
    exchange?: Address;
    pool?: UniswapV2EventPool;
    checkExistenceAfter?: number;
}
export declare class UniswapV2EventPool extends StatefulEventSubscriber<UniswapV2PoolState> {
    protected dexHelper: IDexHelper;
    private poolAddress;
    private token0;
    private token1;
    private feeCode;
    private dynamicFees;
    private feesMultiCallEntry?;
    private feesMultiCallDecoder?;
    private iface;
    decoder: (log: Log) => import("@ethersproject/abi").LogDescription;
    constructor(parentName: string, dexHelper: IDexHelper, poolAddress: Address, token0: Token, token1: Token, feeCode: number, logger: Logger, dynamicFees?: boolean, feesMultiCallEntry?: {
        target: Address;
        callData: string;
    } | undefined, feesMultiCallDecoder?: ((values: any[]) => number) | undefined, iface?: Interface);
    protected processLog(state: DeepReadonly<UniswapV2PoolState>, log: Readonly<Log>): AsyncOrSync<DeepReadonly<UniswapV2PoolState> | null>;
    generateState(blockNumber?: number | 'latest'): Promise<DeepReadonly<UniswapV2PoolState>>;
}
export declare class UniswapV2 extends SimpleExchange implements IDex<UniswapV2Data, UniswapParam | UniswapV2ParamsDirect> {
    protected network: Network;
    protected dexHelper: IDexHelper;
    protected isDynamicFees: boolean;
    protected factoryAddress: Address;
    protected subgraphURL: string | undefined;
    protected initCode: string;
    protected feeCode: number;
    protected poolGasCost: number;
    protected decoderIface: Interface;
    protected adapters: {
        [side: string]: {
            name: string;
            index: number;
        }[] | null;
    };
    protected router: string;
    protected subgraphType: 'subgraphs' | 'deployments' | undefined;
    pairs: {
        [key: string]: UniswapV2Pair;
    };
    feeFactor: number;
    factory: Contract;
    pairsHashCacheKey: string;
    private findPairPromises;
    routerInterface: Interface;
    exchangeRouterInterface: Interface;
    needWrapNative: boolean;
    logger: Logger;
    private readonly factoryInst;
    private newlyCreatedPoolKeys;
    static directFunctionName: UniswapV2Functions[];
    static directFunctionNameV6: UniswapV2FunctionsV6[];
    readonly hasConstantPriceLargeAmounts = false;
    readonly isFeeOnTransferSupported: boolean;
    readonly SRC_TOKEN_DEX_TRANSFERS = 1;
    readonly DEST_TOKEN_DEX_TRANSFERS = 1;
    static dexKeysWithNetwork: {
        key: string;
        networks: Network[];
    }[];
    constructor(network: Network, dexKey: string, dexHelper: IDexHelper, isDynamicFees?: boolean, factoryAddress?: Address, subgraphURL?: string | undefined, initCode?: string, feeCode?: number, poolGasCost?: number, decoderIface?: Interface, adapters?: {
        [side: string]: {
            name: string;
            index: number;
        }[] | null;
    }, router?: string, subgraphType?: 'subgraphs' | 'deployments' | undefined);
    initializePricing(blockNumber: number): Promise<void>;
    protected getFeesMultiCallData(pair: UniswapV2Pair): undefined | {
        callEntry: {
            target: Address;
            callData: string;
        };
        callDecoder: (values: any[]) => number;
    };
    protected addPool(pair: UniswapV2Pair, reserves0: string, reserves1: string, feeCode: number, blockNumber: number): Promise<void>;
    getBuyPrice(priceParams: UniswapV2PoolOrderedParams, destAmount: bigint): bigint;
    getSellPrice(priceParams: UniswapV2PoolOrderedParams, srcAmount: bigint): bigint;
    getBuyPricePath(amount: bigint, params: UniswapV2PoolOrderedParams[]): bigint;
    getSellPricePath(amount: bigint, params: UniswapV2PoolOrderedParams[]): bigint;
    findPair(from: Token, to: Token): Promise<UniswapV2Pair | null>;
    private _findPair;
    getManyPoolReserves(pairs: UniswapV2Pair[], blockNumber: number): Promise<UniswapV2PoolState[]>;
    batchCatchUpPairs(pairs: [Token, Token][], blockNumber: number): Promise<void>;
    getPairOrderedParams(from: Token, to: Token, blockNumber: number, tokenDexTransferFee: number): Promise<UniswapV2PoolOrderedParams | null>;
    getPoolIdentifiers(_from: Token, _to: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
    getPricesVolume(_from: Token, _to: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams): Promise<ExchangePrices<UniswapV2Data> | null>;
    getCalldataGasCost(poolPrices: PoolPrices<UniswapV2Data>): number | number[];
    getAdapters(side: SwapSide): {
        name: string;
        index: number;
    }[] | null;
    getTopPoolsForToken(tokenAddress: Address, count: number): Promise<PoolLiquidity[]>;
    protected fixPath(path: Address[], srcToken: Address, destToken: Address): string[];
    getWETHAddress(srcToken: Address, destToken: Address, weth?: Address): string;
    getAdapterParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, toAmount: NumberAsString, // required for buy case
    data: UniswapData, side: SwapSide): AdapterExchangeParam;
    getSimpleParam(src: Address, dest: Address, srcAmount: NumberAsString, destAmount: NumberAsString, data: UniswapData, side: SwapSide): Promise<SimpleExchangeParam>;
    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: UniswapData, side: SwapSide): DexExchangeParam;
    getDirectParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, expectedAmount: NumberAsString, _data: UniswapData, side: SwapSide, permit: string, uuid: string, feePercent: NumberAsString, deadline: NumberAsString, partner: string, beneficiary: string, contractMethod: string): TxInfo<UniswapParam>;
    static getDirectFunctionName(): string[];
    getDirectParamV6(srcToken: Address, destToken: Address, fromAmount: NumberAsString, toAmount: NumberAsString, quotedAmount: NumberAsString, data: UniswapV2Data, side: SwapSide, permit: string, uuid: string, partnerAndFee: string, beneficiary: string, blockNumber: number, contractMethod: string): {
        params: UniswapV2ParamsDirect;
        encoder: (...params: (string | UniswapV2ParamsDirect)[]) => string;
        networkFee: string;
    };
    static getDirectFunctionNameV6(): string[];
    protected getPoolIdentifier(token0: string, token1: string): string;
    private onPoolCreatedDeleteFromNonExistingSet;
    private _encodePathV6;
}
export {};