/// <reference types="node" />
import { Worker } from '@zkopru/utils';
import { DB, Deposit as DepositSql, Utxo as UtxoSql, MassDeposit as MassDepositSql, BlockCache } from '@zkopru/database';
import { EventEmitter } from 'events';
import { ZkAddress } from '@zkopru/transaction';
import { L1Contract } from '../context/layer1';
export declare enum NetworkStatus {
    STOPPED = "stopped",
    ON_SYNCING = "on syncing",
    ON_FETCHED = "onFetched",
    ON_PROCESSING = "processing",
    SYNCED = "synced",
    FULLY_SYNCED = "fully synced",
    ON_ERROR = "on error"
}
export declare class Synchronizer extends EventEmitter {
    db: DB;
    blockCache: BlockCache;
    l1Contract: L1Contract;
    depositSubscriber?: EventEmitter;
    depositUtxoSubscriber?: EventEmitter;
    massDepositCommitSubscriber?: EventEmitter;
    proposalSubscriber?: EventEmitter;
    slashSubscriber?: EventEmitter;
    finalizationSubscriber?: EventEmitter;
    erc20RegistrationSubscriber?: EventEmitter;
    erc721RegistrationSubscriber?: EventEmitter;
    isListening: boolean;
    latestProcessed?: number;
    status: NetworkStatus;
    workers: {
        statusUpdater: Worker<void>;
        blockFetcher: Worker<void>;
    };
    fetching: {
        [proposalTx: string]: boolean;
    };
    _genesisPromise: undefined | Promise<void>;
    constructor(db: DB, l1Contract: L1Contract, blockCache: BlockCache);
    sync(accounts?: ZkAddress[], proposalCB?: (hash: string) => void, finalizationCB?: (hash: string) => void): void;
    stop(): Promise<void>;
    isSynced(): boolean;
    updateStatus(): Promise<void>;
    setLatestProcessed(proposalNum: number): void;
    private setStatus;
    loadGenesis(): Promise<void>;
    loadGenesisIfNeeded(): Promise<void>;
    private _loadGenesis;
    listenTokenRegistry(): Promise<void>;
    listenDeposits(cb?: (deposit: DepositSql) => void): Promise<void>;
    listenDepositUtxos(addresses: ZkAddress[], cb?: (utxo: UtxoSql) => void): Promise<void>;
    listenMassDepositCommit(cb?: (commit: MassDepositSql) => void): Promise<void>;
    listenNewProposals(cb?: (hash: string) => void): Promise<void>;
    listenSlash(cb?: (hash: string) => void): Promise<void>;
    listenFinalization(cb?: (hash: string) => void): Promise<void>;
    fetchUnfetchedProposals(): Promise<void>;
    fetch(proposalTx: string): Promise<void>;
}
//# sourceMappingURL=synchronizer.d.ts.map