@neo-one/node-protocol-esnext-esm/Node.d.ts

NEO•ONE NEO node and consensus protocol.

import { Consensus, ConsensusOptions } from '@neo-one/node-consensus-esnext-esm';
import { Block, Blockchain, ConsensusPayload, CreateNetwork, Endpoint, Node as INode, RelayTransactionResult, Transaction } from '@neo-one/node-core-esnext-esm';
import { Disposable } from '@neo-one/utils-esnext-esm';
import BN from 'bn.js';
export interface TransactionAndFee {
    readonly transaction: Transaction;
    readonly networkFee: BN;
}
export interface Options {
    readonly externalPort?: number;
    readonly consensus?: ConsensusOptions;
    readonly rpcURLs?: readonly string[];
    readonly unhealthyPeerSeconds?: number;
}
export declare class Node implements INode {
    get consensus(): Consensus | undefined;
    get connectedPeers(): readonly Endpoint[];
    get memPool(): {
        readonly [hash: string]: Transaction;
    };
    readonly blockchain: Blockchain;
    private mutableMemPool;
    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({ blockchain, createNetwork, options, }: {
        readonly blockchain: Blockchain;
        readonly createNetwork: CreateNetwork;
        readonly options: Options;
    });
    reset(): Promise<void>;
    start(): Promise<Disposable>;
    relayTransaction(transaction: Transaction, { throwVerifyError, forceAdd, }?: {
        readonly throwVerifyError?: boolean;
        readonly forceAdd?: boolean;
    }): Promise<RelayTransactionResult>;
    relayBlock(block: Block): 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;
}