import { Network } from '../../constants';
import { AdapterExchangeParam, Address, DexExchangeParam, ExchangePrices, Log, Logger, PoolLiquidity, PoolPrices, SimpleExchangeParam, Token, TransferFeeParams } from '../../types';
import { IDexHelper } from '../../dex-helper';
import { UniswapParam, UniswapV2Data } from '../uniswap-v2/types';
import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
import { NumberAsString, SwapSide } from '@paraswap/core';
import { Interface } from '@ethersproject/abi';
import { CamelotPoolState, CamelotPoolOrderedParams } from './types';
import { Contract } from 'web3-eth-contract';
import { IDex } from '../idex';
import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
import { SimpleExchange } from '../simple-exchange';
import { SolidlyData } from '../solidly/types';
import { OnPoolCreatedCallback } from '../uniswap-v2/uniswap-v2-factory';
export interface CamelotPair {
    token0: Token;
    token1: Token;
    exchange?: Address;
    pool?: CamelotEventPool;
    checkExistenceAfter?: number;
}
export declare class CamelotEventPool extends StatefulEventSubscriber<CamelotPoolState> {
    protected dexHelper: IDexHelper;
    private poolAddress;
    private token0;
    private token1;
    private iface;
    private callEntries;
    private callDecoder;
    decoder: (log: Log) => import("@ethersproject/abi").LogDescription;
    constructor(parentName: string, dexHelper: IDexHelper, poolAddress: Address, token0: Token, token1: Token, logger: Logger, iface: Interface | undefined, callEntries: any[], callDecoder: (data: any[]) => {
        reserve0: string;
        reserve1: string;
        token0FeeCode: number;
        token1FeeCode: number;
        stable: boolean;
    });
    protected processLog(state: DeepReadonly<CamelotPoolState>, log: Readonly<Log>): AsyncOrSync<DeepReadonly<CamelotPoolState> | null>;
    generateState(blockNumber?: number | 'latest'): Promise<DeepReadonly<CamelotPoolState>>;
}
export declare class Camelot extends SimpleExchange implements IDex<SolidlyData, UniswapParam> {
    protected network: Network;
    protected dexHelper: IDexHelper;
    protected factoryAddress: Address;
    protected subgraphURL: string | undefined;
    protected initCode: string;
    protected poolGasCost: number;
    protected decoderIface: Interface;
    protected adapters: {
        [side: string]: {
            name: string;
            index: number;
        }[] | null;
    };
    protected routerAddress: string;
    pairs: {
        [key: string]: CamelotPair;
    };
    feeFactor: number;
    factory: Contract;
    pairsHashCacheKey: string;
    private findPairPromises;
    needWrapNative: boolean;
    routerInterface: Interface;
    exchangeRouterInterface: Interface;
    readonly hasConstantPriceLargeAmounts: boolean;
    readonly isFeeOnTransferSupported: boolean;
    readonly DEST_TOKEN_DEX_TRANSFERS = 1;
    logger: Logger;
    private readonly factoryInst;
    private newlyCreatedPoolKeys;
    static dexKeysWithNetwork: {
        key: string;
        networks: Network[];
    }[];
    constructor(network: Network, dexKey: string, dexHelper: IDexHelper, factoryAddress?: Address, subgraphURL?: string | undefined, initCode?: string, poolGasCost?: number, decoderIface?: Interface, adapters?: {
        [side: string]: {
            name: string;
            index: number;
        }[] | null;
    }, routerAddress?: string);
    initializePricing(blockNumber: number): Promise<void>;
    private getPoolIdentifier;
    onPoolCreatedDeleteFromNonExistingSet: OnPoolCreatedCallback;
    getPoolStatesMultiCallData(pair: CamelotPair): {
        callEntries: any[];
        callDecoder: (data: any[]) => {
            reserve0: string;
            reserve1: string;
            token0FeeCode: number;
            token1FeeCode: number;
            stable: boolean;
        };
    };
    protected addPool(pair: CamelotPair, reserve0: string, reserve1: string, token0FeeCode: number, token1FeeCode: number, stable: boolean, blockNumber: number): Promise<void>;
    getBuyPrice(priceParams: CamelotPoolOrderedParams, srcAmount: bigint): Promise<bigint>;
    getSellPrice(priceParams: CamelotPoolOrderedParams, srcAmount: bigint): Promise<bigint>;
    getBuyPricePath(amount: bigint, params: CamelotPoolOrderedParams[]): Promise<bigint>;
    getSellPricePath(amount: bigint, params: CamelotPoolOrderedParams[]): Promise<bigint>;
    findPair(from: Token, to: Token): Promise<CamelotPair | null>;
    private _findPair;
    getManyPoolStates(pairs: CamelotPair[], blockNumber: number): Promise<CamelotPoolState[]>;
    batchCatchUpPairs(pairs: [Token, Token][], blockNumber: number): Promise<void>;
    getPairOrderedParams(from: Token, to: Token, blockNumber: number, tokenDexTransferFee: number): Promise<CamelotPoolOrderedParams | 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<SolidlyData> | null>;
    getCalldataGasCost(poolPrices: PoolPrices<UniswapV2Data>): number | number[];
    getAdapters(side: SwapSide): {
        name: string;
        index: number;
    }[] | null;
    getTopPoolsForToken(tokenAddress: Address, count: number): Promise<PoolLiquidity[]>;
    getWETHAddress(srcToken: Address, destToken: Address, weth?: Address): string;
    getAdapterParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, toAmount: NumberAsString, // required for buy case
    data: SolidlyData, side: SwapSide): AdapterExchangeParam;
    getSimpleParam(src: Address, dest: Address, srcAmount: NumberAsString, destAmount: NumberAsString, data: SolidlyData, side: SwapSide): Promise<SimpleExchangeParam>;
    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: SolidlyData, side: SwapSide): DexExchangeParam;
}