/// <reference types="node" />
import { Blockchain } from './blockchain';
import { VerificationResultReason } from './consensus';
import { Logger } from './logger';
import { Meter, MetricsMonitor } from './metrics';
import { RollingAverage } from './metrics/rollingAverage';
import { Identity, Peer, PeerNetwork } from './network';
import { PeerState } from './network/peers/peer';
import { Block } from './primitives/block';
import { Telemetry } from './telemetry';
import { SetTimeoutToken } from './utils';
export type SyncerState = 'stopped' | 'idle' | 'stopping' | 'syncing' | 'measuring';
export declare class Syncer {
    readonly peerNetwork: PeerNetwork;
    readonly chain: Blockchain;
    readonly metrics: MetricsMonitor;
    readonly telemetry: Telemetry;
    readonly logger: Logger;
    readonly speed: Meter;
    readonly downloadSpeed: RollingAverage;
    state: SyncerState;
    stopping: Promise<void> | null;
    eventLoopTimeout: SetTimeoutToken | null;
    loader: Peer | null;
    blocksPerMessage: number;
    nextMeasureTime: number;
    numberOfMeasurements: number;
    lastLoaderIdentity: Identity | null;
    constructor(options: {
        peerNetwork: PeerNetwork;
        chain: Blockchain;
        telemetry: Telemetry;
        metrics?: MetricsMonitor;
        logger?: Logger;
        blocksPerMessage?: number;
    });
    start(): Promise<void>;
    stop(): Promise<void>;
    eventLoop(): Promise<void>;
    /**
     * Chooses a peer to sync from based on measuring the connection of a random
     * sampling of connected peers and begins syncing
     */
    findPeer(currentPeerIdentity: Identity | null): Promise<void>;
    startSyncIfIdle(peer: Peer): void;
    protected startSync(peer: Peer): void;
    stopSync(peer: Peer): void;
    wait(): Promise<void>;
    syncFrom(peer: Peer): Promise<void>;
    /**
     * Find the sequence of the ancestor block between you and peer
     */
    findAncestor(peer: Peer): Promise<{
        sequence: number;
        ancestor: Buffer;
        requests: number;
    }>;
    private getBlocks;
    syncBlocks(peer: Peer, head: Buffer, sequence: number): Promise<void>;
    addBlock(peer: Peer, block: Block): Promise<{
        added: boolean;
        block: Block;
        reason: VerificationResultReason | null;
    }>;
    /**
     * Returns the amount of time to wait until the next sync candidate
     * measurement in milliseconds
     */
    protected getNextMeasurementDelta(): number;
    /**
     * Throws AbortSyncingError which safely stops the syncing
     * with a peer if we should no longer sync from this peer
     */
    protected abort(peer: Peer): void;
    /**
     * When the peer disconnects we use this to stop syncing from them
     */
    protected onPeerStateChanged: ({ peer, state }: {
        peer: Peer;
        state: PeerState;
    }) => void;
}
//# sourceMappingURL=syncer.d.ts.map