import { Monitor } from '@neo-one/monitor';
import { Consensus, ConsensusOptions } from '@neo-one/node-consensus';
import { Block, Blockchain, ConsensusPayload, CreateNetwork, Endpoint, Node as INode, RelayTransactionResult, Transaction } from '@neo-one/node-core';
import BN from 'bn.js';
import { Observable } from 'rxjs';
export interface TransactionAndFee {
    readonly transaction: Transaction;
    readonly networkFee: BN;
}
export interface Environment {
    readonly externalPort?: number;
}
export interface Options {
    readonly consensus?: {
        readonly enabled: boolean;
        readonly options: ConsensusOptions;
    };
    readonly rpcURLs?: readonly string[];
    readonly unhealthyPeerSeconds?: number;
}
export declare class Node implements INode {
    readonly consensus: Consensus | undefined;
    readonly connectedPeers: readonly Endpoint[];
    readonly memPool: {
        readonly [hash: string]: Transaction;
    };
    readonly blockchain: Blockchain;
    private mutableMemPool;
    private readonly monitor;
    private readonly network;
    private readonly options$;
    private readonly externalPort;
    private readonly nonce;
    private readonly userAgent;
    private mutableKnownBlockHashes;
    private readonly tempKnownBlockHashes;
    private mutableKnownTransactionHashes;
    private readonly tempKnownTransactionHashes;
    private mutableKnownHeaderHashes;
    private readonly tempKnownHeaderHashes;
    private mutableGetBlocksRequestsIndex;
    private mutableGetBlocksRequestTime;
    private mutableGetBlocksRequestsCount;
    private mutableBestPeer;
    private mutableUnhealthyPeerSeconds;
    private readonly consensusCache;
    private mutableBlockIndex;
    private mutableConsensus;
    private readonly requestBlocks;
    private readonly onRequestEndpoints;
    private readonly trimMemPool;
    constructor({ monitor, blockchain, createNetwork, environment, options$, }: {
        readonly monitor: Monitor;
        readonly blockchain: Blockchain;
        readonly createNetwork: CreateNetwork;
        readonly environment?: Environment;
        readonly options$: Observable<Options>;
    });
    reset(): Promise<void>;
    start$(): Observable<any>;
    relayTransaction(transaction: Transaction, { throwVerifyError, forceAdd, }?: {
        readonly throwVerifyError?: boolean;
        readonly forceAdd?: boolean;
    }): Promise<RelayTransactionResult>;
    relayBlock(block: Block, monitor?: Monitor): Promise<void>;
    relayConsensusPayload(payload: ConsensusPayload): void;
    syncMemPool(): void;
    private relay;
    private relayTransactionInternal;
    private sendMessage;
    private readonly negotiate;
    private readonly checkPeerHealth;
    private readonly onEvent;
    private findBestPeer;
    private resetRequestBlocks;
    private shouldRequestBlocks;
    private checkVersion;
    private ready;
    private fetchEndpointsFromRPC;
    private doFetchEndpointsFromRPC;
    private fetchEndpointsFromRPCURL;
    private onMessageReceived;
    private onAddrMessageReceived;
    private onBlockMessageReceived;
    private persistBlock;
    private onConsensusMessageReceived;
    private onFilterAddMessageReceived;
    private onFilterClearMessageReceived;
    private onFilterLoadMessageReceived;
    private onGetAddrMessageReceived;
    private onGetBlocksMessageReceived;
    private onGetDataMessageReceived;
    private onGetHeadersMessageReceived;
    private onHeadersMessageReceived;
    private onInvMessageReceived;
    private onMemPoolMessageReceived;
    private onTransactionReceived;
    private onVerackMessageReceived;
    private onVersionMessageReceived;
    private getHeaders;
    private testFilter;
    private createMerkleBlockPayload;
    private createMessage;
}