import { Interface, Result } from '@ethersproject/abi';
import { Logger } from 'log4js';
import { DeepReadonly } from 'ts-essentials';
import { IDexHelper } from '../../../dex-helper/idex-helper';
import { StatefulEventSubscriber } from '../../../stateful-event-subscriber';
import { BlockHeader, Log } from '../../../types';
import { PoolKey, PoolTypeConfig, SwappedEvent } from './utils';
import { EventSubscriber } from '../../../dex-helper';
export type Quote<StateAfter = undefined> = {
    consumedAmount: bigint;
    calculatedAmount: bigint;
    gasConsumed: number;
    skipAhead: number;
} & (StateAfter extends undefined ? {} : {
    stateAfter: StateAfter;
});
export interface IEkuboPool<C extends PoolTypeConfig> extends EventSubscriber {
    key: PoolKey<C>;
    initializationBlockNumber(): number;
    quote(amount: bigint, token: bigint, blockNumber: number): Quote;
    updateState(blockNumber: number): Promise<void>;
    computeTvl(): [bigint, bigint];
}
export type NamedEventHandler<State> = (args: Result, oldState: DeepReadonly<State>, blockHeader: Readonly<BlockHeader>) => DeepReadonly<State> | null;
export type AnonymousEventHandler<State> = (data: string, oldState: DeepReadonly<State>, blockHeader: Readonly<BlockHeader>) => DeepReadonly<State> | null;
export declare class NamedEventHandlers<State> {
    readonly iface: Interface;
    readonly handlers: Record<string, NamedEventHandler<State>>;
    constructor(iface: Interface, handlers: Record<string, NamedEventHandler<State>>);
    parseLog(log: Readonly<Log>, oldState: DeepReadonly<State>, blockHeader: Readonly<BlockHeader>): DeepReadonly<State> | null;
}
export declare abstract class EkuboPool<C extends PoolTypeConfig, S> extends StatefulEventSubscriber<S> implements IEkuboPool<C> {
    private readonly initBlockNumber;
    readonly key: PoolKey<C>;
    protected constructor(parentName: string, dexHelper: IDexHelper, logger: Logger, initBlockNumber: number, key: PoolKey<C>, coreAddress: string, coreIface: Interface, extraNamedEventHandlers?: Record<string, NamedEventHandlers<S>>, extraAnonymousEventHandlers?: Record<string, AnonymousEventHandler<S>>);
    private readonly namedEventHandlers;
    private readonly anonymousEventHandlers;
    initializationBlockNumber(): number;
    updateState(blockNumber: number): Promise<void>;
    quote(amount: bigint, token: bigint, blockNumber: number): Quote;
    computeTvl(): [bigint, bigint];
    /**
     * The function is called every time any of the subscribed
     * addresses release log. The function accepts the current
     * state, updates the state according to the log, and returns
     * the updated state.
     * @param state - Current state of event subscriber
     * @param log - Log released by one of the subscribed addresses
     * @returns Updates state of the event subscriber after the log
     */
    protected processLog(state: DeepReadonly<S>, log: Readonly<Log>, blockHeader: Readonly<BlockHeader>): DeepReadonly<S> | null;
    protected abstract _quote(amount: bigint, isToken1: boolean, state: DeepReadonly<S>, sqrtRatioLimit?: bigint): Quote;
    protected abstract _computeTvl(state: DeepReadonly<S>): [bigint, bigint];
    protected abstract handlePositionUpdated(args: Result, oldState: DeepReadonly<S>): DeepReadonly<S> | null;
    protected abstract handleSwappedEvent(ev: SwappedEvent, oldState: DeepReadonly<S>): DeepReadonly<S> | null;
}