No OneTemporary
Actions

Size

331 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/avalanche/peermanager.cpp b/src/avalanche/peermanager.cpp
	index dbb3f68e0..68c3b156e 100644
	--- a/src/avalanche/peermanager.cpp
	+++ b/src/avalanche/peermanager.cpp
	@@ -1,487 +1,488 @@
	// Copyright (c) 2020 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <avalanche/peermanager.h>

	#include <avalanche/delegation.h>
	#include <avalanche/validation.h>
	#include <random.h>
	#include <validation.h> // For ChainstateActive()

	#include <cassert>

	namespace avalanche {

	bool PeerManager::addNode(NodeId nodeid, const ProofId &proofid) {
	auto &pview = peers.get<proof_index>();
	auto it = pview.find(proofid);
	if (it == pview.end()) {
	return false;
	}

	return addOrUpdateNode(peers.project<0>(it), nodeid);
	}

	bool PeerManager::addOrUpdateNode(const PeerSet::iterator &it, NodeId nodeid) {
	assert(it != peers.end());

	const PeerId peerid = it->peerid;

	auto nit = nodes.find(nodeid);
	if (nit == nodes.end()) {
	if (!nodes.emplace(nodeid, peerid).second) {
	return false;
	}
	} else {
	const PeerId oldpeerid = nit->peerid;
	if (!nodes.modify(nit, [&](Node &n) { n.peerid = peerid; })) {
	return false;
	}

	// We actually have this node already, we need to update it.
	bool success = removeNodeFromPeer(peers.find(oldpeerid));
	assert(success);
	}

	bool success = addNodeToPeer(it);
	assert(success);

	return true;
	}

	bool PeerManager::addNodeToPeer(const PeerSet::iterator &it) {
	assert(it != peers.end());
	return peers.modify(it, [&](Peer &p) {
	if (p.node_count++ > 0) {
	// We are done.
	return;
	}

	// We need to allocate this peer.
	p.index = uint32_t(slots.size());
	const uint32_t score = p.getScore();
	const uint64_t start = slotCount;
	slots.emplace_back(start, score, it->peerid);
	slotCount = start + score;
	});
	}

	bool PeerManager::removeNode(NodeId nodeid) {
	auto it = nodes.find(nodeid);
	if (it == nodes.end()) {
	return false;
	}

	const PeerId peerid = it->peerid;
	nodes.erase(it);

	// Keep the track of the reference count.
	bool success = removeNodeFromPeer(peers.find(peerid));
	assert(success);

	return true;
	}

	bool PeerManager::removeNodeFromPeer(const PeerSet::iterator &it,
	uint32_t count) {
	assert(it != peers.end());
	assert(count <= it->node_count);
	if (count == 0) {
	// This is a NOOP.
	return false;
	}

	const uint32_t new_count = it->node_count - count;
	if (!peers.modify(it, [&](Peer &p) { p.node_count = new_count; })) {
	return false;
	}

	if (new_count > 0) {
	// We are done.
	return true;
	}

	// There are no more node left, we need to cleanup.
	const size_t i = it->index;
	assert(i < slots.size());
	if (i + 1 == slots.size()) {
	slots.pop_back();
	slotCount = slots.empty() ? 0 : slots.back().getStop();
	} else {
	fragmentation += slots[i].getScore();
	slots[i] = slots[i].withPeerId(NO_PEER);
	}

	return true;
	}

	bool PeerManager::updateNextRequestTime(NodeId nodeid, TimePoint timeout) {
	auto it = nodes.find(nodeid);
	if (it == nodes.end()) {
	return false;
	}

	return nodes.modify(it, [&](Node &n) { n.nextRequestTime = timeout; });
	}

	+bool PeerManager::registerProof(const std::shared_ptr<Proof> &proof) {
	+ return !getProof(proof->getId()) && getPeerId(proof) != NO_PEER;
	+}
	+
	NodeId PeerManager::selectNode() {
	for (int retry = 0; retry < SELECT_NODE_MAX_RETRY; retry++) {
	const PeerId p = selectPeer();

	// If we cannot find a peer, it may be due to the fact that it is
	// unlikely due to high fragmentation, so compact and retry.
	if (p == NO_PEER) {
	compact();
	continue;
	}

	// See if that peer has an available node.
	auto &nview = nodes.get<next_request_time>();
	auto it = nview.lower_bound(boost::make_tuple(p, TimePoint()));
	if (it != nview.end() && it->peerid == p &&
	it->nextRequestTime <= std::chrono::steady_clock::now()) {
	return it->nodeid;
	}
	}

	return NO_NODE;
	}

	static bool isOrphanState(const ProofValidationState &state) {
	return state.GetResult() == ProofValidationResult::MISSING_UTXO \|\|
	state.GetResult() == ProofValidationResult::HEIGHT_MISMATCH;
	}

	void PeerManager::updatedBlockTip() {
	std::vector<PeerId> invalidPeers;
	std::vector<std::shared_ptr<Proof>> newOrphans;

	{
	LOCK(cs_main);

	const CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
	for (const auto &p : peers) {
	ProofValidationState state;
	if (!p.proof->verify(state, coins)) {
	if (isOrphanState(state)) {
	newOrphans.push_back(p.proof);
	}
	invalidPeers.push_back(p.peerid);
	}
	}
	}

	orphanProofs.rescan(*this);

	for (auto &p : newOrphans) {
	orphanProofs.addProof(p);
	}

	for (const auto &pid : invalidPeers) {
	removePeer(pid);
	}
	}

	PeerId PeerManager::getPeerId(const std::shared_ptr<Proof> &proof) {
	auto it = fetchOrCreatePeer(proof);
	return it == peers.end() ? NO_PEER : it->peerid;
	}

	std::shared_ptr<Proof> PeerManager::getProof(const ProofId &proofid) const {
	- auto &pview = peers.get<proof_index>();
	- auto it = pview.find(proofid);
	- return it == pview.end() ? nullptr : it->proof;
	-}
	+ std::shared_ptr<Proof> proof = nullptr;

	-std::chrono::seconds
	-PeerManager::getProofRegistrationTime(const ProofId &proofid) const {
	- auto &pview = peers.get<proof_index>();
	- auto it = pview.find(proofid);
	- return it == pview.end() ? std::chrono::seconds::max()
	- : it->registration_time;
	+ forPeer(proofid, [&](const Peer &p) {
	+ proof = p.proof;
	+ return true;
	+ });
	+
	+ return proof;
	}

	PeerManager::PeerSet::iterator
	PeerManager::fetchOrCreatePeer(const std::shared_ptr<Proof> &proof) {
	{
	// Check if we already know of that peer.
	auto &pview = peers.get<proof_index>();
	auto it = pview.find(proof->getId());
	if (it != pview.end()) {
	return peers.project<0>(it);
	}
	}

	// Check the proof's validity.
	ProofValidationState state;
	bool valid = [&](ProofValidationState &state) {
	LOCK(cs_main);
	const CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
	return proof->verify(state, coins);
	}(state);

	if (!valid) {
	if (isOrphanState(state)) {
	orphanProofs.addProof(proof);
	}

	// Reject invalid proof.
	return peers.end();
	}

	orphanProofs.removeProof(proof->getId());

	// New peer means new peerid!
	const PeerId peerid = nextPeerId++;

	// Attach UTXOs to this proof.
	std::unordered_set<PeerId> conflicting_peerids;
	for (const auto &s : proof->getStakes()) {
	auto p = utxos.emplace(s.getStake().getUTXO(), peerid);
	if (!p.second) {
	// We have a collision with an existing proof.
	conflicting_peerids.insert(p.first->second);
	}
	}

	// For now, if there is a conflict, just cleanup the mess.
	if (conflicting_peerids.size() > 0) {
	for (const auto &s : proof->getStakes()) {
	auto it = utxos.find(s.getStake().getUTXO());
	assert(it != utxos.end());

	// We need to delete that one.
	if (it->second == peerid) {
	utxos.erase(it);
	}
	}

	return peers.end();
	}

	// We have no peer for this proof, time to create it.
	auto inserted = peers.emplace(peerid, proof);
	assert(inserted.second);

	return inserted.first;
	}

	bool PeerManager::removePeer(const PeerId peerid) {
	auto it = peers.find(peerid);
	if (it == peers.end()) {
	return false;
	}

	// Remove all nodes from this peer.
	removeNodeFromPeer(it, it->node_count);

	// Remove nodes associated with this peer, unless their timeout is still
	// active. This ensure that we don't overquery them in case they are
	// subsequently added to another peer.
	auto &nview = nodes.get<next_request_time>();
	nview.erase(nview.lower_bound(boost::make_tuple(peerid, TimePoint())),
	nview.upper_bound(boost::make_tuple(
	peerid, std::chrono::steady_clock::now())));

	// Release UTXOs attached to this proof.
	for (const auto &s : it->proof->getStakes()) {
	bool deleted = utxos.erase(s.getStake().getUTXO()) > 0;
	assert(deleted);
	}

	m_unbroadcast_proofids.erase(it->proof->getId());

	peers.erase(it);
	return true;
	}

	PeerId PeerManager::selectPeer() const {
	if (slots.empty() \|\| slotCount == 0) {
	return NO_PEER;
	}

	const uint64_t max = slotCount;
	for (int retry = 0; retry < SELECT_PEER_MAX_RETRY; retry++) {
	size_t i = selectPeerImpl(slots, GetRand(max), max);
	if (i != NO_PEER) {
	return i;
	}
	}

	return NO_PEER;
	}

	uint64_t PeerManager::compact() {
	// There is nothing to compact.
	if (fragmentation == 0) {
	return 0;
	}

	std::vector<Slot> newslots;
	newslots.reserve(peers.size());

	uint64_t prevStop = 0;
	uint32_t i = 0;
	for (auto it = peers.begin(); it != peers.end(); it++) {
	if (it->node_count == 0) {
	continue;
	}

	newslots.emplace_back(prevStop, it->getScore(), it->peerid);
	prevStop = slots[i].getStop();
	if (!peers.modify(it, [&](Peer &p) { p.index = i++; })) {
	return 0;
	}
	}

	slots = std::move(newslots);

	const uint64_t saved = slotCount - prevStop;
	slotCount = prevStop;
	fragmentation = 0;

	return saved;
	}

	bool PeerManager::verify() const {
	uint64_t prevStop = 0;
	for (size_t i = 0; i < slots.size(); i++) {
	const Slot &s = slots[i];

	// Slots must be in correct order.
	if (s.getStart() < prevStop) {
	return false;
	}

	prevStop = s.getStop();

	// If this is a dead slot, then nothing more needs to be checked.
	if (s.getPeerId() == NO_PEER) {
	continue;
	}

	// We have a live slot, verify index.
	auto it = peers.find(s.getPeerId());
	if (it == peers.end() \|\| it->index != i) {
	return false;
	}
	}

	for (const auto &p : peers) {
	// Count node attached to this peer.
	const auto count_nodes = [&]() {
	size_t count = 0;
	auto &nview = nodes.get<next_request_time>();
	auto begin =
	nview.lower_bound(boost::make_tuple(p.peerid, TimePoint()));
	auto end =
	nview.upper_bound(boost::make_tuple(p.peerid + 1, TimePoint()));

	for (auto it = begin; it != end; ++it) {
	count++;
	}

	return count;
	};

	if (p.node_count != count_nodes()) {
	return false;
	}

	// If there are no nodes attached to this peer, then we are done.
	if (p.node_count == 0) {
	continue;
	}

	// The index must point to a slot refering to this peer.
	if (p.index >= slots.size() \|\| slots[p.index].getPeerId() != p.peerid) {
	return false;
	}

	// If the score do not match, same thing.
	if (slots[p.index].getScore() != p.getScore()) {
	return false;
	}
	}

	return true;
	}

	PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
	const uint64_t max) {
	assert(slot <= max);

	size_t begin = 0, end = slots.size();
	uint64_t bottom = 0, top = max;

	// Try to find the slot using dichotomic search.
	while ((end - begin) > 8) {
	// The slot we picked in not allocated.
	if (slot < bottom \|\| slot >= top) {
	return NO_PEER;
	}

	// Guesstimate the position of the slot.
	size_t i = begin + ((slot - bottom) * (end - begin) / (top - bottom));
	assert(begin <= i && i < end);

	// We have a match.
	if (slots[i].contains(slot)) {
	return slots[i].getPeerId();
	}

	// We undershooted.
	if (slots[i].precedes(slot)) {
	begin = i + 1;
	if (begin >= end) {
	return NO_PEER;
	}

	bottom = slots[begin].getStart();
	continue;
	}

	// We overshooted.
	if (slots[i].follows(slot)) {
	end = i;
	top = slots[end].getStart();
	continue;
	}

	// We have an unalocated slot.
	return NO_PEER;
	}

	// Enough of that nonsense, let fallback to linear search.
	for (size_t i = begin; i < end; i++) {
	// We have a match.
	if (slots[i].contains(slot)) {
	return slots[i].getPeerId();
	}
	}

	// We failed to find a slot, retry.
	return NO_PEER;
	}

	bool PeerManager::isOrphan(const ProofId &id) const {
	return orphanProofs.getProof(id) != nullptr;
	}

	std::shared_ptr<Proof> PeerManager::getOrphan(const ProofId &id) const {
	return orphanProofs.getProof(id);
	}

	void PeerManager::addUnbroadcastProof(const ProofId &proofid) {
	// The proof should be known
	if (getProof(proofid)) {
	m_unbroadcast_proofids.insert(proofid);
	}
	}

	void PeerManager::removeUnbroadcastProof(const ProofId &proofid) {
	m_unbroadcast_proofids.erase(proofid);
	}

	} // namespace avalanche
	diff --git a/src/avalanche/peermanager.h b/src/avalanche/peermanager.h
	index 042d112cd..de4e3a991 100644
	--- a/src/avalanche/peermanager.h
	+++ b/src/avalanche/peermanager.h
	@@ -1,255 +1,262 @@
	// Copyright (c) 2020 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_AVALANCHE_PEERMANAGER_H
	#define BITCOIN_AVALANCHE_PEERMANAGER_H

	#include <avalanche/node.h>
	#include <avalanche/orphanproofpool.h>
	#include <avalanche/proof.h>
	#include <coins.h>
	#include <net.h>
	#include <pubkey.h>
	#include <salteduint256hasher.h>

	#include <boost/multi_index/composite_key.hpp>
	#include <boost/multi_index/hashed_index.hpp>
	#include <boost/multi_index/member.hpp>
	#include <boost/multi_index/ordered_index.hpp>
	#include <boost/multi_index_container.hpp>

	#include <chrono>
	#include <cstdint>
	#include <memory>
	#include <unordered_set>
	#include <vector>

	namespace avalanche {

	/**
	* Maximum number of stakes in the orphanProofs.
	* Benchmarking on a consumer grade computer shows that 10000 stakes can be
	* verified in less than 1 second.
	*/
	static constexpr size_t AVALANCHE_ORPHANPROOFPOOL_SIZE = 10000;

	class Delegation;

	struct Slot {
	private:
	uint64_t start;
	uint32_t score;
	PeerId peerid;

	public:
	Slot(uint64_t startIn, uint32_t scoreIn, PeerId peeridIn)
	: start(startIn), score(scoreIn), peerid(peeridIn) {}

	Slot withStart(uint64_t startIn) const {
	return Slot(startIn, score, peerid);
	}
	Slot withScore(uint64_t scoreIn) const {
	return Slot(start, scoreIn, peerid);
	}
	Slot withPeerId(PeerId peeridIn) const {
	return Slot(start, score, peeridIn);
	}

	uint64_t getStart() const { return start; }
	uint64_t getStop() const { return start + score; }
	uint32_t getScore() const { return score; }
	PeerId getPeerId() const { return peerid; }

	bool contains(uint64_t slot) const {
	return getStart() <= slot && slot < getStop();
	}
	bool precedes(uint64_t slot) const { return slot >= getStop(); }
	bool follows(uint64_t slot) const { return getStart() > slot; }
	};

	struct Peer {
	PeerId peerid;
	uint32_t index = -1;
	uint32_t node_count = 0;

	std::shared_ptr<Proof> proof;

	// The network stack uses timestamp in seconds, so we oblige.
	std::chrono::seconds registration_time;

	Peer(PeerId peerid_, std::shared_ptr<Proof> proof_)
	: peerid(peerid_), proof(std::move(proof_)),
	registration_time(GetTime<std::chrono::seconds>()) {}

	const ProofId &getProofId() const { return proof->getId(); }
	uint32_t getScore() const { return proof->getScore(); }
	};

	struct proof_index {
	using result_type = ProofId;
	result_type operator()(const Peer &p) const { return p.proof->getId(); }
	};

	struct next_request_time {};

	namespace bmi = boost::multi_index;

	class PeerManager {
	std::vector<Slot> slots;
	uint64_t slotCount = 0;
	uint64_t fragmentation = 0;

	/**
	* Several nodes can make an avalanche peer. In this case, all nodes are
	* considered interchangeable parts of the same peer.
	*/
	using PeerSet = boost::multi_index_container<
	Peer, bmi::indexed_by<
	// index by peerid
	bmi::hashed_unique<bmi::member<Peer, PeerId, &Peer::peerid>>,
	// index by proof
	bmi::hashed_unique<bmi::tag<proof_index>, proof_index,
	SaltedProofIdHasher>>>;

	PeerId nextPeerId = 0;
	PeerSet peers;

	std::unordered_map<COutPoint, PeerId, SaltedOutpointHasher> utxos;

	using NodeSet = boost::multi_index_container<
	Node,
	bmi::indexed_by<
	// index by nodeid
	bmi::hashed_unique<bmi::member<Node, NodeId, &Node::nodeid>>,
	// sorted by peerid/nextRequestTime
	bmi::ordered_non_unique<
	bmi::tag<next_request_time>,
	bmi::composite_key<
	Node, bmi::member<Node, PeerId, &Node::peerid>,
	bmi::member<Node, TimePoint, &Node::nextRequestTime>>>>>;

	NodeSet nodes;

	static constexpr int SELECT_PEER_MAX_RETRY = 3;
	static constexpr int SELECT_NODE_MAX_RETRY = 3;

	/**
	* Tracks proof which for which the UTXO are unavailable.
	*/
	OrphanProofPool orphanProofs{AVALANCHE_ORPHANPROOFPOOL_SIZE};

	/**
	* Track proof ids to broadcast
	*/
	std::unordered_set<ProofId, SaltedProofIdHasher> m_unbroadcast_proofids;

	public:
	/**
	* Node API.
	*/
	bool addNode(NodeId nodeid, const ProofId &proofid);
	bool removeNode(NodeId nodeid);

	// Update when a node is to be polled next.
	bool updateNextRequestTime(NodeId nodeid, TimePoint timeout);

	// Randomly select a node to poll.
	NodeId selectNode();

	template <typename Callable>
	bool forNode(NodeId nodeid, Callable &&func) const {
	auto it = nodes.find(nodeid);
	return it != nodes.end() && func(*it);
	}

	template <typename Callable>
	void forEachNode(const Peer &peer, Callable &&func) const {
	auto &nview = nodes.get<next_request_time>();
	auto range = nview.equal_range(peer.peerid);
	for (auto it = range.first; it != range.second; ++it) {
	func(*it);
	}
	}

	/**
	* Proof and Peer related API.
	*/
	+ bool registerProof(const std::shared_ptr<Proof> &proof);
	bool exists(const ProofId &proofid) const {
	return getProof(proofid) != nullptr;
	}

	+ template <typename Callable>
	+ bool forPeer(const ProofId &proofid, Callable &&func) const {
	+ auto &pview = peers.get<proof_index>();
	+ auto it = pview.find(proofid);
	+ return it != pview.end() && func(*it);
	+ }
	+
	template <typename Callable> void forEachPeer(Callable &&func) const {
	for (const auto &p : peers) {
	func(p);
	}
	}

	/**
	* Update the peer set when a new block is connected.
	*/
	void updatedBlockTip();

	/**
	* Proof broadcast API.
	*/
	void addUnbroadcastProof(const ProofId &proofid);
	void removeUnbroadcastProof(const ProofId &proofid);
	auto getUnbroadcastProofs() const { return m_unbroadcast_proofids; }

	/****************************************************
	* Functions which are public for testing purposes. *
	****************************************************/
	/**
	* Provide the PeerId associated with the given proof. If the peer does not
	* exist, then it is created.
	*/
	PeerId getPeerId(const std::shared_ptr<Proof> &proof);

	/**
	* Remove an existing peer.
	*/
	bool removePeer(const PeerId peerid);

	/**
	* Randomly select a peer to poll.
	*/
	PeerId selectPeer() const;

	/**
	* Trigger maintenance of internal data structures.
	* Returns how much slot space was saved after compaction.
	*/
	uint64_t compact();

	/**
	* Perform consistency check on internal data structures.
	*/
	bool verify() const;

	// Accessors.
	uint64_t getSlotCount() const { return slotCount; }
	uint64_t getFragmentation() const { return fragmentation; }

	std::shared_ptr<Proof> getProof(const ProofId &proofid) const;
	- std::chrono::seconds getProofRegistrationTime(const ProofId &proofid) const;

	bool isOrphan(const ProofId &id) const;
	std::shared_ptr<Proof> getOrphan(const ProofId &id) const;

	private:
	PeerSet::iterator fetchOrCreatePeer(const std::shared_ptr<Proof> &proof);
	bool addOrUpdateNode(const PeerSet::iterator &it, NodeId nodeid);
	bool addNodeToPeer(const PeerSet::iterator &it);
	bool removeNodeFromPeer(const PeerSet::iterator &it, uint32_t count = 1);
	};

	/**
	* This is an internal method that is exposed for testing purposes.
	*/
	PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
	const uint64_t max);

	} // namespace avalanche

	#endif // BITCOIN_AVALANCHE_PEERMANAGER_H
	diff --git a/src/avalanche/processor.cpp b/src/avalanche/processor.cpp
	index 24374de7b..cfaacca1c 100644
	--- a/src/avalanche/processor.cpp
	+++ b/src/avalanche/processor.cpp
	@@ -1,773 +1,766 @@
	// Copyright (c) 2018-2019 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <avalanche/processor.h>

	#include <avalanche/delegationbuilder.h>
	#include <avalanche/peermanager.h>
	#include <avalanche/validation.h>
	#include <chain.h>
	#include <key_io.h> // For DecodeSecret
	#include <net_processing.h> // For ::PeerManager
	#include <netmessagemaker.h>
	#include <reverse_iterator.h>
	#include <scheduler.h>
	#include <util/bitmanip.h>
	#include <util/translation.h>
	#include <validation.h>

	#include <chrono>
	#include <tuple>

	/**
	* Run the avalanche event loop every 10ms.
	*/
	static constexpr std::chrono::milliseconds AVALANCHE_TIME_STEP{10};

	// Unfortunately, the bitcoind codebase is full of global and we are kinda
	// forced into it here.
	std::unique_ptr<avalanche::Processor> g_avalanche;

	namespace avalanche {

	bool VoteRecord::registerVote(NodeId nodeid, uint32_t error) {
	// We just got a new vote, so there is one less inflight request.
	clearInflightRequest();

	// We want to avoid having the same node voting twice in a quorum.
	if (!addNodeToQuorum(nodeid)) {
	return false;
	}

	/**
	* The result of the vote is determined from the error code. If the error
	* code is 0, there is no error and therefore the vote is yes. If there is
	* an error, we check the most significant bit to decide if the vote is a no
	* (for instance, the block is invalid) or is the vote inconclusive (for
	* instance, the queried node does not have the block yet).
	*/
	votes = (votes << 1) \| (error == 0);
	consider = (consider << 1) \| (int32_t(error) >= 0);

	/**
	* We compute the number of yes and/or no votes as follow:
	*
	* votes: 1010
	* consider: 1100
	*
	* yes votes: 1000 using votes & consider
	* no votes: 0100 using ~votes & consider
	*/
	bool yes = countBits(votes & consider & 0xff) > 6;
	if (!yes) {
	bool no = countBits(~votes & consider & 0xff) > 6;
	if (!no) {
	// The round is inconclusive.
	return false;
	}
	}

	// If the round is in agreement with previous rounds, increase confidence.
	if (isAccepted() == yes) {
	confidence += 2;
	return getConfidence() == AVALANCHE_FINALIZATION_SCORE;
	}

	// The round changed our state. We reset the confidence.
	confidence = yes;
	return true;
	}

	bool VoteRecord::addNodeToQuorum(NodeId nodeid) {
	if (nodeid == NO_NODE) {
	// Helpful for testing.
	return true;
	}

	// MMIX Linear Congruent Generator.
	const uint64_t r1 =
	6364136223846793005 * uint64_t(nodeid) + 1442695040888963407;
	// Fibonacci hashing.
	const uint64_t r2 = 11400714819323198485ull * (nodeid ^ seed);
	// Combine and extract hash.
	const uint16_t h = (r1 + r2) >> 48;

	/**
	* Check if the node is in the filter.
	*/
	for (size_t i = 1; i < nodeFilter.size(); i++) {
	if (nodeFilter[(successfulVotes + i) % nodeFilter.size()] == h) {
	return false;
	}
	}

	/**
	* Add the node which just voted to the filter.
	*/
	nodeFilter[successfulVotes % nodeFilter.size()] = h;
	successfulVotes++;
	return true;
	}

	bool VoteRecord::registerPoll() const {
	uint8_t count = inflight.load();
	while (count < AVALANCHE_MAX_INFLIGHT_POLL) {
	if (inflight.compare_exchange_weak(count, count + 1)) {
	return true;
	}
	}

	return false;
	}

	static bool IsWorthPolling(const CBlockIndex *pindex) {
	AssertLockHeld(cs_main);

	if (pindex->nStatus.isInvalid()) {
	// No point polling invalid blocks.
	return false;
	}

	if (::ChainstateActive().IsBlockFinalized(pindex)) {
	// There is no point polling finalized block.
	return false;
	}

	return true;
	}

	static bool VerifyProof(const Proof &proof, bilingual_str &error) {
	ProofValidationState proof_state;

	if (!proof.verify(proof_state)) {
	switch (proof_state.GetResult()) {
	case ProofValidationResult::NO_STAKE:
	error = _("The avalanche proof has no stake.");
	return false;
	case ProofValidationResult::DUST_THRESOLD:
	error = _("The avalanche proof stake is too low.");
	return false;
	case ProofValidationResult::DUPLICATE_STAKE:
	error = _("The avalanche proof has duplicated stake.");
	return false;
	case ProofValidationResult::INVALID_SIGNATURE:
	error = _("The avalanche proof has invalid stake signatures.");
	return false;
	case ProofValidationResult::TOO_MANY_UTXOS:
	error = strprintf(
	_("The avalanche proof has too many utxos (max: %u)."),
	AVALANCHE_MAX_PROOF_STAKES);
	return false;
	default:
	error = _("The avalanche proof is invalid.");
	return false;
	}
	}

	return true;
	}

	static bool VerifyDelegation(const Delegation &dg,
	const CPubKey &expectedPubKey,
	bilingual_str &error) {
	DelegationState dg_state;

	CPubKey auth;
	if (!dg.verify(dg_state, auth)) {
	switch (dg_state.GetResult()) {
	case avalanche::DelegationResult::INVALID_SIGNATURE:
	error = _("The avalanche delegation has invalid signatures.");
	return false;
	default:
	error = _("The avalanche delegation is invalid.");
	return false;
	}
	}

	if (auth != expectedPubKey) {
	error = _(
	"The avalanche delegation does not match the expected public key.");
	return false;
	}

	return true;
	}

	struct Processor::PeerData {
	std::shared_ptr<Proof> proof;
	Delegation delegation;
	};

	class Processor::NotificationsHandler
	: public interfaces::Chain::Notifications {
	Processor *m_processor;

	public:
	NotificationsHandler(Processor *p) : m_processor(p) {}

	void updatedBlockTip() override {
	LOCK(m_processor->cs_peerManager);

	if (m_processor->mustRegisterProof &&
	!::ChainstateActive().IsInitialBlockDownload()) {
	m_processor->peerManager->getPeerId(m_processor->peerData->proof);
	m_processor->mustRegisterProof = false;
	}

	m_processor->peerManager->updatedBlockTip();
	}
	};

	Processor::Processor(interfaces::Chain &chain, CConnman *connmanIn,
	NodePeerManager *nodePeerManagerIn,
	std::unique_ptr<PeerData> peerDataIn, CKey sessionKeyIn)
	: connman(connmanIn), nodePeerManager(nodePeerManagerIn),
	queryTimeoutDuration(AVALANCHE_DEFAULT_QUERY_TIMEOUT), round(0),
	peerManager(std::make_unique<PeerManager>()),
	peerData(std::move(peerDataIn)), sessionKey(std::move(sessionKeyIn)),
	// Schedule proof registration at the first new block after IBD.
	// FIXME: get rid of this flag
	mustRegisterProof(!!peerData) {
	// Make sure we get notified of chain state changes.
	chainNotificationsHandler =
	chain.handleNotifications(std::make_shared<NotificationsHandler>(this));
	}

	Processor::~Processor() {
	chainNotificationsHandler.reset();
	stopEventLoop();
	}

	std::unique_ptr<Processor>
	Processor::MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain,
	CConnman connman, NodePeerManager nodePeerManager,
	bilingual_str &error) {
	std::unique_ptr<PeerData> peerData;
	CKey masterKey;
	CKey sessionKey;

	if (argsman.IsArgSet("-avasessionkey")) {
	sessionKey = DecodeSecret(argsman.GetArg("-avasessionkey", ""));
	if (!sessionKey.IsValid()) {
	error = _("The avalanche session key is invalid.");
	return nullptr;
	}
	} else {
	// Pick a random key for the session.
	sessionKey.MakeNewKey(true);
	}

	if (argsman.IsArgSet("-avaproof")) {
	if (!argsman.IsArgSet("-avamasterkey")) {
	error = _(
	"The avalanche master key is missing for the avalanche proof.");
	return nullptr;
	}

	masterKey = DecodeSecret(argsman.GetArg("-avamasterkey", ""));
	if (!masterKey.IsValid()) {
	error = _("The avalanche master key is invalid.");
	return nullptr;
	}

	peerData = std::make_unique<PeerData>();
	peerData->proof = std::make_shared<Proof>();
	if (!Proof::FromHex(*peerData->proof, argsman.GetArg("-avaproof", ""),
	error)) {
	// error is set by FromHex
	return nullptr;
	}

	if (!VerifyProof(*peerData->proof, error)) {
	// error is set by VerifyProof
	return nullptr;
	}

	std::unique_ptr<DelegationBuilder> dgb;
	const CPubKey &masterPubKey = masterKey.GetPubKey();

	if (argsman.IsArgSet("-avadelegation")) {
	Delegation dg;
	if (!Delegation::FromHex(dg, argsman.GetArg("-avadelegation", ""),
	error)) {
	// error is set by FromHex()
	return nullptr;
	}

	if (dg.getProofId() != peerData->proof->getId()) {
	error = _("The delegation does not match the proof.");
	return nullptr;
	}

	if (masterPubKey != dg.getDelegatedPubkey()) {
	error = _(
	"The master key does not match the delegation public key.");
	return nullptr;
	}

	dgb = std::make_unique<DelegationBuilder>(dg);
	} else {
	if (masterPubKey != peerData->proof->getMaster()) {
	error =
	_("The master key does not match the proof public key.");
	return nullptr;
	}

	dgb = std::make_unique<DelegationBuilder>(*peerData->proof);
	}

	// Generate the delegation to the session key.
	const CPubKey sessionPubKey = sessionKey.GetPubKey();
	if (sessionPubKey != masterPubKey) {
	if (!dgb->addLevel(masterKey, sessionPubKey)) {
	error = _("Failed to generate a delegation for this session.");
	return nullptr;
	}
	}
	peerData->delegation = dgb->build();

	if (!VerifyDelegation(peerData->delegation, sessionPubKey, error)) {
	// error is set by VerifyDelegation
	return nullptr;
	}
	}

	// We can't use std::make_unique with a private constructor
	return std::unique_ptr<Processor>(
	new Processor(chain, connman, nodePeerManager, std::move(peerData),
	std::move(sessionKey)));
	}

	bool Processor::addBlockToReconcile(const CBlockIndex *pindex) {
	bool isAccepted;

	{
	LOCK(cs_main);
	if (!IsWorthPolling(pindex)) {
	// There is no point polling this block.
	return false;
	}

	isAccepted = ::ChainActive().Contains(pindex);
	}

	return vote_records.getWriteView()
	->insert(std::make_pair(pindex, VoteRecord(isAccepted)))
	.second;
	}

	bool Processor::isAccepted(const CBlockIndex *pindex) const {
	auto r = vote_records.getReadView();
	auto it = r->find(pindex);
	if (it == r.end()) {
	return false;
	}

	return it->second.isAccepted();
	}

	int Processor::getConfidence(const CBlockIndex *pindex) const {
	auto r = vote_records.getReadView();
	auto it = r->find(pindex);
	if (it == r.end()) {
	return -1;
	}

	return it->second.getConfidence();
	}

	namespace {
	/**
	* When using TCP, we need to sign all messages as the transport layer is
	* not secure.
	*/
	class TCPResponse {
	Response response;
	SchnorrSig sig;

	public:
	TCPResponse(Response responseIn, const CKey &key)
	: response(std::move(responseIn)) {
	CHashWriter hasher(SER_GETHASH, 0);
	hasher << response;
	const uint256 hash = hasher.GetHash();

	// Now let's sign!
	if (!key.SignSchnorr(hash, sig)) {
	sig.fill(0);
	}
	}

	// serialization support
	SERIALIZE_METHODS(TCPResponse, obj) {
	READWRITE(obj.response, obj.sig);
	}
	};
	} // namespace

	void Processor::sendResponse(CNode *pfrom, Response response) const {
	connman->PushMessage(
	pfrom, CNetMsgMaker(pfrom->GetCommonVersion())
	.Make(NetMsgType::AVARESPONSE,
	TCPResponse(std::move(response), sessionKey)));
	}

	bool Processor::registerVotes(NodeId nodeid, const Response &response,
	std::vector<BlockUpdate> &updates) {
	{
	// Save the time at which we can query again.
	LOCK(cs_peerManager);

	// FIXME: This will override the time even when we received an old stale
	// message. This should check that the message is indeed the most up to
	// date one before updating the time.
	peerManager->updateNextRequestTime(
	nodeid, std::chrono::steady_clock::now() +
	std::chrono::milliseconds(response.getCooldown()));
	}

	std::vector<CInv> invs;

	{
	// Check that the query exists.
	auto w = queries.getWriteView();
	auto it = w->find(std::make_tuple(nodeid, response.getRound()));
	if (it == w.end()) {
	nodePeerManager->Misbehaving(nodeid, 2, "unexpected-ava-response");
	return false;
	}

	invs = std::move(it->invs);
	w->erase(it);
	}

	// Verify that the request and the vote are consistent.
	const std::vector<Vote> &votes = response.GetVotes();
	size_t size = invs.size();
	if (votes.size() != size) {
	nodePeerManager->Misbehaving(nodeid, 100, "invalid-ava-response-size");
	return false;
	}

	for (size_t i = 0; i < size; i++) {
	if (invs[i].hash != votes[i].GetHash()) {
	nodePeerManager->Misbehaving(nodeid, 100,
	"invalid-ava-response-content");
	return false;
	}
	}

	std::map<CBlockIndex *, Vote> responseIndex;

	{
	LOCK(cs_main);
	for (const auto &v : votes) {
	auto pindex = LookupBlockIndex(BlockHash(v.GetHash()));
	if (!pindex) {
	// This should not happen, but just in case...
	continue;
	}

	if (!IsWorthPolling(pindex)) {
	// There is no point polling this block.
	continue;
	}

	responseIndex.insert(std::make_pair(pindex, v));
	}
	}

	{
	// Register votes.
	auto w = vote_records.getWriteView();
	for (const auto &p : responseIndex) {
	CBlockIndex *pindex = p.first;
	const Vote &v = p.second;

	auto it = w->find(pindex);
	if (it == w.end()) {
	// We are not voting on that item anymore.
	continue;
	}

	auto &vr = it->second;
	if (!vr.registerVote(nodeid, v.GetError())) {
	// This vote did not provide any extra information, move on.
	continue;
	}

	if (!vr.hasFinalized()) {
	// This item has note been finalized, so we have nothing more to
	// do.
	updates.emplace_back(
	pindex, vr.isAccepted() ? BlockUpdate::Status::Accepted
	: BlockUpdate::Status::Rejected);
	continue;
	}

	// We just finalized a vote. If it is valid, then let the caller
	// know. Either way, remove the item from the map.
	updates.emplace_back(pindex, vr.isAccepted()
	? BlockUpdate::Status::Finalized
	: BlockUpdate::Status::Invalid);
	w->erase(it);
	}
	}

	return true;
	}

	bool Processor::addNode(NodeId nodeid, const ProofId &proofid) {
	LOCK(cs_peerManager);
	return peerManager->addNode(nodeid, proofid);
	}

	bool Processor::forNode(NodeId nodeid,
	std::function<bool(const Node &n)> func) const {
	LOCK(cs_peerManager);
	return peerManager->forNode(nodeid, std::move(func));
	}

	CPubKey Processor::getSessionPubKey() const {
	return sessionKey.GetPubKey();
	}

	uint256 Processor::buildLocalSighash(CNode *pfrom) const {
	CHashWriter hasher(SER_GETHASH, 0);
	hasher << peerData->delegation.getId();
	hasher << pfrom->GetLocalNonce();
	hasher << pfrom->nRemoteHostNonce;
	hasher << pfrom->GetLocalExtraEntropy();
	hasher << pfrom->nRemoteExtraEntropy;
	return hasher.GetHash();
	}

	bool Processor::sendHello(CNode *pfrom) const {
	if (!peerData) {
	// We do not have a delegation to advertise.
	return false;
	}

	// Now let's sign!
	SchnorrSig sig;

	{
	const uint256 hash = buildLocalSighash(pfrom);

	if (!sessionKey.SignSchnorr(hash, sig)) {
	return false;
	}
	}

	connman->PushMessage(pfrom, CNetMsgMaker(pfrom->GetCommonVersion())
	.Make(NetMsgType::AVAHELLO,
	Hello(peerData->delegation, sig)));

	pfrom->AddKnownProof(peerData->delegation.getProofId());

	return true;
	}

	bool Processor::addProof(const std::shared_ptr<Proof> &proof) {
	LOCK(cs_peerManager);
	- return !peerManager->getProof(proof->getId()) &&
	- peerManager->getPeerId(proof) != NO_PEER;
	+ return peerManager->registerProof(proof);
	}

	std::shared_ptr<Proof> Processor::getProof(const ProofId &proofid) const {
	LOCK(cs_peerManager);
	return peerManager->getProof(proofid);
	}

	std::shared_ptr<Proof> Processor::getLocalProof() const {
	return peerData ? peerData->proof : nullptr;
	}

	-std::chrono::seconds
	-Processor::getProofRegistrationTime(const ProofId &proofid) const {
	- LOCK(cs_peerManager);
	- return peerManager->getProofRegistrationTime(proofid);
	-}
	-
	std::shared_ptr<Proof> Processor::getOrphan(const ProofId &proofid) const {
	LOCK(cs_peerManager);
	return peerManager->getOrphan(proofid);
	}

	bool Processor::startEventLoop(CScheduler &scheduler) {
	return eventLoop.startEventLoop(
	scheduler, [this]() { this->runEventLoop(); }, AVALANCHE_TIME_STEP);
	}

	bool Processor::stopEventLoop() {
	return eventLoop.stopEventLoop();
	}

	std::vector<CInv> Processor::getInvsForNextPoll(bool forPoll) {
	std::vector<CInv> invs;

	// First remove all blocks that are not worth polling.
	{
	LOCK(cs_main);
	auto w = vote_records.getWriteView();
	for (auto it = w->begin(); it != w->end();) {
	const CBlockIndex *pindex = it->first;
	if (!IsWorthPolling(pindex)) {
	w->erase(it++);
	} else {
	++it;
	}
	}
	}

	auto r = vote_records.getReadView();
	for (const std::pair<const CBlockIndex *const, VoteRecord> &p :
	reverse_iterate(r)) {
	// Check if we can run poll.
	const bool shouldPoll =
	forPoll ? p.second.registerPoll() : p.second.shouldPoll();
	if (!shouldPoll) {
	continue;
	}

	// We don't have a decision, we need more votes.
	invs.emplace_back(MSG_BLOCK, p.first->GetBlockHash());
	if (invs.size() >= AVALANCHE_MAX_ELEMENT_POLL) {
	// Make sure we do not produce more invs than specified by the
	// protocol.
	return invs;
	}
	}

	return invs;
	}

	NodeId Processor::getSuitableNodeToQuery() {
	LOCK(cs_peerManager);
	return peerManager->selectNode();
	}

	void Processor::clearTimedoutRequests() {
	auto now = std::chrono::steady_clock::now();
	std::map<CInv, uint8_t> timedout_items{};

	{
	// Clear expired requests.
	auto w = queries.getWriteView();
	auto it = w->get<query_timeout>().begin();
	while (it != w->get<query_timeout>().end() && it->timeout < now) {
	for (const auto &i : it->invs) {
	timedout_items[i]++;
	}

	w->get<query_timeout>().erase(it++);
	}
	}

	if (timedout_items.empty()) {
	return;
	}

	// In flight request accounting.
	for (const auto &p : timedout_items) {
	const CInv &inv = p.first;
	assert(inv.type == MSG_BLOCK);

	CBlockIndex *pindex;

	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(BlockHash(inv.hash));
	if (!pindex) {
	continue;
	}
	}

	auto w = vote_records.getWriteView();
	auto it = w->find(pindex);
	if (it == w.end()) {
	continue;
	}

	it->second.clearInflightRequest(p.second);
	}
	}

	void Processor::runEventLoop() {
	// Don't do Avalanche while node is IBD'ing
	if (::ChainstateActive().IsInitialBlockDownload()) {
	return;
	}

	// First things first, check if we have requests that timed out and clear
	// them.
	clearTimedoutRequests();

	// Make sure there is at least one suitable node to query before gathering
	// invs.
	NodeId nodeid = getSuitableNodeToQuery();
	if (nodeid == NO_NODE) {
	return;
	}
	std::vector<CInv> invs = getInvsForNextPoll();
	if (invs.empty()) {
	return;
	}

	do {
	/**
	* If we lost contact to that node, then we remove it from nodeids, but
	* never add the request to queries, which ensures bad nodes get cleaned
	* up over time.
	*/
	bool hasSent = connman->ForNode(nodeid, [this, &invs](CNode *pnode) {
	uint64_t current_round = round++;

	{
	// Compute the time at which this requests times out.
	auto timeout =
	std::chrono::steady_clock::now() + queryTimeoutDuration;
	// Register the query.
	queries.getWriteView()->insert(
	{pnode->GetId(), current_round, timeout, invs});
	// Set the timeout.
	LOCK(cs_peerManager);
	peerManager->updateNextRequestTime(pnode->GetId(), timeout);
	}

	// Send the query to the node.
	connman->PushMessage(
	pnode, CNetMsgMaker(pnode->GetCommonVersion())
	.Make(NetMsgType::AVAPOLL,
	Poll(current_round, std::move(invs))));
	return true;
	});

	// Success!
	if (hasSent) {
	return;
	}

	{
	// This node is obsolete, delete it.
	LOCK(cs_peerManager);
	peerManager->removeNode(nodeid);
	}

	// Get next suitable node to try again
	nodeid = getSuitableNodeToQuery();
	} while (nodeid != NO_NODE);
	}

	void Processor::addUnbroadcastProof(const ProofId &proofid) {
	LOCK(cs_peerManager);
	peerManager->addUnbroadcastProof(proofid);
	}

	void Processor::removeUnbroadcastProof(const ProofId &proofid) {
	LOCK(cs_peerManager);
	peerManager->removeUnbroadcastProof(proofid);
	}

	} // namespace avalanche
	diff --git a/src/avalanche/processor.h b/src/avalanche/processor.h
	index 86bf9e6de..3b345f006 100644
	--- a/src/avalanche/processor.h
	+++ b/src/avalanche/processor.h
	@@ -1,328 +1,327 @@
	// Copyright (c) 2018-2019 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_AVALANCHE_PROCESSOR_H
	#define BITCOIN_AVALANCHE_PROCESSOR_H

	#include <avalanche/node.h>
	#include <avalanche/protocol.h>
	#include <blockindexworkcomparator.h>
	#include <eventloop.h>
	#include <interfaces/chain.h>
	#include <interfaces/handler.h>
	#include <key.h>
	#include <rwcollection.h>

	#include <boost/multi_index/composite_key.hpp>
	#include <boost/multi_index/hashed_index.hpp>
	#include <boost/multi_index/member.hpp>
	#include <boost/multi_index/ordered_index.hpp>
	#include <boost/multi_index_container.hpp>

	#include <atomic>
	#include <chrono>
	#include <cstdint>
	#include <memory>
	#include <vector>

	class ArgsManager;
	class Config;
	class CBlockIndex;
	class CScheduler;
	class PeerManager;
	struct bilingual_str;

	using NodePeerManager = PeerManager;

	/**
	* Finalization score.
	*/
	static constexpr int AVALANCHE_FINALIZATION_SCORE = 128;

	/**
	* Maximum item that can be polled at once.
	*/
	static constexpr size_t AVALANCHE_MAX_ELEMENT_POLL = 16;

	/**
	* How long before we consider that a query timed out.
	*/
	static constexpr std::chrono::milliseconds AVALANCHE_DEFAULT_QUERY_TIMEOUT{
	10000};

	/**
	* How many inflight requests can exist for one item.
	*/
	static constexpr int AVALANCHE_MAX_INFLIGHT_POLL = 10;

	namespace avalanche {

	class Delegation;
	class PeerManager;
	class Proof;

	/**
	* Vote history.
	*/
	struct VoteRecord {
	private:
	// confidence's LSB bit is the result. Higher bits are actual confidence
	// score.
	uint16_t confidence = 0;

	// Historical record of votes.
	uint8_t votes = 0;
	// Each bit indicate if the vote is to be considered.
	uint8_t consider = 0;
	// How many in flight requests exists for this element.
	mutable std::atomic<uint8_t> inflight{0};

	// Seed for pseudorandom operations.
	const uint32_t seed = 0;

	// Track how many successful votes occured.
	uint32_t successfulVotes = 0;

	// Track the nodes which are part of the quorum.
	std::array<uint16_t, 8> nodeFilter{{0, 0, 0, 0, 0, 0, 0, 0}};

	public:
	explicit VoteRecord(bool accepted) : confidence(accepted) {}

	/**
	* Copy semantic
	*/
	VoteRecord(const VoteRecord &other)
	: confidence(other.confidence), votes(other.votes),
	consider(other.consider), inflight(other.inflight.load()),
	successfulVotes(other.successfulVotes), nodeFilter(other.nodeFilter) {
	}

	/**
	* Vote accounting facilities.
	*/
	bool isAccepted() const { return confidence & 0x01; }

	uint16_t getConfidence() const { return confidence >> 1; }
	bool hasFinalized() const {
	return getConfidence() >= AVALANCHE_FINALIZATION_SCORE;
	}

	/**
	* Register a new vote for an item and update confidence accordingly.
	* Returns true if the acceptance or finalization state changed.
	*/
	bool registerVote(NodeId nodeid, uint32_t error);

	/**
	* Register that a request is being made regarding that item.
	* The method is made const so that it can be accessed via a read only view
	* of vote_records. It's not a problem as it is made thread safe.
	*/
	bool registerPoll() const;

	/**
	* Return if this item is in condition to be polled at the moment.
	*/
	bool shouldPoll() const { return inflight < AVALANCHE_MAX_INFLIGHT_POLL; }

	/**
	* Clear `count` inflight requests.
	*/
	void clearInflightRequest(uint8_t count = 1) { inflight -= count; }

	private:
	/**
	* Add the node to the quorum.
	* Returns true if the node was added, false if the node already was in the
	* quorum.
	*/
	bool addNodeToQuorum(NodeId nodeid);
	};

	class BlockUpdate {
	union {
	CBlockIndex *pindex;
	uintptr_t raw;
	};

	static const size_t STATUS_BITS = 2;
	static const uintptr_t MASK = (1 << STATUS_BITS) - 1;

	static_assert(
	alignof(CBlockIndex) >= (1 << STATUS_BITS),
	"CBlockIndex alignement doesn't allow for Status to be stored.");

	public:
	enum Status : uint8_t {
	Invalid,
	Rejected,
	Accepted,
	Finalized,
	};

	BlockUpdate(CBlockIndex *pindexIn, Status statusIn) : pindex(pindexIn) {
	raw \|= statusIn;
	}

	Status getStatus() const { return Status(raw & MASK); }

	CBlockIndex *getBlockIndex() {
	return reinterpret_cast<CBlockIndex *>(raw & ~MASK);
	}

	const CBlockIndex *getBlockIndex() const {
	return const_cast<BlockUpdate *>(this)->getBlockIndex();
	}
	};

	using BlockVoteMap =
	std::map<const CBlockIndex *, VoteRecord, CBlockIndexWorkComparator>;

	struct query_timeout {};

	namespace {
	struct AvalancheTest;
	}

	class Processor {
	CConnman *connman;
	NodePeerManager *nodePeerManager;
	std::chrono::milliseconds queryTimeoutDuration;

	/**
	* Blocks to run avalanche on.
	*/
	RWCollection<BlockVoteMap> vote_records;

	/**
	* Keep track of peers and queries sent.
	*/
	std::atomic<uint64_t> round;

	/**
	* Keep track of the peers and associated infos.
	*/
	mutable Mutex cs_peerManager;
	std::unique_ptr<PeerManager> peerManager GUARDED_BY(cs_peerManager);

	struct Query {
	NodeId nodeid;
	uint64_t round;
	TimePoint timeout;

	/**
	* We declare this as mutable so it can be modified in the multi_index.
	* This is ok because we do not use this field to index in anyway.
	*
	* /!\ Do not use any mutable field as index.
	*/
	mutable std::vector<CInv> invs;
	};

	using QuerySet = boost::multi_index_container<
	Query,
	boost::multi_index::indexed_by<
	// index by nodeid/round
	boost::multi_index::hashed_unique<boost::multi_index::composite_key<
	Query,
	boost::multi_index::member<Query, NodeId, &Query::nodeid>,
	boost::multi_index::member<Query, uint64_t, &Query::round>>>,
	// sorted by timeout
	boost::multi_index::ordered_non_unique<
	boost::multi_index::tag<query_timeout>,
	boost::multi_index::member<Query, TimePoint,
	&Query::timeout>>>>;

	RWCollection<QuerySet> queries;

	/** Data required to participate. */
	struct PeerData;
	std::unique_ptr<PeerData> peerData;
	CKey sessionKey;

	/** Event loop machinery. */
	EventLoop eventLoop;

	/** Registered interfaces::Chain::Notifications handler. */
	class NotificationsHandler;
	std::unique_ptr<interfaces::Handler> chainNotificationsHandler;

	/**
	* Flag indicating that the proof must be registered at first new block
	* after IBD
	*/
	bool mustRegisterProof = false;

	Processor(interfaces::Chain &chain, CConnman *connmanIn,
	NodePeerManager *nodePeerManagerIn,
	std::unique_ptr<PeerData> peerDataIn, CKey sessionKeyIn);

	public:
	~Processor();

	static std::unique_ptr<Processor>
	MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain,
	CConnman connman, NodePeerManager nodePeerManager,
	bilingual_str &error);

	void setQueryTimeoutDuration(std::chrono::milliseconds d) {
	queryTimeoutDuration = d;
	}

	bool addBlockToReconcile(const CBlockIndex *pindex);
	bool isAccepted(const CBlockIndex *pindex) const;
	int getConfidence(const CBlockIndex *pindex) const;

	// TDOD: Refactor the API to remove the dependency on avalanche/protocol.h
	void sendResponse(CNode *pfrom, Response response) const;
	bool registerVotes(NodeId nodeid, const Response &response,
	std::vector<BlockUpdate> &updates);

	bool addNode(NodeId nodeid, const ProofId &proofid);
	bool forNode(NodeId nodeid, std::function<bool(const Node &n)> func) const;

	template <typename Callable> auto withPeerManager(Callable &&func) const {
	LOCK(cs_peerManager);
	return func(*peerManager);
	}

	CPubKey getSessionPubKey() const;
	bool sendHello(CNode *pfrom) const;

	bool addProof(const std::shared_ptr<Proof> &proof);
	std::shared_ptr<Proof> getProof(const ProofId &proofid) const;
	std::shared_ptr<Proof> getLocalProof() const;
	- std::chrono::seconds getProofRegistrationTime(const ProofId &proofid) const;
	std::shared_ptr<Proof> getOrphan(const ProofId &proofid) const;

	/*
	* Return whether the avalanche service flag should be set.
	*/
	bool isAvalancheServiceAvailable() { return !!peerData; }

	bool startEventLoop(CScheduler &scheduler);
	bool stopEventLoop();

	void addUnbroadcastProof(const ProofId &proofid);
	void removeUnbroadcastProof(const ProofId &proofid);

	private:
	void runEventLoop();
	void clearTimedoutRequests();
	std::vector<CInv> getInvsForNextPoll(bool forPoll = true);
	NodeId getSuitableNodeToQuery();

	/**
	* Build and return the challenge whose signature is included in the
	* AVAHELLO message that we send to a peer.
	*/
	uint256 buildLocalSighash(CNode *pfrom) const;

	friend struct ::avalanche::AvalancheTest;
	};

	} // namespace avalanche

	#endif // BITCOIN_AVALANCHE_PROCESSOR_H
	diff --git a/src/avalanche/test/processor_tests.cpp b/src/avalanche/test/processor_tests.cpp
	index 7e64e541a..95675117c 100644
	--- a/src/avalanche/test/processor_tests.cpp
	+++ b/src/avalanche/test/processor_tests.cpp
	@@ -1,1015 +1,1003 @@
	// Copyright (c) 2018-2020 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <avalanche/processor.h>

	#include <avalanche/delegationbuilder.h>
	#include <avalanche/peermanager.h>
	#include <avalanche/proofbuilder.h>
	#include <chain.h>
	#include <config.h>
	#include <net_processing.h> // For ::PeerManager
	#include <util/time.h>
	#include <util/translation.h> // For bilingual_str
	// D6970 moved LookupBlockIndex from chain.h to validation.h TODO: remove this
	// when LookupBlockIndex is refactored out of validation
	#include <validation.h>

	#include <test/util/setup_common.h>

	#include <boost/test/unit_test.hpp>

	using namespace avalanche;

	namespace avalanche {
	namespace {
	struct AvalancheTest {
	static void runEventLoop(avalanche::Processor &p) { p.runEventLoop(); }

	static std::vector<CInv> getInvsForNextPoll(Processor &p) {
	return p.getInvsForNextPoll(false);
	}

	static NodeId getSuitableNodeToQuery(Processor &p) {
	return p.getSuitableNodeToQuery();
	}

	static uint64_t getRound(const Processor &p) { return p.round; }
	};
	} // namespace
	} // namespace avalanche

	namespace {
	struct CConnmanTest : public CConnman {
	using CConnman::CConnman;
	void AddNode(CNode &node) {
	LOCK(cs_vNodes);
	vNodes.push_back(&node);
	}
	void ClearNodes() {
	LOCK(cs_vNodes);
	for (CNode *node : vNodes) {
	delete node;
	}
	vNodes.clear();
	}
	};

	CService ip(uint32_t i) {
	struct in_addr s;
	s.s_addr = i;
	return CService(CNetAddr(s), Params().GetDefaultPort());
	}

	struct AvalancheTestingSetup : public TestChain100Setup {
	const Config &config;
	CConnmanTest *m_connman;

	std::unique_ptr<Processor> m_processor;

	CKey masterpriv;

	AvalancheTestingSetup()
	: TestChain100Setup(), config(GetConfig()), masterpriv() {
	// Deterministic randomness for tests.
	auto connman = std::make_unique<CConnmanTest>(config, 0x1337, 0x1337);
	m_connman = connman.get();
	m_node.connman = std::move(connman);
	m_node.peerman = std::make_unique<::PeerManager>(
	config.GetChainParams(), *m_connman, m_node.banman.get(),
	m_node.scheduler, m_node.chainman, *m_node.mempool);
	m_node.chain = interfaces::MakeChain(m_node, config.GetChainParams());

	// Get the processor ready.
	bilingual_str error;
	m_processor = Processor::MakeProcessor(m_node.args, m_node.chain,
	m_node.connman.get(),
	m_node.peerman.get(), error);
	BOOST_CHECK(m_processor);

	// The master private key we delegate to.
	masterpriv.MakeNewKey(true);
	}

	~AvalancheTestingSetup() {
	m_connman->ClearNodes();
	SyncWithValidationInterfaceQueue();
	}

	CNode *ConnectNode(ServiceFlags nServices) {
	static NodeId id = 0;

	CAddress addr(ip(GetRandInt(0xffffffff)), NODE_NONE);
	auto node =
	new CNode(id++, ServiceFlags(NODE_NETWORK), 0, INVALID_SOCKET, addr,
	0, 0, 0, CAddress(), "", ConnectionType::OUTBOUND);
	node->SetCommonVersion(PROTOCOL_VERSION);
	node->nServices = nServices;
	m_node.peerman->InitializeNode(config, node);
	node->nVersion = 1;
	node->fSuccessfullyConnected = true;

	m_connman->AddNode(*node);
	return node;
	}

	size_t next_coinbase = 0;
	std::shared_ptr<Proof> GetProof() {
	size_t current_coinbase = next_coinbase++;
	const CTransaction &coinbase = *m_coinbase_txns[current_coinbase];
	ProofBuilder pb(0, 0, masterpriv.GetPubKey());
	BOOST_CHECK(pb.addUTXO(COutPoint(coinbase.GetId(), 0),
	coinbase.vout[0].nValue, current_coinbase + 1,
	true, coinbaseKey));
	return std::make_shared<Proof>(pb.build());
	}

	bool addNode(NodeId nodeid) {
	auto proof = GetProof();
	BOOST_CHECK(m_processor->addProof(proof));
	return m_processor->addNode(nodeid, proof->getId());
	}

	std::array<CNode *, 8> ConnectNodes() {
	auto proof = GetProof();
	BOOST_CHECK(m_processor->addProof(proof));
	const ProofId &proofid = proof->getId();

	std::array<CNode *, 8> nodes;
	for (CNode *&n : nodes) {
	n = ConnectNode(NODE_AVALANCHE);
	BOOST_CHECK(m_processor->addNode(n->GetId(), proofid));
	}

	return nodes;
	}

	void runEventLoop() { AvalancheTest::runEventLoop(*m_processor); }

	NodeId getSuitableNodeToQuery() {
	return AvalancheTest::getSuitableNodeToQuery(*m_processor);
	}

	std::vector<CInv> getInvsForNextPoll() {
	return AvalancheTest::getInvsForNextPoll(*m_processor);
	}

	uint64_t getRound() const { return AvalancheTest::getRound(*m_processor); }
	};
	} // namespace

	BOOST_FIXTURE_TEST_SUITE(processor_tests, AvalancheTestingSetup)

	#define REGISTER_VOTE_AND_CHECK(vr, vote, state, finalized, confidence) \
	vr.registerVote(NO_NODE, vote); \
	BOOST_CHECK_EQUAL(vr.isAccepted(), state); \
	BOOST_CHECK_EQUAL(vr.hasFinalized(), finalized); \
	BOOST_CHECK_EQUAL(vr.getConfidence(), confidence);

	BOOST_AUTO_TEST_CASE(vote_record) {
	VoteRecord vraccepted(true);

	// Check initial state.
	BOOST_CHECK_EQUAL(vraccepted.isAccepted(), true);
	BOOST_CHECK_EQUAL(vraccepted.hasFinalized(), false);
	BOOST_CHECK_EQUAL(vraccepted.getConfidence(), 0);

	VoteRecord vr(false);

	// Check initial state.
	BOOST_CHECK_EQUAL(vr.isAccepted(), false);
	BOOST_CHECK_EQUAL(vr.hasFinalized(), false);
	BOOST_CHECK_EQUAL(vr.getConfidence(), 0);

	// We need to register 6 positive votes before we start counting.
	for (int i = 0; i < 6; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 0, false, false, 0);
	}

	// Next vote will flip state, and confidence will increase as long as we
	// vote yes.
	REGISTER_VOTE_AND_CHECK(vr, 0, true, false, 0);

	// A single neutral vote do not change anything.
	REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 1);
	for (int i = 2; i < 8; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 0, true, false, i);
	}

	// Two neutral votes will stall progress.
	REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 7);
	REGISTER_VOTE_AND_CHECK(vr, -1, true, false, 7);
	for (int i = 2; i < 8; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 0, true, false, 7);
	}

	// Now confidence will increase as long as we vote yes.
	for (int i = 8; i < AVALANCHE_FINALIZATION_SCORE; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 0, true, false, i);
	}

	// The next vote will finalize the decision.
	REGISTER_VOTE_AND_CHECK(vr, 1, true, true, AVALANCHE_FINALIZATION_SCORE);

	// Now that we have two no votes, confidence stop increasing.
	for (int i = 0; i < 5; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 1, true, true,
	AVALANCHE_FINALIZATION_SCORE);
	}

	// Next vote will flip state, and confidence will increase as long as we
	// vote no.
	REGISTER_VOTE_AND_CHECK(vr, 1, false, false, 0);

	// A single neutral vote do not change anything.
	REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 1);
	for (int i = 2; i < 8; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 1, false, false, i);
	}

	// Two neutral votes will stall progress.
	REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 7);
	REGISTER_VOTE_AND_CHECK(vr, -1, false, false, 7);
	for (int i = 2; i < 8; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 1, false, false, 7);
	}

	// Now confidence will increase as long as we vote no.
	for (int i = 8; i < AVALANCHE_FINALIZATION_SCORE; i++) {
	REGISTER_VOTE_AND_CHECK(vr, 1, false, false, i);
	}

	// The next vote will finalize the decision.
	REGISTER_VOTE_AND_CHECK(vr, 0, false, true, AVALANCHE_FINALIZATION_SCORE);

	// Check that inflight accounting work as expected.
	VoteRecord vrinflight(false);
	for (int i = 0; i < 2 * AVALANCHE_MAX_INFLIGHT_POLL; i++) {
	bool shouldPoll = vrinflight.shouldPoll();
	BOOST_CHECK_EQUAL(shouldPoll, i < AVALANCHE_MAX_INFLIGHT_POLL);
	BOOST_CHECK_EQUAL(vrinflight.registerPoll(), shouldPoll);
	}

	// Clear various number of inflight requests and check everything behaves as
	// expected.
	for (int i = 1; i < AVALANCHE_MAX_INFLIGHT_POLL; i++) {
	vrinflight.clearInflightRequest(i);
	BOOST_CHECK(vrinflight.shouldPoll());

	for (int j = 1; j < i; j++) {
	BOOST_CHECK(vrinflight.registerPoll());
	BOOST_CHECK(vrinflight.shouldPoll());
	}

	BOOST_CHECK(vrinflight.registerPoll());
	BOOST_CHECK(!vrinflight.shouldPoll());
	}
	}

	BOOST_AUTO_TEST_CASE(block_update) {
	CBlockIndex index;
	CBlockIndex *pindex = &index;

	std::set<BlockUpdate::Status> status{
	BlockUpdate::Status::Invalid,
	BlockUpdate::Status::Rejected,
	BlockUpdate::Status::Accepted,
	BlockUpdate::Status::Finalized,
	};

	for (auto s : status) {
	BlockUpdate abu(pindex, s);
	BOOST_CHECK(abu.getBlockIndex() == pindex);
	BOOST_CHECK_EQUAL(abu.getStatus(), s);
	}
	}

	namespace {
	Response next(Response &r) {
	auto copy = r;
	r = {r.getRound() + 1, r.getCooldown(), r.GetVotes()};
	return copy;
	}
	} // namespace

	BOOST_AUTO_TEST_CASE(block_register) {
	std::vector<BlockUpdate> updates;

	CBlock block = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash = block.GetHash();
	const CBlockIndex *pindex;
	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(blockHash);
	}

	// Create nodes that supports avalanche.
	auto avanodes = ConnectNodes();

	// Querying for random block returns false.
	BOOST_CHECK(!m_processor->isAccepted(pindex));

	// Add a new block. Check it is added to the polls.
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
	auto invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);

	// Newly added blocks' state reflect the blockchain.
	BOOST_CHECK(m_processor->isAccepted(pindex));

	int nextNodeIndex = 0;
	auto registerNewVote = [&](const Response &resp) {
	runEventLoop();
	auto nodeid = avanodes[nextNodeIndex++ % avanodes.size()]->GetId();
	BOOST_CHECK(m_processor->registerVotes(nodeid, resp, updates));
	};

	// Let's vote for this block a few times.
	Response resp{0, 0, {Vote(0, blockHash)}};
	for (int i = 0; i < 6; i++) {
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 0);
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// A single neutral vote do not change anything.
	resp = {getRound(), 0, {Vote(-1, blockHash)}};
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 0);
	BOOST_CHECK_EQUAL(updates.size(), 0);

	resp = {getRound(), 0, {Vote(0, blockHash)}};
	for (int i = 1; i < 7; i++) {
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), i);
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// Two neutral votes will stall progress.
	resp = {getRound(), 0, {Vote(-1, blockHash)}};
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 6);
	BOOST_CHECK_EQUAL(updates.size(), 0);
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 6);
	BOOST_CHECK_EQUAL(updates.size(), 0);

	resp = {getRound(), 0, {Vote(0, blockHash)}};
	for (int i = 2; i < 8; i++) {
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), 6);
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// We vote for it numerous times to finalize it.
	for (int i = 7; i < AVALANCHE_FINALIZATION_SCORE; i++) {
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), i);
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// As long as it is not finalized, we poll.
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);

	// Now finalize the decision.
	registerNewVote(next(resp));
	BOOST_CHECK_EQUAL(updates.size(), 1);
	BOOST_CHECK(updates[0].getBlockIndex() == pindex);
	BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
	updates = {};

	// Once the decision is finalized, there is no poll for it.
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 0);

	// Now let's undo this and finalize rejection.
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);

	resp = {getRound(), 0, {Vote(1, blockHash)}};
	for (int i = 0; i < 6; i++) {
	registerNewVote(next(resp));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// Now the state will flip.
	registerNewVote(next(resp));
	BOOST_CHECK(!m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(updates.size(), 1);
	BOOST_CHECK(updates[0].getBlockIndex() == pindex);
	BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Rejected);
	updates = {};

	// Now it is rejected, but we can vote for it numerous times.
	for (int i = 1; i < AVALANCHE_FINALIZATION_SCORE; i++) {
	registerNewVote(next(resp));
	BOOST_CHECK(!m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// As long as it is not finalized, we poll.
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);

	// Now finalize the decision.
	registerNewVote(next(resp));
	BOOST_CHECK(!m_processor->isAccepted(pindex));
	BOOST_CHECK_EQUAL(updates.size(), 1);
	BOOST_CHECK(updates[0].getBlockIndex() == pindex);
	BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Invalid);
	updates = {};

	// Once the decision is finalized, there is no poll for it.
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 0);

	// Adding the block twice does nothing.
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
	BOOST_CHECK(!m_processor->addBlockToReconcile(pindex));
	BOOST_CHECK(m_processor->isAccepted(pindex));
	}

	BOOST_AUTO_TEST_CASE(multi_block_register) {
	CBlockIndex indexA, indexB;

	std::vector<BlockUpdate> updates;

	// Create several nodes that support avalanche.
	auto avanodes = ConnectNodes();

	// Make sure the block has a hash.
	CBlock blockA = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHashA = blockA.GetHash();

	CBlock blockB = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHashB = blockB.GetHash();
	const CBlockIndex *pindexA;
	const CBlockIndex *pindexB;
	{
	LOCK(cs_main);
	pindexA = LookupBlockIndex(blockHashA);
	pindexB = LookupBlockIndex(blockHashB);
	}

	// Querying for random block returns false.
	BOOST_CHECK(!m_processor->isAccepted(pindexA));
	BOOST_CHECK(!m_processor->isAccepted(pindexB));

	// Start voting on block A.
	BOOST_CHECK(m_processor->addBlockToReconcile(pindexA));
	auto invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHashA);

	uint64_t round = getRound();
	runEventLoop();
	BOOST_CHECK(m_processor->registerVotes(
	avanodes[0]->GetId(), {round, 0, {Vote(0, blockHashA)}}, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);

	// Start voting on block B after one vote.
	Response resp{round + 1, 0, {Vote(0, blockHashB), Vote(0, blockHashA)}};
	BOOST_CHECK(m_processor->addBlockToReconcile(pindexB));
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 2);

	// Ensure B comes before A because it has accumulated more PoW.
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHashB);
	BOOST_CHECK_EQUAL(invs[1].type, MSG_BLOCK);
	BOOST_CHECK(invs[1].hash == blockHashA);

	// Let's vote for these blocks a few times.
	for (int i = 0; i < 4; i++) {
	NodeId nodeid = getSuitableNodeToQuery();
	runEventLoop();
	BOOST_CHECK(m_processor->registerVotes(nodeid, next(resp), updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// Now it is accepted, but we can vote for it numerous times.
	for (int i = 0; i < AVALANCHE_FINALIZATION_SCORE; i++) {
	NodeId nodeid = getSuitableNodeToQuery();
	runEventLoop();
	BOOST_CHECK(m_processor->registerVotes(nodeid, next(resp), updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	}

	// Running two iterration of the event loop so that vote gets triggered on A
	// and B.
	NodeId firstNodeid = getSuitableNodeToQuery();
	runEventLoop();
	NodeId secondNodeid = getSuitableNodeToQuery();
	runEventLoop();

	BOOST_CHECK(firstNodeid != secondNodeid);

	// Next vote will finalize block A.
	BOOST_CHECK(m_processor->registerVotes(firstNodeid, next(resp), updates));
	BOOST_CHECK_EQUAL(updates.size(), 1);
	BOOST_CHECK(updates[0].getBlockIndex() == pindexA);
	BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
	updates = {};

	// We do not vote on A anymore.
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHashB);

	// Next vote will finalize block B.
	BOOST_CHECK(m_processor->registerVotes(secondNodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 1);
	BOOST_CHECK(updates[0].getBlockIndex() == pindexB);
	BOOST_CHECK_EQUAL(updates[0].getStatus(), BlockUpdate::Status::Finalized);
	updates = {};

	// There is nothing left to vote on.
	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 0);
	}

	BOOST_AUTO_TEST_CASE(poll_and_response) {
	std::vector<BlockUpdate> updates;

	CBlock block = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash = block.GetHash();
	const CBlockIndex *pindex;
	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(blockHash);
	}

	// There is no node to query.
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);

	// Create a node that supports avalanche and one that doesn't.
	ConnectNode(NODE_NONE);
	auto avanode = ConnectNode(NODE_AVALANCHE);
	NodeId avanodeid = avanode->GetId();
	BOOST_CHECK(addNode(avanodeid));

	// It returns the avalanche peer.
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// Register a block and check it is added to the list of elements to poll.
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));
	auto invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);

	// Trigger a poll on avanode.
	uint64_t round = getRound();
	runEventLoop();

	// There is no more suitable peer available, so return nothing.
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);

	// Respond to the request.
	Response resp = {round, 0, {Vote(0, blockHash)}};
	BOOST_CHECK(m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);

	// Now that avanode fullfilled his request, it is added back to the list of
	// queriable nodes.
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// Sending a response when not polled fails.
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, next(resp), updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);

	// Trigger a poll on avanode.
	round = getRound();
	runEventLoop();
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), NO_NODE);

	// Sending responses that do not match the request also fails.
	// 1. Too many results.
	resp = {round, 0, {Vote(0, blockHash), Vote(0, blockHash)}};
	runEventLoop();
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// 2. Not enough results.
	resp = {getRound(), 0, {}};
	runEventLoop();
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// 3. Do not match the poll.
	resp = {getRound(), 0, {Vote()}};
	runEventLoop();
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// 4. Invalid round count. Request is not discarded.
	uint64_t queryRound = getRound();
	runEventLoop();

	resp = {queryRound + 1, 0, {Vote()}};
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);

	resp = {queryRound - 1, 0, {Vote()}};
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);

	// 5. Making request for invalid nodes do not work. Request is not
	// discarded.
	resp = {queryRound, 0, {Vote(0, blockHash)}};
	BOOST_CHECK(!m_processor->registerVotes(avanodeid + 1234, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);

	// Proper response gets processed and avanode is available again.
	resp = {queryRound, 0, {Vote(0, blockHash)}};
	BOOST_CHECK(m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// Out of order response are rejected.
	CBlock block2 = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash2 = block2.GetHash();
	CBlockIndex *pindex2;
	{
	LOCK(cs_main);
	pindex2 = LookupBlockIndex(blockHash2);
	}
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex2));

	resp = {getRound(), 0, {Vote(0, blockHash), Vote(0, blockHash2)}};
	runEventLoop();
	BOOST_CHECK(!m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// But they are accepted in order.
	resp = {getRound(), 0, {Vote(0, blockHash2), Vote(0, blockHash)}};
	runEventLoop();
	BOOST_CHECK(m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);

	// When a block is marked invalid, stop polling.
	pindex2->nStatus = pindex2->nStatus.withFailed();
	resp = {getRound(), 0, {Vote(0, blockHash)}};
	runEventLoop();
	BOOST_CHECK(m_processor->registerVotes(avanodeid, resp, updates));
	BOOST_CHECK_EQUAL(updates.size(), 0);
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), avanodeid);
	}

	BOOST_AUTO_TEST_CASE(poll_inflight_timeout, *boost::unit_test::timeout(60)) {
	std::vector<BlockUpdate> updates;

	CBlock block = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash = block.GetHash();
	const CBlockIndex *pindex;
	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(blockHash);
	}

	// Add the block
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));

	// Create a node that supports avalanche.
	auto avanode = ConnectNode(NODE_AVALANCHE);
	NodeId avanodeid = avanode->GetId();
	BOOST_CHECK(addNode(avanodeid));

	// Expire requests after some time.
	auto queryTimeDuration = std::chrono::milliseconds(10);
	m_processor->setQueryTimeoutDuration(queryTimeDuration);
	for (int i = 0; i < 10; i++) {
	Response resp = {getRound(), 0, {Vote(0, blockHash)}};

	auto start = std::chrono::steady_clock::now();
	runEventLoop();
	// We cannot guarantee that we'll wait for just 1ms, so we have to bail
	// if we aren't within the proper time range.
	std::this_thread::sleep_for(std::chrono::milliseconds(1));
	runEventLoop();

	bool ret = m_processor->registerVotes(avanodeid, next(resp), updates);
	if (std::chrono::steady_clock::now() > start + queryTimeDuration) {
	// We waited for too long, bail. Because we can't know for sure when
	// previous steps ran, ret is not deterministic and we do not check
	// it.
	i--;
	continue;
	}

	// We are within time bounds, so the vote should have worked.
	BOOST_CHECK(ret);

	// Now try again but wait for expiration.
	runEventLoop();
	std::this_thread::sleep_for(queryTimeDuration);
	runEventLoop();
	BOOST_CHECK(
	!m_processor->registerVotes(avanodeid, next(resp), updates));
	}
	}

	BOOST_AUTO_TEST_CASE(poll_inflight_count) {
	// Create enough nodes so that we run into the inflight request limit.
	auto proof = GetProof();
	BOOST_CHECK(m_processor->addProof(proof));

	std::array<CNode *, AVALANCHE_MAX_INFLIGHT_POLL + 1> nodes;
	for (auto &n : nodes) {
	n = ConnectNode(NODE_AVALANCHE);
	BOOST_CHECK(m_processor->addNode(n->GetId(), proof->getId()));
	}

	// Add a block to poll
	CBlock block = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash = block.GetHash();
	const CBlockIndex *pindex;
	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(blockHash);
	}
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));

	// Ensure there are enough requests in flight.
	std::map<NodeId, uint64_t> node_round_map;
	for (int i = 0; i < AVALANCHE_MAX_INFLIGHT_POLL; i++) {
	NodeId nodeid = getSuitableNodeToQuery();
	BOOST_CHECK(node_round_map.find(nodeid) == node_round_map.end());
	node_round_map[nodeid] = getRound();
	auto invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);
	runEventLoop();
	}

	// Now that we have enough in flight requests, we shouldn't poll.
	auto suitablenodeid = getSuitableNodeToQuery();
	BOOST_CHECK(suitablenodeid != NO_NODE);
	auto invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 0);
	runEventLoop();
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), suitablenodeid);

	std::vector<BlockUpdate> updates;

	// Send one response, now we can poll again.
	auto it = node_round_map.begin();
	Response resp = {it->second, 0, {Vote(0, blockHash)}};
	BOOST_CHECK(m_processor->registerVotes(it->first, resp, updates));
	node_round_map.erase(it);

	invs = getInvsForNextPoll();
	BOOST_CHECK_EQUAL(invs.size(), 1);
	BOOST_CHECK_EQUAL(invs[0].type, MSG_BLOCK);
	BOOST_CHECK(invs[0].hash == blockHash);
	}

	BOOST_AUTO_TEST_CASE(quorum_diversity) {
	std::vector<BlockUpdate> updates;

	CBlock block = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash = block.GetHash();
	const CBlockIndex *pindex;
	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(blockHash);
	}

	// Create nodes that supports avalanche.
	auto avanodes = ConnectNodes();

	// Querying for random block returns false.
	BOOST_CHECK(!m_processor->isAccepted(pindex));

	// Add a new block. Check it is added to the polls.
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));

	// Do one valid round of voting.
	uint64_t round = getRound();
	Response resp{round, 0, {Vote(0, blockHash)}};

	// Check that all nodes can vote.
	for (size_t i = 0; i < avanodes.size(); i++) {
	runEventLoop();
	BOOST_CHECK(m_processor->registerVotes(avanodes[i]->GetId(), next(resp),
	updates));
	}

	// Generate a query for every single node.
	const NodeId firstNodeId = getSuitableNodeToQuery();
	std::map<NodeId, uint64_t> node_round_map;
	round = getRound();
	for (size_t i = 0; i < avanodes.size(); i++) {
	NodeId nodeid = getSuitableNodeToQuery();
	BOOST_CHECK(node_round_map.find(nodeid) == node_round_map.end());
	node_round_map[nodeid] = getRound();
	runEventLoop();
	}

	// Now only tge first node can vote. All others would be duplicate in the
	// quorum.
	auto confidence = m_processor->getConfidence(pindex);
	BOOST_REQUIRE(confidence > 0);

	for (auto &pair : node_round_map) {
	NodeId nodeid = pair.first;
	uint64_t r = pair.second;

	if (nodeid == firstNodeId) {
	// Node 0 is the only one which can vote at this stage.
	round = r;
	continue;
	}

	BOOST_CHECK(m_processor->registerVotes(
	nodeid, {r, 0, {Vote(0, blockHash)}}, updates));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), confidence);
	}

	BOOST_CHECK(m_processor->registerVotes(
	firstNodeId, {round, 0, {Vote(0, blockHash)}}, updates));
	BOOST_CHECK_EQUAL(m_processor->getConfidence(pindex), confidence + 1);
	}

	BOOST_AUTO_TEST_CASE(event_loop) {
	CScheduler s;

	CBlock block = CreateAndProcessBlock({}, CScript());
	const BlockHash blockHash = block.GetHash();
	const CBlockIndex *pindex;
	{
	LOCK(cs_main);
	pindex = LookupBlockIndex(blockHash);
	}

	// Starting the event loop.
	BOOST_CHECK(m_processor->startEventLoop(s));

	// There is one task planned in the next hour (our event loop).
	std::chrono::system_clock::time_point start, stop;
	BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 1);

	// Starting twice doesn't start it twice.
	BOOST_CHECK(!m_processor->startEventLoop(s));

	// Start the scheduler thread.
	std::thread schedulerThread(std::bind(&CScheduler::serviceQueue, &s));

	// Create a node that supports avalanche.
	auto avanode = ConnectNode(NODE_AVALANCHE);
	NodeId nodeid = avanode->GetId();
	BOOST_CHECK(addNode(nodeid));

	// There is no query in flight at the moment.
	BOOST_CHECK_EQUAL(getSuitableNodeToQuery(), nodeid);

	// Add a new block. Check it is added to the polls.
	uint64_t queryRound = getRound();
	BOOST_CHECK(m_processor->addBlockToReconcile(pindex));

	for (int i = 0; i < 60 * 1000; i++) {
	// Technically, this is a race condition, but this should do just fine
	// as we wait up to 1 minute for an event that should take 10ms.
	UninterruptibleSleep(std::chrono::milliseconds(1));
	if (getRound() != queryRound) {
	break;
	}
	}

	// Check that we effectively got a request and not timed out.
	BOOST_CHECK(getRound() > queryRound);

	// Respond and check the cooldown time is respected.
	uint64_t responseRound = getRound();
	auto queryTime =
	std::chrono::steady_clock::now() + std::chrono::milliseconds(100);

	std::vector<BlockUpdate> updates;
	m_processor->registerVotes(nodeid, {queryRound, 100, {Vote(0, blockHash)}},
	updates);
	for (int i = 0; i < 10000; i++) {
	// We make sure that we do not get a request before queryTime.
	UninterruptibleSleep(std::chrono::milliseconds(1));
	if (getRound() != responseRound) {
	BOOST_CHECK(std::chrono::steady_clock::now() > queryTime);
	break;
	}
	}

	// But we eventually get one.
	BOOST_CHECK(getRound() > responseRound);

	// Stop event loop.
	BOOST_CHECK(m_processor->stopEventLoop());

	// We don't have any task scheduled anymore.
	BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 0);

	// Can't stop the event loop twice.
	BOOST_CHECK(!m_processor->stopEventLoop());

	// Wait for the scheduler to stop.
	s.stop(true);
	schedulerThread.join();
	}

	BOOST_AUTO_TEST_CASE(destructor) {
	CScheduler s;
	std::chrono::system_clock::time_point start, stop;

	std::thread schedulerThread;
	BOOST_CHECK(m_processor->startEventLoop(s));
	BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 1);

	// Start the service thread after the queue size check to prevent a race
	// condition where the thread may be processing the event loop task during
	// the check.
	schedulerThread = std::thread(std::bind(&CScheduler::serviceQueue, &s));

	// Destroy the processor.
	m_processor.reset();

	// Now that avalanche is destroyed, there is no more scheduled tasks.
	BOOST_CHECK_EQUAL(s.getQueueInfo(start, stop), 0);

	// Wait for the scheduler to stop.
	s.stop(true);
	schedulerThread.join();
	}

	BOOST_AUTO_TEST_CASE(proof_accessors) {
	constexpr int numProofs = 10;

	std::vector<std::shared_ptr<Proof>> proofs;
	proofs.reserve(numProofs);
	for (int i = 0; i < numProofs; i++) {
	proofs.push_back(GetProof());
	}

	- const auto checkpoint = GetTime<std::chrono::seconds>();
	-
	- for (int i = 0; i < numProofs; i++) {
	- BOOST_CHECK(m_processor->addProof(proofs[i]));
	- // Fail to add an existing proof
	- BOOST_CHECK(!m_processor->addProof(proofs[i]));
	-
	- for (int added = 0; added <= i; added++) {
	- auto proof = m_processor->getProof(proofs[added]->getId());
	- BOOST_CHECK(proof != nullptr);
	-
	- const ProofId &proofid = proof->getId();
	- BOOST_CHECK_EQUAL(proofid, proofs[added]->getId());
	-
	- const auto proofTime =
	- m_processor->getProofRegistrationTime(proofid);
	- BOOST_CHECK(proofTime != std::chrono::seconds::max());
	- BOOST_CHECK(proofTime >= checkpoint);
	- }
	-
	- for (int missing = i + 1; missing < numProofs; missing++) {
	- const ProofId &proofid = proofs[missing]->getId();
	- BOOST_CHECK(!m_processor->getProof(proofid));
	- BOOST_CHECK(m_processor->getProofRegistrationTime(proofid) ==
	- std::chrono::seconds::max());
	+ m_processor->withPeerManager([&](avalanche::PeerManager &pm) {
	+ for (int i = 0; i < numProofs; i++) {
	+ BOOST_CHECK(pm.registerProof(proofs[i]));
	+ // Fail to add an existing proof
	+ BOOST_CHECK(!pm.registerProof(proofs[i]));
	+
	+ for (int added = 0; added <= i; added++) {
	+ auto proof = pm.getProof(proofs[added]->getId());
	+ BOOST_CHECK(proof != nullptr);
	+
	+ const ProofId &proofid = proof->getId();
	+ BOOST_CHECK_EQUAL(proofid, proofs[added]->getId());
	+ }
	}
	- }
	+ });

	// No stake, copied from proof_tests.cpp
	const std::string badProofHex(
	"96527eae083f1f24625f049d9e54bb9a2102a93d98bf42ab90cfc0bf9e7c634ed76a7"
	"3e95b02cacfd357b64e4fb6c92e92dd00");
	bilingual_str error;
	Proof badProof;
	BOOST_CHECK(Proof::FromHex(badProof, badProofHex, error));
	BOOST_CHECK(
	!m_processor->addProof(std::make_shared<Proof>(std::move(badProof))));
	}

	BOOST_AUTO_TEST_SUITE_END()
	diff --git a/src/net_processing.cpp b/src/net_processing.cpp
	index 53502faff..d9bc07c3d 100644
	--- a/src/net_processing.cpp
	+++ b/src/net_processing.cpp
	@@ -1,5861 +1,5867 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2016 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <net_processing.h>

	#include <addrman.h>
	#include <avalanche/avalanche.h>
	#include <avalanche/peermanager.h>
	#include <avalanche/processor.h>
	#include <avalanche/proof.h>
	#include <avalanche/validation.h>
	#include <banman.h>
	#include <blockdb.h>
	#include <blockencodings.h>
	#include <blockfilter.h>
	#include <blockvalidity.h>
	#include <chain.h>
	#include <chainparams.h>
	#include <config.h>
	#include <consensus/validation.h>
	#include <hash.h>
	#include <index/blockfilterindex.h>
	#include <merkleblock.h>
	#include <netbase.h>
	#include <netmessagemaker.h>
	#include <policy/fees.h>
	#include <policy/policy.h>
	#include <primitives/block.h>
	#include <primitives/transaction.h>
	#include <random.h>
	#include <reverse_iterator.h>
	#include <scheduler.h>
	#include <streams.h>
	#include <tinyformat.h>
	#include <txmempool.h>
	#include <util/check.h> // For NDEBUG compile time check
	#include <util/strencodings.h>
	#include <util/system.h>
	#include <validation.h>

	#include <memory>
	#include <typeinfo>

	/** Expiration time for orphan transactions in seconds */
	static constexpr int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
	/** Minimum time between orphan transactions expire time checks in seconds */
	static constexpr int64_t ORPHAN_TX_EXPIRE_INTERVAL = 5 * 60;
	/** How long to cache transactions in mapRelay for normal relay */
	static constexpr std::chrono::seconds RELAY_TX_CACHE_TIME =
	std::chrono::minutes{15};
	/** How long a transaction has to be in the mempool before it can
	* unconditionally be relayed (even when not in mapRelay). */
	static constexpr std::chrono::seconds UNCONDITIONAL_RELAY_DELAY =
	std::chrono::minutes{2};
	/**
	* Headers download timeout expressed in microseconds.
	* Timeout = base + per_header * (expected number of headers)
	*/
	// 15 minutes
	static constexpr int64_t HEADERS_DOWNLOAD_TIMEOUT_BASE = 15 * 60 * 1000000;
	// 1ms/header
	static constexpr int64_t HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER = 1000;
	/**
	* Protect at least this many outbound peers from disconnection due to
	* slow/behind headers chain.
	*/
	static constexpr int32_t MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT = 4;
	/**
	* Timeout for (unprotected) outbound peers to sync to our chainwork, in
	* seconds.
	*/
	// 20 minutes
	static constexpr int64_t CHAIN_SYNC_TIMEOUT = 20 * 60;
	/** How frequently to check for stale tips, in seconds */
	// 10 minutes
	static constexpr int64_t STALE_CHECK_INTERVAL = 10 * 60;
	/**
	* How frequently to check for extra outbound peers and disconnect, in seconds.
	*/
	static constexpr int64_t EXTRA_PEER_CHECK_INTERVAL = 45;
	/**
	* Minimum time an outbound-peer-eviction candidate must be connected for, in
	* order to evict, in seconds.
	*/
	static constexpr int64_t MINIMUM_CONNECT_TIME = 30;
	/** SHA256("main address relay")[0:8] */
	static constexpr uint64_t RANDOMIZER_ID_ADDRESS_RELAY = 0x3cac0035b5866b90ULL;
	/// Age after which a stale block will no longer be served if requested as
	/// protection against fingerprinting. Set to one month, denominated in seconds.
	static constexpr int STALE_RELAY_AGE_LIMIT = 30 * 24 * 60 * 60;
	/// Age after which a block is considered historical for purposes of rate
	/// limiting block relay. Set to one week, denominated in seconds.
	static constexpr int HISTORICAL_BLOCK_AGE = 7 * 24 * 60 * 60;
	/**
	* Time between pings automatically sent out for latency probing and keepalive.
	*/
	static constexpr std::chrono::minutes PING_INTERVAL{2};
	/** The maximum number of entries in a locator */
	static const unsigned int MAX_LOCATOR_SZ = 101;
	/** The maximum number of entries in an 'inv' protocol message */
	static const unsigned int MAX_INV_SZ = 50000;
	static_assert(MAX_PROTOCOL_MESSAGE_LENGTH > MAX_INV_SZ * sizeof(CInv),
	"Max protocol message length must be greater than largest "
	"possible INV message");

	struct DataRequestParameters {
	/**
	* Maximum number of in-flight data requests from a peer. It is not a hard
	* limit, but the threshold at which point the overloaded_peer_delay kicks
	* in.
	*/
	const size_t max_peer_request_in_flight;

	/**
	* Maximum number of inventories to consider for requesting, per peer. It
	* provides a reasonable DoS limit to per-peer memory usage spent on
	* announcements, while covering peers continuously sending INVs at the
	* maximum rate (by our own policy, see INVENTORY_BROADCAST_PER_SECOND) for
	* several minutes, while not receiving the actual data (from any peer) in
	* response to requests for them.
	*/
	const size_t max_peer_announcements;

	/** How long to delay requesting data from non-preferred peers */
	const std::chrono::seconds nonpref_peer_delay;

	/**
	* How long to delay requesting data from overloaded peers (see
	* max_peer_request_in_flight).
	*/
	const std::chrono::seconds overloaded_peer_delay;

	/**
	* How long to wait (in microseconds) before a data request from an
	* additional peer.
	*/
	const std::chrono::microseconds getdata_interval;

	/**
	* Permission flags a peer requires to bypass the request limits tracking
	* limits and delay penalty.
	*/
	const NetPermissionFlags bypass_request_limits_permissions;
	};

	static constexpr DataRequestParameters TX_REQUEST_PARAMS{
	100, // max_peer_request_in_flight
	5000, // max_peer_announcements
	std::chrono::seconds(2), // nonpref_peer_delay
	std::chrono::seconds(2), // overloaded_peer_delay
	std::chrono::seconds(60), // getdata_interval
	PF_RELAY, // bypass_request_limits_permissions
	};

	static constexpr DataRequestParameters PROOF_REQUEST_PARAMS{
	100, // max_peer_request_in_flight
	5000, // max_peer_announcements
	std::chrono::seconds(2), // nonpref_peer_delay
	std::chrono::seconds(2), // overloaded_peer_delay
	std::chrono::seconds(60), // getdata_interval
	PF_BYPASS_PROOF_REQUEST_LIMITS, // bypass_request_limits_permissions
	};

	/**
	* Limit to avoid sending big packets. Not used in processing incoming GETDATA
	* for compatibility.
	*/
	static const unsigned int MAX_GETDATA_SZ = 1000;
	/**
	* Number of blocks that can be requested at any given time from a single peer.
	*/
	static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
	/**
	* Timeout in seconds during which a peer must stall block download progress
	* before being disconnected.
	*/
	static const unsigned int BLOCK_STALLING_TIMEOUT = 2;
	/**
	* Number of headers sent in one getheaders result. We rely on the assumption
	* that if a peer sends
	* less than this number, we reached its tip. Changing this value is a protocol
	* upgrade.
	*/
	static const unsigned int MAX_HEADERS_RESULTS = 2000;
	/**
	* Maximum depth of blocks we're willing to serve as compact blocks to peers
	* when requested. For older blocks, a regular BLOCK response will be sent.
	*/
	static const int MAX_CMPCTBLOCK_DEPTH = 5;
	/**
	* Maximum depth of blocks we're willing to respond to GETBLOCKTXN requests
	* for.
	*/
	static const int MAX_BLOCKTXN_DEPTH = 10;
	/**
	* Size of the "block download window": how far ahead of our current height do
	* we fetch? Larger windows tolerate larger download speed differences between
	* peer, but increase the potential degree of disordering of blocks on disk
	* (which make reindexing and pruning harder). We'll probably
	* want to make this a per-peer adaptive value at some point.
	*/
	static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;
	/**
	* Block download timeout base, expressed in millionths of the block interval
	* (i.e. 10 min)
	*/
	static const int64_t BLOCK_DOWNLOAD_TIMEOUT_BASE = 1000000;
	/**
	* Additional block download timeout per parallel downloading peer (i.e. 5 min)
	*/
	static const int64_t BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 500000;
	/**
	* Maximum number of headers to announce when relaying blocks with headers
	* message.
	*/
	static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;
	/** Maximum number of unconnecting headers announcements before DoS score */
	static const int MAX_UNCONNECTING_HEADERS = 10;
	/** Minimum blocks required to signal NODE_NETWORK_LIMITED */
	static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288;
	/**
	* Average delay between local address broadcasts.
	*/
	static constexpr std::chrono::hours AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL{24};
	/**
	* Average delay between peer address broadcasts.
	*/
	static const std::chrono::seconds AVG_ADDRESS_BROADCAST_INTERVAL{30};
	/**
	* Average delay between trickled inventory transmissions in seconds.
	* Blocks and whitelisted receivers bypass this, outbound peers get half this
	* delay.
	*/
	static const unsigned int INVENTORY_BROADCAST_INTERVAL = 5;
	/**
	* Maximum rate of inventory items to send per second.
	* Limits the impact of low-fee transaction floods.
	*/
	static constexpr unsigned int INVENTORY_BROADCAST_PER_SECOND = 7;
	/** Maximum number of inventory items to send per transmission. */
	static constexpr unsigned int INVENTORY_BROADCAST_MAX_PER_MB =
	INVENTORY_BROADCAST_PER_SECOND * INVENTORY_BROADCAST_INTERVAL;
	/** The number of most recently announced transactions a peer can request. */
	static constexpr unsigned int INVENTORY_MAX_RECENT_RELAY = 3500;
	/**
	* Verify that INVENTORY_MAX_RECENT_RELAY is enough to cache everything
	* typically relayed before unconditional relay from the mempool kicks in. This
	* is only a lower bound, and it should be larger to account for higher inv rate
	* to outbound peers, and random variations in the broadcast mechanism.
	*/
	static_assert(INVENTORY_MAX_RECENT_RELAY >= INVENTORY_BROADCAST_PER_SECOND *
	UNCONDITIONAL_RELAY_DELAY /
	std::chrono::seconds{1},
	"INVENTORY_RELAY_MAX too low");

	/**
	* Average delay between feefilter broadcasts in seconds.
	*/
	static constexpr unsigned int AVG_FEEFILTER_BROADCAST_INTERVAL = 10 * 60;
	/**
	* Maximum feefilter broadcast delay after significant change.
	*/
	static constexpr unsigned int MAX_FEEFILTER_CHANGE_DELAY = 5 * 60;
	/**
	* Maximum number of compact filters that may be requested with one
	* getcfilters. See BIP 157.
	*/
	static constexpr uint32_t MAX_GETCFILTERS_SIZE = 1000;
	/**
	* Maximum number of cf hashes that may be requested with one getcfheaders. See
	* BIP 157.
	*/
	static constexpr uint32_t MAX_GETCFHEADERS_SIZE = 2000;

	/// How many non standard orphan do we consider from a node before ignoring it.
	static constexpr uint32_t MAX_NON_STANDARD_ORPHAN_PER_NODE = 5;

	struct COrphanTx {
	// When modifying, adapt the copy of this definition in tests/DoS_tests.
	CTransactionRef tx;
	NodeId fromPeer;
	int64_t nTimeExpire;
	size_t list_pos;
	};

	RecursiveMutex g_cs_orphans;
	std::map<TxId, COrphanTx> mapOrphanTransactions GUARDED_BY(g_cs_orphans);

	void EraseOrphansFor(NodeId peer);

	// Internal stuff
	namespace {
	/** Number of nodes with fSyncStarted. */
	int nSyncStarted GUARDED_BY(cs_main) = 0;

	/**
	* Sources of received blocks, saved to be able to punish them when processing
	* happens afterwards.
	* Set mapBlockSource[hash].second to false if the node should not be punished
	* if the block is invalid.
	*/
	std::map<BlockHash, std::pair<NodeId, bool>> mapBlockSource GUARDED_BY(cs_main);

	/**
	* Filter for transactions that were recently rejected by AcceptToMemoryPool.
	* These are not rerequested until the chain tip changes, at which point the
	* entire filter is reset.
	*
	* Without this filter we'd be re-requesting txs from each of our peers,
	* increasing bandwidth consumption considerably. For instance, with 100 peers,
	* half of which relay a tx we don't accept, that might be a 50x bandwidth
	* increase. A flooding attacker attempting to roll-over the filter using
	* minimum-sized, 60byte, transactions might manage to send 1000/sec if we have
	* fast peers, so we pick 120,000 to give our peers a two minute window to send
	* invs to us.
	*
	* Decreasing the false positive rate is fairly cheap, so we pick one in a
	* million to make it highly unlikely for users to have issues with this filter.
	*
	* Memory used: 1.3 MB
	*/
	std::unique_ptr<CRollingBloomFilter> recentRejects GUARDED_BY(cs_main);
	uint256 hashRecentRejectsChainTip GUARDED_BY(cs_main);

	/**
	* Filter for proofs that were recently rejected but not orphaned.
	* These are not rerequested until they are rolled out of the filter.
	*
	* Without this filter we'd be re-requesting proofs from each of our peers,
	* increasing bandwidth consumption considerably.
	*
	* Decreasing the false positive rate is fairly cheap, so we pick one in a
	* million to make it highly unlikely for users to have issues with this filter.
	*/
	Mutex cs_rejectedProofs;
	std::unique_ptr<CRollingBloomFilter>
	rejectedProofs GUARDED_BY(cs_rejectedProofs);

	/**
	* Filter for transactions that have been recently confirmed.
	* We use this to avoid requesting transactions that have already been
	* confirmed.
	*/
	Mutex g_cs_recent_confirmed_transactions;
	std::unique_ptr<CRollingBloomFilter> g_recent_confirmed_transactions
	GUARDED_BY(g_cs_recent_confirmed_transactions);

	/**
	* Blocks that are in flight, and that are in the queue to be downloaded.
	*/
	struct QueuedBlock {
	BlockHash hash;
	//! Optional.
	const CBlockIndex *pindex;
	//! Whether this block has validated headers at the time of request.
	bool fValidatedHeaders;
	//! Optional, used for CMPCTBLOCK downloads
	std::unique_ptr<PartiallyDownloadedBlock> partialBlock;
	};
	std::map<BlockHash, std::pair<NodeId, std::list<QueuedBlock>::iterator>>
	mapBlocksInFlight GUARDED_BY(cs_main);

	/** Stack of nodes which we have set to announce using compact blocks */
	std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);

	/** Number of preferable block download peers. */
	int nPreferredDownload GUARDED_BY(cs_main) = 0;

	/** Number of peers from which we're downloading blocks. */
	int nPeersWithValidatedDownloads GUARDED_BY(cs_main) = 0;

	/** Number of outbound peers with m_chain_sync.m_protect. */
	int g_outbound_peers_with_protect_from_disconnect GUARDED_BY(cs_main) = 0;

	/** When our tip was last updated. */
	std::atomic<int64_t> g_last_tip_update(0);

	/** Relay map. */
	typedef std::map<uint256, CTransactionRef> MapRelay;
	MapRelay mapRelay GUARDED_BY(cs_main);
	/**
	* Expiration-time ordered list of (expire time, relay map entry) pairs,
	* protected by cs_main).
	*/
	std::deque<std::pair<int64_t, MapRelay::iterator>>
	vRelayExpiration GUARDED_BY(cs_main);

	struct IteratorComparator {
	template <typename I> bool operator()(const I &a, const I &b) const {
	return &(a) < &(b);
	}
	};
	std::map<COutPoint,
	std::set<std::map<TxId, COrphanTx>::iterator, IteratorComparator>>
	mapOrphanTransactionsByPrev GUARDED_BY(g_cs_orphans);

	//! For random eviction
	std::vector<std::map<TxId, COrphanTx>::iterator>
	g_orphan_list GUARDED_BY(g_cs_orphans);

	static size_t vExtraTxnForCompactIt GUARDED_BY(g_cs_orphans) = 0;
	static std::vector<std::pair<TxHash, CTransactionRef>>
	vExtraTxnForCompact GUARDED_BY(g_cs_orphans);
	} // namespace

	namespace {
	/**
	* Maintain validation-specific state about nodes, protected by cs_main, instead
	* by CNode's own locks. This simplifies asynchronous operation, where
	* processing of incoming data is done after the ProcessMessage call returns,
	* and we're no longer holding the node's locks.
	*/
	struct CNodeState {
	//! The peer's address
	const CService address;
	//! Whether we have a fully established connection.
	bool fCurrentlyConnected;
	//! The best known block we know this peer has announced.
	const CBlockIndex *pindexBestKnownBlock;
	//! The hash of the last unknown block this peer has announced.
	BlockHash hashLastUnknownBlock;
	//! The last full block we both have.
	const CBlockIndex *pindexLastCommonBlock;
	//! The best header we have sent our peer.
	const CBlockIndex *pindexBestHeaderSent;
	//! Length of current-streak of unconnecting headers announcements
	int nUnconnectingHeaders;
	//! Whether we've started headers synchronization with this peer.
	bool fSyncStarted;
	//! When to potentially disconnect peer for stalling headers download
	int64_t nHeadersSyncTimeout;
	//! Since when we're stalling block download progress (in microseconds), or
	//! 0.
	int64_t nStallingSince;
	std::list<QueuedBlock> vBlocksInFlight;
	//! When the first entry in vBlocksInFlight started downloading. Don't care
	//! when vBlocksInFlight is empty.
	int64_t nDownloadingSince;
	int nBlocksInFlight;
	int nBlocksInFlightValidHeaders;
	//! Whether we consider this a preferred download peer.
	bool fPreferredDownload;
	//! Whether this peer wants invs or headers (when possible) for block
	//! announcements.
	bool fPreferHeaders;
	//! Whether this peer wants invs or cmpctblocks (when possible) for block
	//! announcements.
	bool fPreferHeaderAndIDs;
	/**
	* Whether this peer will send us cmpctblocks if we request them.
	* This is not used to gate request logic, as we really only care about
	* fSupportsDesiredCmpctVersion, but is used as a flag to "lock in" the
	* version of compact blocks we send.
	*/
	bool fProvidesHeaderAndIDs;
	/**
	* If we've announced NODE_WITNESS to this peer: whether the peer sends
	* witnesses in cmpctblocks/blocktxns, otherwise: whether this peer sends
	* non-witnesses in cmpctblocks/blocktxns.
	*/
	bool fSupportsDesiredCmpctVersion;

	/**
	* State used to enforce CHAIN_SYNC_TIMEOUT
	* Only in effect for outbound, non-manual, full-relay connections, with
	* m_protect == false
	* Algorithm: if a peer's best known block has less work than our tip, set
	* a timeout CHAIN_SYNC_TIMEOUT seconds in the future:
	* - If at timeout their best known block now has more work than our tip
	* when the timeout was set, then either reset the timeout or clear it
	* (after comparing against our current tip's work)
	* - If at timeout their best known block still has less work than our tip
	* did when the timeout was set, then send a getheaders message, and set a
	* shorter timeout, HEADERS_RESPONSE_TIME seconds in future. If their best
	* known block is still behind when that new timeout is reached, disconnect.
	*/
	struct ChainSyncTimeoutState {
	//! A timeout used for checking whether our peer has sufficiently
	//! synced.
	int64_t m_timeout;
	//! A header with the work we require on our peer's chain.
	const CBlockIndex *m_work_header;
	//! After timeout is reached, set to true after sending getheaders.
	bool m_sent_getheaders;
	//! Whether this peer is protected from disconnection due to a bad/slow
	//! chain.
	bool m_protect;
	};

	ChainSyncTimeoutState m_chain_sync;

	//! Time of last new block announcement
	int64_t m_last_block_announcement;

	struct AvalancheState {
	std::chrono::time_point<std::chrono::steady_clock> last_poll;
	};

	AvalancheState m_avalanche_state;

	//! Whether this peer is an inbound connection
	bool m_is_inbound;

	//! Whether this peer is a manual connection
	bool m_is_manual_connection;

	//! A rolling bloom filter of all announced tx CInvs to this peer.
	CRollingBloomFilter m_recently_announced_invs =
	CRollingBloomFilter{INVENTORY_MAX_RECENT_RELAY, 0.000001};

	//! A rolling bloom filter of all announced Proofs CInvs to this peer.
	CRollingBloomFilter m_recently_announced_proofs =
	CRollingBloomFilter{INVENTORY_MAX_RECENT_RELAY, 0.000001};

	CNodeState(CAddress addrIn, bool is_inbound, bool is_manual)
	: address(addrIn), m_is_inbound(is_inbound),
	m_is_manual_connection(is_manual) {
	fCurrentlyConnected = false;
	pindexBestKnownBlock = nullptr;
	hashLastUnknownBlock = BlockHash();
	pindexLastCommonBlock = nullptr;
	pindexBestHeaderSent = nullptr;
	nUnconnectingHeaders = 0;
	fSyncStarted = false;
	nHeadersSyncTimeout = 0;
	nStallingSince = 0;
	nDownloadingSince = 0;
	nBlocksInFlight = 0;
	nBlocksInFlightValidHeaders = 0;
	fPreferredDownload = false;
	fPreferHeaders = false;
	fPreferHeaderAndIDs = false;
	fProvidesHeaderAndIDs = false;
	fSupportsDesiredCmpctVersion = false;
	m_chain_sync = {0, nullptr, false, false};
	m_last_block_announcement = 0;
	m_recently_announced_invs.reset();
	m_recently_announced_proofs.reset();
	}
	};

	/** Map maintaining per-node state. */
	static std::map<NodeId, CNodeState> mapNodeState GUARDED_BY(cs_main);

	static CNodeState *State(NodeId pnode) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	std::map<NodeId, CNodeState>::iterator it = mapNodeState.find(pnode);
	if (it == mapNodeState.end()) {
	return nullptr;
	}

	return &it->second;
	}

	/**
	* Data structure for an individual peer. This struct is not protected by
	* cs_main since it does not contain validation-critical data.
	*
	* Memory is owned by shared pointers and this object is destructed when
	* the refcount drops to zero.
	*
	* TODO: move most members from CNodeState to this structure.
	* TODO: move remaining application-layer data members from CNode to this
	* structure.
	*/
	struct Peer {
	/** Same id as the CNode object for this peer */
	const NodeId m_id{0};

	/** Protects misbehavior data members */
	Mutex m_misbehavior_mutex;
	/** Accumulated misbehavior score for this peer */
	int m_misbehavior_score GUARDED_BY(m_misbehavior_mutex){0};
	/** Whether this peer should be disconnected and marked as discouraged
	* (unless it has the noban permission). */
	bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};

	Peer(NodeId id) : m_id(id) {}
	};

	using PeerRef = std::shared_ptr<Peer>;

	/**
	* Map of all Peer objects, keyed by peer id. This map is protected
	* by the global g_peer_mutex. Once a shared pointer reference is
	* taken, the lock may be released. Individual fields are protected by
	* their own locks.
	*/
	Mutex g_peer_mutex;
	static std::map<NodeId, PeerRef> g_peer_map GUARDED_BY(g_peer_mutex);

	/**
	* Get a shared pointer to the Peer object.
	* May return nullptr if the Peer object can't be found.
	*/
	static PeerRef GetPeerRef(NodeId id) {
	LOCK(g_peer_mutex);
	auto it = g_peer_map.find(id);
	return it != g_peer_map.end() ? it->second : nullptr;
	}

	static bool isPreferredDownloadPeer(const CNode &pfrom) {
	LOCK(cs_main);
	const CNodeState *state = State(pfrom.GetId());
	return state && state->fPreferredDownload;
	}

	static void UpdatePreferredDownload(const CNode &node, CNodeState *state)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	nPreferredDownload -= state->fPreferredDownload;

	// Whether this node should be marked as a preferred download node.
	state->fPreferredDownload =
	(!node.IsInboundConn() \|\| node.HasPermission(PF_NOBAN)) &&
	!node.IsAddrFetchConn() && !node.fClient;

	nPreferredDownload += state->fPreferredDownload;
	}

	static void PushNodeVersion(const Config &config, CNode &pnode,
	CConnman &connman, int64_t nTime) {
	// Note that pnode.GetLocalServices() is a reflection of the local
	// services we were offering when the CNode object was created for this
	// peer.
	ServiceFlags nLocalNodeServices = pnode.GetLocalServices();
	uint64_t nonce = pnode.GetLocalNonce();
	int nNodeStartingHeight = pnode.GetMyStartingHeight();
	NodeId nodeid = pnode.GetId();
	CAddress addr = pnode.addr;
	uint64_t extraEntropy = pnode.GetLocalExtraEntropy();

	CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr)
	? addr
	: CAddress(CService(), addr.nServices));
	CAddress addrMe = CAddress(CService(), nLocalNodeServices);

	connman.PushMessage(
	&pnode,
	CNetMsgMaker(INIT_PROTO_VERSION)
	.Make(NetMsgType::VERSION, PROTOCOL_VERSION,
	uint64_t(nLocalNodeServices), nTime, addrYou, addrMe, nonce,
	userAgent(config), nNodeStartingHeight,
	::g_relay_txes && pnode.m_tx_relay != nullptr, extraEntropy));

	if (fLogIPs) {
	LogPrint(BCLog::NET,
	"send version message: version %d, blocks=%d, us=%s, them=%s, "
	"peer=%d\n",
	PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(),
	addrYou.ToString(), nodeid);
	} else {
	LogPrint(
	BCLog::NET,
	"send version message: version %d, blocks=%d, us=%s, peer=%d\n",
	PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), nodeid);
	}
	LogPrint(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);
	}

	// Returns a bool indicating whether we requested this block.
	// Also used if a block was /not/ received and timed out or started with another
	// peer.
	static bool MarkBlockAsReceived(const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	std::map<BlockHash,
	std::pair<NodeId, std::list<QueuedBlock>::iterator>>::iterator
	itInFlight = mapBlocksInFlight.find(hash);
	if (itInFlight != mapBlocksInFlight.end()) {
	CNodeState *state = State(itInFlight->second.first);
	assert(state != nullptr);
	state->nBlocksInFlightValidHeaders -=
	itInFlight->second.second->fValidatedHeaders;
	if (state->nBlocksInFlightValidHeaders == 0 &&
	itInFlight->second.second->fValidatedHeaders) {
	// Last validated block on the queue was received.
	nPeersWithValidatedDownloads--;
	}
	if (state->vBlocksInFlight.begin() == itInFlight->second.second) {
	// First block on the queue was received, update the start download
	// time for the next one
	state->nDownloadingSince = std::max(
	state->nDownloadingSince,
	count_microseconds(GetTime<std::chrono::microseconds>()));
	}
	state->vBlocksInFlight.erase(itInFlight->second.second);
	state->nBlocksInFlight--;
	state->nStallingSince = 0;
	mapBlocksInFlight.erase(itInFlight);
	return true;
	}

	return false;
	}

	// returns false, still setting pit, if the block was already in flight from the
	// same peer
	// pit will only be valid as long as the same cs_main lock is being held.
	static bool
	MarkBlockAsInFlight(const Config &config, CTxMemPool &mempool, NodeId nodeid,
	const BlockHash &hash,
	const Consensus::Params &consensusParams,
	const CBlockIndex *pindex = nullptr,
	std::list<QueuedBlock>::iterator **pit = nullptr)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

	// Short-circuit most stuff in case it is from the same node.
	std::map<BlockHash,
	std::pair<NodeId, std::list<QueuedBlock>::iterator>>::iterator
	itInFlight = mapBlocksInFlight.find(hash);
	if (itInFlight != mapBlocksInFlight.end() &&
	itInFlight->second.first == nodeid) {
	if (pit) {
	*pit = &itInFlight->second.second;
	}
	return false;
	}

	// Make sure it's not listed somewhere already.
	MarkBlockAsReceived(hash);

	std::list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(
	state->vBlocksInFlight.end(),
	{hash, pindex, pindex != nullptr,
	std::unique_ptr<PartiallyDownloadedBlock>(
	pit ? new PartiallyDownloadedBlock(config, &mempool) : nullptr)});
	state->nBlocksInFlight++;
	state->nBlocksInFlightValidHeaders += it->fValidatedHeaders;
	if (state->nBlocksInFlight == 1) {
	// We're starting a block download (batch) from this peer.
	state->nDownloadingSince = GetTime<std::chrono::microseconds>().count();
	}

	if (state->nBlocksInFlightValidHeaders == 1 && pindex != nullptr) {
	nPeersWithValidatedDownloads++;
	}

	itInFlight = mapBlocksInFlight
	.insert(std::make_pair(hash, std::make_pair(nodeid, it)))
	.first;

	if (pit) {
	*pit = &itInFlight->second.second;
	}

	return true;
	}

	/** Check whether the last unknown block a peer advertised is not yet known. */
	static void ProcessBlockAvailability(NodeId nodeid)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

	if (!state->hashLastUnknownBlock.IsNull()) {
	const CBlockIndex *pindex =
	LookupBlockIndex(state->hashLastUnknownBlock);
	if (pindex && pindex->nChainWork > 0) {
	if (state->pindexBestKnownBlock == nullptr \|\|
	pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) {
	state->pindexBestKnownBlock = pindex;
	}
	state->hashLastUnknownBlock.SetNull();
	}
	}
	}

	/** Update tracking information about which blocks a peer is assumed to have. */
	static void UpdateBlockAvailability(NodeId nodeid, const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

	ProcessBlockAvailability(nodeid);

	const CBlockIndex *pindex = LookupBlockIndex(hash);
	if (pindex && pindex->nChainWork > 0) {
	// An actually better block was announced.
	if (state->pindexBestKnownBlock == nullptr \|\|
	pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) {
	state->pindexBestKnownBlock = pindex;
	}
	} else {
	// An unknown block was announced; just assume that the latest one is
	// the best one.
	state->hashLastUnknownBlock = hash;
	}
	}

	/**
	* When a peer sends us a valid block, instruct it to announce blocks to us
	* using CMPCTBLOCK if possible by adding its nodeid to the end of
	* lNodesAnnouncingHeaderAndIDs, and keeping that list under a certain size by
	* removing the first element if necessary.
	*/
	static void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid,
	CConnman &connman)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	AssertLockHeld(cs_main);
	CNodeState *nodestate = State(nodeid);
	if (!nodestate) {
	LogPrint(BCLog::NET, "node state unavailable: peer=%d\n", nodeid);
	return;
	}
	if (!nodestate->fProvidesHeaderAndIDs) {
	return;
	}
	for (std::list<NodeId>::iterator it = lNodesAnnouncingHeaderAndIDs.begin();
	it != lNodesAnnouncingHeaderAndIDs.end(); it++) {
	if (*it == nodeid) {
	lNodesAnnouncingHeaderAndIDs.erase(it);
	lNodesAnnouncingHeaderAndIDs.push_back(nodeid);
	return;
	}
	}
	connman.ForNode(nodeid, [&connman](CNode *pfrom) {
	AssertLockHeld(cs_main);
	uint64_t nCMPCTBLOCKVersion = 1;
	if (lNodesAnnouncingHeaderAndIDs.size() >= 3) {
	// As per BIP152, we only get 3 of our peers to announce
	// blocks using compact encodings.
	connman.ForNode(
	lNodesAnnouncingHeaderAndIDs.front(),
	[&connman, nCMPCTBLOCKVersion](CNode *pnodeStop) {
	AssertLockHeld(cs_main);
	connman.PushMessage(
	pnodeStop, CNetMsgMaker(pnodeStop->GetCommonVersion())
	.Make(NetMsgType::SENDCMPCT,
	/fAnnounceUsingCMPCTBLOCK=/false,
	nCMPCTBLOCKVersion));
	return true;
	});
	lNodesAnnouncingHeaderAndIDs.pop_front();
	}
	connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetCommonVersion())
	.Make(NetMsgType::SENDCMPCT,
	/fAnnounceUsingCMPCTBLOCK=/true,
	nCMPCTBLOCKVersion));
	lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());
	return true;
	});
	}

	static bool TipMayBeStale(const Consensus::Params &consensusParams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	AssertLockHeld(cs_main);
	if (g_last_tip_update == 0) {
	g_last_tip_update = GetTime();
	}
	return g_last_tip_update <
	GetTime() - consensusParams.nPowTargetSpacing * 3 &&
	mapBlocksInFlight.empty();
	}

	static bool CanDirectFetch(const Consensus::Params &consensusParams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	return ::ChainActive().Tip()->GetBlockTime() >
	GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20;
	}

	static bool PeerHasHeader(CNodeState state, const CBlockIndex pindex)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	if (state->pindexBestKnownBlock &&
	pindex == state->pindexBestKnownBlock->GetAncestor(pindex->nHeight)) {
	return true;
	}
	if (state->pindexBestHeaderSent &&
	pindex == state->pindexBestHeaderSent->GetAncestor(pindex->nHeight)) {
	return true;
	}
	return false;
	}

	/**
	* Update pindexLastCommonBlock and add not-in-flight missing successors to
	* vBlocks, until it has at most count entries.
	*/
	static void FindNextBlocksToDownload(NodeId nodeid, unsigned int count,
	std::vector<const CBlockIndex *> &vBlocks,
	NodeId &nodeStaller,
	const Consensus::Params &consensusParams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	if (count == 0) {
	return;
	}

	vBlocks.reserve(vBlocks.size() + count);
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

	// Make sure pindexBestKnownBlock is up to date, we'll need it.
	ProcessBlockAvailability(nodeid);

	if (state->pindexBestKnownBlock == nullptr \|\|
	state->pindexBestKnownBlock->nChainWork <
	::ChainActive().Tip()->nChainWork \|\|
	state->pindexBestKnownBlock->nChainWork < nMinimumChainWork) {
	// This peer has nothing interesting.
	return;
	}

	if (state->pindexLastCommonBlock == nullptr) {
	// Bootstrap quickly by guessing a parent of our best tip is the forking
	// point. Guessing wrong in either direction is not a problem.
	state->pindexLastCommonBlock = ::ChainActive()[std::min(
	state->pindexBestKnownBlock->nHeight, ::ChainActive().Height())];
	}

	// If the peer reorganized, our previous pindexLastCommonBlock may not be an
	// ancestor of its current tip anymore. Go back enough to fix that.
	state->pindexLastCommonBlock = LastCommonAncestor(
	state->pindexLastCommonBlock, state->pindexBestKnownBlock);
	if (state->pindexLastCommonBlock == state->pindexBestKnownBlock) {
	return;
	}

	std::vector<const CBlockIndex *> vToFetch;
	const CBlockIndex *pindexWalk = state->pindexLastCommonBlock;
	// Never fetch further than the best block we know the peer has, or more
	// than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last linked block we have in
	// common with this peer. The +1 is so we can detect stalling, namely if we
	// would be able to download that next block if the window were 1 larger.
	int nWindowEnd =
	state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW;
	int nMaxHeight =
	std::min<int>(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1);
	NodeId waitingfor = -1;
	while (pindexWalk->nHeight < nMaxHeight) {
	// Read up to 128 (or more, if more blocks than that are needed)
	// successors of pindexWalk (towards pindexBestKnownBlock) into
	// vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as
	// expensive as iterating over ~100 CBlockIndex* entries anyway.
	int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight,
	std::max<int>(count - vBlocks.size(), 128));
	vToFetch.resize(nToFetch);
	pindexWalk = state->pindexBestKnownBlock->GetAncestor(
	pindexWalk->nHeight + nToFetch);
	vToFetch[nToFetch - 1] = pindexWalk;
	for (unsigned int i = nToFetch - 1; i > 0; i--) {
	vToFetch[i - 1] = vToFetch[i]->pprev;
	}

	// Iterate over those blocks in vToFetch (in forward direction), adding
	// the ones that are not yet downloaded and not in flight to vBlocks. In
	// the meantime, update pindexLastCommonBlock as long as all ancestors
	// are already downloaded, or if it's already part of our chain (and
	// therefore don't need it even if pruned).
	for (const CBlockIndex *pindex : vToFetch) {
	if (!pindex->IsValid(BlockValidity::TREE)) {
	// We consider the chain that this peer is on invalid.
	return;
	}
	if (pindex->nStatus.hasData() \|\| ::ChainActive().Contains(pindex)) {
	if (pindex->HaveTxsDownloaded()) {
	state->pindexLastCommonBlock = pindex;
	}
	} else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) {
	// The block is not already downloaded, and not yet in flight.
	if (pindex->nHeight > nWindowEnd) {
	// We reached the end of the window.
	if (vBlocks.size() == 0 && waitingfor != nodeid) {
	// We aren't able to fetch anything, but we would be if
	// the download window was one larger.
	nodeStaller = waitingfor;
	}
	return;
	}
	vBlocks.push_back(pindex);
	if (vBlocks.size() == count) {
	return;
	}
	} else if (waitingfor == -1) {
	// This is the first already-in-flight block.
	waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;
	}
	}
	}
	}

	} // namespace

	template <class InvId>
	static bool TooManyAnnouncements(const CNode &node,
	const InvRequestTracker<InvId> &requestTracker,
	const DataRequestParameters &requestParams) {
	return !node.HasPermission(
	requestParams.bypass_request_limits_permissions) &&
	requestTracker.Count(node.GetId()) >=
	requestParams.max_peer_announcements;
	}

	/**
	* Compute the request time for this announcement, current time plus delays for:
	* - nonpref_peer_delay for announcements from non-preferred connections
	* - overloaded_peer_delay for announcements from peers which have at least
	* max_peer_request_in_flight requests in flight (and don't have PF_RELAY).
	*/
	template <class InvId>
	static std::chrono::microseconds
	ComputeRequestTime(const CNode &node,
	const InvRequestTracker<InvId> &requestTracker,
	const DataRequestParameters &requestParams,
	std::chrono::microseconds current_time, bool preferred) {
	auto delay = std::chrono::microseconds{0};

	if (!preferred) {
	delay += requestParams.nonpref_peer_delay;
	}

	if (!node.HasPermission(requestParams.bypass_request_limits_permissions) &&
	requestTracker.CountInFlight(node.GetId()) >=
	requestParams.max_peer_request_in_flight) {
	delay += requestParams.overloaded_peer_delay;
	}

	return current_time + delay;
	}

	void PeerManager::AddTxAnnouncement(const CNode &node, const TxId &txid,
	std::chrono::microseconds current_time) {
	// For m_txrequest and state
	AssertLockHeld(::cs_main);

	if (TooManyAnnouncements(node, m_txrequest, TX_REQUEST_PARAMS)) {
	return;
	}

	const bool preferred = isPreferredDownloadPeer(node);
	auto reqtime = ComputeRequestTime(node, m_txrequest, TX_REQUEST_PARAMS,
	current_time, preferred);

	m_txrequest.ReceivedInv(node.GetId(), txid, preferred, reqtime);
	}

	void PeerManager::AddProofAnnouncement(const CNode &node,
	const avalanche::ProofId &proofid,
	std::chrono::microseconds current_time,
	bool preferred) {
	// For m_proofrequest
	AssertLockHeld(cs_proofrequest);

	if (TooManyAnnouncements(node, m_proofrequest, PROOF_REQUEST_PARAMS)) {
	return;
	}

	auto reqtime = ComputeRequestTime(
	node, m_proofrequest, PROOF_REQUEST_PARAMS, current_time, preferred);

	m_proofrequest.ReceivedInv(node.GetId(), proofid, preferred, reqtime);
	}

	// This function is used for testing the stale tip eviction logic, see
	// denialofservice_tests.cpp
	void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds) {
	LOCK(cs_main);
	CNodeState *state = State(node);
	if (state) {
	state->m_last_block_announcement = time_in_seconds;
	}
	}

	void PeerManager::InitializeNode(const Config &config, CNode *pnode) {
	CAddress addr = pnode->addr;
	std::string addrName = pnode->GetAddrName();
	NodeId nodeid = pnode->GetId();
	{
	LOCK(cs_main);
	mapNodeState.emplace_hint(mapNodeState.end(), std::piecewise_construct,
	std::forward_as_tuple(nodeid),
	std::forward_as_tuple(addr,
	pnode->IsInboundConn(),
	pnode->IsManualConn()));
	assert(m_txrequest.Count(nodeid) == 0);
	}
	{
	PeerRef peer = std::make_shared<Peer>(nodeid);
	LOCK(g_peer_mutex);
	g_peer_map.emplace_hint(g_peer_map.end(), nodeid, std::move(peer));
	}
	if (!pnode->IsInboundConn()) {
	PushNodeVersion(config, *pnode, m_connman, GetTime());
	}
	}

	void PeerManager::ReattemptInitialBroadcast(CScheduler &scheduler) const {
	std::set<TxId> unbroadcast_txids = m_mempool.GetUnbroadcastTxs();

	for (const TxId &txid : unbroadcast_txids) {
	// Sanity check: all unbroadcast txns should exist in the mempool
	if (m_mempool.exists(txid)) {
	RelayTransaction(txid, m_connman);
	} else {
	m_mempool.RemoveUnbroadcastTx(txid, true);
	}
	}

	if (g_avalanche && isAvalancheEnabled(gArgs)) {
	g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
	auto unbroadcasted_proofids = pm.getUnbroadcastProofs();

	for (const auto &proofid : unbroadcasted_proofids) {
	// Sanity check: all unbroadcast proofs should exist in the
	// peermanager
	if (pm.exists(proofid)) {
	RelayProof(proofid, m_connman);
	} else {
	pm.removeUnbroadcastProof(proofid);
	}
	}
	});
	}

	// Schedule next run for 10-15 minutes in the future.
	// We add randomness on every cycle to avoid the possibility of P2P
	// fingerprinting.
	const std::chrono::milliseconds delta =
	std::chrono::minutes{10} + GetRandMillis(std::chrono::minutes{5});
	scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); },
	delta);
	}

	void PeerManager::FinalizeNode(const Config &config, NodeId nodeid,
	bool &fUpdateConnectionTime) {
	fUpdateConnectionTime = false;
	{
	LOCK(cs_main);
	int misbehavior{0};
	{
	PeerRef peer = GetPeerRef(nodeid);
	assert(peer != nullptr);
	misbehavior = WITH_LOCK(peer->m_misbehavior_mutex,
	return peer->m_misbehavior_score);
	LOCK(g_peer_mutex);
	g_peer_map.erase(nodeid);
	}
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

	if (state->fSyncStarted) {
	nSyncStarted--;
	}

	if (misbehavior == 0 && state->fCurrentlyConnected) {
	fUpdateConnectionTime = true;
	}

	for (const QueuedBlock &entry : state->vBlocksInFlight) {
	mapBlocksInFlight.erase(entry.hash);
	}
	EraseOrphansFor(nodeid);
	m_txrequest.DisconnectedPeer(nodeid);
	nPreferredDownload -= state->fPreferredDownload;
	nPeersWithValidatedDownloads -=
	(state->nBlocksInFlightValidHeaders != 0);
	assert(nPeersWithValidatedDownloads >= 0);
	g_outbound_peers_with_protect_from_disconnect -=
	state->m_chain_sync.m_protect;
	assert(g_outbound_peers_with_protect_from_disconnect >= 0);

	mapNodeState.erase(nodeid);

	if (mapNodeState.empty()) {
	// Do a consistency check after the last peer is removed.
	assert(mapBlocksInFlight.empty());
	assert(nPreferredDownload == 0);
	assert(nPeersWithValidatedDownloads == 0);
	assert(g_outbound_peers_with_protect_from_disconnect == 0);
	assert(m_txrequest.Size() == 0);
	}
	}

	WITH_LOCK(cs_proofrequest, m_proofrequest.DisconnectedPeer(nodeid));

	LogPrint(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);
	}

	bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {
	{
	LOCK(cs_main);
	CNodeState *state = State(nodeid);
	if (state == nullptr) {
	return false;
	}
	stats.nSyncHeight = state->pindexBestKnownBlock
	? state->pindexBestKnownBlock->nHeight
	: -1;
	stats.nCommonHeight = state->pindexLastCommonBlock
	? state->pindexLastCommonBlock->nHeight
	: -1;
	for (const QueuedBlock &queue : state->vBlocksInFlight) {
	if (queue.pindex) {
	stats.vHeightInFlight.push_back(queue.pindex->nHeight);
	}
	}
	}

	PeerRef peer = GetPeerRef(nodeid);
	if (peer == nullptr) {
	return false;
	}
	stats.m_misbehavior_score =
	WITH_LOCK(peer->m_misbehavior_mutex, return peer->m_misbehavior_score);

	return true;
	}

	//////////////////////////////////////////////////////////////////////////////
	//
	// mapOrphanTransactions
	//

	static void AddToCompactExtraTransactions(const CTransactionRef &tx)
	EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans) {
	size_t max_extra_txn = gArgs.GetArg("-blockreconstructionextratxn",
	DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN);
	if (max_extra_txn <= 0) {
	return;
	}

	if (!vExtraTxnForCompact.size()) {
	vExtraTxnForCompact.resize(max_extra_txn);
	}

	vExtraTxnForCompact[vExtraTxnForCompactIt] =
	std::make_pair(tx->GetHash(), tx);
	vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % max_extra_txn;
	}

	bool AddOrphanTx(const CTransactionRef &tx, NodeId peer)
	EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans) {
	const TxId &txid = tx->GetId();
	if (mapOrphanTransactions.count(txid)) {
	return false;
	}

	// Ignore big transactions, to avoid a send-big-orphans memory exhaustion
	// attack. If a peer has a legitimate large transaction with a missing
	// parent then we assume it will rebroadcast it later, after the parent
	// transaction(s) have been mined or received.
	// 100 orphans, each of which is at most 100,000 bytes big is at most 10
	// megabytes of orphans and somewhat more byprev index (in the worst case):
	unsigned int sz = tx->GetTotalSize();
	if (sz > MAX_STANDARD_TX_SIZE) {
	LogPrint(BCLog::MEMPOOL,
	"ignoring large orphan tx (size: %u, hash: %s)\n", sz,
	txid.ToString());
	return false;
	}

	auto ret = mapOrphanTransactions.emplace(
	txid, COrphanTx{tx, peer, GetTime() + ORPHAN_TX_EXPIRE_TIME,
	g_orphan_list.size()});
	assert(ret.second);
	g_orphan_list.push_back(ret.first);
	for (const CTxIn &txin : tx->vin) {
	mapOrphanTransactionsByPrev[txin.prevout].insert(ret.first);
	}

	AddToCompactExtraTransactions(tx);

	LogPrint(BCLog::MEMPOOL, "stored orphan tx %s (mapsz %u outsz %u)\n",
	txid.ToString(), mapOrphanTransactions.size(),
	mapOrphanTransactionsByPrev.size());
	return true;
	}

	static int EraseOrphanTx(const TxId id) EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans) {
	const auto it = mapOrphanTransactions.find(id);
	if (it == mapOrphanTransactions.end()) {
	return 0;
	}
	for (const CTxIn &txin : it->second.tx->vin) {
	const auto itPrev = mapOrphanTransactionsByPrev.find(txin.prevout);
	if (itPrev == mapOrphanTransactionsByPrev.end()) {
	continue;
	}
	itPrev->second.erase(it);
	if (itPrev->second.empty()) {
	mapOrphanTransactionsByPrev.erase(itPrev);
	}
	}

	size_t old_pos = it->second.list_pos;
	assert(g_orphan_list[old_pos] == it);
	if (old_pos + 1 != g_orphan_list.size()) {
	// Unless we're deleting the last entry in g_orphan_list, move the last
	// entry to the position we're deleting.
	auto it_last = g_orphan_list.back();
	g_orphan_list[old_pos] = it_last;
	it_last->second.list_pos = old_pos;
	}
	g_orphan_list.pop_back();

	mapOrphanTransactions.erase(it);
	return 1;
	}

	void EraseOrphansFor(NodeId peer) {
	LOCK(g_cs_orphans);
	int nErased = 0;
	auto iter = mapOrphanTransactions.begin();
	while (iter != mapOrphanTransactions.end()) {
	// Increment to avoid iterator becoming invalid.
	const auto maybeErase = iter++;
	if (maybeErase->second.fromPeer == peer) {
	nErased += EraseOrphanTx(maybeErase->second.tx->GetId());
	}
	}
	if (nErased > 0) {
	LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx from peer=%d\n", nErased,
	peer);
	}
	}

	unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans) {
	LOCK(g_cs_orphans);

	unsigned int nEvicted = 0;
	static int64_t nNextSweep;
	int64_t nNow = GetTime();
	if (nNextSweep <= nNow) {
	// Sweep out expired orphan pool entries:
	int nErased = 0;
	int64_t nMinExpTime =
	nNow + ORPHAN_TX_EXPIRE_TIME - ORPHAN_TX_EXPIRE_INTERVAL;
	auto iter = mapOrphanTransactions.begin();
	while (iter != mapOrphanTransactions.end()) {
	const auto maybeErase = iter++;
	if (maybeErase->second.nTimeExpire <= nNow) {
	nErased += EraseOrphanTx(maybeErase->second.tx->GetId());
	} else {
	nMinExpTime =
	std::min(maybeErase->second.nTimeExpire, nMinExpTime);
	}
	}
	// Sweep again 5 minutes after the next entry that expires in order to
	// batch the linear scan.
	nNextSweep = nMinExpTime + ORPHAN_TX_EXPIRE_INTERVAL;
	if (nErased > 0) {
	LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx due to expiration\n",
	nErased);
	}
	}
	FastRandomContext rng;
	while (mapOrphanTransactions.size() > nMaxOrphans) {
	// Evict a random orphan:
	size_t randompos = rng.randrange(g_orphan_list.size());
	EraseOrphanTx(g_orphan_list[randompos]->first);
	++nEvicted;
	}
	return nEvicted;
	}

	void PeerManager::Misbehaving(const NodeId pnode, const int howmuch,
	const std::string &message) {
	assert(howmuch > 0);

	PeerRef peer = GetPeerRef(pnode);
	if (peer == nullptr) {
	return;
	}

	LOCK(peer->m_misbehavior_mutex);

	peer->m_misbehavior_score += howmuch;
	const std::string message_prefixed =
	message.empty() ? "" : (": " + message);
	if (peer->m_misbehavior_score >= DISCOURAGEMENT_THRESHOLD &&
	peer->m_misbehavior_score - howmuch < DISCOURAGEMENT_THRESHOLD) {
	LogPrint(BCLog::NET,
	"Misbehaving: peer=%d (%d -> %d) BAN THRESHOLD EXCEEDED%s\n",
	pnode, peer->m_misbehavior_score - howmuch,
	peer->m_misbehavior_score, message_prefixed);
	peer->m_should_discourage = true;
	} else {
	LogPrint(BCLog::NET, "Misbehaving: peer=%d (%d -> %d)%s\n", pnode,
	peer->m_misbehavior_score - howmuch, peer->m_misbehavior_score,
	message_prefixed);
	}
	}

	/**
	* Returns true if the given validation state result may result in a peer
	* banning/disconnecting us. We use this to determine which unaccepted
	* transactions from a whitelisted peer that we can safely relay.
	*/
	static bool TxRelayMayResultInDisconnect(const TxValidationState &state) {
	return state.GetResult() == TxValidationResult::TX_CONSENSUS;
	}

	bool PeerManager::MaybePunishNodeForBlock(NodeId nodeid,
	const BlockValidationState &state,
	bool via_compact_block,
	const std::string &message) {
	switch (state.GetResult()) {
	case BlockValidationResult::BLOCK_RESULT_UNSET:
	break;
	// The node is providing invalid data:
	case BlockValidationResult::BLOCK_CONSENSUS:
	case BlockValidationResult::BLOCK_MUTATED:
	if (!via_compact_block) {
	Misbehaving(nodeid, 100, message);
	return true;
	}
	break;
	case BlockValidationResult::BLOCK_CACHED_INVALID: {
	LOCK(cs_main);
	CNodeState *node_state = State(nodeid);
	if (node_state == nullptr) {
	break;
	}

	// Ban outbound (but not inbound) peers if on an invalid chain.
	// Exempt HB compact block peers and manual connections.
	if (!via_compact_block && !node_state->m_is_inbound &&
	!node_state->m_is_manual_connection) {
	Misbehaving(nodeid, 100, message);
	return true;
	}
	break;
	}
	case BlockValidationResult::BLOCK_INVALID_HEADER:
	case BlockValidationResult::BLOCK_CHECKPOINT:
	case BlockValidationResult::BLOCK_INVALID_PREV:
	Misbehaving(nodeid, 100, message);
	return true;
	case BlockValidationResult::BLOCK_FINALIZATION:
	// TODO: Use the state object to report this is probably not the
	// best idea. This is effectively unreachable, unless there is a bug
	// somewhere.
	Misbehaving(nodeid, 20, message);
	return true;
	// Conflicting (but not necessarily invalid) data or different policy:
	case BlockValidationResult::BLOCK_MISSING_PREV:
	// TODO: Handle this much more gracefully (10 DoS points is super
	// arbitrary)
	Misbehaving(nodeid, 10, message);
	return true;
	case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE:
	case BlockValidationResult::BLOCK_TIME_FUTURE:
	break;
	}
	if (message != "") {
	LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
	}
	return false;
	}

	bool PeerManager::MaybePunishNodeForTx(NodeId nodeid,
	const TxValidationState &state,
	const std::string &message) {
	switch (state.GetResult()) {
	case TxValidationResult::TX_RESULT_UNSET:
	break;
	// The node is providing invalid data:
	case TxValidationResult::TX_CONSENSUS:
	Misbehaving(nodeid, 100, message);
	return true;
	// Conflicting (but not necessarily invalid) data or different policy:
	case TxValidationResult::TX_RECENT_CONSENSUS_CHANGE:
	case TxValidationResult::TX_NOT_STANDARD:
	case TxValidationResult::TX_MISSING_INPUTS:
	case TxValidationResult::TX_PREMATURE_SPEND:
	case TxValidationResult::TX_CONFLICT:
	case TxValidationResult::TX_MEMPOOL_POLICY:
	break;
	}
	if (message != "") {
	LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
	}
	return false;
	}

	//////////////////////////////////////////////////////////////////////////////
	//
	// blockchain -> download logic notification
	//

	// To prevent fingerprinting attacks, only send blocks/headers outside of the
	// active chain if they are no more than a month older (both in time, and in
	// best equivalent proof of work) than the best header chain we know about and
	// we fully-validated them at some point.
	static bool BlockRequestAllowed(const CBlockIndex *pindex,
	const Consensus::Params &consensusParams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	AssertLockHeld(cs_main);
	if (::ChainActive().Contains(pindex)) {
	return true;
	}
	return pindex->IsValid(BlockValidity::SCRIPTS) &&
	(pindexBestHeader != nullptr) &&
	(pindexBestHeader->GetBlockTime() - pindex->GetBlockTime() <
	STALE_RELAY_AGE_LIMIT) &&
	(GetBlockProofEquivalentTime(pindexBestHeader, pindex,
	*pindexBestHeader, consensusParams) <
	STALE_RELAY_AGE_LIMIT);
	}

	PeerManager::PeerManager(const CChainParams &chainparams, CConnman &connman,
	BanMan *banman, CScheduler &scheduler,
	ChainstateManager &chainman, CTxMemPool &pool)
	: m_chainparams(chainparams), m_connman(connman), m_banman(banman),
	m_chainman(chainman), m_mempool(pool), m_stale_tip_check_time(0) {
	// Initialize global variables that cannot be constructed at startup.
	recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));

	{
	LOCK(cs_rejectedProofs);
	rejectedProofs =
	std::make_unique<CRollingBloomFilter>(100000, 0.000001);
	}

	// Blocks don't typically have more than 4000 transactions, so this should
	// be at least six blocks (~1 hr) worth of transactions that we can store.
	// If the number of transactions appearing in a block goes up, or if we are
	// seeing getdata requests more than an hour after initial announcement, we
	// can increase this number.
	// The false positive rate of 1/1M should come out to less than 1
	// transaction per day that would be inadvertently ignored (which is the
	// same probability that we have in the reject filter).
	g_recent_confirmed_transactions.reset(
	new CRollingBloomFilter(24000, 0.000001));

	const Consensus::Params &consensusParams = chainparams.GetConsensus();
	// Stale tip checking and peer eviction are on two different timers, but we
	// don't want them to get out of sync due to drift in the scheduler, so we
	// combine them in one function and schedule at the quicker (peer-eviction)
	// timer.
	static_assert(
	EXTRA_PEER_CHECK_INTERVAL < STALE_CHECK_INTERVAL,
	"peer eviction timer should be less than stale tip check timer");
	scheduler.scheduleEvery(
	[this, &consensusParams]() {
	this->CheckForStaleTipAndEvictPeers(consensusParams);
	return true;
	},
	std::chrono::seconds{EXTRA_PEER_CHECK_INTERVAL});

	// schedule next run for 10-15 minutes in the future
	const std::chrono::milliseconds delta =
	std::chrono::minutes{10} + GetRandMillis(std::chrono::minutes{5});
	scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); },
	delta);
	}

	/**
	* Evict orphan txn pool entries (EraseOrphanTx) based on a newly connected
	* block, remember the recently confirmed transactions, and delete tracked
	* announcements for them. Also save the time of the last tip update.
	*/
	void PeerManager::BlockConnected(const std::shared_ptr<const CBlock> &pblock,
	const CBlockIndex *pindex) {
	{
	LOCK(g_cs_orphans);

	std::vector<TxId> vOrphanErase;

	for (const CTransactionRef &ptx : pblock->vtx) {
	const CTransaction &tx = *ptx;

	// Which orphan pool entries must we evict?
	for (const auto &txin : tx.vin) {
	auto itByPrev = mapOrphanTransactionsByPrev.find(txin.prevout);
	if (itByPrev == mapOrphanTransactionsByPrev.end()) {
	continue;
	}

	for (auto mi = itByPrev->second.begin();
	mi != itByPrev->second.end(); ++mi) {
	const CTransaction &orphanTx = (mi)->second.tx;
	const TxId &orphanId = orphanTx.GetId();
	vOrphanErase.push_back(orphanId);
	}
	}
	}

	// Erase orphan transactions included or precluded by this block
	if (vOrphanErase.size()) {
	int nErased = 0;
	for (const auto &orphanId : vOrphanErase) {
	nErased += EraseOrphanTx(orphanId);
	}
	LogPrint(BCLog::MEMPOOL,
	"Erased %d orphan tx included or conflicted by block\n",
	nErased);
	}

	g_last_tip_update = GetTime();
	}
	{
	LOCK(g_cs_recent_confirmed_transactions);
	for (const CTransactionRef &ptx : pblock->vtx) {
	g_recent_confirmed_transactions->insert(ptx->GetId());
	}
	}
	{
	LOCK(cs_main);
	for (const auto &ptx : pblock->vtx) {
	m_txrequest.ForgetInvId(ptx->GetId());
	}
	}
	}

	void PeerManager::BlockDisconnected(const std::shared_ptr<const CBlock> &block,
	const CBlockIndex *pindex) {
	// To avoid relay problems with transactions that were previously
	// confirmed, clear our filter of recently confirmed transactions whenever
	// there's a reorg.
	// This means that in a 1-block reorg (where 1 block is disconnected and
	// then another block reconnected), our filter will drop to having only one
	// block's worth of transactions in it, but that should be fine, since
	// presumably the most common case of relaying a confirmed transaction
	// should be just after a new block containing it is found.
	LOCK(g_cs_recent_confirmed_transactions);
	g_recent_confirmed_transactions->reset();
	}

	// All of the following cache a recent block, and are protected by
	// cs_most_recent_block
	static RecursiveMutex cs_most_recent_block;
	static std::shared_ptr<const CBlock>
	most_recent_block GUARDED_BY(cs_most_recent_block);
	static std::shared_ptr<const CBlockHeaderAndShortTxIDs>
	most_recent_compact_block GUARDED_BY(cs_most_recent_block);
	static uint256 most_recent_block_hash GUARDED_BY(cs_most_recent_block);

	/**
	* Maintain state about the best-seen block and fast-announce a compact block
	* to compatible peers.
	*/
	void PeerManager::NewPoWValidBlock(
	const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &pblock) {
	std::shared_ptr<const CBlockHeaderAndShortTxIDs> pcmpctblock =
	std::make_shared<const CBlockHeaderAndShortTxIDs>(*pblock);
	const CNetMsgMaker msgMaker(PROTOCOL_VERSION);

	LOCK(cs_main);

	static int nHighestFastAnnounce = 0;
	if (pindex->nHeight <= nHighestFastAnnounce) {
	return;
	}
	nHighestFastAnnounce = pindex->nHeight;

	uint256 hashBlock(pblock->GetHash());

	{
	LOCK(cs_most_recent_block);
	most_recent_block_hash = hashBlock;
	most_recent_block = pblock;
	most_recent_compact_block = pcmpctblock;
	}

	m_connman.ForEachNode([this, &pcmpctblock, pindex, &msgMaker,
	&hashBlock](CNode *pnode) {
	AssertLockHeld(cs_main);

	// TODO: Avoid the repeated-serialization here
	if (pnode->GetCommonVersion() < INVALID_CB_NO_BAN_VERSION \|\|
	pnode->fDisconnect) {
	return;
	}
	ProcessBlockAvailability(pnode->GetId());
	CNodeState &state = *State(pnode->GetId());
	// If the peer has, or we announced to them the previous block already,
	// but we don't think they have this one, go ahead and announce it.
	if (state.fPreferHeaderAndIDs && !PeerHasHeader(&state, pindex) &&
	PeerHasHeader(&state, pindex->pprev)) {
	LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n",
	"PeerManager::NewPoWValidBlock", hashBlock.ToString(),
	pnode->GetId());
	m_connman.PushMessage(
	pnode, msgMaker.Make(NetMsgType::CMPCTBLOCK, *pcmpctblock));
	state.pindexBestHeaderSent = pindex;
	}
	});
	}

	/**
	* Update our best height and announce any block hashes which weren't previously
	* in ::ChainActive() to our peers.
	*/
	void PeerManager::UpdatedBlockTip(const CBlockIndex *pindexNew,
	const CBlockIndex *pindexFork,
	bool fInitialDownload) {
	const int nNewHeight = pindexNew->nHeight;
	m_connman.SetBestHeight(nNewHeight);

	SetServiceFlagsIBDCache(!fInitialDownload);
	if (!fInitialDownload) {
	// Find the hashes of all blocks that weren't previously in the best
	// chain.
	std::vector<BlockHash> vHashes;
	const CBlockIndex *pindexToAnnounce = pindexNew;
	while (pindexToAnnounce != pindexFork) {
	vHashes.push_back(pindexToAnnounce->GetBlockHash());
	pindexToAnnounce = pindexToAnnounce->pprev;
	if (vHashes.size() == MAX_BLOCKS_TO_ANNOUNCE) {
	// Limit announcements in case of a huge reorganization. Rely on
	// the peer's synchronization mechanism in that case.
	break;
	}
	}
	// Relay inventory, but don't relay old inventory during initial block
	// download.
	m_connman.ForEachNode([nNewHeight, &vHashes](CNode *pnode) {
	LOCK(pnode->cs_inventory);
	if (nNewHeight > (pnode->nStartingHeight != -1
	? pnode->nStartingHeight - 2000
	: 0)) {
	for (const BlockHash &hash : reverse_iterate(vHashes)) {
	pnode->vBlockHashesToAnnounce.push_back(hash);
	}
	}
	});
	m_connman.WakeMessageHandler();
	}
	}

	/**
	* Handle invalid block rejection and consequent peer banning, maintain which
	* peers announce compact blocks.
	*/
	void PeerManager::BlockChecked(const CBlock &block,
	const BlockValidationState &state) {
	LOCK(cs_main);

	const BlockHash hash = block.GetHash();
	std::map<BlockHash, std::pair<NodeId, bool>>::iterator it =
	mapBlockSource.find(hash);

	// If the block failed validation, we know where it came from and we're
	// still connected to that peer, maybe punish.
	if (state.IsInvalid() && it != mapBlockSource.end() &&
	State(it->second.first)) {
	MaybePunishNodeForBlock(/nodeid=/it->second.first, state,
	/via_compact_block=/!it->second.second);
	}
	// Check that:
	// 1. The block is valid
	// 2. We're not in initial block download
	// 3. This is currently the best block we're aware of. We haven't updated
	// the tip yet so we have no way to check this directly here. Instead we
	// just check that there are currently no other blocks in flight.
	else if (state.IsValid() &&
	!::ChainstateActive().IsInitialBlockDownload() &&
	mapBlocksInFlight.count(hash) == mapBlocksInFlight.size()) {
	if (it != mapBlockSource.end()) {
	MaybeSetPeerAsAnnouncingHeaderAndIDs(it->second.first, m_connman);
	}
	}

	if (it != mapBlockSource.end()) {
	mapBlockSource.erase(it);
	}
	}

	//////////////////////////////////////////////////////////////////////////////
	//
	// Messages
	//

	static bool AlreadyHaveTx(const TxId &txid, const CTxMemPool &mempool)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	assert(recentRejects);
	if (::ChainActive().Tip()->GetBlockHash() != hashRecentRejectsChainTip) {
	// If the chain tip has changed previously rejected transactions
	// might be now valid, e.g. due to a nLockTime'd tx becoming
	// valid, or a double-spend. Reset the rejects filter and give
	// those txs a second chance.
	hashRecentRejectsChainTip = ::ChainActive().Tip()->GetBlockHash();
	recentRejects->reset();
	}

	{
	LOCK(g_cs_orphans);
	if (mapOrphanTransactions.count(txid)) {
	return true;
	}
	}

	{
	LOCK(g_cs_recent_confirmed_transactions);
	if (g_recent_confirmed_transactions->contains(txid)) {
	return true;
	}
	}

	return recentRejects->contains(txid) \|\| mempool.exists(txid);
	}

	static bool AlreadyHaveBlock(const BlockHash &block_hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	return LookupBlockIndex(block_hash) != nullptr;
	}

	static bool AlreadyHaveProof(const avalanche::ProofId &proofid) {
	assert(g_avalanche);
	LOCK(cs_rejectedProofs);
	return rejectedProofs->contains(proofid) \|\|
	g_avalanche->getProof(proofid) \|\| g_avalanche->getOrphan(proofid);
	}

	void RelayTransaction(const TxId &txid, const CConnman &connman) {
	connman.ForEachNode(
	[&txid](CNode *pnode) { pnode->PushTxInventory(txid); });
	}

	void RelayProof(const avalanche::ProofId &proofid, const CConnman &connman) {
	connman.ForEachNode(
	[&proofid](CNode *pnode) { pnode->PushProofInventory(proofid); });
	}

	static void RelayAddress(const CAddress &addr, bool fReachable,
	const CConnman &connman) {
	// Limited relaying of addresses outside our network(s)
	unsigned int nRelayNodes = fReachable ? 2 : 1;

	// Relay to a limited number of other nodes.
	// Use deterministic randomness to send to the same nodes for 24 hours at a
	// time so the m_addr_knowns of the chosen nodes prevent repeats
	uint64_t hashAddr = addr.GetHash();
	const CSipHasher hasher =
	connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY)
	.Write(hashAddr << 32)
	.Write((GetTime() + hashAddr) / (24 * 60 * 60));
	FastRandomContext insecure_rand;

	std::array<std::pair<uint64_t, CNode *>, 2> best{
	{{0, nullptr}, {0, nullptr}}};
	assert(nRelayNodes <= best.size());

	auto sortfunc = [&best, &hasher, nRelayNodes](CNode *pnode) {
	if (pnode->IsAddrRelayPeer()) {
	uint64_t hashKey =
	CSipHasher(hasher).Write(pnode->GetId()).Finalize();
	for (unsigned int i = 0; i < nRelayNodes; i++) {
	if (hashKey > best[i].first) {
	std::copy(best.begin() + i, best.begin() + nRelayNodes - 1,
	best.begin() + i + 1);
	best[i] = std::make_pair(hashKey, pnode);
	break;
	}
	}
	}
	};

	auto pushfunc = [&addr, &best, nRelayNodes, &insecure_rand] {
	for (unsigned int i = 0; i < nRelayNodes && best[i].first != 0; i++) {
	best[i].second->PushAddress(addr, insecure_rand);
	}
	};

	connman.ForEachNodeThen(std::move(sortfunc), std::move(pushfunc));
	}

	static void ProcessGetBlockData(const Config &config, CNode &pfrom,
	const CInv &inv, CConnman &connman,
	const std::atomic<bool> &interruptMsgProc) {
	const Consensus::Params &consensusParams =
	config.GetChainParams().GetConsensus();

	const BlockHash hash(inv.hash);

	bool send = false;
	std::shared_ptr<const CBlock> a_recent_block;
	std::shared_ptr<const CBlockHeaderAndShortTxIDs> a_recent_compact_block;
	{
	LOCK(cs_most_recent_block);
	a_recent_block = most_recent_block;
	a_recent_compact_block = most_recent_compact_block;
	}

	bool need_activate_chain = false;
	{
	LOCK(cs_main);
	const CBlockIndex *pindex = LookupBlockIndex(hash);
	if (pindex) {
	if (pindex->HaveTxsDownloaded() &&
	!pindex->IsValid(BlockValidity::SCRIPTS) &&
	pindex->IsValid(BlockValidity::TREE)) {
	// If we have the block and all of its parents, but have not yet
	// validated it, we might be in the middle of connecting it (ie
	// in the unlock of cs_main before ActivateBestChain but after
	// AcceptBlock). In this case, we need to run ActivateBestChain
	// prior to checking the relay conditions below.
	need_activate_chain = true;
	}
	}
	} // release cs_main before calling ActivateBestChain
	if (need_activate_chain) {
	BlockValidationState state;
	if (!ActivateBestChain(config, state, a_recent_block)) {
	LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
	state.ToString());
	}
	}

	LOCK(cs_main);
	const CBlockIndex *pindex = LookupBlockIndex(hash);
	if (pindex) {
	send = BlockRequestAllowed(pindex, consensusParams);
	if (!send) {
	LogPrint(BCLog::NET,
	"%s: ignoring request from peer=%i for old "
	"block that isn't in the main chain\n",
	__func__, pfrom.GetId());
	}
	}
	const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
	// Disconnect node in case we have reached the outbound limit for serving
	// historical blocks.
	if (send && connman.OutboundTargetReached(true) &&
	(((pindexBestHeader != nullptr) &&
	(pindexBestHeader->GetBlockTime() - pindex->GetBlockTime() >
	HISTORICAL_BLOCK_AGE)) \|\|
	inv.IsMsgFilteredBlk()) &&
	// nodes with the download permission may exceed target
	!pfrom.HasPermission(PF_DOWNLOAD)) {
	LogPrint(BCLog::NET,
	"historical block serving limit reached, disconnect peer=%d\n",
	pfrom.GetId());

	// disconnect node
	pfrom.fDisconnect = true;
	send = false;
	}
	// Avoid leaking prune-height by never sending blocks below the
	// NODE_NETWORK_LIMITED threshold.
	// Add two blocks buffer extension for possible races
	if (send && !pfrom.HasPermission(PF_NOBAN) &&
	((((pfrom.GetLocalServices() & NODE_NETWORK_LIMITED) ==
	NODE_NETWORK_LIMITED) &&
	((pfrom.GetLocalServices() & NODE_NETWORK) != NODE_NETWORK) &&
	(::ChainActive().Tip()->nHeight - pindex->nHeight >
	(int)NODE_NETWORK_LIMITED_MIN_BLOCKS + 2)))) {
	LogPrint(BCLog::NET,
	"Ignore block request below NODE_NETWORK_LIMITED "
	"threshold from peer=%d\n",
	pfrom.GetId());

	// disconnect node and prevent it from stalling (would otherwise wait
	// for the missing block)
	pfrom.fDisconnect = true;
	send = false;
	}
	// Pruned nodes may have deleted the block, so check whether it's available
	// before trying to send.
	if (send && pindex->nStatus.hasData()) {
	std::shared_ptr<const CBlock> pblock;
	if (a_recent_block &&
	a_recent_block->GetHash() == pindex->GetBlockHash()) {
	pblock = a_recent_block;
	} else {
	// Send block from disk
	std::shared_ptr<CBlock> pblockRead = std::make_shared<CBlock>();
	if (!ReadBlockFromDisk(*pblockRead, pindex, consensusParams)) {
	assert(!"cannot load block from disk");
	}
	pblock = pblockRead;
	}
	if (inv.IsMsgBlk()) {
	connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::BLOCK, *pblock));
	} else if (inv.IsMsgFilteredBlk()) {
	bool sendMerkleBlock = false;
	CMerkleBlock merkleBlock;
	if (pfrom.m_tx_relay != nullptr) {
	LOCK(pfrom.m_tx_relay->cs_filter);
	if (pfrom.m_tx_relay->pfilter) {
	sendMerkleBlock = true;
	merkleBlock =
	CMerkleBlock(pblock, pfrom.m_tx_relay->pfilter);
	}
	}
	if (sendMerkleBlock) {
	connman.PushMessage(
	&pfrom,
	msgMaker.Make(NetMsgType::MERKLEBLOCK, merkleBlock));
	// CMerkleBlock just contains hashes, so also push any
	// transactions in the block the client did not see. This avoids
	// hurting performance by pointlessly requiring a round-trip.
	// Note that there is currently no way for a node to request any
	// single transactions we didn't send here - they must either
	// disconnect and retry or request the full block. Thus, the
	// protocol spec specified allows for us to provide duplicate
	// txn here, however we MUST always provide at least what the
	// remote peer needs.
	typedef std::pair<size_t, uint256> PairType;
	for (PairType &pair : merkleBlock.vMatchedTxn) {
	connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::TX,
	*pblock->vtx[pair.first]));
	}
	}
	// else
	// no response
	} else if (inv.IsMsgCmpctBlk()) {
	// If a peer is asking for old blocks, we're almost guaranteed they
	// won't have a useful mempool to match against a compact block, and
	// we don't feel like constructing the object for them, so instead
	// we respond with the full, non-compact block.
	int nSendFlags = 0;
	if (CanDirectFetch(consensusParams) &&
	pindex->nHeight >=
	::ChainActive().Height() - MAX_CMPCTBLOCK_DEPTH) {
	CBlockHeaderAndShortTxIDs cmpctblock(*pblock);
	connman.PushMessage(
	&pfrom, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK,
	cmpctblock));
	} else {
	connman.PushMessage(
	&pfrom,
	msgMaker.Make(nSendFlags, NetMsgType::BLOCK, *pblock));
	}
	}

	// Trigger the peer node to send a getblocks request for the next batch
	// of inventory.
	if (hash == pfrom.hashContinue) {
	// Send immediately. This must send even if redundant, and
	// we want it right after the last block so they don't wait for
	// other stuff first.
	std::vector<CInv> vInv;
	vInv.push_back(
	CInv(MSG_BLOCK, ::ChainActive().Tip()->GetBlockHash()));
	connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::INV, vInv));
	pfrom.hashContinue = BlockHash();
	}
	}
	}

	//! Determine whether or not a peer can request a transaction, and return it (or
	//! nullptr if not found or not allowed).
	CTransactionRef static FindTxForGetData(const CNode &peer, const TxId &txid,
	const std::chrono::seconds mempool_req,
	const std::chrono::seconds now)
	LOCKS_EXCLUDED(cs_main) {
	auto txinfo = g_mempool.info(txid);
	if (txinfo.tx) {
	// If a TX could have been INVed in reply to a MEMPOOL request,
	// or is older than UNCONDITIONAL_RELAY_DELAY, permit the request
	// unconditionally.
	if ((mempool_req.count() && txinfo.m_time <= mempool_req) \|\|
	txinfo.m_time <= now - UNCONDITIONAL_RELAY_DELAY) {
	return std::move(txinfo.tx);
	}
	}

	{
	LOCK(cs_main);

	// Otherwise, the transaction must have been announced recently.
	if (State(peer.GetId())->m_recently_announced_invs.contains(txid)) {
	// If it was, it can be relayed from either the mempool...
	if (txinfo.tx) {
	return std::move(txinfo.tx);
	}
	// ... or the relay pool.
	auto mi = mapRelay.find(txid);
	if (mi != mapRelay.end()) {
	return mi->second;
	}
	}
	}

	return {};
	}

	//! Determine whether or not a peer can request a proof, and return it (or
	//! nullptr if not found or not allowed).
	static std::shared_ptr<avalanche::Proof>
	FindProofForGetData(const CNode &peer, const avalanche::ProofId &proofid,
	const std::chrono::seconds now) {
	- auto proof = g_avalanche->getProof(proofid);
	+ std::shared_ptr<avalanche::Proof> proof = nullptr;
	+
	+ bool send_unconditionally =
	+ g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
	+ return pm.forPeer(proofid, [&](const avalanche::Peer &peer) {
	+ proof = peer.proof;
	+
	+ // If we know that proof for long enough, allow for requesting
	+ // it.
	+ return peer.registration_time <=
	+ now - UNCONDITIONAL_RELAY_DELAY;
	+ });
	+ });

	// We don't have this proof
	if (!proof) {
	return nullptr;
	}

	- auto proofRegistrationTime = g_avalanche->getProofRegistrationTime(proofid);
	-
	- // If we know that proof for long enough, allow for requesting it
	- if (proofRegistrationTime <= now - UNCONDITIONAL_RELAY_DELAY) {
	+ if (send_unconditionally) {
	return proof;
	}

	- {
	- LOCK(cs_main);
	- // Otherwise, the proofs must have been announced recently.
	- if (State(peer.GetId())
	- ->m_recently_announced_proofs.contains(proofid)) {
	- return proof;
	- }
	+ // Otherwise, the proofs must have been announced recently.
	+ LOCK(cs_main);
	+ if (State(peer.GetId())->m_recently_announced_proofs.contains(proofid)) {
	+ return proof;
	}

	return nullptr;
	}

	static void ProcessGetData(const Config &config, CNode &pfrom,
	CConnman &connman, CTxMemPool &mempool,
	const std::atomic<bool> &interruptMsgProc)
	LOCKS_EXCLUDED(cs_main) {
	AssertLockNotHeld(cs_main);

	std::deque<CInv>::iterator it = pfrom.vRecvGetData.begin();
	std::vector<CInv> vNotFound;
	const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());

	const std::chrono::seconds now = GetTime<std::chrono::seconds>();
	// Get last mempool request time
	const std::chrono::seconds mempool_req =
	pfrom.m_tx_relay != nullptr
	? pfrom.m_tx_relay->m_last_mempool_req.load()
	: std::chrono::seconds::min();

	// Process as many TX or AVA_PROOF items from the front of the getdata
	// queue as possible, since they're common and it's efficient to batch
	// process them.
	while (it != pfrom.vRecvGetData.end()) {
	if (interruptMsgProc) {
	return;
	}
	// The send buffer provides backpressure. If there's no space in
	// the buffer, pause processing until the next call.
	if (pfrom.fPauseSend) {
	break;
	}

	const CInv &inv = *it;

	if (it->IsMsgProof()) {
	const avalanche::ProofId proofid = avalanche::ProofId{inv.hash};
	auto proof = FindProofForGetData(pfrom, proofid, now);
	if (proof) {
	connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof));
	g_avalanche->removeUnbroadcastProof(proofid);
	} else {
	vNotFound.push_back(inv);
	}

	++it;
	continue;
	}

	if (it->IsMsgTx()) {
	if (pfrom.m_tx_relay == nullptr) {
	// Ignore GETDATA requests for transactions from blocks-only
	// peers.
	continue;
	}

	CTransactionRef tx =
	FindTxForGetData(pfrom, TxId{inv.hash}, mempool_req, now);
	if (tx) {
	int nSendFlags = 0;
	connman.PushMessage(
	&pfrom, msgMaker.Make(nSendFlags, NetMsgType::TX, *tx));
	mempool.RemoveUnbroadcastTx(TxId(inv.hash));
	// As we're going to send tx, make sure its unconfirmed parents
	// are made requestable.
	for (const auto &txin : tx->vin) {
	auto txinfo = mempool.info(txin.prevout.GetTxId());
	if (txinfo.tx &&
	txinfo.m_time > now - UNCONDITIONAL_RELAY_DELAY) {
	// Relaying a transaction with a recent but unconfirmed
	// parent.
	if (WITH_LOCK(
	pfrom.m_tx_relay->cs_tx_inventory,
	return !pfrom.m_tx_relay->filterInventoryKnown
	.contains(
	txin.prevout.GetTxId()))) {
	LOCK(cs_main);
	State(pfrom.GetId())
	->m_recently_announced_invs.insert(
	txin.prevout.GetTxId());
	}
	}
	}
	} else {
	vNotFound.push_back(inv);
	}

	++it;
	continue;
	}

	// It's neither a proof nor a transaction
	break;
	}

	// Only process one BLOCK item per call, since they're uncommon and can be
	// expensive to process.
	if (it != pfrom.vRecvGetData.end() && !pfrom.fPauseSend) {
	const CInv &inv = *it++;
	if (inv.IsGenBlkMsg()) {
	ProcessGetBlockData(config, pfrom, inv, connman, interruptMsgProc);
	}
	// else: If the first item on the queue is an unknown type, we erase it
	// and continue processing the queue on the next call.
	}

	pfrom.vRecvGetData.erase(pfrom.vRecvGetData.begin(), it);

	if (!vNotFound.empty()) {
	// Let the peer know that we didn't find what it asked for, so it
	// doesn't have to wait around forever. SPV clients care about this
	// message: it's needed when they are recursively walking the
	// dependencies of relevant unconfirmed transactions. SPV clients want
	// to do that because they want to know about (and store and rebroadcast
	// and risk analyze) the dependencies of transactions relevant to them,
	// without having to download the entire memory pool. Also, other nodes
	// can use these messages to automatically request a transaction from
	// some other peer that annnounced it, and stop waiting for us to
	// respond. In normal operation, we often send NOTFOUND messages for
	// parents of transactions that we relay; if a peer is missing a parent,
	// they may assume we have them and request the parents from us.
	connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::NOTFOUND, vNotFound));
	}
	}

	void PeerManager::SendBlockTransactions(CNode &pfrom, const CBlock &block,
	const BlockTransactionsRequest &req) {
	BlockTransactions resp(req);
	for (size_t i = 0; i < req.indices.size(); i++) {
	if (req.indices[i] >= block.vtx.size()) {
	Misbehaving(pfrom, 100,
	"getblocktxn with out-of-bounds tx indices");
	return;
	}
	resp.txn[i] = block.vtx[req.indices[i]];
	}
	LOCK(cs_main);
	const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
	int nSendFlags = 0;
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCKTXN, resp));
	}

	void PeerManager::ProcessHeadersMessage(
	const Config &config, CNode &pfrom,
	const std::vector<CBlockHeader> &headers, bool via_compact_block) {
	const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
	size_t nCount = headers.size();

	if (nCount == 0) {
	// Nothing interesting. Stop asking this peers for more headers.
	return;
	}

	bool received_new_header = false;
	const CBlockIndex *pindexLast = nullptr;
	{
	LOCK(cs_main);
	CNodeState *nodestate = State(pfrom.GetId());

	// If this looks like it could be a block announcement (nCount <
	// MAX_BLOCKS_TO_ANNOUNCE), use special logic for handling headers that
	// don't connect:
	// - Send a getheaders message in response to try to connect the chain.
	// - The peer can send up to MAX_UNCONNECTING_HEADERS in a row that
	// don't connect before giving DoS points
	// - Once a headers message is received that is valid and does connect,
	// nUnconnectingHeaders gets reset back to 0.
	if (!LookupBlockIndex(headers[0].hashPrevBlock) &&
	nCount < MAX_BLOCKS_TO_ANNOUNCE) {
	nodestate->nUnconnectingHeaders++;
	m_connman.PushMessage(
	&pfrom,
	msgMaker.Make(NetMsgType::GETHEADERS,
	::ChainActive().GetLocator(pindexBestHeader),
	uint256()));
	LogPrint(
	BCLog::NET,
	"received header %s: missing prev block %s, sending getheaders "
	"(%d) to end (peer=%d, nUnconnectingHeaders=%d)\n",
	headers[0].GetHash().ToString(),
	headers[0].hashPrevBlock.ToString(), pindexBestHeader->nHeight,
	pfrom.GetId(), nodestate->nUnconnectingHeaders);
	// Set hashLastUnknownBlock for this peer, so that if we eventually
	// get the headers - even from a different peer - we can use this
	// peer to download.
	UpdateBlockAvailability(pfrom.GetId(), headers.back().GetHash());

	if (nodestate->nUnconnectingHeaders % MAX_UNCONNECTING_HEADERS ==
	0) {
	// The peer is sending us many headers we can't connect.
	Misbehaving(pfrom, 20,
	strprintf("%d non-connecting headers",
	nodestate->nUnconnectingHeaders));
	}
	return;
	}

	BlockHash hashLastBlock;
	for (const CBlockHeader &header : headers) {
	if (!hashLastBlock.IsNull() &&
	header.hashPrevBlock != hashLastBlock) {
	Misbehaving(pfrom, 20, "non-continuous headers sequence");
	return;
	}
	hashLastBlock = header.GetHash();
	}

	// If we don't have the last header, then they'll have given us
	// something new (if these headers are valid).
	if (!LookupBlockIndex(hashLastBlock)) {
	received_new_header = true;
	}
	}

	BlockValidationState state;
	if (!m_chainman.ProcessNewBlockHeaders(config, headers, state,
	&pindexLast)) {
	if (state.IsInvalid()) {
	MaybePunishNodeForBlock(pfrom.GetId(), state, via_compact_block,
	"invalid header received");
	return;
	}
	}

	{
	LOCK(cs_main);
	CNodeState *nodestate = State(pfrom.GetId());
	if (nodestate->nUnconnectingHeaders > 0) {
	LogPrint(BCLog::NET,
	"peer=%d: resetting nUnconnectingHeaders (%d -> 0)\n",
	pfrom.GetId(), nodestate->nUnconnectingHeaders);
	}
	nodestate->nUnconnectingHeaders = 0;

	assert(pindexLast);
	UpdateBlockAvailability(pfrom.GetId(), pindexLast->GetBlockHash());

	// From here, pindexBestKnownBlock should be guaranteed to be non-null,
	// because it is set in UpdateBlockAvailability. Some nullptr checks are
	// still present, however, as belt-and-suspenders.

	if (received_new_header &&
	pindexLast->nChainWork > ::ChainActive().Tip()->nChainWork) {
	nodestate->m_last_block_announcement = GetTime();
	}

	if (nCount == MAX_HEADERS_RESULTS) {
	// Headers message had its maximum size; the peer may have more
	// headers.
	// TODO: optimize: if pindexLast is an ancestor of
	// ::ChainActive().Tip or pindexBestHeader, continue from there
	// instead.
	LogPrint(
	BCLog::NET,
	"more getheaders (%d) to end to peer=%d (startheight:%d)\n",
	pindexLast->nHeight, pfrom.GetId(), pfrom.nStartingHeight);
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETHEADERS,
	::ChainActive().GetLocator(pindexLast),
	uint256()));
	}

	bool fCanDirectFetch = CanDirectFetch(m_chainparams.GetConsensus());
	// If this set of headers is valid and ends in a block with at least as
	// much work as our tip, download as much as possible.
	if (fCanDirectFetch && pindexLast->IsValid(BlockValidity::TREE) &&
	::ChainActive().Tip()->nChainWork <= pindexLast->nChainWork) {
	std::vector<const CBlockIndex *> vToFetch;
	const CBlockIndex *pindexWalk = pindexLast;
	// Calculate all the blocks we'd need to switch to pindexLast, up to
	// a limit.
	while (pindexWalk && !::ChainActive().Contains(pindexWalk) &&
	vToFetch.size() <= MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
	if (!pindexWalk->nStatus.hasData() &&
	!mapBlocksInFlight.count(pindexWalk->GetBlockHash())) {
	// We don't have this block, and it's not yet in flight.
	vToFetch.push_back(pindexWalk);
	}
	pindexWalk = pindexWalk->pprev;
	}
	// If pindexWalk still isn't on our main chain, we're looking at a
	// very large reorg at a time we think we're close to caught up to
	// the main chain -- this shouldn't really happen. Bail out on the
	// direct fetch and rely on parallel download instead.
	if (!::ChainActive().Contains(pindexWalk)) {
	LogPrint(
	BCLog::NET, "Large reorg, won't direct fetch to %s (%d)\n",
	pindexLast->GetBlockHash().ToString(), pindexLast->nHeight);
	} else {
	std::vector<CInv> vGetData;
	// Download as much as possible, from earliest to latest.
	for (const CBlockIndex *pindex : reverse_iterate(vToFetch)) {
	if (nodestate->nBlocksInFlight >=
	MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
	// Can't download any more from this peer
	break;
	}
	vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
	MarkBlockAsInFlight(config, m_mempool, pfrom.GetId(),
	pindex->GetBlockHash(),
	m_chainparams.GetConsensus(), pindex);
	LogPrint(BCLog::NET, "Requesting block %s from peer=%d\n",
	pindex->GetBlockHash().ToString(), pfrom.GetId());
	}
	if (vGetData.size() > 1) {
	LogPrint(BCLog::NET,
	"Downloading blocks toward %s (%d) via headers "
	"direct fetch\n",
	pindexLast->GetBlockHash().ToString(),
	pindexLast->nHeight);
	}
	if (vGetData.size() > 0) {
	if (nodestate->fSupportsDesiredCmpctVersion &&
	vGetData.size() == 1 && mapBlocksInFlight.size() == 1 &&
	pindexLast->pprev->IsValid(BlockValidity::CHAIN)) {
	// In any case, we want to download using a compact
	// block, not a regular one.
	vGetData[0] = CInv(MSG_CMPCT_BLOCK, vGetData[0].hash);
	}
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETDATA, vGetData));
	}
	}
	}
	// If we're in IBD, we want outbound peers that will serve us a useful
	// chain. Disconnect peers that are on chains with insufficient work.
	if (::ChainstateActive().IsInitialBlockDownload() &&
	nCount != MAX_HEADERS_RESULTS) {
	// When nCount < MAX_HEADERS_RESULTS, we know we have no more
	// headers to fetch from this peer.
	if (nodestate->pindexBestKnownBlock &&
	nodestate->pindexBestKnownBlock->nChainWork <
	nMinimumChainWork) {
	// This peer has too little work on their headers chain to help
	// us sync -- disconnect if using an outbound slot (unless
	// whitelisted or addnode).
	// Note: We compare their tip to nMinimumChainWork (rather than
	// ::ChainActive().Tip()) because we won't start block download
	// until we have a headers chain that has at least
	// nMinimumChainWork, even if a peer has a chain past our tip,
	// as an anti-DoS measure.
	if (pfrom.IsOutboundOrBlockRelayConn()) {
	LogPrintf("Disconnecting outbound peer %d -- headers "
	"chain has insufficient work\n",
	pfrom.GetId());
	pfrom.fDisconnect = true;
	}
	}
	}

	if (!pfrom.fDisconnect && pfrom.IsOutboundOrBlockRelayConn() &&
	nodestate->pindexBestKnownBlock != nullptr &&
	pfrom.m_tx_relay != nullptr) {
	// If this is an outbound full-relay peer, check to see if we should
	// protect it from the bad/lagging chain logic. Note that
	// block-relay-only peers are already implicitly protected, so we
	// only consider setting m_protect for the full-relay peers.
	if (g_outbound_peers_with_protect_from_disconnect <
	MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT &&
	nodestate->pindexBestKnownBlock->nChainWork >=
	::ChainActive().Tip()->nChainWork &&
	!nodestate->m_chain_sync.m_protect) {
	LogPrint(BCLog::NET,
	"Protecting outbound peer=%d from eviction\n",
	pfrom.GetId());
	nodestate->m_chain_sync.m_protect = true;
	++g_outbound_peers_with_protect_from_disconnect;
	}
	}
	}
	}

	void PeerManager::ProcessOrphanTx(const Config &config,
	std::set<TxId> &orphan_work_set)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans) {
	AssertLockHeld(cs_main);
	AssertLockHeld(g_cs_orphans);
	std::unordered_map<NodeId, uint32_t> rejectCountPerNode;
	bool done = false;
	while (!done && !orphan_work_set.empty()) {
	const TxId orphanTxId = *orphan_work_set.begin();
	orphan_work_set.erase(orphan_work_set.begin());

	auto orphan_it = mapOrphanTransactions.find(orphanTxId);
	if (orphan_it == mapOrphanTransactions.end()) {
	continue;
	}

	const CTransactionRef porphanTx = orphan_it->second.tx;
	const CTransaction &orphanTx = *porphanTx;
	NodeId fromPeer = orphan_it->second.fromPeer;
	// Use a new TxValidationState because orphans come from different peers
	// (and we call MaybePunishNodeForTx based on the source peer from the
	// orphan map, not based on the peer that relayed the previous
	// transaction).
	TxValidationState orphan_state;

	auto it = rejectCountPerNode.find(fromPeer);
	if (it != rejectCountPerNode.end() &&
	it->second > MAX_NON_STANDARD_ORPHAN_PER_NODE) {
	continue;
	}

	if (AcceptToMemoryPool(config, m_mempool, orphan_state, porphanTx,
	false /* bypass_limits */,
	Amount::zero() /* nAbsurdFee */)) {
	LogPrint(BCLog::MEMPOOL, " accepted orphan tx %s\n",
	orphanTxId.ToString());
	RelayTransaction(orphanTxId, m_connman);
	for (size_t i = 0; i < orphanTx.vout.size(); i++) {
	auto it_by_prev =
	mapOrphanTransactionsByPrev.find(COutPoint(orphanTxId, i));
	if (it_by_prev != mapOrphanTransactionsByPrev.end()) {
	for (const auto &elem : it_by_prev->second) {
	orphan_work_set.insert(elem->first);
	}
	}
	}
	EraseOrphanTx(orphanTxId);
	done = true;
	} else if (orphan_state.GetResult() !=
	TxValidationResult::TX_MISSING_INPUTS) {
	if (orphan_state.IsInvalid()) {
	// Punish peer that gave us an invalid orphan tx
	MaybePunishNodeForTx(fromPeer, orphan_state);
	LogPrint(BCLog::MEMPOOL, " invalid orphan tx %s\n",
	orphanTxId.ToString());
	}
	// Has inputs but not accepted to mempool
	// Probably non-standard or insufficient fee
	LogPrint(BCLog::MEMPOOL, " removed orphan tx %s\n",
	orphanTxId.ToString());

	assert(recentRejects);
	recentRejects->insert(orphanTxId);

	EraseOrphanTx(orphanTxId);
	done = true;
	}
	m_mempool.check(&::ChainstateActive().CoinsTip());
	}
	}

	/**
	* Validation logic for compact filters request handling.
	*
	* May disconnect from the peer in the case of a bad request.
	*
	* @param[in] peer The peer that we received the request from
	* @param[in] chain_params Chain parameters
	* @param[in] filter_type The filter type the request is for. Must be
	* basic filters.
	* @param[in] start_height The start height for the request
	* @param[in] stop_hash The stop_hash for the request
	* @param[in] max_height_diff The maximum number of items permitted to
	* request, as specified in BIP 157
	* @param[out] stop_index The CBlockIndex for the stop_hash block, if the
	* request can be serviced.
	* @param[out] filter_index The filter index, if the request can be
	* serviced.
	* @return True if the request can be serviced.
	*/
	static bool PrepareBlockFilterRequest(
	CNode &peer, const CChainParams &chain_params, BlockFilterType filter_type,
	uint32_t start_height, const BlockHash &stop_hash, uint32_t max_height_diff,
	const CBlockIndex &stop_index, BlockFilterIndex &filter_index) {
	const bool supported_filter_type =
	(filter_type == BlockFilterType::BASIC &&
	(peer.GetLocalServices() & NODE_COMPACT_FILTERS));
	if (!supported_filter_type) {
	LogPrint(BCLog::NET,
	"peer %d requested unsupported block filter type: %d\n",
	peer.GetId(), static_cast<uint8_t>(filter_type));
	peer.fDisconnect = true;
	return false;
	}

	{
	LOCK(cs_main);
	stop_index = LookupBlockIndex(stop_hash);

	// Check that the stop block exists and the peer would be allowed to
	// fetch it.
	if (!stop_index \|\|
	!BlockRequestAllowed(stop_index, chain_params.GetConsensus())) {
	LogPrint(BCLog::NET, "peer %d requested invalid block hash: %s\n",
	peer.GetId(), stop_hash.ToString());
	peer.fDisconnect = true;
	return false;
	}
	}

	uint32_t stop_height = stop_index->nHeight;
	if (start_height > stop_height) {
	LogPrint(
	BCLog::NET,
	"peer %d sent invalid getcfilters/getcfheaders with " /* Continued
	*/
	"start height %d and stop height %d\n",
	peer.GetId(), start_height, stop_height);
	peer.fDisconnect = true;
	return false;
	}
	if (stop_height - start_height >= max_height_diff) {
	LogPrint(BCLog::NET,
	"peer %d requested too many cfilters/cfheaders: %d / %d\n",
	peer.GetId(), stop_height - start_height + 1, max_height_diff);
	peer.fDisconnect = true;
	return false;
	}

	filter_index = GetBlockFilterIndex(filter_type);
	if (!filter_index) {
	LogPrint(BCLog::NET, "Filter index for supported type %s not found\n",
	BlockFilterTypeName(filter_type));
	return false;
	}

	return true;
	}

	/**
	* Handle a cfilters request.
	*
	* May disconnect from the peer in the case of a bad request.
	*
	* @param[in] peer The peer that we received the request from
	* @param[in] vRecv The raw message received
	* @param[in] chain_params Chain parameters
	* @param[in] connman Pointer to the connection manager
	*/
	static void ProcessGetCFilters(CNode &peer, CDataStream &vRecv,
	const CChainParams &chain_params,
	CConnman &connman) {
	uint8_t filter_type_ser;
	uint32_t start_height;
	BlockHash stop_hash;

	vRecv >> filter_type_ser >> start_height >> stop_hash;

	const BlockFilterType filter_type =
	static_cast<BlockFilterType>(filter_type_ser);

	const CBlockIndex *stop_index;
	BlockFilterIndex *filter_index;
	if (!PrepareBlockFilterRequest(
	peer, chain_params, filter_type, start_height, stop_hash,
	MAX_GETCFILTERS_SIZE, stop_index, filter_index)) {
	return;
	}

	std::vector<BlockFilter> filters;
	if (!filter_index->LookupFilterRange(start_height, stop_index, filters)) {
	LogPrint(BCLog::NET,
	"Failed to find block filter in index: filter_type=%s, "
	"start_height=%d, stop_hash=%s\n",
	BlockFilterTypeName(filter_type), start_height,
	stop_hash.ToString());
	return;
	}

	for (const auto &filter : filters) {
	CSerializedNetMsg msg = CNetMsgMaker(peer.GetCommonVersion())
	.Make(NetMsgType::CFILTER, filter);
	connman.PushMessage(&peer, std::move(msg));
	}
	}

	/**
	* Handle a cfheaders request.
	*
	* May disconnect from the peer in the case of a bad request.
	*
	* @param[in] peer The peer that we received the request from
	* @param[in] vRecv The raw message received
	* @param[in] chain_params Chain parameters
	* @param[in] connman Pointer to the connection manager
	*/
	static void ProcessGetCFHeaders(CNode &peer, CDataStream &vRecv,
	const CChainParams &chain_params,
	CConnman &connman) {
	uint8_t filter_type_ser;
	uint32_t start_height;
	BlockHash stop_hash;

	vRecv >> filter_type_ser >> start_height >> stop_hash;

	const BlockFilterType filter_type =
	static_cast<BlockFilterType>(filter_type_ser);

	const CBlockIndex *stop_index;
	BlockFilterIndex *filter_index;
	if (!PrepareBlockFilterRequest(
	peer, chain_params, filter_type, start_height, stop_hash,
	MAX_GETCFHEADERS_SIZE, stop_index, filter_index)) {
	return;
	}

	uint256 prev_header;
	if (start_height > 0) {
	const CBlockIndex *const prev_block =
	stop_index->GetAncestor(static_cast<int>(start_height - 1));
	if (!filter_index->LookupFilterHeader(prev_block, prev_header)) {
	LogPrint(BCLog::NET,
	"Failed to find block filter header in index: "
	"filter_type=%s, block_hash=%s\n",
	BlockFilterTypeName(filter_type),
	prev_block->GetBlockHash().ToString());
	return;
	}
	}

	std::vector<uint256> filter_hashes;
	if (!filter_index->LookupFilterHashRange(start_height, stop_index,
	filter_hashes)) {
	LogPrint(BCLog::NET,
	"Failed to find block filter hashes in index: filter_type=%s, "
	"start_height=%d, stop_hash=%s\n",
	BlockFilterTypeName(filter_type), start_height,
	stop_hash.ToString());
	return;
	}

	CSerializedNetMsg msg =
	CNetMsgMaker(peer.GetCommonVersion())
	.Make(NetMsgType::CFHEADERS, filter_type_ser,
	stop_index->GetBlockHash(), prev_header, filter_hashes);
	connman.PushMessage(&peer, std::move(msg));
	}

	/**
	* Handle a getcfcheckpt request.
	*
	* May disconnect from the peer in the case of a bad request.
	*
	* @param[in] peer The peer that we received the request from
	* @param[in] vRecv The raw message received
	* @param[in] chain_params Chain parameters
	* @param[in] connman Pointer to the connection manager
	*/
	static void ProcessGetCFCheckPt(CNode &peer, CDataStream &vRecv,
	const CChainParams &chain_params,
	CConnman &connman) {
	uint8_t filter_type_ser;
	BlockHash stop_hash;

	vRecv >> filter_type_ser >> stop_hash;

	const BlockFilterType filter_type =
	static_cast<BlockFilterType>(filter_type_ser);

	const CBlockIndex *stop_index;
	BlockFilterIndex *filter_index;
	if (!PrepareBlockFilterRequest(
	peer, chain_params, filter_type, /start_height=/0, stop_hash,
	/max_height_diff=/std::numeric_limits<uint32_t>::max(),
	stop_index, filter_index)) {
	return;
	}

	std::vector<uint256> headers(stop_index->nHeight / CFCHECKPT_INTERVAL);

	// Populate headers.
	const CBlockIndex *block_index = stop_index;
	for (int i = headers.size() - 1; i >= 0; i--) {
	int height = (i + 1) * CFCHECKPT_INTERVAL;
	block_index = block_index->GetAncestor(height);

	if (!filter_index->LookupFilterHeader(block_index, headers[i])) {
	LogPrint(BCLog::NET,
	"Failed to find block filter header in index: "
	"filter_type=%s, block_hash=%s\n",
	BlockFilterTypeName(filter_type),
	block_index->GetBlockHash().ToString());
	return;
	}
	}

	CSerializedNetMsg msg = CNetMsgMaker(peer.GetCommonVersion())
	.Make(NetMsgType::CFCHECKPT, filter_type_ser,
	stop_index->GetBlockHash(), headers);
	connman.PushMessage(&peer, std::move(msg));
	}

	bool IsAvalancheMessageType(const std::string &msg_type) {
	return msg_type == NetMsgType::AVAHELLO \|\|
	msg_type == NetMsgType::AVAPOLL \|\|
	msg_type == NetMsgType::AVARESPONSE \|\|
	msg_type == NetMsgType::AVAPROOF;
	}

	void PeerManager::ProcessMessage(const Config &config, CNode &pfrom,
	const std::string &msg_type,
	CDataStream &vRecv,
	const std::chrono::microseconds time_received,
	const std::atomic<bool> &interruptMsgProc) {
	LogPrint(BCLog::NET, "received: %s (%u bytes) peer=%d\n",
	SanitizeString(msg_type), vRecv.size(), pfrom.GetId());
	if (gArgs.IsArgSet("-dropmessagestest") &&
	GetRand(gArgs.GetArg("-dropmessagestest", 0)) == 0) {
	LogPrintf("dropmessagestest DROPPING RECV MESSAGE\n");
	return;
	}

	if (IsAvalancheMessageType(msg_type)) {
	if (!g_avalanche) {
	LogPrint(BCLog::NET,
	"Avalanche is not initialized, ignoring %s message\n",
	msg_type);
	return;
	}

	if (!isAvalancheEnabled(gArgs)) {
	Misbehaving(pfrom, 20, "unsolicited-" + msg_type);
	return;
	}
	}

	if (msg_type == NetMsgType::VERSION) {
	// Each connection can only send one version message
	if (pfrom.nVersion != 0) {
	Misbehaving(pfrom, 1, "redundant version message");
	return;
	}

	int64_t nTime;
	CAddress addrMe;
	CAddress addrFrom;
	uint64_t nNonce = 1;
	uint64_t nServiceInt;
	ServiceFlags nServices;
	int nVersion;
	std::string cleanSubVer;
	int nStartingHeight = -1;
	bool fRelay = true;
	uint64_t nExtraEntropy = 1;

	vRecv >> nVersion >> nServiceInt >> nTime >> addrMe;
	nServices = ServiceFlags(nServiceInt);
	if (!pfrom.IsInboundConn()) {
	m_connman.SetServices(pfrom.addr, nServices);
	}
	if (pfrom.ExpectServicesFromConn() &&
	!HasAllDesirableServiceFlags(nServices)) {
	LogPrint(BCLog::NET,
	"peer=%d does not offer the expected services "
	"(%08x offered, %08x expected); disconnecting\n",
	pfrom.GetId(), nServices,
	GetDesirableServiceFlags(nServices));
	pfrom.fDisconnect = true;
	return;
	}

	if (nVersion < MIN_PEER_PROTO_VERSION) {
	// disconnect from peers older than this proto version
	LogPrint(BCLog::NET,
	"peer=%d using obsolete version %i; disconnecting\n",
	pfrom.GetId(), nVersion);
	pfrom.fDisconnect = true;
	return;
	}

	if (!vRecv.empty()) {
	vRecv >> addrFrom >> nNonce;
	}
	if (!vRecv.empty()) {
	std::string strSubVer;
	vRecv >> LIMITED_STRING(strSubVer, MAX_SUBVERSION_LENGTH);
	cleanSubVer = SanitizeString(strSubVer);
	}
	if (!vRecv.empty()) {
	vRecv >> nStartingHeight;
	}
	if (!vRecv.empty()) {
	vRecv >> fRelay;
	}
	if (!vRecv.empty()) {
	vRecv >> nExtraEntropy;
	}
	// Disconnect if we connected to ourself
	if (pfrom.IsInboundConn() && !m_connman.CheckIncomingNonce(nNonce)) {
	LogPrintf("connected to self at %s, disconnecting\n",
	pfrom.addr.ToString());
	pfrom.fDisconnect = true;
	return;
	}

	if (pfrom.IsInboundConn() && addrMe.IsRoutable()) {
	SeenLocal(addrMe);
	}

	// Be shy and don't send version until we hear
	if (pfrom.IsInboundConn()) {
	PushNodeVersion(config, pfrom, m_connman, GetAdjustedTime());
	}

	// Change version
	const int greatest_common_version =
	std::min(nVersion, PROTOCOL_VERSION);
	pfrom.SetCommonVersion(greatest_common_version);
	pfrom.nVersion = nVersion;

	const CNetMsgMaker msg_maker(greatest_common_version);

	m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::VERACK));

	// Signal ADDRv2 support (BIP155).
	m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::SENDADDRV2));

	pfrom.nServices = nServices;
	pfrom.SetAddrLocal(addrMe);
	{
	LOCK(pfrom.cs_SubVer);
	pfrom.cleanSubVer = cleanSubVer;
	}
	pfrom.nStartingHeight = nStartingHeight;

	// set nodes not relaying blocks and tx and not serving (parts) of the
	// historical blockchain as "clients"
	pfrom.fClient = (!(nServices & NODE_NETWORK) &&
	!(nServices & NODE_NETWORK_LIMITED));

	// set nodes not capable of serving the complete blockchain history as
	// "limited nodes"
	pfrom.m_limited_node =
	(!(nServices & NODE_NETWORK) && (nServices & NODE_NETWORK_LIMITED));

	if (pfrom.m_tx_relay != nullptr) {
	LOCK(pfrom.m_tx_relay->cs_filter);
	// set to true after we get the first filter* message
	pfrom.m_tx_relay->fRelayTxes = fRelay;
	}

	pfrom.nRemoteHostNonce = nNonce;
	pfrom.nRemoteExtraEntropy = nExtraEntropy;

	// Potentially mark this peer as a preferred download peer.
	{
	LOCK(cs_main);
	UpdatePreferredDownload(pfrom, State(pfrom.GetId()));
	}

	if (!pfrom.IsInboundConn() && pfrom.IsAddrRelayPeer()) {
	// Advertise our address
	if (fListen && !::ChainstateActive().IsInitialBlockDownload()) {
	CAddress addr =
	GetLocalAddress(&pfrom.addr, pfrom.GetLocalServices());
	FastRandomContext insecure_rand;
	if (addr.IsRoutable()) {
	LogPrint(BCLog::NET,
	"ProcessMessages: advertising address %s\n",
	addr.ToString());
	pfrom.PushAddress(addr, insecure_rand);
	} else if (IsPeerAddrLocalGood(&pfrom)) {
	addr.SetIP(addrMe);
	LogPrint(BCLog::NET,
	"ProcessMessages: advertising address %s\n",
	addr.ToString());
	pfrom.PushAddress(addr, insecure_rand);
	}
	}

	// Get recent addresses
	m_connman.PushMessage(&pfrom, CNetMsgMaker(greatest_common_version)
	.Make(NetMsgType::GETADDR));
	pfrom.fGetAddr = true;
	m_connman.MarkAddressGood(pfrom.addr);
	}

	std::string remoteAddr;
	if (fLogIPs) {
	remoteAddr = ", peeraddr=" + pfrom.addr.ToString();
	}

	LogPrint(BCLog::NET,
	"receive version message: [%s] %s: version %d, blocks=%d, "
	"us=%s, peer=%d%s\n",
	pfrom.addr.ToString(), cleanSubVer, pfrom.nVersion,
	pfrom.nStartingHeight, addrMe.ToString(), pfrom.GetId(),
	remoteAddr);

	// Ignore time offsets that are improbable (before the Genesis block)
	// and may underflow the nTimeOffset calculation.
	int64_t currentTime = GetTime();
	if (nTime >= int64_t(m_chainparams.GenesisBlock().nTime)) {
	int64_t nTimeOffset = nTime - currentTime;
	pfrom.nTimeOffset = nTimeOffset;
	AddTimeData(pfrom.addr, nTimeOffset);
	} else {
	Misbehaving(pfrom, 20,
	"Ignoring invalid timestamp in version message");
	}

	// Feeler connections exist only to verify if address is online.
	if (pfrom.IsFeelerConn()) {
	pfrom.fDisconnect = true;
	}
	return;
	}

	if (pfrom.nVersion == 0) {
	// Must have a version message before anything else
	Misbehaving(pfrom, 10, "non-version message before version handshake");
	return;
	}

	// At this point, the outgoing message serialization version can't change.
	const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());

	if (msg_type == NetMsgType::VERACK) {
	if (!pfrom.IsInboundConn()) {
	// Mark this node as currently connected, so we update its timestamp
	// later.
	LOCK(cs_main);
	State(pfrom.GetId())->fCurrentlyConnected = true;
	LogPrintf(
	"New outbound peer connected: version: %d, blocks=%d, "
	"peer=%d%s (%s)\n",
	pfrom.nVersion.load(), pfrom.nStartingHeight, pfrom.GetId(),
	(fLogIPs ? strprintf(", peeraddr=%s", pfrom.addr.ToString())
	: ""),
	pfrom.m_tx_relay == nullptr ? "block-relay" : "full-relay");
	}

	if (pfrom.GetCommonVersion() >= SENDHEADERS_VERSION) {
	// Tell our peer we prefer to receive headers rather than inv's
	// We send this to non-NODE NETWORK peers as well, because even
	// non-NODE NETWORK peers can announce blocks (such as pruning
	// nodes)
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::SENDHEADERS));
	}

	if (pfrom.GetCommonVersion() >= SHORT_IDS_BLOCKS_VERSION) {
	// Tell our peer we are willing to provide version 1 or 2
	// cmpctblocks. However, we do not request new block announcements
	// using cmpctblock messages. We send this to non-NODE NETWORK peers
	// as well, because they may wish to request compact blocks from us.
	bool fAnnounceUsingCMPCTBLOCK = false;
	uint64_t nCMPCTBLOCKVersion = 1;
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::SENDCMPCT,
	fAnnounceUsingCMPCTBLOCK,
	nCMPCTBLOCKVersion));
	}

	if ((pfrom.nServices & NODE_AVALANCHE) && g_avalanche &&
	isAvalancheEnabled(gArgs)) {
	if (g_avalanche->sendHello(&pfrom)) {
	LogPrint(BCLog::NET, "Send avahello to peer %d\n",
	pfrom.GetId());

	auto localProof = g_avalanche->getLocalProof();
	// If we sent a hello message, we should have a proof
	assert(localProof);

	// Add our proof id to the list or the recently announced proof
	// INVs to this peer. This is used for filtering which INV can
	// be requested for download.
	LOCK(cs_main);
	State(pfrom.GetId())
	->m_recently_announced_proofs.insert(localProof->getId());
	}
	}

	pfrom.fSuccessfullyConnected = true;
	return;
	}

	if (!pfrom.fSuccessfullyConnected) {
	// Must have a verack message before anything else
	Misbehaving(pfrom, 10, "non-verack message before version handshake");
	return;
	}

	if (msg_type == NetMsgType::ADDR \|\| msg_type == NetMsgType::ADDRV2) {
	int stream_version = vRecv.GetVersion();
	if (msg_type == NetMsgType::ADDRV2) {
	// Add ADDRV2_FORMAT to the version so that the CNetAddr and
	// CAddress unserialize methods know that an address in v2 format is
	// coming.
	stream_version \|= ADDRV2_FORMAT;
	}

	OverrideStream<CDataStream> s(&vRecv, vRecv.GetType(), stream_version);
	std::vector<CAddress> vAddr;

	s >> vAddr;

	if (!pfrom.IsAddrRelayPeer()) {
	return;
	}
	if (vAddr.size() > 1000) {
	Misbehaving(
	pfrom, 20,
	strprintf("%s message size = %u", msg_type, vAddr.size()));
	return;
	}

	// Store the new addresses
	std::vector<CAddress> vAddrOk;
	int64_t nNow = GetAdjustedTime();
	int64_t nSince = nNow - 10 * 60;
	for (CAddress &addr : vAddr) {
	if (interruptMsgProc) {
	return;
	}

	// We only bother storing full nodes, though this may include things
	// which we would not make an outbound connection to, in part
	// because we may make feeler connections to them.
	if (!MayHaveUsefulAddressDB(addr.nServices) &&
	!HasAllDesirableServiceFlags(addr.nServices)) {
	continue;
	}

	if (addr.nTime <= 100000000 \|\| addr.nTime > nNow + 10 * 60) {
	addr.nTime = nNow - 5 * 24 * 60 * 60;
	}
	pfrom.AddAddressKnown(addr);
	if (m_banman &&
	(m_banman->IsDiscouraged(addr) \|\| m_banman->IsBanned(addr))) {
	// Do not process banned/discouraged addresses beyond
	// remembering we received them
	continue;
	}
	bool fReachable = IsReachable(addr);
	if (addr.nTime > nSince && !pfrom.fGetAddr && vAddr.size() <= 10 &&
	addr.IsRoutable()) {
	// Relay to a limited number of other nodes
	RelayAddress(addr, fReachable, m_connman);
	}
	// Do not store addresses outside our network
	if (fReachable) {
	vAddrOk.push_back(addr);
	}
	}

	m_connman.AddNewAddresses(vAddrOk, pfrom.addr, 2 * 60 * 60);
	if (vAddr.size() < 1000) {
	pfrom.fGetAddr = false;
	}
	if (pfrom.IsAddrFetchConn()) {
	pfrom.fDisconnect = true;
	}
	return;
	}

	if (msg_type == NetMsgType::SENDADDRV2) {
	pfrom.m_wants_addrv2 = true;
	return;
	}

	if (msg_type == NetMsgType::SENDHEADERS) {
	LOCK(cs_main);
	State(pfrom.GetId())->fPreferHeaders = true;
	return;
	}

	if (msg_type == NetMsgType::SENDCMPCT) {
	bool fAnnounceUsingCMPCTBLOCK = false;
	uint64_t nCMPCTBLOCKVersion = 0;
	vRecv >> fAnnounceUsingCMPCTBLOCK >> nCMPCTBLOCKVersion;
	if (nCMPCTBLOCKVersion == 1) {
	LOCK(cs_main);
	// fProvidesHeaderAndIDs is used to "lock in" version of compact
	// blocks we send.
	if (!State(pfrom.GetId())->fProvidesHeaderAndIDs) {
	State(pfrom.GetId())->fProvidesHeaderAndIDs = true;
	}

	State(pfrom.GetId())->fPreferHeaderAndIDs =
	fAnnounceUsingCMPCTBLOCK;
	if (!State(pfrom.GetId())->fSupportsDesiredCmpctVersion) {
	State(pfrom.GetId())->fSupportsDesiredCmpctVersion = true;
	}
	}
	return;
	}

	if (msg_type == NetMsgType::INV) {
	std::vector<CInv> vInv;
	vRecv >> vInv;
	if (vInv.size() > MAX_INV_SZ) {
	Misbehaving(pfrom, 20,
	strprintf("inv message size = %u", vInv.size()));
	return;
	}

	// We won't accept tx inv's if we're in blocks-only mode, or this is a
	// block-relay-only peer
	bool fBlocksOnly = !g_relay_txes \|\| (pfrom.m_tx_relay == nullptr);

	// Allow whitelisted peers to send data other than blocks in blocks only
	// mode if whitelistrelay is true
	if (pfrom.HasPermission(PF_RELAY)) {
	fBlocksOnly = false;
	}

	const auto current_time = GetTime<std::chrono::microseconds>();
	std::optional<BlockHash> best_block;

	auto logInv = [&](const CInv &inv, bool fAlreadyHave) {
	LogPrint(BCLog::NET, "got inv: %s %s peer=%d\n", inv.ToString(),
	fAlreadyHave ? "have" : "new", pfrom.GetId());
	};

	for (CInv &inv : vInv) {
	if (interruptMsgProc) {
	return;
	}

	if (inv.IsMsgBlk()) {
	LOCK(cs_main);
	const bool fAlreadyHave = AlreadyHaveBlock(BlockHash(inv.hash));
	logInv(inv, fAlreadyHave);

	const BlockHash hash{inv.hash};
	UpdateBlockAvailability(pfrom.GetId(), hash);
	if (!fAlreadyHave && !fImporting && !fReindex &&
	!mapBlocksInFlight.count(hash)) {
	// Headers-first is the primary method of announcement on
	// the network. If a node fell back to sending blocks by
	// inv, it's probably for a re-org. The final block hash
	// provided should be the highest, so send a getheaders and
	// then fetch the blocks we need to catch up.
	best_block = std::move(hash);
	}

	continue;
	}

	if (inv.IsMsgProof()) {
	const avalanche::ProofId proofid(inv.hash);
	const bool fAlreadyHave = AlreadyHaveProof(proofid);
	logInv(inv, fAlreadyHave);
	pfrom.AddKnownProof(proofid);

	if (!fAlreadyHave && g_avalanche && isAvalancheEnabled(gArgs)) {
	const bool preferred = isPreferredDownloadPeer(pfrom);

	LOCK(cs_proofrequest);
	AddProofAnnouncement(pfrom, proofid, current_time,
	preferred);
	}
	continue;
	}

	if (inv.IsMsgTx()) {
	LOCK(cs_main);
	const TxId txid(inv.hash);
	const bool fAlreadyHave = AlreadyHaveTx(txid, m_mempool);
	logInv(inv, fAlreadyHave);

	pfrom.AddKnownTx(txid);
	if (fBlocksOnly) {
	LogPrint(BCLog::NET,
	"transaction (%s) inv sent in violation of "
	"protocol, disconnecting peer=%d\n",
	txid.ToString(), pfrom.GetId());
	pfrom.fDisconnect = true;
	return;
	} else if (!fAlreadyHave && !m_chainman.ActiveChainstate()
	.IsInitialBlockDownload()) {
	AddTxAnnouncement(pfrom, txid, current_time);
	}

	continue;
	}

	LogPrint(BCLog::NET,
	"Unknown inv type \"%s\" received from peer=%d\n",
	inv.ToString(), pfrom.GetId());
	}

	if (best_block) {
	m_connman.PushMessage(
	&pfrom,
	msgMaker.Make(NetMsgType::GETHEADERS,
	::ChainActive().GetLocator(pindexBestHeader),
	*best_block));
	LogPrint(BCLog::NET, "getheaders (%d) %s to peer=%d\n",
	pindexBestHeader->nHeight, best_block->ToString(),
	pfrom.GetId());
	}

	return;
	}

	if (msg_type == NetMsgType::GETDATA) {
	std::vector<CInv> vInv;
	vRecv >> vInv;
	if (vInv.size() > MAX_INV_SZ) {
	Misbehaving(pfrom, 20,
	strprintf("getdata message size = %u", vInv.size()));
	return;
	}

	LogPrint(BCLog::NET, "received getdata (%u invsz) peer=%d\n",
	vInv.size(), pfrom.GetId());

	if (vInv.size() > 0) {
	LogPrint(BCLog::NET, "received getdata for: %s peer=%d\n",
	vInv[0].ToString(), pfrom.GetId());
	}

	pfrom.vRecvGetData.insert(pfrom.vRecvGetData.end(), vInv.begin(),
	vInv.end());
	ProcessGetData(config, pfrom, m_connman, m_mempool, interruptMsgProc);
	return;
	}

	if (msg_type == NetMsgType::GETBLOCKS) {
	CBlockLocator locator;
	uint256 hashStop;
	vRecv >> locator >> hashStop;

	if (locator.vHave.size() > MAX_LOCATOR_SZ) {
	LogPrint(BCLog::NET,
	"getblocks locator size %lld > %d, disconnect peer=%d\n",
	locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.GetId());
	pfrom.fDisconnect = true;
	return;
	}

	// We might have announced the currently-being-connected tip using a
	// compact block, which resulted in the peer sending a getblocks
	// request, which we would otherwise respond to without the new block.
	// To avoid this situation we simply verify that we are on our best
	// known chain now. This is super overkill, but we handle it better
	// for getheaders requests, and there are no known nodes which support
	// compact blocks but still use getblocks to request blocks.
	{
	std::shared_ptr<const CBlock> a_recent_block;
	{
	LOCK(cs_most_recent_block);
	a_recent_block = most_recent_block;
	}
	BlockValidationState state;
	if (!ActivateBestChain(config, state, a_recent_block)) {
	LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
	state.ToString());
	}
	}

	LOCK(cs_main);

	// Find the last block the caller has in the main chain
	const CBlockIndex *pindex =
	FindForkInGlobalIndex(::ChainActive(), locator);

	// Send the rest of the chain
	if (pindex) {
	pindex = ::ChainActive().Next(pindex);
	}
	int nLimit = 500;
	LogPrint(BCLog::NET, "getblocks %d to %s limit %d from peer=%d\n",
	(pindex ? pindex->nHeight : -1),
	hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit,
	pfrom.GetId());
	for (; pindex; pindex = ::ChainActive().Next(pindex)) {
	if (pindex->GetBlockHash() == hashStop) {
	LogPrint(BCLog::NET, " getblocks stopping at %d %s\n",
	pindex->nHeight, pindex->GetBlockHash().ToString());
	break;
	}
	// If pruning, don't inv blocks unless we have on disk and are
	// likely to still have for some reasonable time window (1 hour)
	// that block relay might require.
	const int nPrunedBlocksLikelyToHave =
	MIN_BLOCKS_TO_KEEP -
	3600 / m_chainparams.GetConsensus().nPowTargetSpacing;
	if (fPruneMode &&
	(!pindex->nStatus.hasData() \|\|
	pindex->nHeight <= ::ChainActive().Tip()->nHeight -
	nPrunedBlocksLikelyToHave)) {
	LogPrint(
	BCLog::NET,
	" getblocks stopping, pruned or too old block at %d %s\n",
	pindex->nHeight, pindex->GetBlockHash().ToString());
	break;
	}
	WITH_LOCK(pfrom.cs_inventory, pfrom.vInventoryBlockToSend.push_back(
	pindex->GetBlockHash()));
	if (--nLimit <= 0) {
	// When this block is requested, we'll send an inv that'll
	// trigger the peer to getblocks the next batch of inventory.
	LogPrint(BCLog::NET, " getblocks stopping at limit %d %s\n",
	pindex->nHeight, pindex->GetBlockHash().ToString());
	pfrom.hashContinue = pindex->GetBlockHash();
	break;
	}
	}
	return;
	}

	if (msg_type == NetMsgType::GETBLOCKTXN) {
	BlockTransactionsRequest req;
	vRecv >> req;

	std::shared_ptr<const CBlock> recent_block;
	{
	LOCK(cs_most_recent_block);
	if (most_recent_block_hash == req.blockhash) {
	recent_block = most_recent_block;
	}
	// Unlock cs_most_recent_block to avoid cs_main lock inversion
	}
	if (recent_block) {
	SendBlockTransactions(pfrom, *recent_block, req);
	return;
	}

	LOCK(cs_main);

	const CBlockIndex *pindex = LookupBlockIndex(req.blockhash);
	if (!pindex \|\| !pindex->nStatus.hasData()) {
	LogPrint(
	BCLog::NET,
	"Peer %d sent us a getblocktxn for a block we don't have\n",
	pfrom.GetId());
	return;
	}

	if (pindex->nHeight < ::ChainActive().Height() - MAX_BLOCKTXN_DEPTH) {
	// If an older block is requested (should never happen in practice,
	// but can happen in tests) send a block response instead of a
	// blocktxn response. Sending a full block response instead of a
	// small blocktxn response is preferable in the case where a peer
	// might maliciously send lots of getblocktxn requests to trigger
	// expensive disk reads, because it will require the peer to
	// actually receive all the data read from disk over the network.
	LogPrint(BCLog::NET,
	"Peer %d sent us a getblocktxn for a block > %i deep\n",
	pfrom.GetId(), MAX_BLOCKTXN_DEPTH);
	CInv inv;
	inv.type = MSG_BLOCK;
	inv.hash = req.blockhash;
	pfrom.vRecvGetData.push_back(inv);
	// The message processing loop will go around again (without
	// pausing) and we'll respond then (without cs_main)
	return;
	}

	CBlock block;
	bool ret =
	ReadBlockFromDisk(block, pindex, m_chainparams.GetConsensus());
	assert(ret);

	SendBlockTransactions(pfrom, block, req);
	return;
	}

	if (msg_type == NetMsgType::GETHEADERS) {
	CBlockLocator locator;
	BlockHash hashStop;
	vRecv >> locator >> hashStop;

	if (locator.vHave.size() > MAX_LOCATOR_SZ) {
	LogPrint(BCLog::NET,
	"getheaders locator size %lld > %d, disconnect peer=%d\n",
	locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.GetId());
	pfrom.fDisconnect = true;
	return;
	}

	LOCK(cs_main);
	if (::ChainstateActive().IsInitialBlockDownload() &&
	!pfrom.HasPermission(PF_DOWNLOAD)) {
	LogPrint(BCLog::NET,
	"Ignoring getheaders from peer=%d because node is in "
	"initial block download\n",
	pfrom.GetId());
	return;
	}

	CNodeState *nodestate = State(pfrom.GetId());
	const CBlockIndex *pindex = nullptr;
	if (locator.IsNull()) {
	// If locator is null, return the hashStop block
	pindex = LookupBlockIndex(hashStop);
	if (!pindex) {
	return;
	}

	if (!BlockRequestAllowed(pindex, m_chainparams.GetConsensus())) {
	LogPrint(BCLog::NET,
	"%s: ignoring request from peer=%i for old block "
	"header that isn't in the main chain\n",
	__func__, pfrom.GetId());
	return;
	}
	} else {
	// Find the last block the caller has in the main chain
	pindex = FindForkInGlobalIndex(::ChainActive(), locator);
	if (pindex) {
	pindex = ::ChainActive().Next(pindex);
	}
	}

	// we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx
	// count at the end
	std::vector<CBlock> vHeaders;
	int nLimit = MAX_HEADERS_RESULTS;
	LogPrint(BCLog::NET, "getheaders %d to %s from peer=%d\n",
	(pindex ? pindex->nHeight : -1),
	hashStop.IsNull() ? "end" : hashStop.ToString(),
	pfrom.GetId());
	for (; pindex; pindex = ::ChainActive().Next(pindex)) {
	vHeaders.push_back(pindex->GetBlockHeader());
	if (--nLimit <= 0 \|\| pindex->GetBlockHash() == hashStop) {
	break;
	}
	}
	// pindex can be nullptr either if we sent ::ChainActive().Tip() OR
	// if our peer has ::ChainActive().Tip() (and thus we are sending an
	// empty headers message). In both cases it's safe to update
	// pindexBestHeaderSent to be our tip.
	//
	// It is important that we simply reset the BestHeaderSent value here,
	// and not max(BestHeaderSent, newHeaderSent). We might have announced
	// the currently-being-connected tip using a compact block, which
	// resulted in the peer sending a headers request, which we respond to
	// without the new block. By resetting the BestHeaderSent, we ensure we
	// will re-announce the new block via headers (or compact blocks again)
	// in the SendMessages logic.
	nodestate->pindexBestHeaderSent =
	pindex ? pindex : ::ChainActive().Tip();
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::HEADERS, vHeaders));
	return;
	}

	if (msg_type == NetMsgType::TX) {
	// Stop processing the transaction early if
	// 1) We are in blocks only mode and peer has no relay permission
	// 2) This peer is a block-relay-only peer
	if ((!g_relay_txes && !pfrom.HasPermission(PF_RELAY)) \|\|
	(pfrom.m_tx_relay == nullptr)) {
	LogPrint(BCLog::NET,
	"transaction sent in violation of protocol peer=%d\n",
	pfrom.GetId());
	pfrom.fDisconnect = true;
	return;
	}

	CTransactionRef ptx;
	vRecv >> ptx;
	const CTransaction &tx = *ptx;
	const TxId &txid = tx.GetId();
	pfrom.AddKnownTx(txid);

	LOCK2(cs_main, g_cs_orphans);

	TxValidationState state;

	m_txrequest.ReceivedResponse(pfrom.GetId(), txid);

	if (!AlreadyHaveTx(txid, m_mempool) &&
	AcceptToMemoryPool(config, m_mempool, state, ptx,
	false /* bypass_limits */,
	Amount::zero() /* nAbsurdFee */)) {
	m_mempool.check(&::ChainstateActive().CoinsTip());
	// As this version of the transaction was acceptable, we can forget
	// about any requests for it.
	m_txrequest.ForgetInvId(tx.GetId());
	RelayTransaction(tx.GetId(), m_connman);
	for (size_t i = 0; i < tx.vout.size(); i++) {
	auto it_by_prev =
	mapOrphanTransactionsByPrev.find(COutPoint(txid, i));
	if (it_by_prev != mapOrphanTransactionsByPrev.end()) {
	for (const auto &elem : it_by_prev->second) {
	pfrom.orphan_work_set.insert(elem->first);
	}
	}
	}

	pfrom.nLastTXTime = GetTime();

	LogPrint(BCLog::MEMPOOL,
	"AcceptToMemoryPool: peer=%d: accepted %s "
	"(poolsz %u txn, %u kB)\n",
	pfrom.GetId(), tx.GetId().ToString(), m_mempool.size(),
	m_mempool.DynamicMemoryUsage() / 1000);

	// Recursively process any orphan transactions that depended on this
	// one
	ProcessOrphanTx(config, pfrom.orphan_work_set);
	} else if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
	// It may be the case that the orphans parents have all been
	// rejected.
	bool fRejectedParents = false;
	for (const CTxIn &txin : tx.vin) {
	if (recentRejects->contains(txin.prevout.GetTxId())) {
	fRejectedParents = true;
	break;
	}
	}
	if (!fRejectedParents) {
	const auto current_time = GetTime<std::chrono::microseconds>();

	for (const CTxIn &txin : tx.vin) {
	// FIXME: MSG_TX should use a TxHash, not a TxId.
	const TxId _txid = txin.prevout.GetTxId();
	pfrom.AddKnownTx(_txid);
	if (!AlreadyHaveTx(_txid, m_mempool)) {
	AddTxAnnouncement(pfrom, _txid, current_time);
	}
	}
	AddOrphanTx(ptx, pfrom.GetId());

	// Once added to the orphan pool, a tx is considered
	// AlreadyHave, and we shouldn't request it anymore.
	m_txrequest.ForgetInvId(tx.GetId());

	// DoS prevention: do not allow mapOrphanTransactions to grow
	// unbounded (see CVE-2012-3789)
	unsigned int nMaxOrphanTx = (unsigned int)std::max(
	int64_t(0), gArgs.GetArg("-maxorphantx",
	DEFAULT_MAX_ORPHAN_TRANSACTIONS));
	unsigned int nEvicted = LimitOrphanTxSize(nMaxOrphanTx);
	if (nEvicted > 0) {
	LogPrint(BCLog::MEMPOOL,
	"mapOrphan overflow, removed %u tx\n", nEvicted);
	}
	} else {
	LogPrint(BCLog::MEMPOOL,
	"not keeping orphan with rejected parents %s\n",
	tx.GetId().ToString());
	// We will continue to reject this tx since it has rejected
	// parents so avoid re-requesting it from other peers.
	recentRejects->insert(tx.GetId());
	m_txrequest.ForgetInvId(tx.GetId());
	}
	} else {
	assert(recentRejects);
	recentRejects->insert(tx.GetId());
	m_txrequest.ForgetInvId(tx.GetId());

	if (RecursiveDynamicUsage(*ptx) < 100000) {
	AddToCompactExtraTransactions(ptx);
	}

	if (pfrom.HasPermission(PF_FORCERELAY)) {
	// Always relay transactions received from whitelisted peers,
	// even if they were already in the mempool or rejected from it
	// due to policy, allowing the node to function as a gateway for
	// nodes hidden behind it.
	//
	// Never relay transactions that might result in being
	// disconnected (or banned).
	if (state.IsInvalid() && TxRelayMayResultInDisconnect(state)) {
	LogPrintf("Not relaying invalid transaction %s from "
	"whitelisted peer=%d (%s)\n",
	tx.GetId().ToString(), pfrom.GetId(),
	state.ToString());
	} else {
	LogPrintf("Force relaying tx %s from whitelisted peer=%d\n",
	tx.GetId().ToString(), pfrom.GetId());
	RelayTransaction(tx.GetId(), m_connman);
	}
	}
	}

	// If a tx has been detected by recentRejects, we will have reached
	// this point and the tx will have been ignored. Because we haven't run
	// the tx through AcceptToMemoryPool, we won't have computed a DoS
	// score for it or determined exactly why we consider it invalid.
	//
	// This means we won't penalize any peer subsequently relaying a DoSy
	// tx (even if we penalized the first peer who gave it to us) because
	// we have to account for recentRejects showing false positives. In
	// other words, we shouldn't penalize a peer if we aren't sure they
	// submitted a DoSy tx.
	//
	// Note that recentRejects doesn't just record DoSy or invalid
	// transactions, but any tx not accepted by the mempool, which may be
	// due to node policy (vs. consensus). So we can't blanket penalize a
	// peer simply for relaying a tx that our recentRejects has caught,
	// regardless of false positives.

	if (state.IsInvalid()) {
	LogPrint(BCLog::MEMPOOLREJ,
	"%s from peer=%d was not accepted: %s\n",
	tx.GetHash().ToString(), pfrom.GetId(), state.ToString());
	MaybePunishNodeForTx(pfrom.GetId(), state);
	}
	return;
	}

	if (msg_type == NetMsgType::CMPCTBLOCK) {
	// Ignore cmpctblock received while importing
	if (fImporting \|\| fReindex) {
	LogPrint(BCLog::NET,
	"Unexpected cmpctblock message received from peer %d\n",
	pfrom.GetId());
	return;
	}

	CBlockHeaderAndShortTxIDs cmpctblock;
	vRecv >> cmpctblock;

	bool received_new_header = false;

	{
	LOCK(cs_main);

	if (!LookupBlockIndex(cmpctblock.header.hashPrevBlock)) {
	// Doesn't connect (or is genesis), instead of DoSing in
	// AcceptBlockHeader, request deeper headers
	if (!::ChainstateActive().IsInitialBlockDownload()) {
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETHEADERS,
	::ChainActive().GetLocator(
	pindexBestHeader),
	uint256()));
	}
	return;
	}

	if (!LookupBlockIndex(cmpctblock.header.GetHash())) {
	received_new_header = true;
	}
	}

	const CBlockIndex *pindex = nullptr;
	BlockValidationState state;
	if (!m_chainman.ProcessNewBlockHeaders(config, {cmpctblock.header},
	state, &pindex)) {
	if (state.IsInvalid()) {
	MaybePunishNodeForBlock(pfrom.GetId(), state,
	/via_compact_block/ true,
	"invalid header via cmpctblock");
	return;
	}
	}

	// When we succeed in decoding a block's txids from a cmpctblock
	// message we typically jump to the BLOCKTXN handling code, with a
	// dummy (empty) BLOCKTXN message, to re-use the logic there in
	// completing processing of the putative block (without cs_main).
	bool fProcessBLOCKTXN = false;
	CDataStream blockTxnMsg(SER_NETWORK, PROTOCOL_VERSION);

	// If we end up treating this as a plain headers message, call that as
	// well
	// without cs_main.
	bool fRevertToHeaderProcessing = false;

	// Keep a CBlock for "optimistic" compactblock reconstructions (see
	// below)
	std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
	bool fBlockReconstructed = false;

	{
	LOCK2(cs_main, g_cs_orphans);
	// If AcceptBlockHeader returned true, it set pindex
	assert(pindex);
	UpdateBlockAvailability(pfrom.GetId(), pindex->GetBlockHash());

	CNodeState *nodestate = State(pfrom.GetId());

	// If this was a new header with more work than our tip, update the
	// peer's last block announcement time
	if (received_new_header &&
	pindex->nChainWork > ::ChainActive().Tip()->nChainWork) {
	nodestate->m_last_block_announcement = GetTime();
	}

	std::map<BlockHash,
	std::pair<NodeId, std::list<QueuedBlock>::iterator>>::
	iterator blockInFlightIt =
	mapBlocksInFlight.find(pindex->GetBlockHash());
	bool fAlreadyInFlight = blockInFlightIt != mapBlocksInFlight.end();

	if (pindex->nStatus.hasData()) {
	// Nothing to do here
	return;
	}

	if (pindex->nChainWork <=
	::ChainActive()
	.Tip()
	->nChainWork \|\| // We know something better
	pindex->nTx != 0) {
	// We had this block at some point, but pruned it
	if (fAlreadyInFlight) {
	// We requested this block for some reason, but our mempool
	// will probably be useless so we just grab the block via
	// normal getdata.
	std::vector<CInv> vInv(1);
	vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash());
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv));
	}
	return;
	}

	// If we're not close to tip yet, give up and let parallel block
	// fetch work its magic.
	if (!fAlreadyInFlight &&
	!CanDirectFetch(m_chainparams.GetConsensus())) {
	return;
	}

	// We want to be a bit conservative just to be extra careful about
	// DoS possibilities in compact block processing...
	if (pindex->nHeight <= ::ChainActive().Height() + 2) {
	if ((!fAlreadyInFlight && nodestate->nBlocksInFlight <
	MAX_BLOCKS_IN_TRANSIT_PER_PEER) \|\|
	(fAlreadyInFlight &&
	blockInFlightIt->second.first == pfrom.GetId())) {
	std::list<QueuedBlock>::iterator *queuedBlockIt = nullptr;
	if (!MarkBlockAsInFlight(config, m_mempool, pfrom.GetId(),
	pindex->GetBlockHash(),
	m_chainparams.GetConsensus(),
	pindex, &queuedBlockIt)) {
	if (!(*queuedBlockIt)->partialBlock) {
	(*queuedBlockIt)
	->partialBlock.reset(
	new PartiallyDownloadedBlock(config,
	&m_mempool));
	} else {
	// The block was already in flight using compact
	// blocks from the same peer.
	LogPrint(BCLog::NET, "Peer sent us compact block "
	"we were already syncing!\n");
	return;
	}
	}

	PartiallyDownloadedBlock &partialBlock =
	(queuedBlockIt)->partialBlock;
	ReadStatus status =
	partialBlock.InitData(cmpctblock, vExtraTxnForCompact);
	if (status == READ_STATUS_INVALID) {
	// Reset in-flight state in case of whitelist
	MarkBlockAsReceived(pindex->GetBlockHash());
	Misbehaving(pfrom, 100, "invalid compact block");
	return;
	} else if (status == READ_STATUS_FAILED) {
	// Duplicate txindices, the block is now in-flight, so
	// just request it.
	std::vector<CInv> vInv(1);
	vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash());
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv));
	return;
	}

	BlockTransactionsRequest req;
	for (size_t i = 0; i < cmpctblock.BlockTxCount(); i++) {
	if (!partialBlock.IsTxAvailable(i)) {
	req.indices.push_back(i);
	}
	}
	if (req.indices.empty()) {
	// Dirty hack to jump to BLOCKTXN code (TODO: move
	// message handling into their own functions)
	BlockTransactions txn;
	txn.blockhash = cmpctblock.header.GetHash();
	blockTxnMsg << txn;
	fProcessBLOCKTXN = true;
	} else {
	req.blockhash = pindex->GetBlockHash();
	m_connman.PushMessage(
	&pfrom,
	msgMaker.Make(NetMsgType::GETBLOCKTXN, req));
	}
	} else {
	// This block is either already in flight from a different
	// peer, or this peer has too many blocks outstanding to
	// download from. Optimistically try to reconstruct anyway
	// since we might be able to without any round trips.
	PartiallyDownloadedBlock tempBlock(config, &m_mempool);
	ReadStatus status =
	tempBlock.InitData(cmpctblock, vExtraTxnForCompact);
	if (status != READ_STATUS_OK) {
	// TODO: don't ignore failures
	return;
	}
	std::vector<CTransactionRef> dummy;
	status = tempBlock.FillBlock(*pblock, dummy);
	if (status == READ_STATUS_OK) {
	fBlockReconstructed = true;
	}
	}
	} else {
	if (fAlreadyInFlight) {
	// We requested this block, but its far into the future, so
	// our mempool will probably be useless - request the block
	// normally.
	std::vector<CInv> vInv(1);
	vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash());
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv));
	return;
	} else {
	// If this was an announce-cmpctblock, we want the same
	// treatment as a header message.
	fRevertToHeaderProcessing = true;
	}
	}
	} // cs_main

	if (fProcessBLOCKTXN) {
	return ProcessMessage(config, pfrom, NetMsgType::BLOCKTXN,
	blockTxnMsg, time_received, interruptMsgProc);
	}

	if (fRevertToHeaderProcessing) {
	// Headers received from HB compact block peers are permitted to be
	// relayed before full validation (see BIP 152), so we don't want to
	// disconnect the peer if the header turns out to be for an invalid
	// block. Note that if a peer tries to build on an invalid chain,
	// that will be detected and the peer will be banned.
	return ProcessHeadersMessage(config, pfrom, {cmpctblock.header},
	/via_compact_block=/true);
	}

	if (fBlockReconstructed) {
	// If we got here, we were able to optimistically reconstruct a
	// block that is in flight from some other peer.
	{
	LOCK(cs_main);
	mapBlockSource.emplace(pblock->GetHash(),
	std::make_pair(pfrom.GetId(), false));
	}
	bool fNewBlock = false;
	// Setting fForceProcessing to true means that we bypass some of
	// our anti-DoS protections in AcceptBlock, which filters
	// unrequested blocks that might be trying to waste our resources
	// (eg disk space). Because we only try to reconstruct blocks when
	// we're close to caught up (via the CanDirectFetch() requirement
	// above, combined with the behavior of not requesting blocks until
	// we have a chain with at least nMinimumChainWork), and we ignore
	// compact blocks with less work than our tip, it is safe to treat
	// reconstructed compact blocks as having been requested.
	m_chainman.ProcessNewBlock(config, pblock,
	/fForceProcessing=/true, &fNewBlock);
	if (fNewBlock) {
	pfrom.nLastBlockTime = GetTime();
	} else {
	LOCK(cs_main);
	mapBlockSource.erase(pblock->GetHash());
	}

	// hold cs_main for CBlockIndex::IsValid()
	LOCK(cs_main);
	if (pindex->IsValid(BlockValidity::TRANSACTIONS)) {
	// Clear download state for this block, which is in process from
	// some other peer. We do this after calling. ProcessNewBlock so
	// that a malleated cmpctblock announcement can't be used to
	// interfere with block relay.
	MarkBlockAsReceived(pblock->GetHash());
	}
	}
	return;
	}

	if (msg_type == NetMsgType::BLOCKTXN) {
	// Ignore blocktxn received while importing
	if (fImporting \|\| fReindex) {
	LogPrint(BCLog::NET,
	"Unexpected blocktxn message received from peer %d\n",
	pfrom.GetId());
	return;
	}

	BlockTransactions resp;
	vRecv >> resp;

	std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
	bool fBlockRead = false;
	{
	LOCK(cs_main);

	std::map<BlockHash,
	std::pair<NodeId, std::list<QueuedBlock>::iterator>>::
	iterator it = mapBlocksInFlight.find(resp.blockhash);
	if (it == mapBlocksInFlight.end() \|\|
	!it->second.second->partialBlock \|\|
	it->second.first != pfrom.GetId()) {
	LogPrint(BCLog::NET,
	"Peer %d sent us block transactions for block "
	"we weren't expecting\n",
	pfrom.GetId());
	return;
	}

	PartiallyDownloadedBlock &partialBlock =
	*it->second.second->partialBlock;
	ReadStatus status = partialBlock.FillBlock(*pblock, resp.txn);
	if (status == READ_STATUS_INVALID) {
	// Reset in-flight state in case of whitelist.
	MarkBlockAsReceived(resp.blockhash);
	Misbehaving(
	pfrom, 100,
	"invalid compact block/non-matching block transactions");
	return;
	} else if (status == READ_STATUS_FAILED) {
	// Might have collided, fall back to getdata now :(
	std::vector<CInv> invs;
	invs.push_back(CInv(MSG_BLOCK, resp.blockhash));
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::GETDATA, invs));
	} else {
	// Block is either okay, or possibly we received
	// READ_STATUS_CHECKBLOCK_FAILED.
	// Note that CheckBlock can only fail for one of a few reasons:
	// 1. bad-proof-of-work (impossible here, because we've already
	// accepted the header)
	// 2. merkleroot doesn't match the transactions given (already
	// caught in FillBlock with READ_STATUS_FAILED, so
	// impossible here)
	// 3. the block is otherwise invalid (eg invalid coinbase,
	// block is too big, too many legacy sigops, etc).
	// So if CheckBlock failed, #3 is the only possibility.
	// Under BIP 152, we don't DoS-ban unless proof of work is
	// invalid (we don't require all the stateless checks to have
	// been run). This is handled below, so just treat this as
	// though the block was successfully read, and rely on the
	// handling in ProcessNewBlock to ensure the block index is
	// updated, etc.

	// it is now an empty pointer
	MarkBlockAsReceived(resp.blockhash);
	fBlockRead = true;
	// mapBlockSource is used for potentially punishing peers and
	// updating which peers send us compact blocks, so the race
	// between here and cs_main in ProcessNewBlock is fine.
	// BIP 152 permits peers to relay compact blocks after
	// validating the header only; we should not punish peers
	// if the block turns out to be invalid.
	mapBlockSource.emplace(resp.blockhash,
	std::make_pair(pfrom.GetId(), false));
	}
	} // Don't hold cs_main when we call into ProcessNewBlock
	if (fBlockRead) {
	bool fNewBlock = false;
	// Since we requested this block (it was in mapBlocksInFlight),
	// force it to be processed, even if it would not be a candidate for
	// new tip (missing previous block, chain not long enough, etc)
	// This bypasses some anti-DoS logic in AcceptBlock (eg to prevent
	// disk-space attacks), but this should be safe due to the
	// protections in the compact block handler -- see related comment
	// in compact block optimistic reconstruction handling.
	m_chainman.ProcessNewBlock(config, pblock,
	/fForceProcessing=/true, &fNewBlock);
	if (fNewBlock) {
	pfrom.nLastBlockTime = GetTime();
	} else {
	LOCK(cs_main);
	mapBlockSource.erase(pblock->GetHash());
	}
	}
	return;
	}

	if (msg_type == NetMsgType::HEADERS) {
	// Ignore headers received while importing
	if (fImporting \|\| fReindex) {
	LogPrint(BCLog::NET,
	"Unexpected headers message received from peer %d\n",
	pfrom.GetId());
	return;
	}

	std::vector<CBlockHeader> headers;

	// Bypass the normal CBlock deserialization, as we don't want to risk
	// deserializing 2000 full blocks.
	unsigned int nCount = ReadCompactSize(vRecv);
	if (nCount > MAX_HEADERS_RESULTS) {
	Misbehaving(pfrom, 20,
	strprintf("too-many-headers: headers message size = %u",
	nCount));
	return;
	}
	headers.resize(nCount);
	for (unsigned int n = 0; n < nCount; n++) {
	vRecv >> headers[n];
	// Ignore tx count; assume it is 0.
	ReadCompactSize(vRecv);
	}

	return ProcessHeadersMessage(config, pfrom, headers,
	/via_compact_block=/false);
	}

	if (msg_type == NetMsgType::BLOCK) {
	// Ignore block received while importing
	if (fImporting \|\| fReindex) {
	LogPrint(BCLog::NET,
	"Unexpected block message received from peer %d\n",
	pfrom.GetId());
	return;
	}

	std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
	vRecv >> *pblock;

	LogPrint(BCLog::NET, "received block %s peer=%d\n",
	pblock->GetHash().ToString(), pfrom.GetId());

	// Process all blocks from whitelisted peers, even if not requested,
	// unless we're still syncing with the network. Such an unrequested
	// block may still be processed, subject to the conditions in
	// AcceptBlock().
	bool forceProcessing = pfrom.HasPermission(PF_NOBAN) &&
	!::ChainstateActive().IsInitialBlockDownload();
	const BlockHash hash = pblock->GetHash();
	{
	LOCK(cs_main);
	// Also always process if we requested the block explicitly, as we
	// may need it even though it is not a candidate for a new best tip.
	forceProcessing \|= MarkBlockAsReceived(hash);
	// mapBlockSource is only used for punishing peers and setting
	// which peers send us compact blocks, so the race between here and
	// cs_main in ProcessNewBlock is fine.
	mapBlockSource.emplace(hash, std::make_pair(pfrom.GetId(), true));
	}
	bool fNewBlock = false;
	m_chainman.ProcessNewBlock(config, pblock, forceProcessing, &fNewBlock);
	if (fNewBlock) {
	pfrom.nLastBlockTime = GetTime();
	} else {
	LOCK(cs_main);
	mapBlockSource.erase(hash);
	}
	return;
	}

	if (msg_type == NetMsgType::AVAHELLO) {
	if (!pfrom.m_avalanche_state) {
	pfrom.m_avalanche_state = std::make_unique<CNode::AvalancheState>();
	}

	CHashVerifier<CDataStream> verifier(&vRecv);
	avalanche::Delegation delegation;
	verifier >> delegation;

	avalanche::DelegationState state;
	CPubKey &pubkey = pfrom.m_avalanche_state->pubkey;
	if (!delegation.verify(state, pubkey)) {
	Misbehaving(pfrom, 100, "invalid-delegation");
	return;
	}

	CHashWriter sighasher(SER_GETHASH, 0);
	sighasher << delegation.getId();
	sighasher << pfrom.nRemoteHostNonce;
	sighasher << pfrom.GetLocalNonce();
	sighasher << pfrom.nRemoteExtraEntropy;
	sighasher << pfrom.GetLocalExtraEntropy();

	SchnorrSig sig;
	verifier >> sig;
	if (!pubkey.VerifySchnorr(sighasher.GetHash(), sig)) {
	Misbehaving(pfrom, 100, "invalid-avahello-signature");
	return;
	}

	// If we don't know this proof already, add it to the tracker so it can
	// be requested.
	const avalanche::ProofId proofid(delegation.getProofId());
	if (!AlreadyHaveProof(proofid)) {
	const bool preferred = isPreferredDownloadPeer(pfrom);
	LOCK(cs_proofrequest);
	AddProofAnnouncement(pfrom, proofid,
	GetTime<std::chrono::microseconds>(),
	preferred);
	}

	return;
	}

	if (msg_type == NetMsgType::AVAPOLL) {
	auto now = std::chrono::steady_clock::now();
	int64_t cooldown =
	gArgs.GetArg("-avacooldown", AVALANCHE_DEFAULT_COOLDOWN);

	{
	LOCK(cs_main);
	auto &node_state = State(pfrom.GetId())->m_avalanche_state;

	if (now <
	node_state.last_poll + std::chrono::milliseconds(cooldown)) {
	Misbehaving(pfrom, 20, "avapool-cooldown");
	}

	node_state.last_poll = now;
	}

	uint64_t round;
	Unserialize(vRecv, round);

	unsigned int nCount = ReadCompactSize(vRecv);
	if (nCount > AVALANCHE_MAX_ELEMENT_POLL) {
	Misbehaving(
	pfrom, 20,
	strprintf("too-many-ava-poll: poll message size = %u", nCount));
	return;
	}

	std::vector<avalanche::Vote> votes;
	votes.reserve(nCount);

	LogPrint(BCLog::NET, "received avalanche poll from peer=%d\n",
	pfrom.GetId());

	{
	LOCK(cs_main);

	for (unsigned int n = 0; n < nCount; n++) {
	CInv inv;
	vRecv >> inv;

	const auto insertVote = [&](uint32_t e) {
	votes.emplace_back(e, inv.hash);
	};

	// Not a block.
	if (inv.type != MSG_BLOCK) {
	insertVote(-1);
	continue;
	}

	// We have a block.
	const CBlockIndex *pindex =
	LookupBlockIndex(BlockHash(inv.hash));

	// Unknown block.
	if (!pindex) {
	insertVote(-1);
	continue;
	}

	// Invalid block
	if (pindex->nStatus.isInvalid()) {
	insertVote(1);
	continue;
	}

	// Parked block
	if (pindex->nStatus.isOnParkedChain()) {
	insertVote(2);
	continue;
	}

	const CBlockIndex *pindexTip = ::ChainActive().Tip();
	const CBlockIndex *pindexFork =
	LastCommonAncestor(pindex, pindexTip);

	// Active block.
	if (pindex == pindexFork) {
	insertVote(0);
	continue;
	}

	// Fork block.
	if (pindexFork != pindexTip) {
	insertVote(3);
	continue;
	}

	// Missing block data.
	if (!pindex->nStatus.hasData()) {
	insertVote(-2);
	continue;
	}

	// This block is built on top of the tip, we have the data, it
	// is pending connection or rejection.
	insertVote(-3);
	}
	}

	// Send the query to the node.
	g_avalanche->sendResponse(
	&pfrom, avalanche::Response(round, cooldown, std::move(votes)));
	return;
	}

	if (msg_type == NetMsgType::AVARESPONSE) {
	// As long as QUIC is not implemented, we need to sign response and
	// verify response's signatures in order to avoid any manipulation of
	// messages at the transport level.
	CHashVerifier<CDataStream> verifier(&vRecv);
	avalanche::Response response;
	verifier >> response;

	SchnorrSig sig;
	vRecv >> sig;
	if (!pfrom.m_avalanche_state \|\|
	!pfrom.m_avalanche_state->pubkey.VerifySchnorr(verifier.GetHash(),
	sig)) {
	Misbehaving(pfrom, 100, "invalid-ava-response-signature");
	return;
	}

	std::vector<avalanche::BlockUpdate> updates;
	if (!g_avalanche->registerVotes(pfrom.GetId(), response, updates)) {
	return;
	}

	if (updates.size()) {
	for (avalanche::BlockUpdate &u : updates) {
	CBlockIndex *pindex = u.getBlockIndex();
	switch (u.getStatus()) {
	case avalanche::BlockUpdate::Status::Invalid:
	case avalanche::BlockUpdate::Status::Rejected: {
	LogPrintf("Avalanche rejected %s, parking\n",
	pindex->GetBlockHash().GetHex());
	BlockValidationState state;
	::ChainstateActive().ParkBlock(config, state, pindex);
	if (!state.IsValid()) {
	LogPrintf("ERROR: Database error: %s\n",
	state.GetRejectReason());
	return;
	}
	} break;
	case avalanche::BlockUpdate::Status::Accepted:
	case avalanche::BlockUpdate::Status::Finalized: {
	LogPrintf("Avalanche accepted %s\n",
	pindex->GetBlockHash().GetHex());
	LOCK(cs_main);
	UnparkBlock(pindex);
	} break;
	}
	}

	BlockValidationState state;
	if (!ActivateBestChain(config, state)) {
	LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
	state.ToString());
	}
	}

	return;
	}

	if (msg_type == NetMsgType::AVAPROOF) {
	auto proof = std::make_shared<avalanche::Proof>();
	vRecv >> *proof;
	const avalanche::ProofId &proofid = proof->getId();

	pfrom.AddKnownProof(proofid);

	const NodeId nodeid = pfrom.GetId();

	{
	LOCK(cs_proofrequest);
	m_proofrequest.ReceivedResponse(nodeid, proofid);

	if (AlreadyHaveProof(proofid)) {
	m_proofrequest.ForgetInvId(proofid);
	return;
	}
	}

	// addProof should not be called while cs_proofrequest because it holds
	// cs_main and that creates a potential deadlock during shutdown
	if (g_avalanche->addProof(proof)) {
	WITH_LOCK(cs_proofrequest, m_proofrequest.ForgetInvId(proofid));
	RelayProof(proofid, m_connman);

	LogPrint(BCLog::NET, "New avalanche proof: peer=%d, proofid %s\n",
	nodeid, proofid.ToString());
	} else {
	// If the proof couldn't be added, it can be either orphan or
	// invalid. In the latter case we should increase the ban score.
	// TODO improve the ban reason by printing the validation state
	if (!g_avalanche->getOrphan(proofid)) {
	WITH_LOCK(cs_rejectedProofs, rejectedProofs->insert(proofid));
	Misbehaving(nodeid, 100, "invalid-avaproof");
	}
	}

	return;
	}

	if (msg_type == NetMsgType::GETADDR) {
	// This asymmetric behavior for inbound and outbound connections was
	// introduced to prevent a fingerprinting attack: an attacker can send
	// specific fake addresses to users' AddrMan and later request them by
	// sending getaddr messages. Making nodes which are behind NAT and can
	// only make outgoing connections ignore the getaddr message mitigates
	// the attack.
	if (!pfrom.IsInboundConn()) {
	LogPrint(BCLog::NET,
	"Ignoring \"getaddr\" from outbound connection. peer=%d\n",
	pfrom.GetId());
	return;
	}
	if (!pfrom.IsAddrRelayPeer()) {
	LogPrint(BCLog::NET,
	"Ignoring \"getaddr\" from block-relay-only connection. "
	"peer=%d\n",
	pfrom.GetId());
	return;
	}

	// Only send one GetAddr response per connection to reduce resource
	// waste and discourage addr stamping of INV announcements.
	if (pfrom.fSentAddr) {
	LogPrint(BCLog::NET, "Ignoring repeated \"getaddr\". peer=%d\n",
	pfrom.GetId());
	return;
	}
	pfrom.fSentAddr = true;

	pfrom.vAddrToSend.clear();
	std::vector<CAddress> vAddr = m_connman.GetAddresses();
	FastRandomContext insecure_rand;
	for (const CAddress &addr : vAddr) {
	bool banned_or_discouraged =
	m_banman &&
	(m_banman->IsDiscouraged(addr) \|\| m_banman->IsBanned(addr));
	if (!banned_or_discouraged) {
	pfrom.PushAddress(addr, insecure_rand);
	}
	}
	return;
	}

	if (msg_type == NetMsgType::MEMPOOL) {
	if (!(pfrom.GetLocalServices() & NODE_BLOOM) &&
	!pfrom.HasPermission(PF_MEMPOOL)) {
	if (!pfrom.HasPermission(PF_NOBAN)) {
	LogPrint(BCLog::NET,
	"mempool request with bloom filters disabled, "
	"disconnect peer=%d\n",
	pfrom.GetId());
	pfrom.fDisconnect = true;
	}
	return;
	}

	if (m_connman.OutboundTargetReached(false) &&
	!pfrom.HasPermission(PF_MEMPOOL)) {
	if (!pfrom.HasPermission(PF_NOBAN)) {
	LogPrint(BCLog::NET,
	"mempool request with bandwidth limit reached, "
	"disconnect peer=%d\n",
	pfrom.GetId());
	pfrom.fDisconnect = true;
	}
	return;
	}

	if (pfrom.m_tx_relay != nullptr) {
	LOCK(pfrom.m_tx_relay->cs_tx_inventory);
	pfrom.m_tx_relay->fSendMempool = true;
	}
	return;
	}

	if (msg_type == NetMsgType::PING) {
	if (pfrom.GetCommonVersion() > BIP0031_VERSION) {
	uint64_t nonce = 0;
	vRecv >> nonce;
	// Echo the message back with the nonce. This allows for two useful
	// features:
	//
	// 1) A remote node can quickly check if the connection is
	// operational.
	// 2) Remote nodes can measure the latency of the network thread. If
	// this node is overloaded it won't respond to pings quickly and the
	// remote node can avoid sending us more work, like chain download
	// requests.
	//
	// The nonce stops the remote getting confused between different
	// pings: without it, if the remote node sends a ping once per
	// second and this node takes 5 seconds to respond to each, the 5th
	// ping the remote sends would appear to return very quickly.
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::PONG, nonce));
	}
	return;
	}

	if (msg_type == NetMsgType::PONG) {
	const auto ping_end = time_received;
	uint64_t nonce = 0;
	size_t nAvail = vRecv.in_avail();
	bool bPingFinished = false;
	std::string sProblem;

	if (nAvail >= sizeof(nonce)) {
	vRecv >> nonce;

	// Only process pong message if there is an outstanding ping (old
	// ping without nonce should never pong)
	if (pfrom.nPingNonceSent != 0) {
	if (nonce == pfrom.nPingNonceSent) {
	// Matching pong received, this ping is no longer
	// outstanding
	bPingFinished = true;
	const auto ping_time = ping_end - pfrom.m_ping_start.load();
	if (ping_time.count() >= 0) {
	// Successful ping time measurement, replace previous
	pfrom.nPingUsecTime = count_microseconds(ping_time);
	pfrom.nMinPingUsecTime =
	std::min(pfrom.nMinPingUsecTime.load(),
	count_microseconds(ping_time));
	} else {
	// This should never happen
	sProblem = "Timing mishap";
	}
	} else {
	// Nonce mismatches are normal when pings are overlapping
	sProblem = "Nonce mismatch";
	if (nonce == 0) {
	// This is most likely a bug in another implementation
	// somewhere; cancel this ping
	bPingFinished = true;
	sProblem = "Nonce zero";
	}
	}
	} else {
	sProblem = "Unsolicited pong without ping";
	}
	} else {
	// This is most likely a bug in another implementation somewhere;
	// cancel this ping
	bPingFinished = true;
	sProblem = "Short payload";
	}

	if (!(sProblem.empty())) {
	LogPrint(BCLog::NET,
	"pong peer=%d: %s, %x expected, %x received, %u bytes\n",
	pfrom.GetId(), sProblem, pfrom.nPingNonceSent, nonce,
	nAvail);
	}
	if (bPingFinished) {
	pfrom.nPingNonceSent = 0;
	}
	return;
	}

	if (msg_type == NetMsgType::FILTERLOAD) {
	if (!(pfrom.GetLocalServices() & NODE_BLOOM)) {
	pfrom.fDisconnect = true;
	return;
	}
	CBloomFilter filter;
	vRecv >> filter;

	if (!filter.IsWithinSizeConstraints()) {
	// There is no excuse for sending a too-large filter
	Misbehaving(pfrom, 100, "too-large bloom filter");
	} else if (pfrom.m_tx_relay != nullptr) {
	LOCK(pfrom.m_tx_relay->cs_filter);
	pfrom.m_tx_relay->pfilter.reset(new CBloomFilter(filter));
	pfrom.m_tx_relay->fRelayTxes = true;
	}
	return;
	}

	if (msg_type == NetMsgType::FILTERADD) {
	if (!(pfrom.GetLocalServices() & NODE_BLOOM)) {
	pfrom.fDisconnect = true;
	return;
	}
	std::vector<uint8_t> vData;
	vRecv >> vData;

	// Nodes must NEVER send a data item > 520 bytes (the max size for a
	// script data object, and thus, the maximum size any matched object can
	// have) in a filteradd message.
	bool bad = false;
	if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) {
	bad = true;
	} else if (pfrom.m_tx_relay != nullptr) {
	LOCK(pfrom.m_tx_relay->cs_filter);
	if (pfrom.m_tx_relay->pfilter) {
	pfrom.m_tx_relay->pfilter->insert(vData);
	} else {
	bad = true;
	}
	}
	if (bad) {
	// The structure of this code doesn't really allow for a good error
	// code. We'll go generic.
	Misbehaving(pfrom, 100, "bad filteradd message");
	}
	return;
	}

	if (msg_type == NetMsgType::FILTERCLEAR) {
	if (!(pfrom.GetLocalServices() & NODE_BLOOM)) {
	pfrom.fDisconnect = true;
	return;
	}
	if (pfrom.m_tx_relay == nullptr) {
	return;
	}
	LOCK(pfrom.m_tx_relay->cs_filter);
	pfrom.m_tx_relay->pfilter = nullptr;
	pfrom.m_tx_relay->fRelayTxes = true;
	return;
	}

	if (msg_type == NetMsgType::FEEFILTER) {
	Amount newFeeFilter = Amount::zero();
	vRecv >> newFeeFilter;
	if (MoneyRange(newFeeFilter)) {
	if (pfrom.m_tx_relay != nullptr) {
	LOCK(pfrom.m_tx_relay->cs_feeFilter);
	pfrom.m_tx_relay->minFeeFilter = newFeeFilter;
	}
	LogPrint(BCLog::NET, "received: feefilter of %s from peer=%d\n",
	CFeeRate(newFeeFilter).ToString(), pfrom.GetId());
	}
	return;
	}

	if (msg_type == NetMsgType::GETCFILTERS) {
	ProcessGetCFilters(pfrom, vRecv, m_chainparams, m_connman);
	return;
	}

	if (msg_type == NetMsgType::GETCFHEADERS) {
	ProcessGetCFHeaders(pfrom, vRecv, m_chainparams, m_connman);
	return;
	}

	if (msg_type == NetMsgType::GETCFCHECKPT) {
	ProcessGetCFCheckPt(pfrom, vRecv, m_chainparams, m_connman);
	return;
	}

	if (msg_type == NetMsgType::NOTFOUND) {
	std::vector<CInv> vInv;
	vRecv >> vInv;
	// A peer might send up to 1 notfound per getdata request, but no more
	if (vInv.size() <= PROOF_REQUEST_PARAMS.max_peer_announcements +
	TX_REQUEST_PARAMS.max_peer_announcements +
	MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
	for (CInv &inv : vInv) {
	if (inv.IsMsgTx()) {
	// If we receive a NOTFOUND message for a tx we requested,
	// mark the announcement for it as completed in
	// InvRequestTracker.
	LOCK(::cs_main);
	m_txrequest.ReceivedResponse(pfrom.GetId(), TxId(inv.hash));
	continue;
	}
	if (inv.IsMsgProof()) {
	LOCK(cs_proofrequest);
	m_proofrequest.ReceivedResponse(
	pfrom.GetId(), avalanche::ProofId(inv.hash));
	}
	}
	}
	return;
	}

	// Ignore unknown commands for extensibility
	LogPrint(BCLog::NET, "Unknown command \"%s\" from peer=%d\n",
	SanitizeString(msg_type), pfrom.GetId());
	return;
	}

	bool PeerManager::MaybeDiscourageAndDisconnect(CNode &pnode) {
	const NodeId peer_id{pnode.GetId()};
	PeerRef peer = GetPeerRef(peer_id);
	if (peer == nullptr) {
	return false;
	}
	{
	LOCK(peer->m_misbehavior_mutex);

	// There's nothing to do if the m_should_discourage flag isn't set
	if (!peer->m_should_discourage) {
	return false;
	}

	peer->m_should_discourage = false;
	} // peer.m_misbehavior_mutex

	if (pnode.HasPermission(PF_NOBAN)) {
	// We never disconnect or discourage peers for bad behavior if they have
	// the NOBAN permission flag
	LogPrintf("Warning: not punishing noban peer %d!\n", peer_id);
	return false;
	}

	if (pnode.IsManualConn()) {
	// We never disconnect or discourage manual peers for bad behavior
	LogPrintf("Warning: not punishing manually connected peer %d!\n",
	peer_id);
	return false;
	}

	if (pnode.addr.IsLocal()) {
	// We disconnect local peers for bad behavior but don't discourage
	// (since that would discourage all peers on the same local address)
	LogPrintf(
	"Warning: disconnecting but not discouraging local peer %d!\n",
	peer_id);
	pnode.fDisconnect = true;
	return true;
	}

	// Normal case: Disconnect the peer and discourage all nodes sharing the
	// address
	LogPrintf("Disconnecting and discouraging peer %d!\n", peer_id);
	if (m_banman) {
	m_banman->Discourage(pnode.addr);
	}
	m_connman.DisconnectNode(pnode.addr);
	return true;
	}

	bool PeerManager::ProcessMessages(const Config &config, CNode *pfrom,
	std::atomic<bool> &interruptMsgProc) {
	//
	// Message format
	// (4) message start
	// (12) command
	// (4) size
	// (4) checksum
	// (x) data
	//
	bool fMoreWork = false;

	if (!pfrom->vRecvGetData.empty()) {
	ProcessGetData(config, *pfrom, m_connman, m_mempool, interruptMsgProc);
	}

	if (!pfrom->orphan_work_set.empty()) {
	LOCK2(cs_main, g_cs_orphans);
	ProcessOrphanTx(config, pfrom->orphan_work_set);
	}

	if (pfrom->fDisconnect) {
	return false;
	}

	// this maintains the order of responses and prevents vRecvGetData from
	// growing unbounded
	if (!pfrom->vRecvGetData.empty()) {
	return true;
	}
	if (!pfrom->orphan_work_set.empty()) {
	return true;
	}

	// Don't bother if send buffer is too full to respond anyway
	if (pfrom->fPauseSend) {
	return false;
	}

	std::list<CNetMessage> msgs;
	{
	LOCK(pfrom->cs_vProcessMsg);
	if (pfrom->vProcessMsg.empty()) {
	return false;
	}
	// Just take one message
	msgs.splice(msgs.begin(), pfrom->vProcessMsg,
	pfrom->vProcessMsg.begin());
	pfrom->nProcessQueueSize -= msgs.front().m_raw_message_size;
	pfrom->fPauseRecv =
	pfrom->nProcessQueueSize > m_connman.GetReceiveFloodSize();
	fMoreWork = !pfrom->vProcessMsg.empty();
	}
	CNetMessage &msg(msgs.front());

	msg.SetVersion(pfrom->GetCommonVersion());

	// Check network magic
	if (!msg.m_valid_netmagic) {
	LogPrint(BCLog::NET,
	"PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n",
	SanitizeString(msg.m_command), pfrom->GetId());

	// Make sure we discourage where that come from for some time.
	if (m_banman) {
	m_banman->Discourage(pfrom->addr);
	}
	m_connman.DisconnectNode(pfrom->addr);

	pfrom->fDisconnect = true;
	return false;
	}

	// Check header
	if (!msg.m_valid_header) {
	LogPrint(BCLog::NET, "PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n",
	SanitizeString(msg.m_command), pfrom->GetId());
	return fMoreWork;
	}
	const std::string &msg_type = msg.m_command;

	// Message size
	unsigned int nMessageSize = msg.m_message_size;

	// Checksum
	CDataStream &vRecv = msg.m_recv;
	if (!msg.m_valid_checksum) {
	LogPrint(BCLog::NET, "%s(%s, %u bytes): CHECKSUM ERROR peer=%d\n",
	__func__, SanitizeString(msg_type), nMessageSize,
	pfrom->GetId());
	if (m_banman) {
	m_banman->Discourage(pfrom->addr);
	}
	m_connman.DisconnectNode(pfrom->addr);
	return fMoreWork;
	}

	try {
	ProcessMessage(config, *pfrom, msg_type, vRecv, msg.m_time,
	interruptMsgProc);
	if (interruptMsgProc) {
	return false;
	}

	if (!pfrom->vRecvGetData.empty()) {
	fMoreWork = true;
	}
	} catch (const std::exception &e) {
	LogPrint(BCLog::NET, "%s(%s, %u bytes): Exception '%s' (%s) caught\n",
	__func__, SanitizeString(msg_type), nMessageSize, e.what(),
	typeid(e).name());
	} catch (...) {
	LogPrint(BCLog::NET, "%s(%s, %u bytes): Unknown exception caught\n",
	__func__, SanitizeString(msg_type), nMessageSize);
	}

	return fMoreWork;
	}

	void PeerManager::ConsiderEviction(CNode &pto, int64_t time_in_seconds) {
	AssertLockHeld(cs_main);

	CNodeState &state = *State(pto.GetId());
	const CNetMsgMaker msgMaker(pto.GetCommonVersion());

	if (!state.m_chain_sync.m_protect && pto.IsOutboundOrBlockRelayConn() &&
	state.fSyncStarted) {
	// This is an outbound peer subject to disconnection if they don't
	// announce a block with as much work as the current tip within
	// CHAIN_SYNC_TIMEOUT + HEADERS_RESPONSE_TIME seconds (note: if their
	// chain has more work than ours, we should sync to it, unless it's
	// invalid, in which case we should find that out and disconnect from
	// them elsewhere).
	if (state.pindexBestKnownBlock != nullptr &&
	state.pindexBestKnownBlock->nChainWork >=
	::ChainActive().Tip()->nChainWork) {
	if (state.m_chain_sync.m_timeout != 0) {
	state.m_chain_sync.m_timeout = 0;
	state.m_chain_sync.m_work_header = nullptr;
	state.m_chain_sync.m_sent_getheaders = false;
	}
	} else if (state.m_chain_sync.m_timeout == 0 \|\|
	(state.m_chain_sync.m_work_header != nullptr &&
	state.pindexBestKnownBlock != nullptr &&
	state.pindexBestKnownBlock->nChainWork >=
	state.m_chain_sync.m_work_header->nChainWork)) {
	// Our best block known by this peer is behind our tip, and we're
	// either noticing that for the first time, OR this peer was able to
	// catch up to some earlier point where we checked against our tip.
	// Either way, set a new timeout based on current tip.
	state.m_chain_sync.m_timeout = time_in_seconds + CHAIN_SYNC_TIMEOUT;
	state.m_chain_sync.m_work_header = ::ChainActive().Tip();
	state.m_chain_sync.m_sent_getheaders = false;
	} else if (state.m_chain_sync.m_timeout > 0 &&
	time_in_seconds > state.m_chain_sync.m_timeout) {
	// No evidence yet that our peer has synced to a chain with work
	// equal to that of our tip, when we first detected it was behind.
	// Send a single getheaders message to give the peer a chance to
	// update us.
	if (state.m_chain_sync.m_sent_getheaders) {
	// They've run out of time to catch up!
	LogPrintf(
	"Disconnecting outbound peer %d for old chain, best known "
	"block = %s\n",
	pto.GetId(),
	state.pindexBestKnownBlock != nullptr
	? state.pindexBestKnownBlock->GetBlockHash().ToString()
	: "<none>");
	pto.fDisconnect = true;
	} else {
	assert(state.m_chain_sync.m_work_header);
	LogPrint(
	BCLog::NET,
	"sending getheaders to outbound peer=%d to verify chain "
	"work (current best known block:%s, benchmark blockhash: "
	"%s)\n",
	pto.GetId(),
	state.pindexBestKnownBlock != nullptr
	? state.pindexBestKnownBlock->GetBlockHash().ToString()
	: "<none>",
	state.m_chain_sync.m_work_header->GetBlockHash()
	.ToString());
	m_connman.PushMessage(
	&pto,
	msgMaker.Make(NetMsgType::GETHEADERS,
	::ChainActive().GetLocator(
	state.m_chain_sync.m_work_header->pprev),
	uint256()));
	state.m_chain_sync.m_sent_getheaders = true;
	// 2 minutes
	constexpr int64_t HEADERS_RESPONSE_TIME = 120;
	// Bump the timeout to allow a response, which could clear the
	// timeout (if the response shows the peer has synced), reset
	// the timeout (if the peer syncs to the required work but not
	// to our tip), or result in disconnect (if we advance to the
	// timeout and pindexBestKnownBlock has not sufficiently
	// progressed)
	state.m_chain_sync.m_timeout =
	time_in_seconds + HEADERS_RESPONSE_TIME;
	}
	}
	}
	}

	void PeerManager::EvictExtraOutboundPeers(int64_t time_in_seconds) {
	// Check whether we have too many outbound peers
	int extra_peers = m_connman.GetExtraOutboundCount();
	if (extra_peers <= 0) {
	return;
	}

	// If we have more outbound peers than we target, disconnect one.
	// Pick the outbound peer that least recently announced us a new block, with
	// ties broken by choosing the more recent connection (higher node id)
	NodeId worst_peer = -1;
	int64_t oldest_block_announcement = std::numeric_limits<int64_t>::max();

	m_connman.ForEachNode([&](CNode *pnode) {
	AssertLockHeld(cs_main);

	// Ignore non-outbound peers, or nodes marked for disconnect already
	if (!pnode->IsOutboundOrBlockRelayConn() \|\| pnode->fDisconnect) {
	return;
	}
	CNodeState *state = State(pnode->GetId());
	if (state == nullptr) {
	// shouldn't be possible, but just in case
	return;
	}
	// Don't evict our protected peers
	if (state->m_chain_sync.m_protect) {
	return;
	}
	// Don't evict our block-relay-only peers.
	if (pnode->m_tx_relay == nullptr) {
	return;
	}

	if (state->m_last_block_announcement < oldest_block_announcement \|\|
	(state->m_last_block_announcement == oldest_block_announcement &&
	pnode->GetId() > worst_peer)) {
	worst_peer = pnode->GetId();
	oldest_block_announcement = state->m_last_block_announcement;
	}
	});

	if (worst_peer == -1) {
	return;
	}

	bool disconnected = m_connman.ForNode(worst_peer, [&](CNode *pnode) {
	AssertLockHeld(cs_main);

	// Only disconnect a peer that has been connected to us for some
	// reasonable fraction of our check-frequency, to give it time for new
	// information to have arrived.
	// Also don't disconnect any peer we're trying to download a block from.
	CNodeState &state = *State(pnode->GetId());
	if (time_in_seconds - pnode->nTimeConnected > MINIMUM_CONNECT_TIME &&
	state.nBlocksInFlight == 0) {
	LogPrint(BCLog::NET,
	"disconnecting extra outbound peer=%d (last block "
	"announcement received at time %d)\n",
	pnode->GetId(), oldest_block_announcement);
	pnode->fDisconnect = true;
	return true;
	} else {
	LogPrint(BCLog::NET,
	"keeping outbound peer=%d chosen for eviction "
	"(connect time: %d, blocks_in_flight: %d)\n",
	pnode->GetId(), pnode->nTimeConnected,
	state.nBlocksInFlight);
	return false;
	}
	});

	if (disconnected) {
	// If we disconnected an extra peer, that means we successfully
	// connected to at least one peer after the last time we detected a
	// stale tip. Don't try any more extra peers until we next detect a
	// stale tip, to limit the load we put on the network from these extra
	// connections.
	m_connman.SetTryNewOutboundPeer(false);
	}
	}

	void PeerManager::CheckForStaleTipAndEvictPeers(
	const Consensus::Params &consensusParams) {
	LOCK(cs_main);

	int64_t time_in_seconds = GetTime();

	EvictExtraOutboundPeers(time_in_seconds);

	if (time_in_seconds <= m_stale_tip_check_time) {
	return;
	}

	// Check whether our tip is stale, and if so, allow using an extra outbound
	// peer.
	if (!fImporting && !fReindex && m_connman.GetNetworkActive() &&
	m_connman.GetUseAddrmanOutgoing() && TipMayBeStale(consensusParams)) {
	LogPrintf("Potential stale tip detected, will try using extra outbound "
	"peer (last tip update: %d seconds ago)\n",
	time_in_seconds - g_last_tip_update);
	m_connman.SetTryNewOutboundPeer(true);
	} else if (m_connman.GetTryNewOutboundPeer()) {
	m_connman.SetTryNewOutboundPeer(false);
	}
	m_stale_tip_check_time = time_in_seconds + STALE_CHECK_INTERVAL;
	}

	namespace {
	class CompareInvMempoolOrder {
	CTxMemPool *mp;

	public:
	explicit CompareInvMempoolOrder(CTxMemPool *_mempool) { mp = _mempool; }

	bool operator()(std::set<TxId>::iterator a, std::set<TxId>::iterator b) {
	/**
	* As std::make_heap produces a max-heap, we want the entries with the
	* fewest ancestors/highest fee to sort later.
	*/
	return mp->CompareDepthAndScore(b, a);
	}
	};
	} // namespace

	bool PeerManager::SendMessages(const Config &config, CNode *pto,
	std::atomic<bool> &interruptMsgProc) {
	const Consensus::Params &consensusParams =
	config.GetChainParams().GetConsensus();

	// We must call MaybeDiscourageAndDisconnect first, to ensure that we'll
	// disconnect misbehaving peers even before the version handshake is
	// complete.
	if (MaybeDiscourageAndDisconnect(*pto)) {
	return true;
	}

	// Don't send anything until the version handshake is complete
	if (!pto->fSuccessfullyConnected \|\| pto->fDisconnect) {
	return true;
	}

	// If we get here, the outgoing message serialization version is set and
	// can't change.
	const CNetMsgMaker msgMaker(pto->GetCommonVersion());

	//
	// Message: ping
	//
	bool pingSend = false;
	if (pto->fPingQueued) {
	// RPC ping request by user
	pingSend = true;
	}
	if (pto->nPingNonceSent == 0 && pto->m_ping_start.load() + PING_INTERVAL <
	GetTime<std::chrono::microseconds>()) {
	// Ping automatically sent as a latency probe & keepalive.
	pingSend = true;
	}
	if (pingSend) {
	uint64_t nonce = 0;
	while (nonce == 0) {
	GetRandBytes((uint8_t *)&nonce, sizeof(nonce));
	}
	pto->fPingQueued = false;
	pto->m_ping_start = GetTime<std::chrono::microseconds>();
	if (pto->GetCommonVersion() > BIP0031_VERSION) {
	pto->nPingNonceSent = nonce;
	m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::PING, nonce));
	} else {
	// Peer is too old to support ping command with nonce, pong will
	// never arrive.
	pto->nPingNonceSent = 0;
	m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::PING));
	}
	}

	auto current_time = GetTime<std::chrono::microseconds>();
	bool fFetch;

	{
	LOCK(cs_main);

	CNodeState &state = *State(pto->GetId());

	// Address refresh broadcast
	if (pto->IsAddrRelayPeer() &&
	!::ChainstateActive().IsInitialBlockDownload() &&
	pto->m_next_local_addr_send < current_time) {
	AdvertiseLocal(pto);
	pto->m_next_local_addr_send = PoissonNextSend(
	current_time, AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL);
	}

	//
	// Message: addr
	//
	if (pto->IsAddrRelayPeer() && pto->m_next_addr_send < current_time) {
	pto->m_next_addr_send =
	PoissonNextSend(current_time, AVG_ADDRESS_BROADCAST_INTERVAL);
	std::vector<CAddress> vAddr;
	vAddr.reserve(pto->vAddrToSend.size());
	assert(pto->m_addr_known);

	const char *msg_type;
	int make_flags;
	if (pto->m_wants_addrv2) {
	msg_type = NetMsgType::ADDRV2;
	make_flags = ADDRV2_FORMAT;
	} else {
	msg_type = NetMsgType::ADDR;
	make_flags = 0;
	}

	for (const CAddress &addr : pto->vAddrToSend) {
	if (!pto->m_addr_known->contains(addr.GetKey())) {
	pto->m_addr_known->insert(addr.GetKey());
	vAddr.push_back(addr);
	// receiver rejects addr messages larger than 1000
	if (vAddr.size() >= 1000) {
	m_connman.PushMessage(
	pto, msgMaker.Make(make_flags, msg_type, vAddr));
	vAddr.clear();
	}
	}
	}
	pto->vAddrToSend.clear();
	if (!vAddr.empty()) {
	m_connman.PushMessage(
	pto, msgMaker.Make(make_flags, msg_type, vAddr));
	}

	// we only send the big addr message once
	if (pto->vAddrToSend.capacity() > 40) {
	pto->vAddrToSend.shrink_to_fit();
	}
	}

	// Start block sync
	if (pindexBestHeader == nullptr) {
	pindexBestHeader = ::ChainActive().Tip();
	}

	// Download if this is a nice peer, or we have no nice peers and this
	// one might do.
	fFetch = state.fPreferredDownload \|\|
	(nPreferredDownload == 0 && !pto->fClient &&
	!pto->IsAddrFetchConn());

	if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) {
	// Only actively request headers from a single peer, unless we're
	// close to today.
	if ((nSyncStarted == 0 && fFetch) \|\|
	pindexBestHeader->GetBlockTime() >
	GetAdjustedTime() - 24 * 60 * 60) {
	state.fSyncStarted = true;
	state.nHeadersSyncTimeout =
	count_microseconds(current_time) +
	HEADERS_DOWNLOAD_TIMEOUT_BASE +
	HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER *
	(GetAdjustedTime() - pindexBestHeader->GetBlockTime()) /
	(consensusParams.nPowTargetSpacing);
	nSyncStarted++;
	const CBlockIndex *pindexStart = pindexBestHeader;
	/**
	* If possible, start at the block preceding the currently best
	* known header. This ensures that we always get a non-empty
	* list of headers back as long as the peer is up-to-date. With
	* a non-empty response, we can initialise the peer's known best
	* block. This wouldn't be possible if we requested starting at
	* pindexBestHeader and got back an empty response.
	*/
	if (pindexStart->pprev) {
	pindexStart = pindexStart->pprev;
	}

	LogPrint(
	BCLog::NET,
	"initial getheaders (%d) to peer=%d (startheight:%d)\n",
	pindexStart->nHeight, pto->GetId(), pto->nStartingHeight);
	m_connman.PushMessage(
	pto, msgMaker.Make(NetMsgType::GETHEADERS,
	::ChainActive().GetLocator(pindexStart),
	uint256()));
	}
	}

	//
	// Try sending block announcements via headers
	//
	{
	// If we have less than MAX_BLOCKS_TO_ANNOUNCE in our list of block
	// hashes we're relaying, and our peer wants headers announcements,
	// then find the first header not yet known to our peer but would
	// connect, and send. If no header would connect, or if we have too
	// many blocks, or if the peer doesn't want headers, just add all to
	// the inv queue.
	LOCK(pto->cs_inventory);
	std::vector<CBlock> vHeaders;
	bool fRevertToInv =
	((!state.fPreferHeaders &&
	(!state.fPreferHeaderAndIDs \|\|
	pto->vBlockHashesToAnnounce.size() > 1)) \|\|
	pto->vBlockHashesToAnnounce.size() > MAX_BLOCKS_TO_ANNOUNCE);
	// last header queued for delivery
	const CBlockIndex *pBestIndex = nullptr;
	// ensure pindexBestKnownBlock is up-to-date
	ProcessBlockAvailability(pto->GetId());

	if (!fRevertToInv) {
	bool fFoundStartingHeader = false;
	// Try to find first header that our peer doesn't have, and then
	// send all headers past that one. If we come across an headers
	// that aren't on ::ChainActive(), give up.
	for (const BlockHash &hash : pto->vBlockHashesToAnnounce) {
	const CBlockIndex *pindex = LookupBlockIndex(hash);
	assert(pindex);
	if (::ChainActive()[pindex->nHeight] != pindex) {
	// Bail out if we reorged away from this block
	fRevertToInv = true;
	break;
	}
	if (pBestIndex != nullptr && pindex->pprev != pBestIndex) {
	// This means that the list of blocks to announce don't
	// connect to each other. This shouldn't really be
	// possible to hit during regular operation (because
	// reorgs should take us to a chain that has some block
	// not on the prior chain, which should be caught by the
	// prior check), but one way this could happen is by
	// using invalidateblock / reconsiderblock repeatedly on
	// the tip, causing it to be added multiple times to
	// vBlockHashesToAnnounce. Robustly deal with this rare
	// situation by reverting to an inv.
	fRevertToInv = true;
	break;
	}
	pBestIndex = pindex;
	if (fFoundStartingHeader) {
	// add this to the headers message
	vHeaders.push_back(pindex->GetBlockHeader());
	} else if (PeerHasHeader(&state, pindex)) {
	// Keep looking for the first new block.
	continue;
	} else if (pindex->pprev == nullptr \|\|
	PeerHasHeader(&state, pindex->pprev)) {
	// Peer doesn't have this header but they do have the
	// prior one. Start sending headers.
	fFoundStartingHeader = true;
	vHeaders.push_back(pindex->GetBlockHeader());
	} else {
	// Peer doesn't have this header or the prior one --
	// nothing will connect, so bail out.
	fRevertToInv = true;
	break;
	}
	}
	}
	if (!fRevertToInv && !vHeaders.empty()) {
	if (vHeaders.size() == 1 && state.fPreferHeaderAndIDs) {
	// We only send up to 1 block as header-and-ids, as
	// otherwise probably means we're doing an initial-ish-sync
	// or they're slow.
	LogPrint(BCLog::NET,
	"%s sending header-and-ids %s to peer=%d\n",
	__func__, vHeaders.front().GetHash().ToString(),
	pto->GetId());

	int nSendFlags = 0;

	bool fGotBlockFromCache = false;
	{
	LOCK(cs_most_recent_block);
	if (most_recent_block_hash ==
	pBestIndex->GetBlockHash()) {
	CBlockHeaderAndShortTxIDs cmpctblock(
	*most_recent_block);
	m_connman.PushMessage(
	pto, msgMaker.Make(nSendFlags,
	NetMsgType::CMPCTBLOCK,
	cmpctblock));
	fGotBlockFromCache = true;
	}
	}
	if (!fGotBlockFromCache) {
	CBlock block;
	bool ret = ReadBlockFromDisk(block, pBestIndex,
	consensusParams);
	assert(ret);
	CBlockHeaderAndShortTxIDs cmpctblock(block);
	m_connman.PushMessage(
	pto,
	msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK,
	cmpctblock));
	}
	state.pindexBestHeaderSent = pBestIndex;
	} else if (state.fPreferHeaders) {
	if (vHeaders.size() > 1) {
	LogPrint(BCLog::NET,
	"%s: %u headers, range (%s, %s), to peer=%d\n",
	__func__, vHeaders.size(),
	vHeaders.front().GetHash().ToString(),
	vHeaders.back().GetHash().ToString(),
	pto->GetId());
	} else {
	LogPrint(BCLog::NET,
	"%s: sending header %s to peer=%d\n", __func__,
	vHeaders.front().GetHash().ToString(),
	pto->GetId());
	}
	m_connman.PushMessage(
	pto, msgMaker.Make(NetMsgType::HEADERS, vHeaders));
	state.pindexBestHeaderSent = pBestIndex;
	} else {
	fRevertToInv = true;
	}
	}
	if (fRevertToInv) {
	// If falling back to using an inv, just try to inv the tip. The
	// last entry in vBlockHashesToAnnounce was our tip at some
	// point in the past.
	if (!pto->vBlockHashesToAnnounce.empty()) {
	const BlockHash &hashToAnnounce =
	pto->vBlockHashesToAnnounce.back();
	const CBlockIndex *pindex =
	LookupBlockIndex(hashToAnnounce);
	assert(pindex);

	// Warn if we're announcing a block that is not on the main
	// chain. This should be very rare and could be optimized
	// out. Just log for now.
	if (::ChainActive()[pindex->nHeight] != pindex) {
	LogPrint(
	BCLog::NET,
	"Announcing block %s not on main chain (tip=%s)\n",
	hashToAnnounce.ToString(),
	::ChainActive().Tip()->GetBlockHash().ToString());
	}

	// If the peer's chain has this block, don't inv it back.
	if (!PeerHasHeader(&state, pindex)) {
	pto->vInventoryBlockToSend.push_back(hashToAnnounce);
	LogPrint(BCLog::NET,
	"%s: sending inv peer=%d hash=%s\n", __func__,
	pto->GetId(), hashToAnnounce.ToString());
	}
	}
	}
	pto->vBlockHashesToAnnounce.clear();
	}
	} // release cs_main

	//
	// Message: inventory
	//
	std::vector<CInv> vInv;
	auto addInvAndMaybeFlush = [&](uint32_t type, const uint256 &hash) {
	vInv.emplace_back(type, hash);
	if (vInv.size() == MAX_INV_SZ) {
	m_connman.PushMessage(
	pto, msgMaker.Make(NetMsgType::INV, std::move(vInv)));
	vInv.clear();
	}
	};

	{
	LOCK2(cs_main, pto->cs_inventory);

	vInv.reserve(std::max<size_t>(pto->vInventoryBlockToSend.size(),
	INVENTORY_BROADCAST_MAX_PER_MB *
	config.GetMaxBlockSize() / 1000000));

	// Add blocks
	for (const BlockHash &hash : pto->vInventoryBlockToSend) {
	addInvAndMaybeFlush(MSG_BLOCK, hash);
	}
	pto->vInventoryBlockToSend.clear();

	auto computeNextInvSendTime =
	[&](std::chrono::microseconds &next) -> bool {
	bool fSendTrickle = pto->HasPermission(PF_NOBAN);

	if (next < current_time) {
	fSendTrickle = true;
	if (pto->IsInboundConn()) {
	next = std::chrono::microseconds{
	m_connman.PoissonNextSendInbound(
	count_microseconds(current_time),
	INVENTORY_BROADCAST_INTERVAL)};
	} else {
	// Skip delay for outbound peers, as there is less privacy
	// concern for them.
	next = current_time;
	}
	}

	return fSendTrickle;
	};

	// Add proofs to inventory
	if (pto->m_proof_relay != nullptr) {
	LOCK(pto->m_proof_relay->cs_proof_inventory);

	if (computeNextInvSendTime(pto->m_proof_relay->nextInvSend)) {
	auto it = pto->m_proof_relay->setInventoryProofToSend.begin();
	while (it !=
	pto->m_proof_relay->setInventoryProofToSend.end()) {
	const avalanche::ProofId proofid = *it;

	it = pto->m_proof_relay->setInventoryProofToSend.erase(it);

	if (pto->m_proof_relay->filterProofKnown.contains(
	proofid)) {
	continue;
	}

	pto->m_proof_relay->filterProofKnown.insert(proofid);
	addInvAndMaybeFlush(MSG_AVA_PROOF, proofid);
	}
	}
	}

	if (pto->m_tx_relay != nullptr) {
	LOCK(pto->m_tx_relay->cs_tx_inventory);
	// Check whether periodic sends should happen
	const bool fSendTrickle =
	computeNextInvSendTime(pto->m_tx_relay->nNextInvSend);

	// Time to send but the peer has requested we not relay
	// transactions.
	if (fSendTrickle) {
	LOCK(pto->m_tx_relay->cs_filter);
	if (!pto->m_tx_relay->fRelayTxes) {
	pto->m_tx_relay->setInventoryTxToSend.clear();
	}
	}

	// Respond to BIP35 mempool requests
	if (fSendTrickle && pto->m_tx_relay->fSendMempool) {
	auto vtxinfo = m_mempool.infoAll();
	pto->m_tx_relay->fSendMempool = false;
	CFeeRate filterrate;
	{
	LOCK(pto->m_tx_relay->cs_feeFilter);
	filterrate = CFeeRate(pto->m_tx_relay->minFeeFilter);
	}

	LOCK(pto->m_tx_relay->cs_filter);

	for (const auto &txinfo : vtxinfo) {
	const TxId &txid = txinfo.tx->GetId();
	pto->m_tx_relay->setInventoryTxToSend.erase(txid);
	// Don't send transactions that peers will not put into
	// their mempool
	if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) {
	continue;
	}
	if (pto->m_tx_relay->pfilter &&
	!pto->m_tx_relay->pfilter->IsRelevantAndUpdate(
	*txinfo.tx)) {
	continue;
	}
	pto->m_tx_relay->filterInventoryKnown.insert(txid);
	// Responses to MEMPOOL requests bypass the
	// m_recently_announced_invs filter.
	addInvAndMaybeFlush(MSG_TX, txid);
	}
	pto->m_tx_relay->m_last_mempool_req =
	GetTime<std::chrono::seconds>();
	}

	// Determine transactions to relay
	if (fSendTrickle) {
	// Produce a vector with all candidates for sending
	std::vector<std::set<TxId>::iterator> vInvTx;
	vInvTx.reserve(pto->m_tx_relay->setInventoryTxToSend.size());
	for (std::set<TxId>::iterator it =
	pto->m_tx_relay->setInventoryTxToSend.begin();
	it != pto->m_tx_relay->setInventoryTxToSend.end(); it++) {
	vInvTx.push_back(it);
	}
	CFeeRate filterrate;
	{
	LOCK(pto->m_tx_relay->cs_feeFilter);
	filterrate = CFeeRate(pto->m_tx_relay->minFeeFilter);
	}
	// Topologically and fee-rate sort the inventory we send for
	// privacy and priority reasons. A heap is used so that not
	// all items need sorting if only a few are being sent.
	CompareInvMempoolOrder compareInvMempoolOrder(&m_mempool);
	std::make_heap(vInvTx.begin(), vInvTx.end(),
	compareInvMempoolOrder);
	// No reason to drain out at many times the network's
	// capacity, especially since we have many peers and some
	// will draw much shorter delays.
	unsigned int nRelayedTransactions = 0;
	LOCK(pto->m_tx_relay->cs_filter);
	while (!vInvTx.empty() &&
	nRelayedTransactions < INVENTORY_BROADCAST_MAX_PER_MB *
	config.GetMaxBlockSize() /
	1000000) {
	// Fetch the top element from the heap
	std::pop_heap(vInvTx.begin(), vInvTx.end(),
	compareInvMempoolOrder);
	std::set<TxId>::iterator it = vInvTx.back();
	vInvTx.pop_back();
	const TxId txid = *it;
	// Remove it from the to-be-sent set
	pto->m_tx_relay->setInventoryTxToSend.erase(it);
	// Check if not in the filter already
	if (pto->m_tx_relay->filterInventoryKnown.contains(txid)) {
	continue;
	}
	// Not in the mempool anymore? don't bother sending it.
	auto txinfo = m_mempool.info(txid);
	if (!txinfo.tx) {
	continue;
	}
	// Peer told you to not send transactions at that
	// feerate? Don't bother sending it.
	if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) {
	continue;
	}
	if (pto->m_tx_relay->pfilter &&
	!pto->m_tx_relay->pfilter->IsRelevantAndUpdate(
	*txinfo.tx)) {
	continue;
	}
	// Send
	State(pto->GetId())->m_recently_announced_invs.insert(txid);
	addInvAndMaybeFlush(MSG_TX, txid);
	nRelayedTransactions++;
	{
	// Expire old relay messages
	while (!vRelayExpiration.empty() &&
	vRelayExpiration.front().first <
	count_microseconds(current_time)) {
	mapRelay.erase(vRelayExpiration.front().second);
	vRelayExpiration.pop_front();
	}

	auto ret = mapRelay.insert(
	std::make_pair(txid, std::move(txinfo.tx)));
	if (ret.second) {
	vRelayExpiration.push_back(std::make_pair(
	count_microseconds(current_time) +
	std::chrono::microseconds{
	RELAY_TX_CACHE_TIME}
	.count(),
	ret.first));
	}
	}
	pto->m_tx_relay->filterInventoryKnown.insert(txid);
	}
	}
	}
	} // release cs_main, pto->cs_inventory

	if (!vInv.empty()) {
	m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
	}

	{
	LOCK(cs_main);

	CNodeState &state = *State(pto->GetId());

	// Detect whether we're stalling
	current_time = GetTime<std::chrono::microseconds>();
	if (state.nStallingSince &&
	state.nStallingSince < count_microseconds(current_time) -
	1000000 * BLOCK_STALLING_TIMEOUT) {
	// Stalling only triggers when the block download window cannot
	// move. During normal steady state, the download window should be
	// much larger than the to-be-downloaded set of blocks, so
	// disconnection should only happen during initial block download.
	LogPrintf("Peer=%d is stalling block download, disconnecting\n",
	pto->GetId());
	pto->fDisconnect = true;
	return true;
	}
	// In case there is a block that has been in flight from this peer for 2
	// + 0.5 * N times the block interval (with N the number of peers from
	// which we're downloading validated blocks), disconnect due to timeout.
	// We compensate for other peers to prevent killing off peers due to our
	// own downstream link being saturated. We only count validated
	// in-flight blocks so peers can't advertise non-existing block hashes
	// to unreasonably increase our timeout.
	if (state.vBlocksInFlight.size() > 0) {
	QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
	int nOtherPeersWithValidatedDownloads =
	nPeersWithValidatedDownloads -
	(state.nBlocksInFlightValidHeaders > 0);
	if (count_microseconds(current_time) >
	state.nDownloadingSince +
	consensusParams.nPowTargetSpacing *
	(BLOCK_DOWNLOAD_TIMEOUT_BASE +
	BLOCK_DOWNLOAD_TIMEOUT_PER_PEER *
	nOtherPeersWithValidatedDownloads)) {
	LogPrintf("Timeout downloading block %s from peer=%d, "
	"disconnecting\n",
	queuedBlock.hash.ToString(), pto->GetId());
	pto->fDisconnect = true;
	return true;
	}
	}

	// Check for headers sync timeouts
	if (state.fSyncStarted &&
	state.nHeadersSyncTimeout < std::numeric_limits<int64_t>::max()) {
	// Detect whether this is a stalling initial-headers-sync peer
	if (pindexBestHeader->GetBlockTime() <=
	GetAdjustedTime() - 24 * 60 * 60) {
	if (count_microseconds(current_time) >
	state.nHeadersSyncTimeout &&
	nSyncStarted == 1 &&
	(nPreferredDownload - state.fPreferredDownload >= 1)) {
	// Disconnect a (non-whitelisted) peer if it is our only
	// sync peer, and we have others we could be using instead.
	// Note: If all our peers are inbound, then we won't
	// disconnect our sync peer for stalling; we have bigger
	// problems if we can't get any outbound peers.
	if (!pto->HasPermission(PF_NOBAN)) {
	LogPrintf("Timeout downloading headers from peer=%d, "
	"disconnecting\n",
	pto->GetId());
	pto->fDisconnect = true;
	return true;
	} else {
	LogPrintf(
	"Timeout downloading headers from whitelisted "
	"peer=%d, not disconnecting\n",
	pto->GetId());
	// Reset the headers sync state so that we have a chance
	// to try downloading from a different peer. Note: this
	// will also result in at least one more getheaders
	// message to be sent to this peer (eventually).
	state.fSyncStarted = false;
	nSyncStarted--;
	state.nHeadersSyncTimeout = 0;
	}
	}
	} else {
	// After we've caught up once, reset the timeout so we can't
	// trigger disconnect later.
	state.nHeadersSyncTimeout = std::numeric_limits<int64_t>::max();
	}
	}

	// Check that outbound peers have reasonable chains GetTime() is used by
	// this anti-DoS logic so we can test this using mocktime.
	ConsiderEviction(*pto, GetTime());
	} // release cs_main

	std::vector<CInv> vGetData;

	//
	// Message: getdata (blocks)
	//
	{
	LOCK(cs_main);

	CNodeState &state = *State(pto->GetId());

	if (!pto->fClient &&
	((fFetch && !pto->m_limited_node) \|\|
	!::ChainstateActive().IsInitialBlockDownload()) &&
	state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
	std::vector<const CBlockIndex *> vToDownload;
	NodeId staller = -1;
	FindNextBlocksToDownload(pto->GetId(),
	MAX_BLOCKS_IN_TRANSIT_PER_PEER -
	state.nBlocksInFlight,
	vToDownload, staller, consensusParams);
	for (const CBlockIndex *pindex : vToDownload) {
	vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
	MarkBlockAsInFlight(config, m_mempool, pto->GetId(),
	pindex->GetBlockHash(), consensusParams,
	pindex);
	LogPrint(BCLog::NET, "Requesting block %s (%d) peer=%d\n",
	pindex->GetBlockHash().ToString(), pindex->nHeight,
	pto->GetId());
	}
	if (state.nBlocksInFlight == 0 && staller != -1) {
	if (State(staller)->nStallingSince == 0) {
	State(staller)->nStallingSince =
	count_microseconds(current_time);
	LogPrint(BCLog::NET, "Stall started peer=%d\n", staller);
	}
	}
	}
	} // release cs_main

	auto addGetDataAndMaybeFlush = [&](uint32_t type, const uint256 &hash) {
	CInv inv(type, hash);
	LogPrint(BCLog::NET, "Requesting %s from peer=%d\n", inv.ToString(),
	pto->GetId());
	vGetData.push_back(std::move(inv));
	if (vGetData.size() >= MAX_GETDATA_SZ) {
	m_connman.PushMessage(
	pto, msgMaker.Make(NetMsgType::GETDATA, std::move(vGetData)));
	vGetData.clear();
	}
	};

	//
	// Message: getdata (proof)
	//
	{
	LOCK(cs_proofrequest);
	std::vector<std::pair<NodeId, avalanche::ProofId>> expired;
	auto requestable =
	m_proofrequest.GetRequestable(pto->GetId(), current_time, &expired);
	for (const auto &entry : expired) {
	LogPrint(BCLog::NET, "timeout of inflight proof %s from peer=%d\n",
	entry.second.ToString(), entry.first);
	}
	for (const auto &proofid : requestable) {
	if (!AlreadyHaveProof(proofid)) {
	addGetDataAndMaybeFlush(MSG_AVA_PROOF, proofid);
	m_proofrequest.RequestedData(
	pto->GetId(), proofid,
	current_time + PROOF_REQUEST_PARAMS.getdata_interval);
	} else {
	// We have already seen this proof, no need to download.
	// This is just a belt-and-suspenders, as this should
	// already be called whenever a transaction becomes
	// AlreadyHaveProof().
	m_proofrequest.ForgetInvId(proofid);
	}
	}
	} // release cs_proofrequest

	//
	// Message: getdata (transactions)
	//
	{
	LOCK(cs_main);
	std::vector<std::pair<NodeId, TxId>> expired;
	auto requestable =
	m_txrequest.GetRequestable(pto->GetId(), current_time, &expired);
	for (const auto &entry : expired) {
	LogPrint(BCLog::NET, "timeout of inflight tx %s from peer=%d\n",
	entry.second.ToString(), entry.first);
	}
	for (const TxId &txid : requestable) {
	if (!AlreadyHaveTx(txid, m_mempool)) {
	addGetDataAndMaybeFlush(MSG_TX, txid);
	m_txrequest.RequestedData(
	pto->GetId(), txid,
	current_time + TX_REQUEST_PARAMS.getdata_interval);
	} else {
	// We have already seen this transaction, no need to download.
	// This is just a belt-and-suspenders, as this should already be
	// called whenever a transaction becomes AlreadyHaveTx().
	m_txrequest.ForgetInvId(txid);
	}
	}

	if (!vGetData.empty()) {
	m_connman.PushMessage(pto,
	msgMaker.Make(NetMsgType::GETDATA, vGetData));
	}

	//
	// Message: feefilter
	//
	// peers with the forcerelay permission should not filter txs to us
	if (pto->m_tx_relay != nullptr &&
	pto->GetCommonVersion() >= FEEFILTER_VERSION &&
	gArgs.GetBoolArg("-feefilter", DEFAULT_FEEFILTER) &&
	!pto->HasPermission(PF_FORCERELAY)) {
	Amount currentFilter =
	m_mempool
	.GetMinFee(
	gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *
	1000000)
	.GetFeePerK();
	static FeeFilterRounder g_filter_rounder{
	CFeeRate{DEFAULT_MIN_RELAY_TX_FEE_PER_KB}};
	if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
	// Received tx-inv messages are discarded when the active
	// chainstate is in IBD, so tell the peer to not send them.
	currentFilter = MAX_MONEY;
	} else {
	static const Amount MAX_FILTER{
	g_filter_rounder.round(MAX_MONEY)};
	if (pto->m_tx_relay->lastSentFeeFilter == MAX_FILTER) {
	// Send the current filter if we sent MAX_FILTER previously
	// and made it out of IBD.
	pto->m_tx_relay->nextSendTimeFeeFilter =
	count_microseconds(current_time) - 1;
	}
	}
	if (count_microseconds(current_time) >
	pto->m_tx_relay->nextSendTimeFeeFilter) {
	Amount filterToSend = g_filter_rounder.round(currentFilter);
	filterToSend =
	std::max(filterToSend, ::minRelayTxFee.GetFeePerK());

	if (filterToSend != pto->m_tx_relay->lastSentFeeFilter) {
	m_connman.PushMessage(
	pto,
	msgMaker.Make(NetMsgType::FEEFILTER, filterToSend));
	pto->m_tx_relay->lastSentFeeFilter = filterToSend;
	}
	pto->m_tx_relay->nextSendTimeFeeFilter =
	PoissonNextSend(count_microseconds(current_time),
	AVG_FEEFILTER_BROADCAST_INTERVAL);
	}
	// If the fee filter has changed substantially and it's still more
	// than MAX_FEEFILTER_CHANGE_DELAY until scheduled broadcast, then
	// move the broadcast to within MAX_FEEFILTER_CHANGE_DELAY.
	else if (count_microseconds(current_time) +
	MAX_FEEFILTER_CHANGE_DELAY * 1000000 <
	pto->m_tx_relay->nextSendTimeFeeFilter &&
	(currentFilter <
	3 * pto->m_tx_relay->lastSentFeeFilter / 4 \|\|
	currentFilter >
	4 * pto->m_tx_relay->lastSentFeeFilter / 3)) {
	pto->m_tx_relay->nextSendTimeFeeFilter =
	count_microseconds(current_time) +
	GetRandInt(MAX_FEEFILTER_CHANGE_DELAY) * 1000000;
	}
	}
	} // release cs_main
	return true;
	}

	class CNetProcessingCleanup {
	public:
	CNetProcessingCleanup() {}
	~CNetProcessingCleanup() {
	// orphan transactions
	mapOrphanTransactions.clear();
	mapOrphanTransactionsByPrev.clear();
	}
	};
	static CNetProcessingCleanup instance_of_cnetprocessingcleanup;

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jan 29, 16:56 (10 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5053344
Default Alt Text: (331 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions