@neo-one/node-protocol-esnext-esm/src/Node.js

import { common, crypto, utils } from '@neo-one/client-common-esnext-esm';
import { metrics } from '@neo-one/monitor-esnext-esm';
import { Consensus } from '@neo-one/node-consensus-esnext-esm';
import { createEndpoint, getEndpointConfig, MerkleTree, RegisterTransaction, TransactionType, } from '@neo-one/node-core-esnext-esm';
import { finalize, labels, neverComplete, utils as commonUtils } from '@neo-one/utils-esnext-esm';
import { ScalingBloem } from 'bloem';
// tslint:disable-next-line:match-default-export-name
import BloomFilter from 'bloom-filter';
import fetch from 'cross-fetch';
import { Address6 } from 'ip-address';
import _ from 'lodash';
import LRU from 'lru-cache';
import { combineLatest, defer, of as _of } from 'rxjs';
import { distinctUntilChanged, map, switchMap, take } from 'rxjs/operators';
import { Command } from './Command';
import { AlreadyConnectedError, NegotiationError } from './errors';
import { Message, MessageTransform } from './Message';
import { AddrPayload, GetBlocksPayload, HeadersPayload, InventoryType, InvPayload, MerkleBlockPayload, NetworkAddress, SERVICES, VersionPayload, } from './payload';
const messageReceivedLabelNames = [labels.COMMAND_NAME];
const messageReceivedLabels = Object.keys(Command).map((command) => ({
    [labels.COMMAND_NAME]: command,
}));
const NEO_PROTOCOL_MESSAGES_RECEIVED_TOTAL = metrics.createCounter({
    name: 'neo_protocol_messages_received_total',
    labelNames: messageReceivedLabelNames,
    labels: messageReceivedLabels,
});
const NEO_PROTOCOL_MESSAGES_FAILURES_TOTAL = metrics.createCounter({
    name: 'neo_protocol_messages_failures_total',
    labelNames: messageReceivedLabelNames,
    labels: messageReceivedLabels,
});
const NEO_PROTOCOL_MEMPOOL_SIZE = metrics.createGauge({
    name: 'neo_protocol_mempool_size',
});
const createPeerBloomFilter = ({ filter, k, tweak, }) => new BloomFilter({
    vData: Buffer.from(filter),
    nHashFuncs: k,
    nTweak: tweak,
});
const createScalingBloomFilter = () => new ScalingBloem(0.05, {
    initial_capacity: 100000,
    scaling: 4,
});
const compareTransactionAndFees = (val1, val2) => {
    const a = val1.networkFee.divn(val1.transaction.size);
    const b = val2.networkFee.divn(val2.transaction.size);
    if (a.lt(b)) {
        return -1;
    }
    if (b.lt(a)) {
        return 1;
    }
    return val1.transaction.hash.compare(val2.transaction.hash);
};
const MEM_POOL_SIZE = 5000;
const GET_ADDR_PEER_COUNT = 200;
const GET_BLOCKS_COUNT = 500;
// Assume that we get 500 back, but if not, at least request every 10 seconds
const GET_BLOCKS_BUFFER = GET_BLOCKS_COUNT / 3;
const GET_BLOCKS_TIME_MS = 10000;
const GET_BLOCKS_THROTTLE_MS = 1000;
const TRIM_MEMPOOL_THROTTLE = 5000;
const GET_BLOCKS_CLOSE_COUNT = 2;
const UNHEALTHY_PEER_SECONDS = 300;
const LOCAL_HOST_ADDRESSES = new Set(['', '0.0.0.0', 'localhost', '127.0.0.1', '::', '::1']);
export class Node {
    constructor({ monitor, blockchain, createNetwork, environment = {}, options$, }) {
        this.mutableUnhealthyPeerSeconds = UNHEALTHY_PEER_SECONDS;
        this.requestBlocks = _.debounce(() => {
            const peer = this.mutableBestPeer;
            const previousBlock = this.blockchain.previousBlock;
            const block = previousBlock === undefined ? this.blockchain.currentBlock : previousBlock;
            if (peer !== undefined && block.index < peer.data.startHeight) {
                if (this.mutableGetBlocksRequestsCount > GET_BLOCKS_CLOSE_COUNT) {
                    this.mutableBestPeer = this.findBestPeer(peer);
                    this.network.blacklistAndClose(peer);
                    this.mutableGetBlocksRequestsCount = 0;
                }
                else if (this.shouldRequestBlocks()) {
                    if (this.mutableGetBlocksRequestsIndex === block.index) {
                        this.mutableGetBlocksRequestsCount += 1;
                    }
                    else {
                        this.mutableGetBlocksRequestsCount = 1;
                        this.mutableGetBlocksRequestsIndex = block.index;
                    }
                    this.mutableGetBlocksRequestTime = Date.now();
                    this.sendMessage(peer, this.createMessage({
                        command: Command.getblocks,
                        payload: new GetBlocksPayload({
                            hashStart: [block.hash],
                        }),
                    }));
                }
                this.requestBlocks();
            }
        }, GET_BLOCKS_THROTTLE_MS);
        this.onRequestEndpoints = _.throttle(() => {
            this.relay(this.createMessage({ command: Command.getaddr }));
            // tslint:disable-next-line no-floating-promises
            this.fetchEndpointsFromRPC();
        }, 5000);
        // tslint:disable-next-line no-unnecessary-type-annotation
        this.trimMemPool = _.throttle(async (monitor) => {
            const memPool = Object.values(this.mutableMemPool);
            if (memPool.length > MEM_POOL_SIZE) {
                await monitor.captureSpan(async () => {
                    const transactionAndFees = await Promise.all(memPool.map(async (transaction) => {
                        const networkFee = await transaction.getNetworkFee({
                            getOutput: this.blockchain.output.get,
                            governingToken: this.blockchain.settings.governingToken,
                            utilityToken: this.blockchain.settings.utilityToken,
                            fees: this.blockchain.settings.fees,
                            registerValidatorFee: this.blockchain.settings.registerValidatorFee,
                        });
                        return { transaction, networkFee };
                    }));
                    const hashesToRemove = _.take(
                    // tslint:disable-next-line no-array-mutation
                    transactionAndFees.slice().sort(compareTransactionAndFees), this.blockchain.settings.memPoolSize).map((transactionAndFee) => transactionAndFee.transaction.hashHex);
                    hashesToRemove.forEach((hash) => {
                        // tslint:disable-next-line no-dynamic-delete
                        delete this.mutableMemPool[hash];
                    });
                    NEO_PROTOCOL_MEMPOOL_SIZE.set(Object.keys(this.mutableMemPool).length);
                }, {
                    name: 'neo_protocol_trim_mempool',
                });
            }
        }, TRIM_MEMPOOL_THROTTLE);
        this.negotiate = async (peer) => {
            this.sendMessage(peer, this.createMessage({
                command: Command.version,
                payload: new VersionPayload({
                    protocolVersion: 0,
                    services: SERVICES.NODE_NETWORK,
                    timestamp: Math.round(Date.now() / 1000),
                    port: this.externalPort,
                    nonce: this.nonce,
                    userAgent: this.userAgent,
                    startHeight: this.blockchain.currentBlockIndex,
                    relay: true,
                }),
            }));
            const message = await peer.receiveMessage(30000);
            let versionPayload;
            if (message.value.command === Command.version) {
                versionPayload = message.value.payload;
            }
            else {
                throw new NegotiationError(message);
            }
            this.checkVersion(peer, message, versionPayload);
            const { host } = getEndpointConfig(peer.endpoint);
            let address;
            if (NetworkAddress.isValid(host)) {
                address = new NetworkAddress({
                    host,
                    port: versionPayload.port,
                    timestamp: versionPayload.timestamp,
                    services: versionPayload.services,
                });
            }
            this.sendMessage(peer, this.createMessage({ command: Command.verack }));
            const nextMessage = await peer.receiveMessage(30000);
            if (nextMessage.value.command !== Command.verack) {
                throw new NegotiationError(nextMessage);
            }
            return {
                data: {
                    nonce: versionPayload.nonce,
                    startHeight: versionPayload.startHeight,
                    mutableBloomFilter: undefined,
                    address,
                },
                relay: versionPayload.relay,
            };
        };
        this.checkPeerHealth = (peer, prevHealth) => {
            const checkTimeSeconds = commonUtils.nowSeconds();
            const blockIndex = this.mutableBlockIndex[peer.endpoint];
            // If first check -> healthy
            if (prevHealth === undefined) {
                return { healthy: true, checkTimeSeconds, blockIndex };
            }
            // If seen new block -> healthy + update check time
            if (prevHealth.blockIndex !== undefined && blockIndex !== undefined && prevHealth.blockIndex < blockIndex) {
                return { healthy: true, checkTimeSeconds, blockIndex };
            }
            // If not seen a block or a new block BUT it has NOT been a long
            // time -> healthy
            if (prevHealth.blockIndex === blockIndex &&
                commonUtils.nowSeconds() - prevHealth.checkTimeSeconds < this.mutableUnhealthyPeerSeconds) {
                return {
                    healthy: true,
                    checkTimeSeconds: prevHealth.checkTimeSeconds,
                    blockIndex: prevHealth.blockIndex,
                };
            }
            return { healthy: false, checkTimeSeconds, blockIndex };
        };
        this.onEvent = (event) => {
            if (event.event === 'PEER_CONNECT_SUCCESS') {
                const { connectedPeer } = event;
                if (this.mutableBestPeer === undefined ||
                    // Only change best peer at most every 100 blocks
                    this.mutableBestPeer.data.startHeight + 100 < connectedPeer.data.startHeight) {
                    this.mutableBestPeer = connectedPeer;
                    this.resetRequestBlocks();
                    this.requestBlocks();
                }
            }
            else if (event.event === 'PEER_CLOSED' &&
                this.mutableBestPeer !== undefined &&
                this.mutableBestPeer.endpoint === event.peer.endpoint) {
                this.mutableBestPeer = this.findBestPeer();
                this.resetRequestBlocks();
                this.requestBlocks();
            }
        };
        this.blockchain = blockchain;
        this.monitor = monitor.at('node_protocol');
        this.network = createNetwork({
            negotiate: this.negotiate,
            checkPeerHealth: this.checkPeerHealth,
            createMessageTransform: () => new MessageTransform(this.blockchain.deserializeWireContext),
            onMessageReceived: (peer, message) => {
                this.onMessageReceived(peer, message);
            },
            onRequestEndpoints: this.onRequestEndpoints.bind(this),
            onEvent: this.onEvent,
        });
        this.options$ = options$;
        const { externalPort = 0 } = environment;
        this.externalPort = externalPort;
        this.nonce = Math.floor(Math.random() * utils.UINT_MAX_NUMBER);
        this.userAgent = `NEO:neo-one-js:1.0.0-preview`;
        this.mutableMemPool = {};
        this.mutableKnownBlockHashes = createScalingBloomFilter();
        this.tempKnownBlockHashes = new Set();
        this.mutableKnownTransactionHashes = createScalingBloomFilter();
        this.tempKnownTransactionHashes = new Set();
        this.mutableKnownHeaderHashes = createScalingBloomFilter();
        this.tempKnownHeaderHashes = new Set();
        this.mutableGetBlocksRequestsCount = 1;
        this.consensusCache = LRU(10000);
        this.mutableBlockIndex = {};
    }
    get consensus() {
        return this.mutableConsensus;
    }
    get connectedPeers() {
        return this.network.connectedPeers.map((peer) => peer.endpoint);
    }
    get memPool() {
        return this.mutableMemPool;
    }
    async reset() {
        this.mutableMemPool = {};
        this.mutableKnownBlockHashes = createScalingBloomFilter();
        this.tempKnownBlockHashes.clear();
        this.mutableKnownTransactionHashes = createScalingBloomFilter();
        this.tempKnownTransactionHashes.clear();
        this.mutableKnownHeaderHashes = createScalingBloomFilter();
        this.tempKnownHeaderHashes.clear();
        this.mutableGetBlocksRequestsCount = 1;
        this.consensusCache.reset();
        this.mutableBlockIndex = {};
    }
    // tslint:disable-next-line no-any
    start$() {
        const network$ = defer(async () => {
            this.network.start();
            this.monitor.log({
                name: 'neo_protocol_start',
                message: 'Protocol started.',
                level: 'verbose',
            });
        }).pipe(neverComplete(), finalize(() => {
            this.network.stop();
            this.monitor.log({
                name: 'neo_protocol_stop',
                message: 'Protocol stopped.',
                level: 'verbose',
            });
        }));
        const defaultOptions = {
            enabled: false,
            options: { privateKey: 'unused', privateNet: false },
        };
        const consensus$ = this.options$.pipe(map(({ consensus = defaultOptions }) => consensus.enabled), distinctUntilChanged(), switchMap((enabled) => {
            if (enabled) {
                const mutableConsensus = new Consensus({
                    monitor: this.monitor,
                    options$: this.options$.pipe(map(({ consensus = defaultOptions }) => consensus.options), distinctUntilChanged()),
                    node: this,
                });
                this.mutableConsensus = mutableConsensus;
                return mutableConsensus.start$();
            }
            return _of(undefined);
        }));
        const options$ = this.options$.pipe(map(({ unhealthyPeerSeconds = UNHEALTHY_PEER_SECONDS }) => {
            this.mutableUnhealthyPeerSeconds = unhealthyPeerSeconds;
        }));
        return combineLatest(network$, consensus$, options$);
    }
    async relayTransaction(transaction, { throwVerifyError = false, forceAdd = false, } = {
        throwVerifyError: false,
        forceAdd: false,
    }) {
        const result = {};
        if (transaction.type === TransactionType.Miner ||
            this.mutableMemPool[transaction.hashHex] !== undefined ||
            this.tempKnownTransactionHashes.has(transaction.hashHex)) {
            return result;
        }
        if (!this.mutableKnownTransactionHashes.has(transaction.hash)) {
            this.tempKnownTransactionHashes.add(transaction.hashHex);
            try {
                const memPool = Object.values(this.mutableMemPool);
                if (memPool.length > MEM_POOL_SIZE / 2 && !forceAdd) {
                    this.mutableKnownTransactionHashes.add(transaction.hash);
                    return result;
                }
                // tslint:disable-next-line prefer-immediate-return
                const finalResult = await this.monitor
                    .withData({ [labels.NEO_TRANSACTION_HASH]: transaction.hashHex })
                    .captureSpanLog(async (span) => {
                    let foundTransaction;
                    try {
                        foundTransaction = await this.blockchain.transaction.tryGet({
                            hash: transaction.hash,
                        });
                    }
                    finally {
                        span.setLabels({
                            [labels.NEO_TRANSACTION_FOUND]: foundTransaction !== undefined,
                        });
                    }
                    let verifyResult;
                    if (foundTransaction === undefined) {
                        verifyResult = await this.blockchain.verifyTransaction({
                            monitor: span,
                            transaction,
                            memPool: Object.values(this.mutableMemPool),
                        });
                        const verified = verifyResult.verifications.every(({ failureMessage }) => failureMessage === undefined);
                        if (verified) {
                            this.mutableMemPool[transaction.hashHex] = transaction;
                            NEO_PROTOCOL_MEMPOOL_SIZE.inc();
                            if (this.mutableConsensus !== undefined) {
                                this.mutableConsensus.onTransactionReceived(transaction);
                            }
                            this.relayTransactionInternal(transaction);
                            await this.trimMemPool(span);
                        }
                    }
                    this.mutableKnownTransactionHashes.add(transaction.hash);
                    return { verifyResult };
                }, {
                    name: 'neo_relay_transaction',
                    level: { log: 'verbose', span: 'info' },
                    trace: true,
                });
                // tslint:disable-next-line no-var-before-return
                return finalResult;
            }
            catch (error) {
                if (error.code === undefined ||
                    typeof error.code !== 'string' ||
                    !error.code.includes('VERIFY') ||
                    throwVerifyError) {
                    throw error;
                }
            }
            finally {
                this.tempKnownTransactionHashes.delete(transaction.hashHex);
            }
        }
        return result;
    }
    async relayBlock(block, monitor) {
        await this.persistBlock(block, monitor);
    }
    relayConsensusPayload(payload) {
        const message = this.createMessage({
            command: Command.inv,
            payload: new InvPayload({
                type: InventoryType.Consensus,
                hashes: [payload.hash],
            }),
        });
        this.consensusCache.set(payload.hashHex, payload);
        this.relay(message);
    }
    syncMemPool() {
        this.relay(this.createMessage({ command: Command.mempool }));
    }
    relay(message) {
        this.network.relay(message.serializeWire());
    }
    relayTransactionInternal(transaction) {
        const message = this.createMessage({
            command: Command.inv,
            payload: new InvPayload({
                type: InventoryType.Transaction,
                hashes: [transaction.hash],
            }),
        });
        const messagePayload = message.serializeWire();
        this.network.connectedPeers.forEach((peer) => {
            if (peer.relay && this.testFilter(peer.data.mutableBloomFilter, transaction)) {
                peer.write(messagePayload);
            }
        });
    }
    sendMessage(peer, message) {
        peer.write(message.serializeWire());
    }
    findBestPeer(bestPeer) {
        let peers = this.network.connectedPeers;
        if (bestPeer !== undefined) {
            peers = peers.filter((peer) => peer.endpoint !== bestPeer.endpoint);
        }
        const result = _.maxBy(peers, (peer) => peer.data.startHeight);
        if (result === undefined) {
            return undefined;
        }
        return _.shuffle(peers.filter((peer) => peer.data.startHeight === result.data.startHeight))[0];
    }
    resetRequestBlocks() {
        this.mutableGetBlocksRequestsIndex = undefined;
        this.mutableGetBlocksRequestsCount = 0;
    }
    shouldRequestBlocks() {
        const block = this.blockchain.currentBlock;
        const getBlocksRequestTime = this.mutableGetBlocksRequestTime;
        return (this.mutableGetBlocksRequestsIndex === undefined ||
            block.index - this.mutableGetBlocksRequestsIndex > GET_BLOCKS_BUFFER ||
            getBlocksRequestTime === undefined ||
            Date.now() - getBlocksRequestTime > GET_BLOCKS_TIME_MS);
    }
    checkVersion(peer, message, version) {
        if (version.nonce === this.nonce) {
            this.network.permanentlyBlacklist(peer.endpoint);
            throw new NegotiationError(message, 'Nonce equals my nonce.');
        }
        const connectedPeer = this.network.connectedPeers.find((otherPeer) => version.nonce === otherPeer.data.nonce);
        if (connectedPeer !== undefined) {
            throw new AlreadyConnectedError('Already connected to nonce.');
        }
    }
    ready() {
        const peer = this.mutableBestPeer;
        const block = this.blockchain.currentBlock;
        return peer !== undefined && block.index >= peer.data.startHeight;
    }
    async fetchEndpointsFromRPC() {
        try {
            await this.doFetchEndpointsFromRPC();
        }
        catch {
            // ignore, logged deeper in the stack
        }
    }
    async doFetchEndpointsFromRPC() {
        const { rpcURLs = [] } = await this.options$.pipe(take(1)).toPromise();
        await Promise.all(rpcURLs.map(async (rpcURL) => this.fetchEndpointsFromRPCURL(rpcURL)));
    }
    async fetchEndpointsFromRPCURL(rpcURL) {
        try {
            const response = await fetch(rpcURL, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    jsonrpc: '2.0',
                    id: 1,
                    method: 'getpeers',
                    params: [],
                }),
            });
            if (!response.ok) {
                throw new Error(`Failed to fetch peers from ${rpcURL}: ${response.status} ${response.statusText}`);
            }
            const result = await response.json();
            if (typeof result === 'object' &&
                result.error !== undefined &&
                typeof result.error === 'object' &&
                typeof result.error.code === 'number' &&
                typeof result.error.message === 'string') {
                throw new Error(result.error);
            }
            const connected = result.result.connected;
            connected
                .map((peer) => {
                const { address, port } = peer;
                const host = new Address6(address);
                const canonicalForm = host.canonicalForm();
                return { host: canonicalForm == undefined ? '' : canonicalForm, port };
            })
                .filter((endpoint) => !LOCAL_HOST_ADDRESSES.has(endpoint.host))
                .map((endpoint) => createEndpoint({
                type: 'tcp',
                host: endpoint.host,
                port: endpoint.port,
            }))
                .forEach((endpoint) => this.network.addEndpoint(endpoint));
        }
        catch (error) {
            this.monitor.withData({ [this.monitor.labels.HTTP_URL]: rpcURL }).logError({
                name: 'neo_protocol_fetch_endpoints_error',
                message: `Failed to fetch endpoints from ${rpcURL}`,
                error,
            });
        }
    }
    onMessageReceived(peer, message) {
        this.monitor
            .withLabels({ [labels.COMMAND_NAME]: message.value.command })
            .withData({ [this.monitor.labels.PEER_ADDRESS]: peer.endpoint })
            .captureLog(async (monitor) => {
            switch (message.value.command) {
                case Command.addr:
                    this.onAddrMessageReceived(monitor, message.value.payload);
                    break;
                case Command.block:
                    await this.onBlockMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.consensus:
                    await this.onConsensusMessageReceived(monitor, message.value.payload);
                    break;
                case Command.filteradd:
                    this.onFilterAddMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.filterclear:
                    this.onFilterClearMessageReceived(monitor, peer);
                    break;
                case Command.filterload:
                    this.onFilterLoadMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.getaddr:
                    this.onGetAddrMessageReceived(monitor, peer);
                    break;
                case Command.getblocks:
                    await this.onGetBlocksMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.getdata:
                    await this.onGetDataMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.getheaders:
                    await this.onGetHeadersMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.headers:
                    await this.onHeadersMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.inv:
                    this.onInvMessageReceived(monitor, peer, message.value.payload);
                    break;
                case Command.mempool:
                    this.onMemPoolMessageReceived(monitor, peer);
                    break;
                case Command.tx:
                    await this.onTransactionReceived(monitor, message.value.payload);
                    break;
                case Command.verack:
                    this.onVerackMessageReceived(monitor, peer);
                    break;
                case Command.version:
                    this.onVersionMessageReceived(monitor, peer);
                    break;
                case Command.alert:
                    break;
                case Command.merkleblock:
                    break;
                case Command.notfound:
                    break;
                case Command.ping:
                    break;
                case Command.pong:
                    break;
                case Command.reject:
                    break;
                default:
                    commonUtils.assertNever(message.value);
            }
        }, {
            name: 'neo_protocol_message_received',
            level: 'debug',
            message: `Received ${message.value.command} from ${peer.endpoint}`,
            metric: NEO_PROTOCOL_MESSAGES_RECEIVED_TOTAL,
            error: {
                metric: NEO_PROTOCOL_MESSAGES_FAILURES_TOTAL,
                message: `Failed to process message ${message.value.command} from ${peer.endpoint}`,
            },
        })
            .catch(() => {
            // do nothing
        });
    }
    onAddrMessageReceived(_monitor, addr) {
        addr.addresses
            .filter((address) => !LOCAL_HOST_ADDRESSES.has(address.host))
            .map((address) => createEndpoint({
            type: 'tcp',
            host: address.host,
            port: address.port,
        }))
            .forEach((endpoint) => this.network.addEndpoint(endpoint));
    }
    async onBlockMessageReceived(monitor, peer, block) {
        const blockIndex = this.mutableBlockIndex[peer.endpoint];
        this.mutableBlockIndex[peer.endpoint] = Math.max(block.index, blockIndex === undefined ? 0 : blockIndex);
        await this.relayBlock(block, monitor);
    }
    async persistBlock(block, monitor = this.monitor) {
        if (this.blockchain.currentBlockIndex > block.index || this.tempKnownBlockHashes.has(block.hashHex)) {
            return;
        }
        if (!this.mutableKnownBlockHashes.has(block.hash)) {
            this.tempKnownBlockHashes.add(block.hashHex);
            try {
                const foundBlock = await this.blockchain.block.tryGet({
                    hashOrIndex: block.hash,
                });
                if (foundBlock === undefined) {
                    await monitor.withData({ [labels.NEO_BLOCK_INDEX]: block.index }).captureSpanLog(async (span) => {
                        await this.blockchain.persistBlock({ monitor: span, block });
                        if (this.mutableConsensus !== undefined) {
                            this.mutableConsensus.onPersistBlock();
                        }
                        const peer = this.mutableBestPeer;
                        if (peer !== undefined && block.index > peer.data.startHeight) {
                            this.relay(this.createMessage({
                                command: Command.inv,
                                payload: new InvPayload({
                                    type: InventoryType.Block,
                                    hashes: [block.hash],
                                }),
                            }));
                        }
                    }, {
                        name: 'neo_relay_block',
                        level: { log: 'verbose', span: 'info' },
                        trace: true,
                    });
                }
                this.mutableKnownBlockHashes.add(block.hash);
                this.mutableKnownHeaderHashes.add(block.hash);
                block.transactions.forEach((transaction) => {
                    // tslint:disable-next-line no-dynamic-delete
                    delete this.mutableMemPool[transaction.hashHex];
                    this.mutableKnownTransactionHashes.add(transaction.hash);
                });
                NEO_PROTOCOL_MEMPOOL_SIZE.set(Object.keys(this.mutableMemPool).length);
            }
            finally {
                this.tempKnownBlockHashes.delete(block.hashHex);
            }
        }
    }
    async onConsensusMessageReceived(monitor, payload) {
        const { consensus } = this;
        if (consensus !== undefined) {
            await this.blockchain.verifyConsensusPayload(payload, monitor);
            consensus.onConsensusPayloadReceived(payload);
        }
    }
    onFilterAddMessageReceived(_monitor, peer, filterAdd) {
        if (peer.data.mutableBloomFilter !== undefined) {
            peer.data.mutableBloomFilter.insert(filterAdd.data);
        }
    }
    onFilterClearMessageReceived(_monitor, peer) {
        // tslint:disable-next-line no-object-mutation
        peer.data.mutableBloomFilter = undefined;
    }
    onFilterLoadMessageReceived(_monitor, peer, filterLoad) {
        // tslint:disable-next-line no-object-mutation
        peer.data.mutableBloomFilter = createPeerBloomFilter(filterLoad);
    }
    onGetAddrMessageReceived(_monitor, peer) {
        const addresses = _.take(_.shuffle(this.network.connectedPeers.map((connectedPeer) => connectedPeer.data.address).filter(commonUtils.notNull)), GET_ADDR_PEER_COUNT);
        if (addresses.length > 0) {
            this.sendMessage(peer, this.createMessage({
                command: Command.addr,
                payload: new AddrPayload({ addresses }),
            }));
        }
    }
    async onGetBlocksMessageReceived(_monitor, peer, getBlocks) {
        const headers = await this.getHeaders(getBlocks, this.blockchain.currentBlockIndex);
        this.sendMessage(peer, this.createMessage({
            command: Command.inv,
            payload: new InvPayload({
                type: InventoryType.Block,
                hashes: headers.map((header) => header.hash),
            }),
        }));
    }
    async onGetDataMessageReceived(_monitor, peer, getData) {
        switch (getData.type) {
            case InventoryType.Transaction:
                await Promise.all(getData.hashes.map(async (hash) => {
                    let transaction = this.mutableMemPool[common.uInt256ToHex(hash)];
                    if (transaction === undefined) {
                        transaction = await this.blockchain.transaction.tryGet({ hash });
                    }
                    if (transaction !== undefined) {
                        this.sendMessage(peer, this.createMessage({
                            command: Command.tx,
                            payload: transaction,
                        }));
                    }
                }));
                break;
            case InventoryType.Block: // Block
                await Promise.all(getData.hashes.map(async (hash) => {
                    const block = await this.blockchain.block.tryGet({
                        hashOrIndex: hash,
                    });
                    if (block !== undefined) {
                        if (peer.data.mutableBloomFilter === undefined) {
                            this.sendMessage(peer, this.createMessage({
                                command: Command.block,
                                payload: block,
                            }));
                        }
                        else {
                            this.sendMessage(peer, this.createMessage({
                                command: Command.merkleblock,
                                payload: this.createMerkleBlockPayload({
                                    block,
                                    flags: block.transactions.map((transaction) => this.testFilter(peer.data.mutableBloomFilter, transaction)),
                                }),
                            }));
                        }
                    }
                }));
                break;
            case InventoryType.Consensus: // Consensus
                getData.hashes.forEach((hash) => {
                    const payload = this.consensusCache.get(common.uInt256ToHex(hash));
                    if (payload !== undefined) {
                        this.sendMessage(peer, this.createMessage({
                            command: Command.consensus,
                            payload,
                        }));
                    }
                });
                break;
            default:
                commonUtils.assertNever(getData.type);
        }
    }
    async onGetHeadersMessageReceived(_monitor, peer, getBlocks) {
        const headers = await this.getHeaders(getBlocks, this.blockchain.currentHeader.index);
        this.sendMessage(peer, this.createMessage({
            command: Command.headers,
            payload: new HeadersPayload({ headers }),
        }));
    }
    async onHeadersMessageReceived(_monitor, peer, headersPayload) {
        const headers = headersPayload.headers.filter((header) => !this.mutableKnownHeaderHashes.has(header.hash) && !this.tempKnownHeaderHashes.has(header.hashHex));
        if (headers.length > 0) {
            headers.forEach((header) => {
                this.tempKnownHeaderHashes.add(header.hashHex);
            });
            try {
                await this.blockchain.persistHeaders(headers);
                headers.forEach((header) => {
                    this.mutableKnownHeaderHashes.add(header.hash);
                });
            }
            finally {
                headers.forEach((header) => {
                    this.tempKnownHeaderHashes.delete(header.hashHex);
                });
            }
        }
        if (this.blockchain.currentHeader.index < peer.data.startHeight) {
            this.sendMessage(peer, this.createMessage({
                command: Command.getheaders,
                payload: new GetBlocksPayload({
                    hashStart: [this.blockchain.currentHeader.hash],
                }),
            }));
        }
    }
    onInvMessageReceived(_monitor, peer, inv) {
        let hashes;
        switch (inv.type) {
            case InventoryType.Transaction: // Transaction
                hashes = inv.hashes.filter((hash) => !this.mutableKnownTransactionHashes.has(hash) &&
                    !this.tempKnownTransactionHashes.has(common.uInt256ToHex(hash)));
                break;
            case InventoryType.Block: // Block
                hashes = inv.hashes.filter((hash) => !this.mutableKnownBlockHashes.has(hash) && !this.tempKnownBlockHashes.has(common.uInt256ToHex(hash)));
                break;
            case InventoryType.Consensus: // Consensus
                hashes = inv.hashes;
                break;
            default:
                commonUtils.assertNever(inv.type);
                hashes = [];
        }
        if (hashes.length > 0) {
            this.sendMessage(peer, this.createMessage({
                command: Command.getdata,
                payload: new InvPayload({ type: inv.type, hashes }),
            }));
        }
    }
    onMemPoolMessageReceived(_monitor, peer) {
        this.sendMessage(peer, this.createMessage({
            command: Command.inv,
            payload: new InvPayload({
                type: InventoryType.Transaction,
                hashes: Object.values(this.mutableMemPool).map((transaction) => transaction.hash),
            }),
        }));
    }
    async onTransactionReceived(_monitor, transaction) {
        if (this.ready()) {
            if (transaction.type === TransactionType.Miner) {
                if (this.mutableConsensus !== undefined) {
                    this.mutableConsensus.onTransactionReceived(transaction);
                }
            }
            else {
                await this.relayTransaction(transaction);
            }
        }
    }
    onVerackMessageReceived(_monitor, peer) {
        peer.close();
    }
    onVersionMessageReceived(_monitor, peer) {
        peer.close();
    }
    async getHeaders(getBlocks, maxHeight) {
        let hashStopIndexPromise = Promise.resolve(maxHeight);
        if (!getBlocks.hashStop.equals(common.ZERO_UINT256)) {
            hashStopIndexPromise = this.blockchain.header
                .tryGet({ hashOrIndex: getBlocks.hashStop })
                .then((hashStopHeader) => hashStopHeader === undefined ? maxHeight : Math.min(hashStopHeader.index, maxHeight));
        }
        const [hashStartHeaders, hashEnd] = await Promise.all([
            Promise.all(getBlocks.hashStart.map(async (hash) => this.blockchain.header.tryGet({ hashOrIndex: hash }))),
            hashStopIndexPromise,
        ]);
        const hashStartHeader = _.head(_.orderBy(hashStartHeaders.filter(commonUtils.notNull), [(header) => header.index]));
        if (hashStartHeader === undefined) {
            return [];
        }
        const hashStart = hashStartHeader.index + 1;
        if (hashStart > maxHeight) {
            return [];
        }
        return Promise.all(_.range(hashStart, Math.min(hashStart + GET_BLOCKS_COUNT, hashEnd)).map(async (index) => this.blockchain.header.get({ hashOrIndex: index })));
    }
    testFilter(bloomFilterIn, transaction) {
        const bloomFilter = bloomFilterIn;
        if (bloomFilter === undefined) {
            return true;
        }
        return (bloomFilter.contains(transaction.hash) ||
            transaction.outputs.some((output) => bloomFilter.contains(output.address)) ||
            transaction.inputs.some((input) => bloomFilter.contains(input.serializeWire())) ||
            transaction.scripts.some((script) => bloomFilter.contains(crypto.toScriptHash(script.verification))) ||
            (transaction.type === TransactionType.Register &&
                transaction instanceof RegisterTransaction &&
                bloomFilter.contains(transaction.asset.admin)));
    }
    createMerkleBlockPayload({ block, flags, }) {
        const tree = new MerkleTree(block.transactions.map((transaction) => transaction.hash)).trim(flags);
        const mutableBuffer = Buffer.allocUnsafe(Math.floor((flags.length + 7) / 8));
        // tslint:disable-next-line no-loop-statement
        for (let i = 0; i < flags.length; i += 1) {
            if (flags[i]) {
                // tslint:disable-next-line no-bitwise
                mutableBuffer[Math.floor(i / 8)] |= 1 << i % 8;
            }
        }
        return new MerkleBlockPayload({
            version: block.version,
            previousHash: block.previousHash,
            merkleRoot: block.merkleRoot,
            timestamp: block.timestamp,
            index: block.index,
            consensusData: block.consensusData,
            nextConsensus: block.nextConsensus,
            script: block.script,
            transactionCount: block.transactions.length,
            hashes: tree.toHashArray(),
            flags: mutableBuffer,
        });
    }
    createMessage(value) {
        return new Message({
            magic: this.blockchain.settings.messageMagic,
            value,
        });
    }
}

//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["Node.ts"],"names":[],"mappings":"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","file":"neo-one-node-protocol/src/Node.js","sourcesContent":["import { common, crypto, UInt256Hex, utils } from '@neo-one/client-common-esnext-esm';\nimport { metrics, Monitor } from '@neo-one/monitor-esnext-esm';\nimport { Consensus, ConsensusOptions } from '@neo-one/node-consensus-esnext-esm';\nimport {\n  Block,\n  Blockchain,\n  ConnectedPeer,\n  ConsensusPayload,\n  createEndpoint,\n  CreateNetwork,\n  Endpoint,\n  getEndpointConfig,\n  Header,\n  MerkleTree,\n  NegotiateResult,\n  Network,\n  NetworkEventMessage,\n  Node as INode,\n  Peer,\n  RegisterTransaction,\n  RelayTransactionResult,\n  Transaction,\n  TransactionType,\n  VerifyTransactionResult,\n} from '@neo-one/node-core-esnext-esm';\nimport { finalize, labels, neverComplete, utils as commonUtils } from '@neo-one/utils-esnext-esm';\nimport { ScalingBloem } from 'bloem';\n// tslint:disable-next-line:match-default-export-name\nimport BloomFilter from 'bloom-filter';\nimport BN from 'bn.js';\nimport fetch from 'cross-fetch';\nimport { Address6 } from 'ip-address';\nimport _ from 'lodash';\nimport LRU from 'lru-cache';\nimport { combineLatest, defer, Observable, of as _of } from 'rxjs';\nimport { distinctUntilChanged, map, switchMap, take } from 'rxjs/operators';\nimport { Command } from './Command';\nimport { AlreadyConnectedError, NegotiationError } from './errors';\nimport { Message, MessageTransform, MessageValue } from './Message';\nimport {\n  AddrPayload,\n  FilterAddPayload,\n  FilterLoadPayload,\n  GetBlocksPayload,\n  HeadersPayload,\n  InventoryType,\n  InvPayload,\n  MerkleBlockPayload,\n  NetworkAddress,\n  SERVICES,\n  VersionPayload,\n} from './payload';\nimport { PeerData } from './PeerData';\n\nconst messageReceivedLabelNames: ReadonlyArray<string> = [labels.COMMAND_NAME];\nconst messageReceivedLabels = Object.keys(Command).map((command) => ({\n  [labels.COMMAND_NAME]: command,\n}));\n\nconst NEO_PROTOCOL_MESSAGES_RECEIVED_TOTAL = metrics.createCounter({\n  name: 'neo_protocol_messages_received_total',\n  labelNames: messageReceivedLabelNames,\n  labels: messageReceivedLabels,\n});\n\nconst NEO_PROTOCOL_MESSAGES_FAILURES_TOTAL = metrics.createCounter({\n  name: 'neo_protocol_messages_failures_total',\n  labelNames: messageReceivedLabelNames,\n  labels: messageReceivedLabels,\n});\n\nconst NEO_PROTOCOL_MEMPOOL_SIZE = metrics.createGauge({\n  name: 'neo_protocol_mempool_size',\n});\nexport interface TransactionAndFee {\n  readonly transaction: Transaction;\n  readonly networkFee: BN;\n}\n\nexport interface Environment {\n  readonly externalPort?: number;\n}\nexport interface Options {\n  readonly consensus?: {\n    readonly enabled: boolean;\n    readonly options: ConsensusOptions;\n  };\n  readonly rpcURLs?: ReadonlyArray<string>;\n  readonly unhealthyPeerSeconds?: number;\n}\n\nconst createPeerBloomFilter = ({\n  filter,\n  k,\n  tweak,\n}: {\n  readonly filter: Buffer;\n  readonly k: number;\n  readonly tweak: number;\n}) =>\n  new BloomFilter({\n    vData: Buffer.from(filter),\n    nHashFuncs: k,\n    nTweak: tweak,\n  });\n\nconst createScalingBloomFilter = () =>\n  new ScalingBloem(0.05, {\n    initial_capacity: 100000,\n    scaling: 4,\n  });\n\nconst compareTransactionAndFees = (val1: TransactionAndFee, val2: TransactionAndFee) => {\n  const a = val1.networkFee.divn(val1.transaction.size);\n  const b = val2.networkFee.divn(val2.transaction.size);\n  if (a.lt(b)) {\n    return -1;\n  }\n  if (b.lt(a)) {\n    return 1;\n  }\n\n  return val1.transaction.hash.compare(val2.transaction.hash);\n};\n\nconst MEM_POOL_SIZE = 5000;\nconst GET_ADDR_PEER_COUNT = 200;\nconst GET_BLOCKS_COUNT = 500;\n// Assume that we get 500 back, but if not, at least request every 10 seconds\nconst GET_BLOCKS_BUFFER = GET_BLOCKS_COUNT / 3;\nconst GET_BLOCKS_TIME_MS = 10000;\nconst GET_BLOCKS_THROTTLE_MS = 1000;\nconst TRIM_MEMPOOL_THROTTLE = 5000;\nconst GET_BLOCKS_CLOSE_COUNT = 2;\nconst UNHEALTHY_PEER_SECONDS = 300;\nconst LOCAL_HOST_ADDRESSES = new Set(['', '0.0.0.0', 'localhost', '127.0.0.1', '::', '::1']);\n\ninterface PeerHealth {\n  readonly healthy: boolean;\n  readonly blockIndex: number | undefined;\n  readonly checkTimeSeconds: number;\n}\n\nexport class Node implements INode {\n  public get consensus(): Consensus | undefined {\n    return this.mutableConsensus;\n  }\n\n  public get connectedPeers(): ReadonlyArray<Endpoint> {\n    return this.network.connectedPeers.map((peer) => peer.endpoint);\n  }\n\n  public get memPool(): { readonly [hash: string]: Transaction } {\n    return this.mutableMemPool;\n  }\n  public readonly blockchain: Blockchain;\n  // tslint:disable-next-line readonly-keyword\n  private mutableMemPool: { [hash: string]: Transaction };\n  private readonly monitor: Monitor;\n  private readonly network: Network<Message, PeerData>;\n  private readonly options$: Observable<Options>;\n  private readonly externalPort: number;\n  private readonly nonce: number;\n  private readonly userAgent: string;\n  private mutableKnownBlockHashes: ScalingBloem;\n  private readonly tempKnownBlockHashes: Set<UInt256Hex>;\n  private mutableKnownTransactionHashes: ScalingBloem;\n  private readonly tempKnownTransactionHashes: Set<UInt256Hex>;\n  private mutableKnownHeaderHashes: ScalingBloem;\n  private readonly tempKnownHeaderHashes: Set<UInt256Hex>;\n  private mutableGetBlocksRequestsIndex: number | undefined;\n  private mutableGetBlocksRequestTime: number | undefined;\n  private mutableGetBlocksRequestsCount: number;\n  private mutableBestPeer: ConnectedPeer<Message, PeerData> | undefined;\n  private mutableUnhealthyPeerSeconds = UNHEALTHY_PEER_SECONDS;\n  private readonly consensusCache: LRU.Cache<string, ConsensusPayload>;\n  // tslint:disable-next-line readonly-keyword\n  private mutableBlockIndex: { [endpoint: string]: number };\n  private mutableConsensus: Consensus | undefined;\n  private readonly requestBlocks = _.debounce(() => {\n    const peer = this.mutableBestPeer;\n    const previousBlock = this.blockchain.previousBlock;\n    const block = previousBlock === undefined ? this.blockchain.currentBlock : previousBlock;\n    if (peer !== undefined && block.index < peer.data.startHeight) {\n      if (this.mutableGetBlocksRequestsCount > GET_BLOCKS_CLOSE_COUNT) {\n        this.mutableBestPeer = this.findBestPeer(peer);\n        this.network.blacklistAndClose(peer);\n        this.mutableGetBlocksRequestsCount = 0;\n      } else if (this.shouldRequestBlocks()) {\n        if (this.mutableGetBlocksRequestsIndex === block.index) {\n          this.mutableGetBlocksRequestsCount += 1;\n        } else {\n          this.mutableGetBlocksRequestsCount = 1;\n          this.mutableGetBlocksRequestsIndex = block.index;\n        }\n        this.mutableGetBlocksRequestTime = Date.now();\n        this.sendMessage(\n          peer,\n          this.createMessage({\n            command: Command.getblocks,\n            payload: new GetBlocksPayload({\n              hashStart: [block.hash],\n            }),\n          }),\n        );\n      }\n\n      this.requestBlocks();\n    }\n  }, GET_BLOCKS_THROTTLE_MS);\n  private readonly onRequestEndpoints = _.throttle((): void => {\n    this.relay(this.createMessage({ command: Command.getaddr }));\n    // tslint:disable-next-line no-floating-promises\n    this.fetchEndpointsFromRPC();\n  }, 5000);\n\n  // tslint:disable-next-line no-unnecessary-type-annotation\n  private readonly trimMemPool = _.throttle(async (monitor: Monitor): Promise<void> => {\n    const memPool = Object.values(this.mutableMemPool);\n    if (memPool.length > MEM_POOL_SIZE) {\n      await monitor.captureSpan(\n        async () => {\n          const transactionAndFees = await Promise.all(\n            memPool.map<Promise<TransactionAndFee>>(async (transaction) => {\n              const networkFee = await transaction.getNetworkFee({\n                getOutput: this.blockchain.output.get,\n                governingToken: this.blockchain.settings.governingToken,\n                utilityToken: this.blockchain.settings.utilityToken,\n                fees: this.blockchain.settings.fees,\n                registerValidatorFee: this.blockchain.settings.registerValidatorFee,\n              });\n\n              return { transaction, networkFee };\n            }),\n          );\n\n          const hashesToRemove = _.take<TransactionAndFee>(\n            // tslint:disable-next-line no-array-mutation\n            transactionAndFees.slice().sort(compareTransactionAndFees),\n            this.blockchain.settings.memPoolSize,\n          ).map((transactionAndFee) => transactionAndFee.transaction.hashHex);\n          hashesToRemove.forEach((hash) => {\n            // tslint:disable-next-line no-dynamic-delete\n            delete this.mutableMemPool[hash];\n          });\n          NEO_PROTOCOL_MEMPOOL_SIZE.set(Object.keys(this.mutableMemPool).length);\n        },\n        {\n          name: 'neo_protocol_trim_mempool',\n        },\n      );\n    }\n  }, TRIM_MEMPOOL_THROTTLE);\n\n  public constructor({\n    monitor,\n    blockchain,\n    createNetwork,\n    environment = {},\n    options$,\n  }: {\n    readonly monitor: Monitor;\n    readonly blockchain: Blockchain;\n    readonly createNetwork: CreateNetwork;\n    readonly environment?: Environment;\n    readonly options$: Observable<Options>;\n  }) {\n    this.blockchain = blockchain;\n    this.monitor = monitor.at('node_protocol');\n    this.network = createNetwork({\n      negotiate: this.negotiate,\n      checkPeerHealth: this.checkPeerHealth,\n      createMessageTransform: () => new MessageTransform(this.blockchain.deserializeWireContext),\n      onMessageReceived: (peer, message: Message) => {\n        this.onMessageReceived(peer, message);\n      },\n      onRequestEndpoints: this.onRequestEndpoints.bind(this),\n      onEvent: this.onEvent,\n    });\n\n    this.options$ = options$;\n\n    const { externalPort = 0 } = environment;\n    this.externalPort = externalPort;\n    this.nonce = Math.floor(Math.random() * utils.UINT_MAX_NUMBER);\n    this.userAgent = `NEO:neo-one-js:1.0.0-preview`;\n\n    this.mutableMemPool = {};\n    this.mutableKnownBlockHashes = createScalingBloomFilter();\n    this.tempKnownBlockHashes = new Set();\n    this.mutableKnownTransactionHashes = createScalingBloomFilter();\n    this.tempKnownTransactionHashes = new Set();\n    this.mutableKnownHeaderHashes = createScalingBloomFilter();\n    this.tempKnownHeaderHashes = new Set();\n    this.mutableGetBlocksRequestsCount = 1;\n    this.consensusCache = LRU(10000);\n    this.mutableBlockIndex = {};\n  }\n\n  public async reset(): Promise<void> {\n    this.mutableMemPool = {};\n    this.mutableKnownBlockHashes = createScalingBloomFilter();\n    this.tempKnownBlockHashes.clear();\n    this.mutableKnownTransactionHashes = createScalingBloomFilter();\n    this.tempKnownTransactionHashes.clear();\n    this.mutableKnownHeaderHashes = createScalingBloomFilter();\n    this.tempKnownHeaderHashes.clear();\n    this.mutableGetBlocksRequestsCount = 1;\n    this.consensusCache.reset();\n    this.mutableBlockIndex = {};\n  }\n\n  // tslint:disable-next-line no-any\n  public start$(): Observable<any> {\n    const network$ = defer(async () => {\n      this.network.start();\n      this.monitor.log({\n        name: 'neo_protocol_start',\n        message: 'Protocol started.',\n        level: 'verbose',\n      });\n    }).pipe(\n      neverComplete(),\n      finalize(() => {\n        this.network.stop();\n        this.monitor.log({\n          name: 'neo_protocol_stop',\n          message: 'Protocol stopped.',\n          level: 'verbose',\n        });\n      }),\n    );\n\n    const defaultOptions = {\n      enabled: false,\n      options: { privateKey: 'unused', privateNet: false },\n    };\n\n    const consensus$ = this.options$.pipe(\n      map(({ consensus = defaultOptions }) => consensus.enabled),\n      distinctUntilChanged(),\n      switchMap((enabled) => {\n        if (enabled) {\n          const mutableConsensus = new Consensus({\n            monitor: this.monitor,\n            options$: this.options$.pipe(\n              map(({ consensus = defaultOptions }) => consensus.options),\n              distinctUntilChanged(),\n            ),\n\n            node: this,\n          });\n\n          this.mutableConsensus = mutableConsensus;\n\n          return mutableConsensus.start$();\n        }\n\n        return _of(undefined);\n      }),\n    );\n\n    const options$ = this.options$.pipe(\n      map(({ unhealthyPeerSeconds = UNHEALTHY_PEER_SECONDS }) => {\n        this.mutableUnhealthyPeerSeconds = unhealthyPeerSeconds;\n      }),\n    );\n\n    return combineLatest(network$, consensus$, options$);\n  }\n\n  public async relayTransaction(\n    transaction: Transaction,\n    {\n      throwVerifyError = false,\n      forceAdd = false,\n    }: { readonly throwVerifyError?: boolean; readonly forceAdd?: boolean } = {\n      throwVerifyError: false,\n      forceAdd: false,\n    },\n  ): Promise<RelayTransactionResult> {\n    const result = {};\n\n    if (\n      transaction.type === TransactionType.Miner ||\n      (this.mutableMemPool[transaction.hashHex] as Transaction | undefined) !== undefined ||\n      this.tempKnownTransactionHashes.has(transaction.hashHex)\n    ) {\n      return result;\n    }\n\n    if (!this.mutableKnownTransactionHashes.has(transaction.hash)) {\n      this.tempKnownTransactionHashes.add(transaction.hashHex);\n\n      try {\n        const memPool = Object.values(this.mutableMemPool);\n        if (memPool.length > MEM_POOL_SIZE / 2 && !forceAdd) {\n          this.mutableKnownTransactionHashes.add(transaction.hash);\n\n          return result;\n        }\n\n        // tslint:disable-next-line prefer-immediate-return\n        const finalResult = await this.monitor\n          .withData({ [labels.NEO_TRANSACTION_HASH]: transaction.hashHex })\n          .captureSpanLog(\n            async (span) => {\n              let foundTransaction;\n              try {\n                foundTransaction = await this.blockchain.transaction.tryGet({\n                  hash: transaction.hash,\n                });\n              } finally {\n                span.setLabels({\n                  [labels.NEO_TRANSACTION_FOUND]: foundTransaction !== undefined,\n                });\n              }\n              let verifyResult: VerifyTransactionResult | undefined;\n              if (foundTransaction === undefined) {\n                verifyResult = await this.blockchain.verifyTransaction({\n                  monitor: span,\n                  transaction,\n                  memPool: Object.values(this.mutableMemPool),\n                });\n                const verified = verifyResult.verifications.every(({ failureMessage }) => failureMessage === undefined);\n\n                if (verified) {\n                  this.mutableMemPool[transaction.hashHex] = transaction;\n                  NEO_PROTOCOL_MEMPOOL_SIZE.inc();\n                  if (this.mutableConsensus !== undefined) {\n                    this.mutableConsensus.onTransactionReceived(transaction);\n                  }\n                  this.relayTransactionInternal(transaction);\n                  await this.trimMemPool(span);\n                }\n              }\n\n              this.mutableKnownTransactionHashes.add(transaction.hash);\n\n              return { verifyResult };\n            },\n            {\n              name: 'neo_relay_transaction',\n              level: { log: 'verbose', span: 'info' },\n              trace: true,\n            },\n          );\n\n        // tslint:disable-next-line no-var-before-return\n        return finalResult;\n      } catch (error) {\n        if (\n          error.code === undefined ||\n          typeof error.code !== 'string' ||\n          !error.code.includes('VERIFY') ||\n          throwVerifyError\n        ) {\n          throw error;\n        }\n      } finally {\n        this.tempKnownTransactionHashes.delete(transaction.hashHex);\n      }\n    }\n\n    return result;\n  }\n\n  public async relayBlock(block: Block, monitor?: Monitor): Promise<void> {\n    await this.persistBlock(block, monitor);\n  }\n\n  public relayConsensusPayload(payload: ConsensusPayload): void {\n    const message = this.createMessage({\n      command: Command.inv,\n      payload: new InvPayload({\n        type: InventoryType.Consensus,\n        hashes: [payload.hash],\n      }),\n    });\n\n    this.consensusCache.set(payload.hashHex, payload);\n    this.relay(message);\n  }\n\n  public syncMemPool(): void {\n    this.relay(this.createMessage({ command: Command.mempool }));\n  }\n\n  private relay(message: Message): void {\n    this.network.relay(message.serializeWire());\n  }\n\n  private relayTransactionInternal(transaction: Transaction): void {\n    const message = this.createMessage({\n      command: Command.inv,\n      payload: new InvPayload({\n        type: InventoryType.Transaction,\n        hashes: [transaction.hash],\n      }),\n    });\n\n    const messagePayload = message.serializeWire();\n    this.network.connectedPeers.forEach((peer) => {\n      if (peer.relay && this.testFilter(peer.data.mutableBloomFilter, transaction)) {\n        peer.write(messagePayload);\n      }\n    });\n  }\n\n  private sendMessage(peer: Peer<Message> | ConnectedPeer<Message, PeerData>, message: Message): void {\n    peer.write(message.serializeWire());\n  }\n  private readonly negotiate = async (peer: Peer<Message>): Promise<NegotiateResult<PeerData>> => {\n    this.sendMessage(\n      peer,\n      this.createMessage({\n        command: Command.version,\n        payload: new VersionPayload({\n          protocolVersion: 0,\n          services: SERVICES.NODE_NETWORK,\n          timestamp: Math.round(Date.now() / 1000),\n          port: this.externalPort,\n          nonce: this.nonce,\n          userAgent: this.userAgent,\n          startHeight: this.blockchain.currentBlockIndex,\n          relay: true,\n        }),\n      }),\n    );\n\n    const message = await peer.receiveMessage(30000);\n    let versionPayload;\n    if (message.value.command === Command.version) {\n      versionPayload = message.value.payload;\n    } else {\n      throw new NegotiationError(message);\n    }\n\n    this.checkVersion(peer, message, versionPayload);\n\n    const { host } = getEndpointConfig(peer.endpoint);\n    let address;\n    if (NetworkAddress.isValid(host)) {\n      address = new NetworkAddress({\n        host,\n        port: versionPayload.port,\n        timestamp: versionPayload.timestamp,\n        services: versionPayload.services,\n      });\n    }\n\n    this.sendMessage(peer, this.createMessage({ command: Command.verack }));\n\n    const nextMessage = await peer.receiveMessage(30000);\n    if (nextMessage.value.command !== Command.verack) {\n      throw new NegotiationError(nextMessage);\n    }\n\n    return {\n      data: {\n        nonce: versionPayload.nonce,\n        startHeight: versionPayload.startHeight,\n        mutableBloomFilter: undefined,\n        address,\n      },\n\n      relay: versionPayload.relay,\n    };\n  };\n  private readonly checkPeerHealth = (peer: ConnectedPeer<Message, PeerData>, prevHealth?: PeerHealth) => {\n    const checkTimeSeconds = commonUtils.nowSeconds();\n    const blockIndex = this.mutableBlockIndex[peer.endpoint] as number | undefined;\n\n    // If first check -> healthy\n    if (prevHealth === undefined) {\n      return { healthy: true, checkTimeSeconds, blockIndex };\n    }\n\n    // If seen new block -> healthy + update check time\n    if (prevHealth.blockIndex !== undefined && blockIndex !== undefined && prevHealth.blockIndex < blockIndex) {\n      return { healthy: true, checkTimeSeconds, blockIndex };\n    }\n\n    // If not seen a block or a new block BUT it has NOT been a long\n    // time -> healthy\n    if (\n      prevHealth.blockIndex === blockIndex &&\n      commonUtils.nowSeconds() - prevHealth.checkTimeSeconds < this.mutableUnhealthyPeerSeconds\n    ) {\n      return {\n        healthy: true,\n        checkTimeSeconds: prevHealth.checkTimeSeconds,\n        blockIndex: prevHealth.blockIndex,\n      };\n    }\n\n    return { healthy: false, checkTimeSeconds, blockIndex };\n  };\n  private readonly onEvent = (event: NetworkEventMessage<Message, PeerData>) => {\n    if (event.event === 'PEER_CONNECT_SUCCESS') {\n      const { connectedPeer } = event;\n      if (\n        this.mutableBestPeer === undefined ||\n        // Only change best peer at most every 100 blocks\n        this.mutableBestPeer.data.startHeight + 100 < connectedPeer.data.startHeight\n      ) {\n        this.mutableBestPeer = connectedPeer;\n        this.resetRequestBlocks();\n        this.requestBlocks();\n      }\n    } else if (\n      event.event === 'PEER_CLOSED' &&\n      this.mutableBestPeer !== undefined &&\n      this.mutableBestPeer.endpoint === event.peer.endpoint\n    ) {\n      this.mutableBestPeer = this.findBestPeer();\n      this.resetRequestBlocks();\n      this.requestBlocks();\n    }\n  };\n\n  private findBestPeer(bestPeer?: ConnectedPeer<Message, PeerData>): ConnectedPeer<Message, PeerData> | undefined {\n    let peers = this.network.connectedPeers;\n    if (bestPeer !== undefined) {\n      peers = peers.filter((peer) => peer.endpoint !== bestPeer.endpoint);\n    }\n    const result = _.maxBy(peers, (peer) => peer.data.startHeight);\n    if (result === undefined) {\n      return undefined;\n    }\n\n    return _.shuffle(peers.filter((peer) => peer.data.startHeight === result.data.startHeight))[0];\n  }\n\n  private resetRequestBlocks(): void {\n    this.mutableGetBlocksRequestsIndex = undefined;\n    this.mutableGetBlocksRequestsCount = 0;\n  }\n\n  private shouldRequestBlocks(): boolean {\n    const block = this.blockchain.currentBlock;\n    const getBlocksRequestTime = this.mutableGetBlocksRequestTime;\n\n    return (\n      this.mutableGetBlocksRequestsIndex === undefined ||\n      block.index - this.mutableGetBlocksRequestsIndex > GET_BLOCKS_BUFFER ||\n      getBlocksRequestTime === undefined ||\n      Date.now() - getBlocksRequestTime > GET_BLOCKS_TIME_MS\n    );\n  }\n\n  private checkVersion(peer: Peer<Message>, message: Message, version: VersionPayload): void {\n    if (version.nonce === this.nonce) {\n      this.network.permanentlyBlacklist(peer.endpoint);\n      throw new NegotiationError(message, 'Nonce equals my nonce.');\n    }\n\n    const connectedPeer = this.network.connectedPeers.find((otherPeer) => version.nonce === otherPeer.data.nonce);\n\n    if (connectedPeer !== undefined) {\n      throw new AlreadyConnectedError('Already connected to nonce.');\n    }\n  }\n\n  private ready(): boolean {\n    const peer = this.mutableBestPeer;\n    const block = this.blockchain.currentBlock;\n\n    return peer !== undefined && block.index >= peer.data.startHeight;\n  }\n\n  private async fetchEndpointsFromRPC(): Promise<void> {\n    try {\n      await this.doFetchEndpointsFromRPC();\n    } catch {\n      // ignore, logged deeper in the stack\n    }\n  }\n\n  private async doFetchEndpointsFromRPC(): Promise<void> {\n    const { rpcURLs = [] } = await this.options$.pipe(take(1)).toPromise();\n    await Promise.all(rpcURLs.map(async (rpcURL) => this.fetchEndpointsFromRPCURL(rpcURL)));\n  }\n\n  private async fetchEndpointsFromRPCURL(rpcURL: string): Promise<void> {\n    try {\n      const response = await fetch(rpcURL, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n        },\n        body: JSON.stringify({\n          jsonrpc: '2.0',\n          id: 1,\n          method: 'getpeers',\n          params: [],\n        }),\n      });\n\n      if (!response.ok) {\n        throw new Error(`Failed to fetch peers from ${rpcURL}: ${response.status} ${response.statusText}`);\n      }\n\n      const result = await response.json();\n\n      if (\n        typeof result === 'object' &&\n        result.error !== undefined &&\n        typeof result.error === 'object' &&\n        typeof result.error.code === 'number' &&\n        typeof result.error.message === 'string'\n      ) {\n        throw new Error(result.error);\n      }\n\n      const connected: ReadonlyArray<{ readonly address: string; readonly port: number }> = result.result.connected;\n      connected\n        .map((peer) => {\n          const { address, port } = peer;\n          const host = new Address6(address);\n          const canonicalForm = host.canonicalForm() as string | undefined | null;\n\n          return { host: canonicalForm == undefined ? '' : canonicalForm, port };\n        })\n        .filter((endpoint) => !LOCAL_HOST_ADDRESSES.has(endpoint.host))\n        .map((endpoint) =>\n          createEndpoint({\n            type: 'tcp',\n            host: endpoint.host,\n            port: endpoint.port,\n          }),\n        )\n        .forEach((endpoint) => this.network.addEndpoint(endpoint));\n    } catch (error) {\n      this.monitor.withData({ [this.monitor.labels.HTTP_URL]: rpcURL }).logError({\n        name: 'neo_protocol_fetch_endpoints_error',\n        message: `Failed to fetch endpoints from ${rpcURL}`,\n        error,\n      });\n    }\n  }\n\n  private onMessageReceived(peer: ConnectedPeer<Message, PeerData>, message: Message): void {\n    this.monitor\n      .withLabels({ [labels.COMMAND_NAME]: message.value.command })\n      .withData({ [this.monitor.labels.PEER_ADDRESS]: peer.endpoint })\n      .captureLog(\n        async (monitor) => {\n          switch (message.value.command) {\n            case Command.addr:\n              this.onAddrMessageReceived(monitor, message.value.payload);\n              break;\n            case Command.block:\n              await this.onBlockMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.consensus:\n              await this.onConsensusMessageReceived(monitor, message.value.payload);\n\n              break;\n            case Command.filteradd:\n              this.onFilterAddMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.filterclear:\n              this.onFilterClearMessageReceived(monitor, peer);\n              break;\n            case Command.filterload:\n              this.onFilterLoadMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.getaddr:\n              this.onGetAddrMessageReceived(monitor, peer);\n              break;\n            case Command.getblocks:\n              await this.onGetBlocksMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.getdata:\n              await this.onGetDataMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.getheaders:\n              await this.onGetHeadersMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.headers:\n              await this.onHeadersMessageReceived(monitor, peer, message.value.payload);\n\n              break;\n            case Command.inv:\n              this.onInvMessageReceived(monitor, peer, message.value.payload);\n              break;\n            case Command.mempool:\n              this.onMemPoolMessageReceived(monitor, peer);\n              break;\n            case Command.tx:\n              await this.onTransactionReceived(monitor, message.value.payload);\n              break;\n            case Command.verack:\n              this.onVerackMessageReceived(monitor, peer);\n              break;\n            case Command.version:\n              this.onVersionMessageReceived(monitor, peer);\n              break;\n            case Command.alert:\n              break;\n            case Command.merkleblock:\n              break;\n            case Command.notfound:\n              break;\n            case Command.ping:\n              break;\n            case Command.pong:\n              break;\n            case Command.reject:\n              break;\n            default:\n              commonUtils.assertNever(message.value);\n          }\n        },\n        {\n          name: 'neo_protocol_message_received',\n          level: 'debug',\n          message: `Received ${message.value.command} from ${peer.endpoint}`,\n          metric: NEO_PROTOCOL_MESSAGES_RECEIVED_TOTAL,\n          error: {\n            metric: NEO_PROTOCOL_MESSAGES_FAILURES_TOTAL,\n            message: `Failed to process message ${message.value.command} from ${peer.endpoint}`,\n          },\n        },\n      )\n      .catch(() => {\n        // do nothing\n      });\n  }\n\n  private onAddrMessageReceived(_monitor: Monitor, addr: AddrPayload): void {\n    addr.addresses\n      .filter((address) => !LOCAL_HOST_ADDRESSES.has(address.host))\n      .map((address) =>\n        createEndpoint({\n          type: 'tcp',\n          host: address.host,\n          port: address.port,\n        }),\n      )\n      .forEach((endpoint) => this.network.addEndpoint(endpoint));\n  }\n\n  private async onBlockMessageReceived(\n    monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    block: Block,\n  ): Promise<void> {\n    const blockIndex = this.mutableBlockIndex[peer.endpoint] as number | undefined;\n    this.mutableBlockIndex[peer.endpoint] = Math.max(block.index, blockIndex === undefined ? 0 : blockIndex);\n\n    await this.relayBlock(block, monitor);\n  }\n\n  private async persistBlock(block: Block, monitor: Monitor = this.monitor): Promise<void> {\n    if (this.blockchain.currentBlockIndex > block.index || this.tempKnownBlockHashes.has(block.hashHex)) {\n      return;\n    }\n\n    if (!this.mutableKnownBlockHashes.has(block.hash)) {\n      this.tempKnownBlockHashes.add(block.hashHex);\n\n      try {\n        const foundBlock = await this.blockchain.block.tryGet({\n          hashOrIndex: block.hash,\n        });\n\n        if (foundBlock === undefined) {\n          await monitor.withData({ [labels.NEO_BLOCK_INDEX]: block.index }).captureSpanLog(\n            async (span) => {\n              await this.blockchain.persistBlock({ monitor: span, block });\n              if (this.mutableConsensus !== undefined) {\n                this.mutableConsensus.onPersistBlock();\n              }\n\n              const peer = this.mutableBestPeer;\n              if (peer !== undefined && block.index > peer.data.startHeight) {\n                this.relay(\n                  this.createMessage({\n                    command: Command.inv,\n                    payload: new InvPayload({\n                      type: InventoryType.Block,\n                      hashes: [block.hash],\n                    }),\n                  }),\n                );\n              }\n            },\n            {\n              name: 'neo_relay_block',\n              level: { log: 'verbose', span: 'info' },\n              trace: true,\n            },\n          );\n        }\n\n        this.mutableKnownBlockHashes.add(block.hash);\n        this.mutableKnownHeaderHashes.add(block.hash);\n        block.transactions.forEach((transaction) => {\n          // tslint:disable-next-line no-dynamic-delete\n          delete this.mutableMemPool[transaction.hashHex];\n          this.mutableKnownTransactionHashes.add(transaction.hash);\n        });\n        NEO_PROTOCOL_MEMPOOL_SIZE.set(Object.keys(this.mutableMemPool).length);\n      } finally {\n        this.tempKnownBlockHashes.delete(block.hashHex);\n      }\n    }\n  }\n\n  private async onConsensusMessageReceived(monitor: Monitor, payload: ConsensusPayload): Promise<void> {\n    const { consensus } = this;\n    if (consensus !== undefined) {\n      await this.blockchain.verifyConsensusPayload(payload, monitor);\n      consensus.onConsensusPayloadReceived(payload);\n    }\n  }\n\n  private onFilterAddMessageReceived(\n    _monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    filterAdd: FilterAddPayload,\n  ): void {\n    if (peer.data.mutableBloomFilter !== undefined) {\n      peer.data.mutableBloomFilter.insert(filterAdd.data);\n    }\n  }\n\n  private onFilterClearMessageReceived(_monitor: Monitor, peer: ConnectedPeer<Message, PeerData>): void {\n    // tslint:disable-next-line no-object-mutation\n    peer.data.mutableBloomFilter = undefined;\n  }\n\n  private onFilterLoadMessageReceived(\n    _monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    filterLoad: FilterLoadPayload,\n  ): void {\n    // tslint:disable-next-line no-object-mutation\n    peer.data.mutableBloomFilter = createPeerBloomFilter(filterLoad);\n  }\n\n  private onGetAddrMessageReceived(_monitor: Monitor, peer: ConnectedPeer<Message, PeerData>): void {\n    const addresses = _.take(\n      _.shuffle(\n        this.network.connectedPeers.map((connectedPeer) => connectedPeer.data.address).filter(commonUtils.notNull),\n      ),\n      GET_ADDR_PEER_COUNT,\n    );\n\n    if (addresses.length > 0) {\n      this.sendMessage(\n        peer,\n        this.createMessage({\n          command: Command.addr,\n          payload: new AddrPayload({ addresses }),\n        }),\n      );\n    }\n  }\n\n  private async onGetBlocksMessageReceived(\n    _monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    getBlocks: GetBlocksPayload,\n  ): Promise<void> {\n    const headers = await this.getHeaders(getBlocks, this.blockchain.currentBlockIndex);\n\n    this.sendMessage(\n      peer,\n      this.createMessage({\n        command: Command.inv,\n        payload: new InvPayload({\n          type: InventoryType.Block,\n          hashes: headers.map((header) => header.hash),\n        }),\n      }),\n    );\n  }\n\n  private async onGetDataMessageReceived(\n    _monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    getData: InvPayload,\n  ): Promise<void> {\n    switch (getData.type) {\n      case InventoryType.Transaction:\n        await Promise.all(\n          getData.hashes.map(async (hash) => {\n            let transaction = this.mutableMemPool[common.uInt256ToHex(hash)] as Transaction | undefined;\n            if (transaction === undefined) {\n              transaction = await this.blockchain.transaction.tryGet({ hash });\n            }\n\n            if (transaction !== undefined) {\n              this.sendMessage(\n                peer,\n                this.createMessage({\n                  command: Command.tx,\n                  payload: transaction,\n                }),\n              );\n            }\n          }),\n        );\n\n        break;\n      case InventoryType.Block: // Block\n        await Promise.all(\n          getData.hashes.map(async (hash) => {\n            const block = await this.blockchain.block.tryGet({\n              hashOrIndex: hash,\n            });\n\n            if (block !== undefined) {\n              if (peer.data.mutableBloomFilter === undefined) {\n                this.sendMessage(\n                  peer,\n                  this.createMessage({\n                    command: Command.block,\n                    payload: block,\n                  }),\n                );\n              } else {\n                this.sendMessage(\n                  peer,\n                  this.createMessage({\n                    command: Command.merkleblock,\n                    payload: this.createMerkleBlockPayload({\n                      block,\n                      flags: block.transactions.map((transaction) =>\n                        this.testFilter(peer.data.mutableBloomFilter, transaction),\n                      ),\n                    }),\n                  }),\n                );\n              }\n            }\n          }),\n        );\n\n        break;\n      case InventoryType.Consensus: // Consensus\n        getData.hashes.forEach((hash) => {\n          const payload = this.consensusCache.get(common.uInt256ToHex(hash));\n          if (payload !== undefined) {\n            this.sendMessage(\n              peer,\n              this.createMessage({\n                command: Command.consensus,\n                payload,\n              }),\n            );\n          }\n        });\n        break;\n      default:\n        commonUtils.assertNever(getData.type);\n    }\n  }\n\n  private async onGetHeadersMessageReceived(\n    _monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    getBlocks: GetBlocksPayload,\n  ): Promise<void> {\n    const headers = await this.getHeaders(getBlocks, this.blockchain.currentHeader.index);\n\n    this.sendMessage(\n      peer,\n      this.createMessage({\n        command: Command.headers,\n        payload: new HeadersPayload({ headers }),\n      }),\n    );\n  }\n\n  private async onHeadersMessageReceived(\n    _monitor: Monitor,\n    peer: ConnectedPeer<Message, PeerData>,\n    headersPayload: HeadersPayload,\n  ): Promise<void> {\n    const headers = headersPayload.headers.filter(\n      (header) => !this.mutableKnownHeaderHashes.has(header.hash) && !this.tempKnownHeaderHashes.has(header.hashHex),\n    );\n\n    if (headers.length > 0) {\n      headers.forEach((header) => {\n        this.tempKnownHeaderHashes.add(header.hashHex);\n      });\n      try {\n        await this.blockchain.persistHeaders(headers);\n        headers.forEach((header) => {\n          this.mutableKnownHeaderHashes.add(header.hash);\n        });\n      } finally {\n        headers.forEach((header) => {\n          this.tempKnownHeaderHashes.delete(header.hashHex);\n        });\n      }\n    }\n\n    if (this.blockchain.currentHeader.index < peer.data.startHeight) {\n      this.sendMessage(\n        peer,\n        this.createMessage({\n          command: Command.getheaders,\n          payload: new GetBlocksPayload({\n            hashStart: [this.blockchain.currentHeader.hash],\n          }),\n        }),\n      );\n    }\n  }\n\n  private onInvMessageReceived(_monitor: Monitor, peer: ConnectedPeer<Message, PeerData>, inv: InvPayload): void {\n    let hashes;\n    switch (inv.type) {\n      case InventoryType.Transaction: // Transaction\n        hashes = inv.hashes.filter(\n          (hash) =>\n            !this.mutableKnownTransactionHashes.has(hash) &&\n            !this.tempKnownTransactionHashes.has(common.uInt256ToHex(hash)),\n        );\n\n        break;\n      case InventoryType.Block: // Block\n        hashes = inv.hashes.filter(\n          (hash) =>\n            !this.mutableKnownBlockHashes.has(hash) && !this.tempKnownBlockHashes.has(common.uInt256ToHex(hash)),\n        );\n\n        break;\n      case InventoryType.Consensus: // Consensus\n        hashes = inv.hashes;\n        break;\n      default:\n        commonUtils.assertNever(inv.type);\n        hashes = [];\n    }\n\n    if (hashes.length > 0) {\n      this.sendMessage(\n        peer,\n        this.createMessage({\n          command: Command.getdata,\n          payload: new InvPayload({ type: inv.type, hashes }),\n        }),\n      );\n    }\n  }\n\n  private onMemPoolMessageReceived(_monitor: Monitor, peer: ConnectedPeer<Message, PeerData>): void {\n    this.sendMessage(\n      peer,\n      this.createMessage({\n        command: Command.inv,\n        payload: new InvPayload({\n          type: InventoryType.Transaction,\n          hashes: Object.values(this.mutableMemPool).map((transaction) => transaction.hash),\n        }),\n      }),\n    );\n  }\n\n  private async onTransactionReceived(_monitor: Monitor, transaction: Transaction): Promise<void> {\n    if (this.ready()) {\n      if (transaction.type === TransactionType.Miner) {\n        if (this.mutableConsensus !== undefined) {\n          this.mutableConsensus.onTransactionReceived(transaction);\n        }\n      } else {\n        await this.relayTransaction(transaction);\n      }\n    }\n  }\n\n  private onVerackMessageReceived(_monitor: Monitor, peer: ConnectedPeer<Message, PeerData>): void {\n    peer.close();\n  }\n\n  private onVersionMessageReceived(_monitor: Monitor, peer: ConnectedPeer<Message, PeerData>): void {\n    peer.close();\n  }\n\n  private async getHeaders(getBlocks: GetBlocksPayload, maxHeight: number): Promise<ReadonlyArray<Header>> {\n    let hashStopIndexPromise = Promise.resolve(maxHeight);\n    if (!getBlocks.hashStop.equals(common.ZERO_UINT256)) {\n      hashStopIndexPromise = this.blockchain.header\n        .tryGet({ hashOrIndex: getBlocks.hashStop })\n        .then((hashStopHeader) =>\n          hashStopHeader === undefined ? maxHeight : Math.min(hashStopHeader.index, maxHeight),\n        );\n    }\n    const [hashStartHeaders, hashEnd] = await Promise.all([\n      Promise.all(getBlocks.hashStart.map(async (hash) => this.blockchain.header.tryGet({ hashOrIndex: hash }))),\n\n      hashStopIndexPromise,\n    ]);\n\n    const hashStartHeader = _.head(_.orderBy(hashStartHeaders.filter(commonUtils.notNull), [(header) => header.index]));\n\n    if (hashStartHeader === undefined) {\n      return [];\n    }\n    const hashStart = hashStartHeader.index + 1;\n    if (hashStart > maxHeight) {\n      return [];\n    }\n\n    return Promise.all(\n      _.range(hashStart, Math.min(hashStart + GET_BLOCKS_COUNT, hashEnd)).map(async (index) =>\n        this.blockchain.header.get({ hashOrIndex: index }),\n      ),\n    );\n  }\n\n  private testFilter(bloomFilterIn: BloomFilter | undefined, transaction: Transaction): boolean {\n    const bloomFilter = bloomFilterIn;\n    if (bloomFilter === undefined) {\n      return true;\n    }\n\n    return (\n      bloomFilter.contains(transaction.hash) ||\n      transaction.outputs.some((output) => bloomFilter.contains(output.address)) ||\n      transaction.inputs.some((input) => bloomFilter.contains(input.serializeWire())) ||\n      transaction.scripts.some((script) => bloomFilter.contains(crypto.toScriptHash(script.verification))) ||\n      (transaction.type === TransactionType.Register &&\n        transaction instanceof RegisterTransaction &&\n        bloomFilter.contains(transaction.asset.admin))\n    );\n  }\n\n  private createMerkleBlockPayload({\n    block,\n    flags,\n  }: {\n    readonly block: Block;\n    readonly flags: ReadonlyArray<boolean>;\n  }): MerkleBlockPayload {\n    const tree = new MerkleTree(block.transactions.map((transaction) => transaction.hash)).trim(flags);\n\n    const mutableBuffer = Buffer.allocUnsafe(Math.floor((flags.length + 7) / 8));\n    // tslint:disable-next-line no-loop-statement\n    for (let i = 0; i < flags.length; i += 1) {\n      if (flags[i]) {\n        // tslint:disable-next-line no-bitwise\n        mutableBuffer[Math.floor(i / 8)] |= 1 << i % 8;\n      }\n    }\n\n    return new MerkleBlockPayload({\n      version: block.version,\n      previousHash: block.previousHash,\n      merkleRoot: block.merkleRoot,\n      timestamp: block.timestamp,\n      index: block.index,\n      consensusData: block.consensusData,\n      nextConsensus: block.nextConsensus,\n      script: block.script,\n      transactionCount: block.transactions.length,\n      hashes: tree.toHashArray(),\n      flags: mutableBuffer,\n    });\n  }\n\n  private createMessage(value: MessageValue): Message {\n    return new Message({\n      magic: this.blockchain.settings.messageMagic,\n      value,\n    });\n  }\n}\n"]}