No OneTemporary
Actions

Size

699 KB

Subscribers

None

View Options

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

	diff --git a/doc/README.md b/doc/README.md
	index 86dab7286..e8e648163 100644
	--- a/doc/README.md
	+++ b/doc/README.md
	@@ -1,116 +1,117 @@
	Bitcoin ABC
	=====================

	Setup
	---------------------
	Bitcoin ABC is a fork of Bitcoin Core, which is the original Bitcoin client and builds the backbone of the network. It downloads and, by default, stores the entire history of Bitcoin transactions, which requires a few hundred gigabytes of disk space. Depending on the speed of your computer and network connection, the synchronization process can take anywhere from a few hours to a day or more.

	To download Bitcoin ABC, visit [bitcoinabc.org](https://download.bitcoinabc.org/).

	Verify
	---------------------

	If you download the associated signature files with the binaries from the above link,
	you can verify the integrity of the binaries by following these instructions, replacing
	VERSION with the value relevant to you:

	Get the keys for versions 0.20.11 or later:
	```
	VERSION="0.20.11"
	URL="https://download.bitcoinabc.org/${VERSION}/src/bitcoin-abc-${VERSION}.tar.gz"
	KEYS_FILE="bitcoin-abc-${VERSION}/contrib/gitian-signing/keys.txt"
	wget -q -O - "${URL}" \| tar -zxOf - "${KEYS_FILE}" \| while read FINGERPRINT _; do gpg --recv-keys "${FINGERPRINT}"; done
	```

	Get the keys for versions 0.20.10 or earlier:
	```
	VERSION="0.20.10"
	URL="https://raw.githubusercontent.com/Bitcoin-ABC/bitcoin-abc/v${VERSION}/contrib/gitian-signing/keys.txt"
	wget -q -O - "${URL}" \| awk 1 \| while read FINGERPRINT _; do gpg --recv-keys "${FINGERPRINT}"; done
	```

	Check the binaries (all versions):
	```
	FILE_PATTERN="./*-sha256sums.${VERSION}.asc"
	gpg --verify-files ${FILE_PATTERN}
	grep "bitcoin-abc-${VERSION}" ${FILE_PATTERN} \| cut -d " " -f 2- \| xargs ls 2> /dev/null \|\
	xargs -i grep -h "{}" ${FILE_PATTERN} \| uniq \| sha256sum -c
	```

	IMPORTANT NOTE: The first time you run this, all of the signing keys will be UNTRUSTED and you will see warnings
	indicating this. For best security practices, you should `gpg --sign-key <signer key>` for each release signer key
	and rerun the above script (there should be no warnings the second time). If the keys change unexpectedly,
	the presence of those warnings should be heeded with extreme caution.

	Running
	---------------------
	The following are some helpful notes on how to run Bitcoin ABC on your native platform.

	### Unix

	Unpack the files into a directory and run:

	- `bin/bitcoin-qt` (GUI) or
	- `bin/bitcoind` (headless)

	### Windows

	Unpack the files into a directory, and then run bitcoin-qt.exe.

	### macOS

	Drag bitcoin-abc to your applications folder, and then run bitcoin-abc.

	### Need Help?

	* See the documentation at the [Bitcoin Wiki](https://en.bitcoin.it/wiki/Main_Page)
	for help and more information.
	* Ask for help on the [Bitcoin ABC Subreddit](https://www.reddit.com/r/BitcoinABC/).

	Building
	---------------------
	The following are developer notes on how to build Bitcoin ABC on your native platform. They are not complete guides, but include notes on the necessary libraries, compile flags, etc.

	- [Dependencies](dependencies.md)
	- [macOS Build Notes](build-osx.md)
	- [Unix Build Notes](build-unix.md)
	- [Windows Build Notes](build-windows.md)
	- [Gitian Building Guide](gitian-building.md)

	Development
	---------------------
	The Bitcoin ABC repo's [root README](/README.md) contains relevant information on the development process and automated testing.

	- [Developer Notes](developer-notes.md)
	- [Productivity Notes](productivity.md)
	- [Release Notes](release-notes.md)
	- [Release Process](release-process.md)
	- [Source Code Documentation (External Link)](https://www.bitcoinabc.org/doc/dev/)
	- [Translation Process](translation_process.md)
	- [Translation Strings Policy](translation_strings_policy.md)
	- [JSON-RPC Interface](JSON-RPC-interface.md)
	- [Unauthenticated REST Interface](REST-interface.md)
	- [Shared Libraries](shared-libraries.md)
	- [BIPS](bips.md)
	- [Dnsseed Policy](dnsseed-policy.md)
	- [Benchmarking](benchmarking.md)

	### Miscellaneous
	- [Assets Attribution](assets-attribution.md)
	- [bitcoin.conf Configuration File](bitcoin-conf.md)
	- [Files](files.md)
	- [Fuzz-testing](fuzzing.md)
	- [I2P Support](i2p.md)
	- [Init Scripts (systemd/upstart/openrc)](init.md)
	+- [P2P bad ports definition and list](p2p-bad-ports.md)
	- [PSBT support](psbt.md)
	- [Reduce Memory](reduce-memory.md)
	- [Reduce Traffic](reduce-traffic.md)
	- [Tor Support](tor.md)
	- [ZMQ](zmq.md)

	License
	---------------------
	Distribution is done under the [MIT software license](/COPYING).
	This product includes software developed by the OpenSSL Project for use in the [OpenSSL Toolkit](https://www.openssl.org/), cryptographic software written by Eric Young ([eay@cryptsoft.com](mailto:eay@cryptsoft.com)), and UPnP software written by Thomas Bernard.
	The `gitian-builder` software developed by the Gitian Developers and distributed
	as part of the project is [licenced](../contrib/gitian-builder/LICENSE) under the [GNU General Public License version 3](../contrib/gitian-builder/COPYING).
	diff --git a/doc/p2p-bad-ports.md b/doc/p2p-bad-ports.md
	new file mode 100644
	index 000000000..59898dc67
	--- /dev/null
	+++ b/doc/p2p-bad-ports.md
	@@ -0,0 +1,114 @@
	+When Bitcoin ABC automatically opens outgoing P2P connections it chooses
	+a peer (address and port) from its list of potential peers. This list is
	+populated with unchecked data, gossiped over the P2P network by other peers.
	+
	+A malicious actor may gossip an address:port where no Bitcoin ABC node is
	+listening, or one where a service is listening that is not related to the eCash
	+network. As a result, this service may occasionally get connection attempts from
	+Bitcoin ABC nodes.
	+
	+"Bad" ports are ones used by services which are usually not open to the public
	+and usually require authentication. A connection attempt (by Bitcoin ABC, trying
	+to connect because it thinks there is a Bitcoin node on that address:port) to
	+such service may be considered a malicious action by an ultra-paranoid
	+administrator. An example for such a port is 22 (ssh). On the other hand,
	+connection attempts to public services that usually do not require
	+authentication are unlikely to be considered a malicious action, e.g. port 80
	+(http).
	+
	+Below is a list of "bad" ports which Bitcoin ABC avoids when choosing a peer to
	+connect to. If a node is listening on such a port, it will likely receive less
	+incoming connections.
	+
	+ 1: tcpmux
	+ 7: echo
	+ 9: discard
	+ 11: systat
	+ 13: daytime
	+ 15: netstat
	+ 17: qotd
	+ 19: chargen
	+ 20: ftp data
	+ 21: ftp access
	+ 22: ssh
	+ 23: telnet
	+ 25: smtp
	+ 37: time
	+ 42: name
	+ 43: nicname
	+ 53: domain
	+ 69: tftp
	+ 77: priv-rjs
	+ 79: finger
	+ 87: ttylink
	+ 95: supdup
	+ 101: hostname
	+ 102: iso-tsap
	+ 103: gppitnp
	+ 104: acr-nema
	+ 109: pop2
	+ 110: pop3
	+ 111: sunrpc
	+ 113: auth
	+ 115: sftp
	+ 117: uucp-path
	+ 119: nntp
	+ 123: NTP
	+ 135: loc-srv /epmap
	+ 137: netbios
	+ 139: netbios
	+ 143: imap2
	+ 161: snmp
	+ 179: BGP
	+ 389: ldap
	+ 427: SLP (Also used by Apple Filing Protocol)
	+ 465: smtp+ssl
	+ 512: print / exec
	+ 513: login
	+ 514: shell
	+ 515: printer
	+ 526: tempo
	+ 530: courier
	+ 531: chat
	+ 532: netnews
	+ 540: uucp
	+ 548: AFP (Apple Filing Protocol)
	+ 554: rtsp
	+ 556: remotefs
	+ 563: nntp+ssl
	+ 587: smtp (rfc6409)
	+ 601: syslog-conn (rfc3195)
	+ 636: ldap+ssl
	+ 989: ftps-data
	+ 990: ftps
	+ 993: ldap+ssl
	+ 995: pop3+ssl
	+ 1719: h323gatestat
	+ 1720: h323hostcall
	+ 1723: pptp
	+ 2049: nfs
	+ 3659: apple-sasl / PasswordServer
	+ 4045: lockd
	+ 5060: sip
	+ 5061: sips
	+ 6000: X11
	+ 6566: sane-port
	+ 6665: Alternate IRC
	+ 6666: Alternate IRC
	+ 6667: Standard IRC
	+ 6668: Alternate IRC
	+ 6669: Alternate IRC
	+ 6697: IRC + TLS
	+ 10080: Amanda
	+
	+For further information see:
	+
	+[pull/23306](https://github.com/bitcoin/bitcoin/pull/23306#issuecomment-947516736)
	+
	+[pull/23542](https://github.com/bitcoin/bitcoin/pull/23542)
	+
	+[fetch.spec.whatwg.org](https://fetch.spec.whatwg.org/#port-blocking)
	+
	+[chromium.googlesource.com](https://chromium.googlesource.com/chromium/src.git/+/refs/heads/main/net/base/port_util.cc)
	+
	+[hg.mozilla.org](https://hg.mozilla.org/mozilla-central/file/tip/netwerk/base/nsIOService.cpp)
	diff --git a/src/init.cpp b/src/init.cpp
	index 5a7151d76..bf252a16b 100644
	--- a/src/init.cpp
	+++ b/src/init.cpp
	@@ -1,3198 +1,3222 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2018 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#if defined(HAVE_CONFIG_H)
	#include <config/bitcoin-config.h>
	#endif

	#include <init.h>

	#include <addrman.h>
	#include <avalanche/avalanche.h>
	#include <avalanche/processor.h>
	#include <avalanche/proof.h> // For AVALANCHE_LEGACY_PROOF_DEFAULT
	#include <avalanche/validation.h>
	#include <avalanche/voterecord.h> // For AVALANCHE_VOTE_STALE_*
	#include <banman.h>
	#include <blockfilter.h>
	#include <chain.h>
	#include <chainparams.h>
	#include <compat/sanity.h>
	#include <config.h>
	#include <consensus/amount.h>
	#include <currencyunit.h>
	#include <flatfile.h>
	#include <fs.h>
	#include <hash.h>
	#include <httprpc.h>
	#include <httpserver.h>
	#include <index/blockfilterindex.h>
	#include <index/coinstatsindex.h>
	#include <index/txindex.h>
	#include <interfaces/chain.h>
	#include <interfaces/node.h>
	#include <key.h>
	#include <mapport.h>
	#include <miner.h>
	#include <net.h>
	#include <net_permissions.h>
	#include <net_processing.h>
	#include <netbase.h>
	#include <node/blockstorage.h>
	#include <node/context.h>
	#include <node/ui_interface.h>
	#include <policy/mempool.h>
	#include <policy/policy.h>
	#include <policy/settings.h>
	#include <rpc/blockchain.h>
	#include <rpc/register.h>
	#include <rpc/server.h>
	#include <rpc/util.h>
	#include <scheduler.h>
	#include <script/scriptcache.h>
	#include <script/sigcache.h>
	#include <script/standard.h>
	#include <shutdown.h>
	#include <sync.h>
	#include <timedata.h>
	#include <torcontrol.h>
	#include <txdb.h>
	#include <txmempool.h>
	#include <txorphanage.h>
	#include <util/asmap.h>
	#include <util/check.h>
	#include <util/moneystr.h>
	#include <util/string.h>
	#include <util/thread.h>
	#include <util/threadnames.h>
	#include <util/translation.h>
	#include <validation.h>
	#include <validationinterface.h>
	#include <walletinitinterface.h>

	#include <boost/algorithm/string/replace.hpp>
	#include <boost/signals2/signal.hpp>

	#if ENABLE_CHRONIK
	#include <chronik-cpp/chronik.h>
	#endif

	#if ENABLE_ZMQ
	#include <zmq/zmqabstractnotifier.h>
	#include <zmq/zmqnotificationinterface.h>
	#include <zmq/zmqrpc.h>
	#endif

	#ifndef WIN32
	#include <attributes.h>
	#include <cerrno>
	#include <csignal>
	#include <sys/stat.h>
	#endif
	#include <cstdint>
	#include <cstdio>
	#include <functional>
	#include <set>
	#include <thread>
	#include <vector>

	static const bool DEFAULT_PROXYRANDOMIZE = true;
	static const bool DEFAULT_REST_ENABLE = false;

	#ifdef WIN32
	// Win32 LevelDB doesn't use filedescriptors, and the ones used for accessing
	// block files don't count towards the fd_set size limit anyway.
	#define MIN_CORE_FILEDESCRIPTORS 0
	#else
	#define MIN_CORE_FILEDESCRIPTORS 150
	#endif

	static const char *DEFAULT_ASMAP_FILENAME = "ip_asn.map";

	/**
	* The PID file facilities.
	*/
	static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";

	static fs::path GetPidFile(const ArgsManager &args) {
	return AbsPathForConfigVal(
	fs::PathFromString(args.GetArg("-pid", BITCOIN_PID_FILENAME)));
	}

	[[nodiscard]] static bool CreatePidFile(const ArgsManager &args) {
	fsbridge::ofstream file{GetPidFile(args)};
	if (file) {
	#ifdef WIN32
	tfm::format(file, "%d\n", GetCurrentProcessId());
	#else
	tfm::format(file, "%d\n", getpid());
	#endif
	return true;
	} else {
	return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
	fs::PathToString(GetPidFile(args)),
	std::strerror(errno)));
	}
	}

	//////////////////////////////////////////////////////////////////////////////
	//
	// Shutdown
	//

	//
	// Thread management and startup/shutdown:
	//
	// The network-processing threads are all part of a thread group created by
	// AppInit() or the Qt main() function.
	//
	// A clean exit happens when StartShutdown() or the SIGTERM signal handler sets
	// fRequestShutdown, which makes main thread's WaitForShutdown() interrupts the
	// thread group.
	// And then, WaitForShutdown() makes all other on-going threads in the thread
	// group join the main thread.
	// Shutdown() is then called to clean up database connections, and stop other
	// threads that should only be stopped after the main network-processing threads
	// have exited.
	//
	// Shutdown for Qt is very similar, only it uses a QTimer to detect
	// ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
	//

	static std::unique_ptr<ECCVerifyHandle> globalVerifyHandle;

	void Interrupt(NodeContext &node) {
	InterruptHTTPServer();
	InterruptHTTPRPC();
	InterruptRPC();
	InterruptREST();
	InterruptTorControl();
	InterruptMapPort();
	if (g_avalanche) {
	// Avalanche needs to be stopped before we interrupt the thread group as
	// the scheduler will stop working then.
	g_avalanche->stopEventLoop();
	}
	if (node.connman) {
	node.connman->Interrupt();
	}
	if (g_txindex) {
	g_txindex->Interrupt();
	}
	ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Interrupt(); });
	if (g_coin_stats_index) {
	g_coin_stats_index->Interrupt();
	}
	}

	void Shutdown(NodeContext &node) {
	static Mutex g_shutdown_mutex;
	TRY_LOCK(g_shutdown_mutex, lock_shutdown);
	if (!lock_shutdown) {
	return;
	}
	LogPrintf("%s: In progress...\n", __func__);
	Assert(node.args);

	/// Note: Shutdown() must be able to handle cases in which initialization
	/// failed part of the way, for example if the data directory was found to
	/// be locked. Be sure that anything that writes files or flushes caches
	/// only does this if the respective module was initialized.
	util::ThreadRename("shutoff");
	if (node.mempool) {
	node.mempool->AddTransactionsUpdated(1);
	}

	StopHTTPRPC();
	StopREST();
	StopRPC();
	StopHTTPServer();
	for (const auto &client : node.chain_clients) {
	client->flush();
	}
	StopMapPort();

	// Because avalanche and the network depend on each other, it is important
	// to shut them down in this order:
	// 1. Stop avalanche event loop.
	// 2. Shutdown network processing.
	// 3. Destroy avalanche::Processor.
	// 4. Destroy CConnman
	if (g_avalanche) {
	g_avalanche->stopEventLoop();
	}

	// Because these depend on each-other, we make sure that neither can be
	// using the other before destroying them.
	if (node.peerman) {
	UnregisterValidationInterface(node.peerman.get());
	}
	if (node.connman) {
	node.connman->Stop();
	}

	#if ENABLE_CHRONIK
	chronik::Stop();
	#endif

	StopTorControl();

	// After everything has been shut down, but before things get flushed, stop
	// the CScheduler/checkqueue, scheduler and load block thread.
	if (node.scheduler) {
	node.scheduler->stop();
	}
	if (node.chainman && node.chainman->m_load_block.joinable()) {
	node.chainman->m_load_block.join();
	}
	StopScriptCheckWorkerThreads();

	// After the threads that potentially access these pointers have been
	// stopped, destruct and reset all to nullptr.
	node.peerman.reset();

	// Destroy various global instances
	g_avalanche.reset();
	node.connman.reset();
	node.banman.reset();
	node.addrman.reset();

	if (node.mempool && node.mempool->IsLoaded() &&
	node.args->GetBoolArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
	DumpMempool(*node.mempool);
	}

	// FlushStateToDisk generates a ChainStateFlushed callback, which we should
	// avoid missing
	if (node.chainman) {
	LOCK(cs_main);
	for (CChainState *chainstate : node.chainman->GetAll()) {
	if (chainstate->CanFlushToDisk()) {
	chainstate->ForceFlushStateToDisk();
	}
	}
	}

	// After there are no more peers/RPC left to give us new data which may
	// generate CValidationInterface callbacks, flush them...
	GetMainSignals().FlushBackgroundCallbacks();

	// Stop and delete all indexes only after flushing background callbacks.
	if (g_txindex) {
	g_txindex->Stop();
	g_txindex.reset();
	}
	if (g_coin_stats_index) {
	g_coin_stats_index->Stop();
	g_coin_stats_index.reset();
	}
	ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Stop(); });
	DestroyAllBlockFilterIndexes();

	// Any future callbacks will be dropped. This should absolutely be safe - if
	// missing a callback results in an unrecoverable situation, unclean
	// shutdown would too. The only reason to do the above flushes is to let the
	// wallet catch up with our current chain to avoid any strange pruning edge
	// cases and make next startup faster by avoiding rescan.

	if (node.chainman) {
	LOCK(cs_main);
	for (CChainState *chainstate : node.chainman->GetAll()) {
	if (chainstate->CanFlushToDisk()) {
	chainstate->ForceFlushStateToDisk();
	chainstate->ResetCoinsViews();
	}
	}
	}
	for (const auto &client : node.chain_clients) {
	client->stop();
	}

	#if ENABLE_ZMQ
	if (g_zmq_notification_interface) {
	UnregisterValidationInterface(g_zmq_notification_interface);
	delete g_zmq_notification_interface;
	g_zmq_notification_interface = nullptr;
	}
	#endif

	node.chain_clients.clear();
	UnregisterAllValidationInterfaces();
	GetMainSignals().UnregisterBackgroundSignalScheduler();
	globalVerifyHandle.reset();
	ECC_Stop();
	node.mempool.reset();
	node.chainman.reset();
	node.scheduler.reset();

	try {
	if (!fs::remove(GetPidFile(*node.args))) {
	LogPrintf("%s: Unable to remove PID file: File does not exist\n",
	__func__);
	}
	} catch (const fs::filesystem_error &e) {
	LogPrintf("%s: Unable to remove PID file: %s\n", __func__,
	fsbridge::get_filesystem_error_message(e));
	}

	node.args = nullptr;
	LogPrintf("%s: done\n", __func__);
	}

	/**
	* Signal handlers are very limited in what they are allowed to do.
	* The execution context the handler is invoked in is not guaranteed,
	* so we restrict handler operations to just touching variables:
	*/
	#ifndef WIN32
	static void HandleSIGTERM(int) {
	StartShutdown();
	}

	static void HandleSIGHUP(int) {
	LogInstance().m_reopen_file = true;
	}
	#else
	static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) {
	StartShutdown();
	Sleep(INFINITE);
	return true;
	}
	#endif

	#ifndef WIN32
	static void registerSignalHandler(int signal, void (*handler)(int)) {
	struct sigaction sa;
	sa.sa_handler = handler;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	sigaction(signal, &sa, NULL);
	}
	#endif

	static boost::signals2::connection rpc_notify_block_change_connection;
	static void OnRPCStarted() {
	rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(
	std::bind(RPCNotifyBlockChange, std::placeholders::_2));
	}

	static void OnRPCStopped() {
	rpc_notify_block_change_connection.disconnect();
	RPCNotifyBlockChange(nullptr);
	g_best_block_cv.notify_all();
	LogPrint(BCLog::RPC, "RPC stopped.\n");
	}

	void SetupServerArgs(NodeContext &node) {
	assert(!node.args);
	node.args = &gArgs;
	ArgsManager &argsman = *node.args;

	SetupHelpOptions(argsman);
	SetupCurrencyUnitOptions(argsman);
	// server-only for now
	argsman.AddArg("-help-debug",
	"Print help message with debugging options and exit", false,
	OptionsCategory::DEBUG_TEST);

	const auto defaultBaseParams =
	CreateBaseChainParams(CBaseChainParams::MAIN);
	const auto testnetBaseParams =
	CreateBaseChainParams(CBaseChainParams::TESTNET);
	const auto regtestBaseParams =
	CreateBaseChainParams(CBaseChainParams::REGTEST);
	const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);
	const auto testnetChainParams =
	CreateChainParams(CBaseChainParams::TESTNET);
	const auto regtestChainParams =
	CreateChainParams(CBaseChainParams::REGTEST);

	// Hidden Options
	std::vector<std::string> hidden_args = {
	// Don't apply addrman network group limit for outbound connections
	"-bypassnetgrouplimit",
	"-dbcrashratio",
	"-forcecompactdb",
	"-maxaddrtosend",
	"-parkdeepreorg",
	"-automaticunparking",
	"-replayprotectionactivationtime",
	"-enableminerfund",
	// GUI args. These will be overwritten by SetupUIArgs for the GUI
	"-allowselfsignedrootcertificates",
	"-choosedatadir",
	"-lang=<lang>",
	"-min",
	"-resetguisettings",
	"-rootcertificates=<file>",
	"-splash",
	"-uiplatform",
	// TODO remove after the May 2023 upgrade
	"-wellingtonactivationtime",
	};

	// Set all of the args and their help
	// When adding new options to the categories, please keep and ensure
	// alphabetical ordering. Do not translate _(...) -help-debug options, Many
	// technical terms, and only a very small audience, so is unnecessary stress
	// to translators.
	argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
	OptionsCategory::OPTIONS);
	#if defined(HAVE_SYSTEM)
	argsman.AddArg(
	"-alertnotify=<cmd>",
	"Execute command when a relevant alert is received or we see "
	"a really long fork (%s in cmd is replaced by message)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	argsman.AddArg(
	"-assumevalid=<hex>",
	strprintf(
	"If this block is in the chain assume that it and its ancestors "
	"are valid and potentially skip their script verification (0 to "
	"verify all, default: %s, testnet: %s)",
	defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
	testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-blocksdir=<dir>",
	"Specify directory to hold blocks subdirectory for *.dat "
	"files (default: <datadir>)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-fastprune",
	"Use smaller block files and lower minimum prune height for "
	"testing purposes",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	#if defined(HAVE_SYSTEM)
	argsman.AddArg("-blocknotify=<cmd>",
	"Execute command when the best block changes (%s in cmd is "
	"replaced by block hash)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	argsman.AddArg("-blockreconstructionextratxn=<n>",
	strprintf("Extra transactions to keep in memory for compact "
	"block reconstructions (default: %u)",
	DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-blocksonly",
	strprintf("Whether to reject transactions from network peers. "
	"Automatic broadcast and rebroadcast of any transactions "
	"from inbound peers is disabled, unless the peer has the "
	"'forcerelay' permission. RPC transactions are"
	" not affected. (default: %u)",
	DEFAULT_BLOCKSONLY),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-coinstatsindex",
	strprintf("Maintain coinstats index used by the "
	"gettxoutsetinfo RPC (default: %u)",
	DEFAULT_COINSTATSINDEX),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-conf=<file>",
	strprintf("Specify path to read-only configuration file. Relative "
	"paths will be prefixed by datadir location. (default: %s)",
	BITCOIN_CONF_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-datadir=<dir>", "Specify data directory",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-dbbatchsize",
	strprintf("Maximum database write batch size in bytes (default: %u)",
	DEFAULT_DB_BATCH_SIZE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-dbcache=<n>",
	strprintf("Set database cache size in MiB (%d to %d, default: %d)",
	MIN_DB_CACHE_MB, MAX_DB_CACHE_MB, DEFAULT_DB_CACHE_MB),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-debuglogfile=<file>",
	strprintf("Specify location of debug log file. Relative paths "
	"will be prefixed by a net-specific datadir "
	"location. (0 to disable; default: %s)",
	DEFAULT_DEBUGLOGFILE),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-finalizationdelay=<n>",
	strprintf("Set the minimum amount of time to wait between a "
	"block header reception and the block finalization. "
	"Unit is seconds (default: %d)",
	DEFAULT_MIN_FINALIZATION_DELAY),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-includeconf=<file>",
	"Specify additional configuration file, relative to the -datadir path "
	"(only useable from configuration file, not command line)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-maxreorgdepth=<n>",
	strprintf("Configure at what depth blocks are considered "
	"final (default: %d). Use -1 to disable.",
	DEFAULT_MAX_REORG_DEPTH),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-loadblock=<file>",
	"Imports blocks from external file on startup",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-maxmempool=<n>",
	strprintf("Keep the transaction memory pool below <n> "
	"megabytes (default: %u)",
	DEFAULT_MAX_MEMPOOL_SIZE),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-maxorphantx=<n>",
	strprintf("Keep at most <n> unconnectable transactions in "
	"memory (default: %u)",
	DEFAULT_MAX_ORPHAN_TRANSACTIONS),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-mempoolexpiry=<n>",
	strprintf("Do not keep transactions in the mempool longer "
	"than <n> hours (default: %u)",
	DEFAULT_MEMPOOL_EXPIRY),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-minimumchainwork=<hex>",
	strprintf(
	"Minimum work assumed to exist on a valid chain in hex "
	"(default: %s, testnet: %s)",
	defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
	testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-par=<n>",
	strprintf("Set the number of script verification threads (%u to %d, 0 "
	"= auto, <0 = leave that many cores free, default: %d)",
	-GetNumCores(), MAX_SCRIPTCHECK_THREADS,
	DEFAULT_SCRIPTCHECK_THREADS),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-persistmempool",
	strprintf("Whether to save the mempool on shutdown and load "
	"on restart (default: %u)",
	DEFAULT_PERSIST_MEMPOOL),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-pid=<file>",
	strprintf("Specify pid file. Relative paths will be prefixed "
	"by a net-specific datadir location. (default: %s)",
	BITCOIN_PID_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-prune=<n>",
	strprintf("Reduce storage requirements by enabling pruning (deleting) "
	"of old blocks. This allows the pruneblockchain RPC to be "
	"called to delete specific blocks, and enables automatic "
	"pruning of old blocks if a target size in MiB is provided. "
	"This mode is incompatible with -txindex, -coinstatsindex "
	"and -rescan. Warning: Reverting this setting requires "
	"re-downloading the entire blockchain. (default: 0 = disable "
	"pruning blocks, 1 = allow manual pruning via RPC, >=%u = "
	"automatically prune block files to stay under the specified "
	"target size in MiB)",
	MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-reindex-chainstate",
	"Rebuild chain state from the currently indexed blocks. When "
	"in pruning mode or if blocks on disk might be corrupted, use "
	"full -reindex instead.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-reindex",
	"Rebuild chain state and block index from the blk*.dat files on disk",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-settings=<file>",
	strprintf(
	"Specify path to dynamic settings data file. Can be disabled with "
	"-nosettings. File is written at runtime and not meant to be "
	"edited by users (use %s instead for custom settings). Relative "
	"paths will be prefixed by datadir location. (default: %s)",
	BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#if HAVE_SYSTEM
	argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	#ifndef WIN32
	argsman.AddArg(
	"-sysperms",
	"Create new files with system default permissions, instead of umask "
	"077 (only effective with disabled wallet functionality)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#else
	hidden_args.emplace_back("-sysperms");
	#endif
	argsman.AddArg("-txindex",
	strprintf("Maintain a full transaction index, used by the "
	"getrawtransaction rpc call (default: %d)",
	DEFAULT_TXINDEX),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-blockfilterindex=<type>",
	strprintf("Maintain an index of compact filters by block "
	"(default: %s, values: %s).",
	DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
	" If <type> is not supplied or if <type> = 1, indexes for "
	"all known types are enabled.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-usecashaddr",
	"Use Cash Address for destination encoding instead of base58 "
	"(activate by default on Jan, 14)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

	argsman.AddArg(
	"-addnode=<ip>",
	"Add a node to connect to and attempt to keep the connection "
	"open (see the `addnode` RPC command help for more info)",
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CONNECTION);
	argsman.AddArg("-asmap=<file>",
	strprintf("Specify asn mapping used for bucketing of the "
	"peers (default: %s). Relative paths will be "
	"prefixed by the net-specific datadir location.",
	DEFAULT_ASMAP_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-bantime=<n>",
	strprintf("Default duration (in seconds) of manually "
	"configured bans (default: %u)",
	DEFAULT_MISBEHAVING_BANTIME),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-bind=<addr>[:<port>][=onion]",
	strprintf("Bind to given address and always listen on it (default: "
	"0.0.0.0). Use [host]:port notation for IPv6. Append =onion "
	"to tag any incoming connections to that address and port as "
	"incoming Tor connections (default: 127.0.0.1:%u=onion, "
	"testnet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)",
	defaultBaseParams->OnionServiceTargetPort(),
	testnetBaseParams->OnionServiceTargetPort(),
	regtestBaseParams->OnionServiceTargetPort()),
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-connect=<ip>",
	"Connect only to the specified node(s); -connect=0 disables automatic "
	"connections (the rules for this peer are the same as for -addnode)",
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-discover",
	"Discover own IP addresses (default: 1 when listening and no "
	"-externalip or -proxy)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-dns",
	strprintf("Allow DNS lookups for -addnode, -seednode and "
	"-connect (default: %d)",
	DEFAULT_NAME_LOOKUP),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-dnsseed",
	strprintf(
	"Query for peer addresses via DNS lookup, if low on addresses "
	"(default: %u unless -connect used)",
	DEFAULT_DNSSEED),
	ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
	argsman.AddArg("-externalip=<ip>", "Specify your own public address",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-fixedseeds",
	strprintf(
	"Allow fixed seeds if DNS seeds don't provide peers (default: %u)",
	DEFAULT_FIXEDSEEDS),
	ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-forcednsseed",
	strprintf(
	"Always query for peer addresses via DNS lookup (default: %d)",
	DEFAULT_FORCEDNSSEED),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-overridednsseed",
	"If set, only use the specified DNS seed when "
	"querying for peer addresses via DNS lookup.",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-listen",
	"Accept connections from outside (default: 1 if no -proxy or -connect)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-listenonion",
	strprintf("Automatically create Tor onion service (default: %d)",
	DEFAULT_LISTEN_ONION),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-maxconnections=<n>",
	strprintf("Maintain at most <n> connections to peers. The effective "
	"limit depends on system limitations and might be lower than "
	"the specified value (default: %u)",
	DEFAULT_MAX_PEER_CONNECTIONS),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-maxreceivebuffer=<n>",
	strprintf("Maximum per-connection receive buffer, <n>*1000 "
	"bytes (default: %u)",
	DEFAULT_MAXRECEIVEBUFFER),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-maxsendbuffer=<n>",
	strprintf(
	"Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
	DEFAULT_MAXSENDBUFFER),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-maxtimeadjustment",
	strprintf("Maximum allowed median peer time offset adjustment. Local "
	"perspective of time may be influenced by peers forward or "
	"backward by this amount. (default: %u seconds)",
	DEFAULT_MAX_TIME_ADJUSTMENT),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-onion=<ip:port>",
	strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
	"onion services (default: %s)",
	"-proxy"),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-i2psam=<ip:port>",
	"I2P SAM proxy to reach I2P peers and accept I2P "
	"connections (default: none)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-i2pacceptincoming",
	"If set and -i2psam is also set then incoming I2P connections are "
	"accepted via the SAM proxy. If this is not set but -i2psam is set "
	"then only outgoing connections will be made to the I2P network. "
	"Ignored if -i2psam is not set. Listening for incoming I2P connections "
	"is done through the SAM proxy, not by binding to a local address and "
	"port (default: 1)",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);

	argsman.AddArg(
	"-onlynet=<net>",
	"Make outgoing connections only through network <net> (" +
	Join(GetNetworkNames(), ", ") +
	"). Incoming connections are not affected by this option. This "
	"option can be specified multiple times to allow multiple "
	"networks. Warning: if it is used with non-onion networks "
	"and the -onion or -proxy option is set, then outbound onion "
	"connections will still be made; use -noonion or -onion=0 to "
	"disable outbound onion connections in this case",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-peerbloomfilters",
	strprintf("Support filtering of blocks and transaction with "
	"bloom filters (default: %d)",
	DEFAULT_PEERBLOOMFILTERS),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-peerblockfilters",
	strprintf(
	"Serve compact block filters to peers per BIP 157 (default: %u)",
	DEFAULT_PEERBLOCKFILTERS),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-permitbaremultisig",
	strprintf("Relay non-P2SH multisig (default: %d)",
	DEFAULT_PERMIT_BAREMULTISIG),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	+ // TODO: remove the sentence "Nodes not using ... incoming connections."
	+ // once the changes from https://github.com/bitcoin/bitcoin/pull/23542 have
	+ // become widespread.
	argsman.AddArg("-port=<port>",
	strprintf("Listen for connections on <port>. Nodes not "
	"using the default ports (default: %u, "
	"testnet: %u, regtest: %u) are unlikely to get "
	"incoming connections. Not relevant for I2P (see "
	"doc/i2p.md).",
	defaultChainParams->GetDefaultPort(),
	testnetChainParams->GetDefaultPort(),
	regtestChainParams->GetDefaultPort()),
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CONNECTION);
	argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-proxyrandomize",
	strprintf("Randomize credentials for every proxy connection. "
	"This enables Tor stream isolation (default: %d)",
	DEFAULT_PROXYRANDOMIZE),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-seednode=<ip>",
	"Connect to a node to retrieve peer addresses, and disconnect",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-networkactive",
	"Enable all P2P network activity (default: 1). Can be changed "
	"by the setnetworkactive RPC command",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
	argsman.AddArg("-timeout=<n>",
	strprintf("Specify connection timeout in milliseconds "
	"(minimum: 1, default: %d)",
	DEFAULT_CONNECT_TIMEOUT),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-peertimeout=<n>",
	strprintf("Specify p2p connection timeout in seconds. This option "
	"determines the amount of time a peer may be inactive before "
	"the connection to it is dropped. (minimum: 1, default: %d)",
	DEFAULT_PEER_CONNECT_TIMEOUT),
	true, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-torcontrol=<ip>:<port>",
	strprintf(
	"Tor control port to use if onion listening enabled (default: %s)",
	DEFAULT_TOR_CONTROL),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg("-torpassword=<pass>",
	"Tor control port password (default: empty)",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::CONNECTION);
	#ifdef USE_UPNP
	#if USE_UPNP
	argsman.AddArg("-upnp",
	"Use UPnP to map the listening port (default: 1 when "
	"listening and no -proxy)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	#else
	argsman.AddArg(
	"-upnp",
	strprintf("Use UPnP to map the listening port (default: %u)", 0),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	#endif
	#else
	hidden_args.emplace_back("-upnp");
	#endif
	#ifdef USE_NATPMP
	argsman.AddArg(
	"-natpmp",
	strprintf("Use NAT-PMP to map the listening port (default: %s)",
	DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"),
	ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
	#else
	hidden_args.emplace_back("-natpmp");
	#endif // USE_NATPMP
	argsman.AddArg(
	"-whitebind=<[permissions@]addr>",
	"Bind to the given address and add permission flags to the peers "
	"connecting to it."
	"Use [host]:port notation for IPv6. Allowed permissions: " +
	Join(NET_PERMISSIONS_DOC, ", ") +
	". "
	"Specify multiple permissions separated by commas (default: "
	"download,noban,mempool,relay). Can be specified multiple times.",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

	argsman.AddArg("-whitelist=<[permissions@]IP address or network>",
	"Add permission flags to the peers connecting from the "
	"given IP address (e.g. 1.2.3.4) or CIDR-notated network "
	"(e.g. 1.2.3.0/24). "
	"Uses the same permissions as -whitebind. Can be specified "
	"multiple times.",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	argsman.AddArg(
	"-maxuploadtarget=<n>",
	strprintf("Tries to keep outbound traffic under the given target (in "
	"MiB per 24h). Limit does not apply to peers with 'download' "
	"permission. 0 = no limit (default: %d)",
	DEFAULT_MAX_UPLOAD_TARGET),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

	g_wallet_init_interface.AddWalletOptions(argsman);

	#if ENABLE_ZMQ
	argsman.AddArg("-zmqpubhashblock=<address>",
	"Enable publish hash block in <address>",
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg("-zmqpubhashtx=<address>",
	"Enable publish hash transaction in <address>",
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg("-zmqpubrawblock=<address>",
	"Enable publish raw block in <address>",
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg("-zmqpubrawtx=<address>",
	"Enable publish raw transaction in <address>",
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg("-zmqpubsequence=<address>",
	"Enable publish hash block and tx sequence in <address>",
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg(
	"-zmqpubhashblockhwm=<n>",
	strprintf("Set publish hash block outbound message high water "
	"mark (default: %d)",
	CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg(
	"-zmqpubhashtxhwm=<n>",
	strprintf("Set publish hash transaction outbound message high "
	"water mark (default: %d)",
	CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
	false, OptionsCategory::ZMQ);
	argsman.AddArg(
	"-zmqpubrawblockhwm=<n>",
	strprintf("Set publish raw block outbound message high water "
	"mark (default: %d)",
	CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg(
	"-zmqpubrawtxhwm=<n>",
	strprintf("Set publish raw transaction outbound message high "
	"water mark (default: %d)",
	CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	argsman.AddArg("-zmqpubsequencehwm=<n>",
	strprintf("Set publish hash sequence message high water mark"
	" (default: %d)",
	CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
	ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
	#else
	hidden_args.emplace_back("-zmqpubhashblock=<address>");
	hidden_args.emplace_back("-zmqpubhashtx=<address>");
	hidden_args.emplace_back("-zmqpubrawblock=<address>");
	hidden_args.emplace_back("-zmqpubrawtx=<address>");
	hidden_args.emplace_back("-zmqpubsequence=<n>");
	hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
	hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
	hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
	hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
	hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
	#endif

	argsman.AddArg(
	"-checkblocks=<n>",
	strprintf("How many blocks to check at startup (default: %u, 0 = all)",
	DEFAULT_CHECKBLOCKS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checklevel=<n>",
	strprintf("How thorough the block verification of "
	"-checkblocks is: %s (0-4, default: %u)",
	Join(CHECKLEVEL_DOC, ", "), DEFAULT_CHECKLEVEL),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checkblockindex",
	strprintf("Do a consistency check for the block tree, "
	"chainstate, and other validation data structures "
	"occasionally. (default: %u, regtest: %u)",
	defaultChainParams->DefaultConsistencyChecks(),
	regtestChainParams->DefaultConsistencyChecks()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checkaddrman=<n>",
	strprintf("Run addrman consistency checks every <n> "
	"operations. Use 0 to disable. (default: %u)",
	DEFAULT_ADDRMAN_CONSISTENCY_CHECKS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-checkmempool=<n>",
	strprintf("Run mempool consistency checks every <n> transactions. Use "
	"0 to disable. (default: %u, regtest: %u)",
	defaultChainParams->DefaultConsistencyChecks(),
	regtestChainParams->DefaultConsistencyChecks()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checkpoints",
	strprintf("Only accept block chain matching built-in "
	"checkpoints (default: %d)",
	DEFAULT_CHECKPOINTS_ENABLED),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-deprecatedrpc=<method>",
	"Allows deprecated RPC method(s) to be used",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-stopafterblockimport",
	strprintf("Stop running after importing blocks from disk (default: %d)",
	DEFAULT_STOPAFTERBLOCKIMPORT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-stopatheight",
	strprintf("Stop running after reaching the given height in "
	"the main chain (default: %u)",
	DEFAULT_STOPATHEIGHT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-limitancestorcount=<n>",
	strprintf("Do not accept transactions if number of in-mempool "
	"ancestors is <n> or more (default: %u)",
	DEFAULT_ANCESTOR_LIMIT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-limitancestorsize=<n>",
	strprintf("Do not accept transactions whose size with all in-mempool "
	"ancestors exceeds <n> kilobytes (default: %u)",
	DEFAULT_ANCESTOR_SIZE_LIMIT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-limitdescendantcount=<n>",
	strprintf("Do not accept transactions if any ancestor would have <n> "
	"or more in-mempool descendants (default: %u)",
	DEFAULT_DESCENDANT_LIMIT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-limitdescendantsize=<n>",
	strprintf("Do not accept transactions if any ancestor would have more "
	"than <n> kilobytes of in-mempool descendants (default: %u).",
	DEFAULT_DESCENDANT_SIZE_LIMIT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-addrmantest", "Allows to test address relay on localhost",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);

	argsman.AddArg("-debug=<category>",
	strprintf("Output debugging information (default: %u, "
	"supplying <category> is optional)",
	0) +
	". " +
	"If <category> is not supplied or if <category> = 1, "
	"output all debugging information. <category> can be: " +
	LogInstance().LogCategoriesString() + ".",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-debugexclude=<category>",
	strprintf("Exclude debugging information for a category. Can be used "
	"in conjunction with -debug=1 to output debug logs for all "
	"categories except one or more specified categories."),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-logips",
	strprintf("Include IP addresses in debug output (default: %d)",
	DEFAULT_LOGIPS),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-logtimestamps",
	strprintf("Prepend debug output with timestamp (default: %d)",
	DEFAULT_LOGTIMESTAMPS),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	#ifdef HAVE_THREAD_LOCAL
	argsman.AddArg(
	"-logthreadnames",
	strprintf(
	"Prepend debug output with name of the originating thread (only "
	"available on platforms supporting thread_local) (default: %u)",
	DEFAULT_LOGTHREADNAMES),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	#else
	hidden_args.emplace_back("-logthreadnames");
	#endif
	argsman.AddArg(
	"-logsourcelocations",
	strprintf(
	"Prepend debug output with name of the originating source location "
	"(source file, line number and function name) (default: %u)",
	DEFAULT_LOGSOURCELOCATIONS),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-logtimemicros",
	strprintf("Add microsecond precision to debug timestamps (default: %d)",
	DEFAULT_LOGTIMEMICROS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-mocktime=<n>",
	"Replace actual time with " + UNIX_EPOCH_TIME +
	" (default: 0)",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-maxsigcachesize=<n>",
	strprintf("Limit size of signature cache to <n> MiB (default: %u)",
	DEFAULT_MAX_SIG_CACHE_SIZE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-maxscriptcachesize=<n>",
	strprintf("Limit size of script cache to <n> MiB (default: %u)",
	DEFAULT_MAX_SCRIPT_CACHE_SIZE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-maxtipage=<n>",
	strprintf("Maximum tip age in seconds to consider node in "
	"initial block download (default: %u)",
	DEFAULT_MAX_TIP_AGE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);

	argsman.AddArg(
	"-printtoconsole",
	"Send trace/debug info to console instead of debug.log file (default: "
	"1 when no -daemon. To disable logging to file, set debuglogfile=0)",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-printpriority",
	strprintf("Log transaction priority and fee per kB when "
	"mining blocks (default: %d)",
	DEFAULT_PRINTPRIORITY),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-shrinkdebugfile",
	"Shrink debug.log file on client startup (default: 1 when no -debug)",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

	argsman.AddArg("-uacomment=<cmt>",
	"Append comment to the user agent string",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-uaclientname=<clientname>", "Set user agent client name",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-uaclientversion=<clientversion>",
	"Set user agent client version", ArgsManager::ALLOW_ANY,
	OptionsCategory::DEBUG_TEST);

	SetupChainParamsBaseOptions(argsman);

	argsman.AddArg(
	"-acceptnonstdtxn",
	strprintf(
	"Relay and mine \"non-standard\" transactions (%sdefault: %u)",
	"testnet/regtest only; ", defaultChainParams->RequireStandard()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::NODE_RELAY);
	argsman.AddArg("-excessiveblocksize=<n>",
	strprintf("Do not accept blocks larger than this limit, in "
	"bytes (default: %d)",
	DEFAULT_MAX_BLOCK_SIZE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::NODE_RELAY);
	const auto &ticker = Currency::get().ticker;
	argsman.AddArg(
	"-dustrelayfee=<amt>",
	strprintf("Fee rate (in %s/kB) used to define dust, the value of an "
	"output such that it will cost about 1/3 of its value in "
	"fees at this fee rate to spend it. (default: %s)",
	ticker, FormatMoney(DUST_RELAY_TX_FEE)),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::NODE_RELAY);

	argsman.AddArg("-bytespersigop",
	strprintf("Equivalent bytes per sigop in transactions for "
	"relay and mining (default: %u)",
	DEFAULT_BYTES_PER_SIGOP),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	argsman.AddArg(
	"-datacarrier",
	strprintf("Relay and mine data carrier transactions (default: %d)",
	DEFAULT_ACCEPT_DATACARRIER),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	argsman.AddArg(
	"-datacarriersize",
	strprintf("Maximum size of data in data carrier transactions "
	"we relay and mine (default: %u)",
	MAX_OP_RETURN_RELAY),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	argsman.AddArg(
	"-minrelaytxfee=<amt>",
	strprintf("Fees (in %s/kB) smaller than this are rejected for "
	"relaying, mining and transaction creation (default: %s)",
	ticker, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE_PER_KB)),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	argsman.AddArg(
	"-whitelistrelay",
	strprintf("Add 'relay' permission to whitelisted inbound peers "
	"with default permissions. This will accept relayed "
	"transactions even when not relaying transactions "
	"(default: %d)",
	DEFAULT_WHITELISTRELAY),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	argsman.AddArg(
	"-whitelistforcerelay",
	strprintf("Add 'forcerelay' permission to whitelisted inbound peers"
	" with default permissions. This will relay transactions "
	"even if the transactions were already in the mempool "
	"(default: %d)",
	DEFAULT_WHITELISTFORCERELAY),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);

	// Not sure this really belongs here, but it will do for now.
	// FIXME: This doesn't work anyways.
	argsman.AddArg("-excessutxocharge=<amt>",
	strprintf("Fees (in %s/kB) to charge per utxo created for "
	"relaying, and mining (default: %s)",
	ticker, FormatMoney(DEFAULT_UTXO_FEE)),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::NODE_RELAY);

	argsman.AddArg("-blockmaxsize=<n>",
	strprintf("Set maximum block size in bytes (default: %d)",
	DEFAULT_MAX_GENERATED_BLOCK_SIZE),
	ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
	argsman.AddArg(
	"-blockmintxfee=<amt>",
	strprintf("Set lowest fee rate (in %s/kB) for transactions to "
	"be included in block creation. (default: %s)",
	ticker, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB)),
	ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);

	argsman.AddArg("-blockversion=<n>",
	"Override block version to test forking scenarios",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::BLOCK_CREATION);

	argsman.AddArg("-server", "Accept command line and JSON-RPC commands",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	argsman.AddArg("-rest",
	strprintf("Accept public REST requests (default: %d)",
	DEFAULT_REST_ENABLE),
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	argsman.AddArg(
	"-rpcbind=<addr>[:port]",
	"Bind to given address to listen for JSON-RPC connections. Do not "
	"expose the RPC server to untrusted networks such as the public "
	"internet! This option is ignored unless -rpcallowip is also passed. "
	"Port is optional and overrides -rpcport. Use [host]:port notation "
	"for IPv6. This option can be specified multiple times (default: "
	"127.0.0.1 and ::1 i.e., localhost)",
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY \|
	ArgsManager::SENSITIVE,
	OptionsCategory::RPC);
	argsman.AddArg(
	"-rpccookiefile=<loc>",
	"Location of the auth cookie. Relative paths will be prefixed "
	"by a net-specific datadir location. (default: data dir)",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::RPC);
	argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::RPC);
	argsman.AddArg(
	"-rpcwhitelist=<whitelist>",
	"Set a whitelist to filter incoming RPC calls for a specific user. The "
	"field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc "
	"2>,...,<rpc n>. If multiple whitelists are set for a given user, they "
	"are set-intersected. See -rpcwhitelistdefault documentation for "
	"information on default whitelist behavior.",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	argsman.AddArg(
	"-rpcwhitelistdefault",
	"Sets default behavior for rpc whitelisting. Unless "
	"rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc "
	"server acts as if all rpc users are subject to "
	"empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault "
	"is set to 1 and no -rpcwhitelist is set, rpc server acts as if all "
	"rpc users are subject to empty whitelists.",
	ArgsManager::ALLOW_BOOL, OptionsCategory::RPC);
	argsman.AddArg(
	"-rpcauth=<userpw>",
	"Username and HMAC-SHA-256 hashed password for JSON-RPC connections. "
	"The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A "
	"canonical python script is included in share/rpcauth. The client then "
	"connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> "
	"pair of arguments. This option can be specified multiple times",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE, OptionsCategory::RPC);
	argsman.AddArg("-rpcport=<port>",
	strprintf("Listen for JSON-RPC connections on <port> "
	"(default: %u, testnet: %u, regtest: %u)",
	defaultBaseParams->RPCPort(),
	testnetBaseParams->RPCPort(),
	regtestBaseParams->RPCPort()),
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::RPC);
	argsman.AddArg(
	"-rpcallowip=<ip>",
	"Allow JSON-RPC connections from specified source. Valid for "
	"<ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. "
	"1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). "
	"This option can be specified multiple times",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	argsman.AddArg(
	"-rpcthreads=<n>",
	strprintf(
	"Set the number of threads to service RPC calls (default: %d)",
	DEFAULT_HTTP_THREADS),
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	argsman.AddArg(
	"-rpccorsdomain=value",
	"Domain from which to accept cross origin requests (browser enforced)",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

	argsman.AddArg("-rpcworkqueue=<n>",
	strprintf("Set the depth of the work queue to service RPC "
	"calls (default: %d)",
	DEFAULT_HTTP_WORKQUEUE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::RPC);
	argsman.AddArg("-rpcservertimeout=<n>",
	strprintf("Timeout during HTTP requests (default: %d)",
	DEFAULT_HTTP_SERVER_TIMEOUT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::RPC);

	#if HAVE_DECL_DAEMON
	argsman.AddArg("-daemon",
	"Run in the background as a daemon and accept commands",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#else
	hidden_args.emplace_back("-daemon");
	#endif

	// Avalanche options.
	argsman.AddArg("-avalanche",
	strprintf("Enable the avalanche feature (default: %u)",
	AVALANCHE_DEFAULT_ENABLED),
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	argsman.AddArg("-avalancheconflictingproofcooldown",
	strprintf("Mandatory cooldown before a proof conflicting "
	"with an already registered one can be considered "
	"in seconds (default: %u)",
	AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN),
	ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
	argsman.AddArg("-avalanchepeerreplacementcooldown",
	strprintf("Mandatory cooldown before a peer can be replaced "
	"in seconds (default: %u)",
	AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN),
	ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avaminquorumstake",
	strprintf(
	"Minimum amount of known stake for a usable quorum (default: %s)",
	FormatMoney(AVALANCHE_DEFAULT_MIN_QUORUM_STAKE)),
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avaminquorumconnectedstakeratio",
	strprintf("Minimum proportion of known stake we"
	" need nodes for to have a usable quorum (default: %s)",
	AVALANCHE_DEFAULT_MIN_QUORUM_CONNECTED_STAKE_RATIO),
	ArgsManager::ALLOW_STRING, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avaminavaproofsnodecount",
	strprintf("Minimum number of node that needs to send us an avaproofs"
	" message before we consider we have a usable quorum"
	" (default: %s)",
	AVALANCHE_DEFAULT_MIN_AVAPROOFS_NODE_COUNT),
	ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avastalevotethreshold",
	strprintf("Number of avalanche votes before a voted item goes stale "
	"when voting confidence is low (default: %u)",
	AVALANCHE_VOTE_STALE_THRESHOLD),
	ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avastalevotefactor",
	strprintf(
	"Factor affecting the number of avalanche votes before a voted "
	"item goes stale when voting confidence is high (default: %u)",
	AVALANCHE_VOTE_STALE_FACTOR),
	ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
	argsman.AddArg("-avacooldown",
	strprintf("Mandatory cooldown between two avapoll in "
	"milliseconds (default: %u)",
	AVALANCHE_DEFAULT_COOLDOWN),
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avatimeout",
	strprintf("Avalanche query timeout in milliseconds (default: %u)",
	AVALANCHE_DEFAULT_QUERY_TIMEOUT.count()),
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avadelegation",
	"Avalanche proof delegation to the master key used by this node "
	"(default: none). Should be used in conjunction with -avaproof and "
	"-avamasterkey",
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	argsman.AddArg("-avaproof",
	"Avalanche proof to be used by this node (default: none)",
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	argsman.AddArg(
	"-avaproofstakeutxoconfirmations",
	strprintf(
	"Minimum number of confirmations before a stake utxo is mature"
	" enough to be included into a proof. Utxos in the mempool are not "
	"accepted (i.e this value must be greater than 0) (default: %s)",
	AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS),
	ArgsManager::ALLOW_INT, OptionsCategory::HIDDEN);
	argsman.AddArg("-avaproofstakeutxodustthreshold",
	strprintf("Minimum value each stake utxo must have to be "
	"considered valid (default: %s)",
	avalanche::PROOF_DUST_THRESHOLD),
	ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
	argsman.AddArg("-avamasterkey",
	"Master key associated with the proof. If a proof is "
	"required, this is mandatory.",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::AVALANCHE);
	argsman.AddArg("-avasessionkey", "Avalanche session key (default: random)",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::HIDDEN);
	argsman.AddArg(
	"-maxavalancheoutbound",
	strprintf(
	"Set the maximum number of avalanche outbound peers to connect to. "
	"Note that the -maxconnections option takes precedence (default: "
	"%u).",
	DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS),
	ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);

	// Add the hidden options
	argsman.AddHiddenArgs(hidden_args);
	}

	std::string LicenseInfo() {
	const std::string URL_SOURCE_CODE =
	"<https://github.com/Bitcoin-ABC/bitcoin-abc>";
	const std::string URL_WEBSITE = "<https://www.bitcoinabc.org>";

	return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009,
	COPYRIGHT_YEAR) +
	" ") +
	"\n" + "\n" +
	strprintf(_("Please contribute if you find %s useful. "
	"Visit %s for further information about the software.")
	.translated,
	PACKAGE_NAME, URL_WEBSITE) +
	"\n" +
	strprintf(_("The source code is available from %s.").translated,
	URL_SOURCE_CODE) +
	"\n" + "\n" + _("This is experimental software.").translated + "\n" +
	strprintf(_("Distributed under the MIT software license, see the "
	"accompanying file %s or %s")
	.translated,
	"COPYING", "<https://opensource.org/licenses/MIT>") +
	"\n" + "\n" +
	strprintf(_("This product includes software developed by the "
	"OpenSSL Project for use in the OpenSSL Toolkit %s and "
	"cryptographic software written by Eric Young and UPnP "
	"software written by Thomas Bernard.")
	.translated,
	"<https://www.openssl.org>") +
	"\n";
	}

	static bool fHaveGenesis = false;
	static Mutex g_genesis_wait_mutex;
	static std::condition_variable g_genesis_wait_cv;

	static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex) {
	if (pBlockIndex != nullptr) {
	{
	LOCK(g_genesis_wait_mutex);
	fHaveGenesis = true;
	}
	g_genesis_wait_cv.notify_all();
	}
	}

	#if HAVE_SYSTEM
	static void StartupNotify(const ArgsManager &args) {
	std::string cmd = args.GetArg("-startupnotify", "");
	if (!cmd.empty()) {
	std::thread t(runCommand, cmd);
	// thread runs free
	t.detach();
	}
	}
	#endif

	/** Sanity checks
	* Ensure that Bitcoin is running in a usable environment with all
	* necessary library support.
	*/
	static bool InitSanityCheck() {
	if (!ECC_InitSanityCheck()) {
	return InitError(Untranslated(
	"Elliptic curve cryptography sanity check failure. Aborting."));
	}

	if (!glibcxx_sanity_test()) {
	return false;
	}

	if (!Random_SanityCheck()) {
	return InitError(Untranslated(
	"OS cryptographic RNG sanity check failure. Aborting."));
	}

	if (!ChronoSanityCheck()) {
	return InitError(Untranslated("Clock epoch mismatch. Aborting."));
	}

	return true;
	}

	static bool AppInitServers(Config &config,
	HTTPRPCRequestProcessor &httpRPCRequestProcessor,
	NodeContext &node) {
	const ArgsManager &args = *Assert(node.args);
	RPCServerSignals::OnStarted(&OnRPCStarted);
	RPCServerSignals::OnStopped(&OnRPCStopped);
	if (!InitHTTPServer(config)) {
	return false;
	}

	StartRPC();
	node.rpc_interruption_point = RpcInterruptionPoint;

	if (!StartHTTPRPC(httpRPCRequestProcessor)) {
	return false;
	}
	if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
	StartREST(&node);
	}

	StartHTTPServer();
	return true;
	}

	// Parameter interaction based on rules
	void InitParameterInteraction(ArgsManager &args) {
	// when specifying an explicit binding address, you want to listen on it
	// even when -connect or -proxy is specified.
	if (args.IsArgSet("-bind")) {
	if (args.SoftSetBoolArg("-listen", true)) {
	LogPrintf(
	"%s: parameter interaction: -bind set -> setting -listen=1\n",
	__func__);
	}
	}
	if (args.IsArgSet("-whitebind")) {
	if (args.SoftSetBoolArg("-listen", true)) {
	LogPrintf("%s: parameter interaction: -whitebind set -> setting "
	"-listen=1\n",
	__func__);
	}
	}

	if (args.IsArgSet("-connect")) {
	// when only connecting to trusted nodes, do not seed via DNS, or listen
	// by default.
	if (args.SoftSetBoolArg("-dnsseed", false)) {
	LogPrintf("%s: parameter interaction: -connect set -> setting "
	"-dnsseed=0\n",
	__func__);
	}
	if (args.SoftSetBoolArg("-listen", false)) {
	LogPrintf("%s: parameter interaction: -connect set -> setting "
	"-listen=0\n",
	__func__);
	}
	}

	if (args.IsArgSet("-proxy")) {
	// to protect privacy, do not listen by default if a default proxy
	// server is specified.
	if (args.SoftSetBoolArg("-listen", false)) {
	LogPrintf(
	"%s: parameter interaction: -proxy set -> setting -listen=0\n",
	__func__);
	}
	// to protect privacy, do not map ports when a proxy is set. The user
	// may still specify -listen=1 to listen locally, so don't rely on this
	// happening through -listen below.
	if (args.SoftSetBoolArg("-upnp", false)) {
	LogPrintf(
	"%s: parameter interaction: -proxy set -> setting -upnp=0\n",
	__func__);
	}
	if (args.SoftSetBoolArg("-natpmp", false)) {
	LogPrintf(
	"%s: parameter interaction: -proxy set -> setting -natpmp=0\n",
	__func__);
	}
	// to protect privacy, do not discover addresses by default
	if (args.SoftSetBoolArg("-discover", false)) {
	LogPrintf("%s: parameter interaction: -proxy set -> setting "
	"-discover=0\n",
	__func__);
	}
	}

	if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
	// do not map ports or try to retrieve public IP when not listening
	// (pointless)
	if (args.SoftSetBoolArg("-upnp", false)) {
	LogPrintf(
	"%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
	__func__);
	}
	if (args.SoftSetBoolArg("-natpmp", false)) {
	LogPrintf(
	"%s: parameter interaction: -listen=0 -> setting -natpmp=0\n",
	__func__);
	}
	if (args.SoftSetBoolArg("-discover", false)) {
	LogPrintf(
	"%s: parameter interaction: -listen=0 -> setting -discover=0\n",
	__func__);
	}
	if (args.SoftSetBoolArg("-listenonion", false)) {
	LogPrintf("%s: parameter interaction: -listen=0 -> setting "
	"-listenonion=0\n",
	__func__);
	}
	if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
	LogPrintf("%s: parameter interaction: -listen=0 -> setting "
	"-i2pacceptincoming=0\n",
	__func__);
	}
	}

	if (args.IsArgSet("-externalip")) {
	// if an explicit public IP is specified, do not try to find others
	if (args.SoftSetBoolArg("-discover", false)) {
	LogPrintf("%s: parameter interaction: -externalip set -> setting "
	"-discover=0\n",
	__func__);
	}
	}

	// disable whitelistrelay in blocksonly mode
	if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
	if (args.SoftSetBoolArg("-whitelistrelay", false)) {
	LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
	"-whitelistrelay=0\n",
	__func__);
	}
	}

	// Forcing relay from whitelisted hosts implies we will accept relays from
	// them in the first place.
	if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
	if (args.SoftSetBoolArg("-whitelistrelay", true)) {
	LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
	"setting -whitelistrelay=1\n",
	__func__);
	}
	}

	// If avalanche is set, soft set all the feature flags accordingly.
	if (args.IsArgSet("-avalanche")) {
	const bool fAvalanche =
	args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
	args.SoftSetBoolArg("-automaticunparking", !fAvalanche);
	}
	}

	/**
	* Initialize global loggers.
	*
	* Note that this is called very early in the process lifetime, so you should be
	* careful about what global state you rely on here.
	*/
	void InitLogging(const ArgsManager &args) {
	LogInstance().m_print_to_file = !args.IsArgNegated("-debuglogfile");
	LogInstance().m_file_path = AbsPathForConfigVal(
	fs::PathFromString(args.GetArg("-debuglogfile", DEFAULT_DEBUGLOGFILE)));

	LogInstance().m_print_to_console =
	args.GetBoolArg("-printtoconsole", !args.GetBoolArg("-daemon", false));
	LogInstance().m_log_timestamps =
	args.GetBoolArg("-logtimestamps", DEFAULT_LOGTIMESTAMPS);
	LogInstance().m_log_time_micros =
	args.GetBoolArg("-logtimemicros", DEFAULT_LOGTIMEMICROS);
	#ifdef HAVE_THREAD_LOCAL
	LogInstance().m_log_threadnames =
	args.GetBoolArg("-logthreadnames", DEFAULT_LOGTHREADNAMES);
	#endif
	LogInstance().m_log_sourcelocations =
	args.GetBoolArg("-logsourcelocations", DEFAULT_LOGSOURCELOCATIONS);

	fLogIPs = args.GetBoolArg("-logips", DEFAULT_LOGIPS);

	std::string version_string = FormatFullVersion();
	#ifdef DEBUG
	version_string += " (debug build)";
	#else
	version_string += " (release build)";
	#endif
	LogPrintf("%s version %s\n", CLIENT_NAME, version_string);
	}

	namespace { // Variables internal to initialization process only

	int nMaxConnections;
	int nUserMaxConnections;
	int nFD;
	ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK \| NODE_NETWORK_LIMITED);
	int64_t peer_connect_timeout;
	std::set<BlockFilterType> g_enabled_filter_types;

	} // namespace

	[[noreturn]] static void new_handler_terminate() {
	// Rather than throwing std::bad-alloc if allocation fails, terminate
	// immediately to (try to) avoid chain corruption. Since LogPrintf may
	// itself allocate memory, set the handler directly to terminate first.
	std::set_new_handler(std::terminate);
	LogPrintf("Error: Out of memory. Terminating.\n");

	// The log was successful, terminate now.
	std::terminate();
	};

	bool AppInitBasicSetup(const ArgsManager &args) {
	// Step 1: setup
	#ifdef _MSC_VER
	// Turn off Microsoft heap dump noise
	_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
	_CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
	OPEN_EXISTING, 0, 0));
	// Disable confusing "helpful" text message on abort, Ctrl-C
	_set_abort_behavior(0, _WRITE_ABORT_MSG \| _CALL_REPORTFAULT);
	#endif
	#ifdef WIN32
	// Enable Data Execution Prevention (DEP)
	SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
	#endif

	if (!SetupNetworking()) {
	return InitError(Untranslated("Initializing networking failed"));
	}

	#ifndef WIN32
	if (!args.GetBoolArg("-sysperms", false)) {
	umask(077);
	}

	// Clean shutdown on SIGTERM
	registerSignalHandler(SIGTERM, HandleSIGTERM);
	registerSignalHandler(SIGINT, HandleSIGTERM);

	// Reopen debug.log on SIGHUP
	registerSignalHandler(SIGHUP, HandleSIGHUP);

	// Ignore SIGPIPE, otherwise it will bring the daemon down if the client
	// closes unexpectedly
	signal(SIGPIPE, SIG_IGN);
	#else
	SetConsoleCtrlHandler(consoleCtrlHandler, true);
	#endif

	std::set_new_handler(new_handler_terminate);

	return true;
	}

	bool AppInitParameterInteraction(Config &config, const ArgsManager &args) {
	const CChainParams &chainparams = config.GetChainParams();
	// Step 2: parameter interactions

	// also see: InitParameterInteraction()

	// Error if network-specific options (-addnode, -connect, etc) are
	// specified in default section of config file, but not overridden
	// on the command line or in this network's section of the config file.
	std::string network = args.GetChainName();
	bilingual_str errors;
	for (const auto &arg : args.GetUnsuitableSectionOnlyArgs()) {
	errors += strprintf(_("Config setting for %s only applied on %s "
	"network when in [%s] section.") +
	Untranslated("\n"),
	arg, network, network);
	}

	if (!errors.empty()) {
	return InitError(errors);
	}

	// Warn if unrecognized section name are present in the config file.
	bilingual_str warnings;
	for (const auto &section : args.GetUnrecognizedSections()) {
	warnings += strprintf(Untranslated("%s:%i ") +
	_("Section [%s] is not recognized.") +
	Untranslated("\n"),
	section.m_file, section.m_line, section.m_name);
	}

	if (!warnings.empty()) {
	InitWarning(warnings);
	}

	if (!fs::is_directory(gArgs.GetBlocksDirPath())) {
	return InitError(
	strprintf(_("Specified blocks directory \"%s\" does not exist."),
	args.GetArg("-blocksdir", "")));
	}

	// parse and validate enabled filter types
	std::string blockfilterindex_value =
	args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
	if (blockfilterindex_value == "" \|\| blockfilterindex_value == "1") {
	g_enabled_filter_types = AllBlockFilterTypes();
	} else if (blockfilterindex_value != "0") {
	const std::vector<std::string> names =
	args.GetArgs("-blockfilterindex");
	for (const auto &name : names) {
	BlockFilterType filter_type;
	if (!BlockFilterTypeByName(name, filter_type)) {
	return InitError(
	strprintf(_("Unknown -blockfilterindex value %s."), name));
	}
	g_enabled_filter_types.insert(filter_type);
	}
	}

	// Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index
	// are both enabled.
	if (gArgs.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
	if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
	return InitError(
	_("Cannot set -peerblockfilters without -blockfilterindex."));
	}

	nLocalServices = ServiceFlags(nLocalServices \| NODE_COMPACT_FILTERS);
	}

	// if using block pruning, then disallow txindex and coinstatsindex
	if (args.GetIntArg("-prune", 0)) {
	if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	return InitError(_("Prune mode is incompatible with -txindex."));
	}
	if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
	return InitError(
	_("Prune mode is incompatible with -coinstatsindex."));
	}
	}

	// -bind and -whitebind can't be set when not listening
	size_t nUserBind =
	args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
	if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
	return InitError(Untranslated(
	"Cannot set -bind or -whitebind together with -listen=0"));
	}

	// Make sure enough file descriptors are available
	int nBind = std::max(nUserBind, size_t(1));
	nUserMaxConnections =
	args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
	nMaxConnections = std::max(nUserMaxConnections, 0);

	// Trim requested connection counts, to fit into system limitations
	// <int> in std::min<int>(...) to work around FreeBSD compilation issue
	// described in #2695
	nFD = RaiseFileDescriptorLimit(nMaxConnections + nBind +
	MIN_CORE_FILEDESCRIPTORS +
	MAX_ADDNODE_CONNECTIONS);
	#ifdef USE_POLL
	int fd_max = nFD;
	#else
	int fd_max = FD_SETSIZE;
	#endif
	nMaxConnections =
	std::max(std::min<int>(nMaxConnections, fd_max - nBind -
	MIN_CORE_FILEDESCRIPTORS -
	MAX_ADDNODE_CONNECTIONS),
	0);
	if (nFD < MIN_CORE_FILEDESCRIPTORS) {
	return InitError(_("Not enough file descriptors available."));
	}
	nMaxConnections =
	std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS,
	nMaxConnections);

	if (nMaxConnections < nUserMaxConnections) {
	// Not categorizing as "Warning" because this is the normal behavior for
	// platforms using the select() interface for which FD_SETSIZE is
	// usually 1024.
	LogPrintf("Reducing -maxconnections from %d to %d, because of system "
	"limitations.\n",
	nUserMaxConnections, nMaxConnections);
	}

	// Step 3: parameter-to-internal-flags
	if (args.IsArgSet("-debug")) {
	// Special-case: if -debug=0/-nodebug is set, turn off debugging
	// messages
	const std::vector<std::string> &categories = args.GetArgs("-debug");
	if (std::none_of(
	categories.begin(), categories.end(),
	[](std::string cat) { return cat == "0" \|\| cat == "none"; })) {
	for (const auto &cat : categories) {
	if (!LogInstance().EnableCategory(cat)) {
	InitWarning(
	strprintf(_("Unsupported logging category %s=%s."),
	"-debug", cat));
	}
	}
	}
	}

	// Now remove the logging categories which were explicitly excluded
	for (const std::string &cat : args.GetArgs("-debugexclude")) {
	if (!LogInstance().DisableCategory(cat)) {
	InitWarning(strprintf(_("Unsupported logging category %s=%s."),
	"-debugexclude", cat));
	}
	}

	fCheckBlockIndex = args.GetBoolArg("-checkblockindex",
	chainparams.DefaultConsistencyChecks());
	fCheckpointsEnabled =
	args.GetBoolArg("-checkpoints", DEFAULT_CHECKPOINTS_ENABLED);
	if (fCheckpointsEnabled) {
	LogPrintf("Checkpoints will be verified.\n");
	} else {
	LogPrintf("Skipping checkpoint verification.\n");
	}

	hashAssumeValid = BlockHash::fromHex(
	args.GetArg("-assumevalid",
	chainparams.GetConsensus().defaultAssumeValid.GetHex()));
	if (!hashAssumeValid.IsNull()) {
	LogPrintf("Assuming ancestors of block %s have valid signatures.\n",
	hashAssumeValid.GetHex());
	} else {
	LogPrintf("Validating signatures for all blocks.\n");
	}

	if (args.IsArgSet("-minimumchainwork")) {
	const std::string minChainWorkStr =
	args.GetArg("-minimumchainwork", "");
	if (!IsHexNumber(minChainWorkStr)) {
	return InitError(strprintf(
	Untranslated(
	"Invalid non-hex (%s) minimum chain work value specified"),
	minChainWorkStr));
	}
	nMinimumChainWork = UintToArith256(uint256S(minChainWorkStr));
	} else {
	nMinimumChainWork =
	UintToArith256(chainparams.GetConsensus().nMinimumChainWork);
	}
	LogPrintf("Setting nMinimumChainWork=%s\n", nMinimumChainWork.GetHex());
	if (nMinimumChainWork <
	UintToArith256(chainparams.GetConsensus().nMinimumChainWork)) {
	LogPrintf("Warning: nMinimumChainWork set below default value of %s\n",
	chainparams.GetConsensus().nMinimumChainWork.GetHex());
	}

	// mempool limits
	int64_t nMempoolSizeMax =
	args.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
	int64_t nMempoolSizeMin =
	args.GetIntArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) *
	1000 * 40;
	if (nMempoolSizeMax < 0 \|\| nMempoolSizeMax < nMempoolSizeMin) {
	return InitError(strprintf(_("-maxmempool must be at least %d MB"),
	std::ceil(nMempoolSizeMin / 1000000.0)));
	}

	// Configure excessive block size.
	const int64_t nProposedExcessiveBlockSize =
	args.GetIntArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
	if (nProposedExcessiveBlockSize <= 0 \|\|
	!config.SetMaxBlockSize(nProposedExcessiveBlockSize)) {
	return InitError(
	_("Excessive block size must be > 1,000,000 bytes (1MB)"));
	}

	// Check blockmaxsize does not exceed maximum accepted block size.
	const int64_t nProposedMaxGeneratedBlockSize =
	args.GetIntArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
	if (nProposedMaxGeneratedBlockSize <= 0) {
	return InitError(_("Max generated block size must be greater than 0"));
	}
	if (uint64_t(nProposedMaxGeneratedBlockSize) > config.GetMaxBlockSize()) {
	return InitError(_("Max generated block size (blockmaxsize) cannot "
	"exceed the excessive block size "
	"(excessiveblocksize)"));
	}

	// block pruning; get the amount of disk space (in MiB) to allot for block &
	// undo files
	int64_t nPruneArg = args.GetIntArg("-prune", 0);
	if (nPruneArg < 0) {
	return InitError(
	_("Prune cannot be configured with a negative value."));
	}
	nPruneTarget = (uint64_t)nPruneArg * 1024 * 1024;
	if (nPruneArg == 1) {
	// manual pruning: -prune=1
	LogPrintf("Block pruning enabled. Use RPC call "
	"pruneblockchain(height) to manually prune block and undo "
	"files.\n");
	nPruneTarget = std::numeric_limits<uint64_t>::max();
	fPruneMode = true;
	} else if (nPruneTarget) {
	if (nPruneTarget < MIN_DISK_SPACE_FOR_BLOCK_FILES) {
	return InitError(
	strprintf(_("Prune configured below the minimum of %d MiB. "
	"Please use a higher number."),
	MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
	}
	LogPrintf("Prune configured to target %u MiB on disk for block and "
	"undo files.\n",
	nPruneTarget / 1024 / 1024);
	fPruneMode = true;
	}

	nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
	if (nConnectTimeout <= 0) {
	nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
	}

	peer_connect_timeout =
	args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
	if (peer_connect_timeout <= 0) {
	return InitError(Untranslated(
	"peertimeout cannot be configured with a negative value."));
	}

	// Obtain the amount to charge excess UTXO
	if (args.IsArgSet("-excessutxocharge")) {
	Amount n = Amount::zero();
	auto parsed = ParseMoney(args.GetArg("-excessutxocharge", ""), n);
	if (!parsed \|\| Amount::zero() > n) {
	return InitError(AmountErrMsg(
	"excessutxocharge", args.GetArg("-excessutxocharge", "")));
	}
	config.SetExcessUTXOCharge(n);
	} else {
	config.SetExcessUTXOCharge(DEFAULT_UTXO_FEE);
	}

	if (args.IsArgSet("-minrelaytxfee")) {
	Amount n = Amount::zero();
	auto parsed = ParseMoney(args.GetArg("-minrelaytxfee", ""), n);
	if (!parsed \|\| n == Amount::zero()) {
	return InitError(AmountErrMsg("minrelaytxfee",
	args.GetArg("-minrelaytxfee", "")));
	}
	// High fee check is done afterward in CWallet::Create()
	::minRelayTxFee = CFeeRate(n);
	}

	// Sanity check argument for min fee for including tx in block
	// TODO: Harmonize which arguments need sanity checking and where that
	// happens.
	if (args.IsArgSet("-blockmintxfee")) {
	Amount n = Amount::zero();
	if (!ParseMoney(args.GetArg("-blockmintxfee", ""), n)) {
	return InitError(AmountErrMsg("blockmintxfee",
	args.GetArg("-blockmintxfee", "")));
	}
	}

	// Feerate used to define dust. Shouldn't be changed lightly as old
	// implementations may inadvertently create non-standard transactions.
	if (args.IsArgSet("-dustrelayfee")) {
	Amount n = Amount::zero();
	auto parsed = ParseMoney(args.GetArg("-dustrelayfee", ""), n);
	if (!parsed \|\| Amount::zero() == n) {
	return InitError(
	AmountErrMsg("dustrelayfee", args.GetArg("-dustrelayfee", "")));
	}
	dustRelayFee = CFeeRate(n);
	}

	fRequireStandard =
	!args.GetBoolArg("-acceptnonstdtxn", !chainparams.RequireStandard());
	if (!chainparams.IsTestChain() && !fRequireStandard) {
	return InitError(strprintf(
	Untranslated(
	"acceptnonstdtxn is not currently supported for %s chain"),
	chainparams.NetworkIDString()));
	}
	nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);

	if (!g_wallet_init_interface.ParameterInteraction()) {
	return false;
	}

	fIsBareMultisigStd =
	args.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
	fAcceptDatacarrier =
	args.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER);

	// Option to startup with mocktime set (used for regression testing):
	SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op

	if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
	nLocalServices = ServiceFlags(nLocalServices \| NODE_BLOOM);
	}

	nMaxTipAge = args.GetIntArg("-maxtipage", DEFAULT_MAX_TIP_AGE);

	if (args.IsArgSet("-proxy") && args.GetArg("-proxy", "").empty()) {
	return InitError(_(
	"No proxy server specified. Use -proxy=<ip> or -proxy=<ip:port>."));
	}

	// Avalanche parameters
	const int64_t stakeUtxoMinConfirmations =
	args.GetIntArg("-avaproofstakeutxoconfirmations",
	AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS);

	if (!chainparams.IsTestChain() &&
	stakeUtxoMinConfirmations !=
	AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS) {
	return InitError(_("Avalanche stake UTXO minimum confirmations can "
	"only be set on test chains."));
	}

	if (stakeUtxoMinConfirmations <= 0) {
	return InitError(_("Avalanche stake UTXO minimum confirmations must be "
	"a positive integer."));
	}

	if (args.IsArgSet("-avaproofstakeutxodustthreshold")) {
	Amount amount = Amount::zero();
	auto parsed = ParseMoney(
	args.GetArg("-avaproofstakeutxodustthreshold", ""), amount);
	if (!parsed \|\| Amount::zero() == amount) {
	return InitError(AmountErrMsg(
	"avaproofstakeutxodustthreshold",
	args.GetArg("-avaproofstakeutxodustthreshold", "")));
	}

	if (!chainparams.IsTestChain() &&
	amount != avalanche::PROOF_DUST_THRESHOLD) {
	return InitError(_("Avalanche stake UTXO dust threshold can "
	"only be set on test chains."));
	}
	}

	return true;
	}

	static bool LockDataDirectory(bool probeOnly) {
	// Make sure only a single Bitcoin process is using the data directory.
	fs::path datadir = gArgs.GetDataDirNet();
	if (!DirIsWritable(datadir)) {
	return InitError(strprintf(
	_("Cannot write to data directory '%s'; check permissions."),
	fs::PathToString(datadir)));
	}
	if (!LockDirectory(datadir, ".lock", probeOnly)) {
	return InitError(strprintf(_("Cannot obtain a lock on data directory "
	"%s. %s is probably already running."),
	fs::PathToString(datadir), PACKAGE_NAME));
	}
	return true;
	}

	bool AppInitSanityChecks() {
	// Step 4: sanity checks

	// Initialize elliptic curve code
	std::string sha256_algo = SHA256AutoDetect();
	LogPrintf("Using the '%s' SHA256 implementation\n", sha256_algo);
	RandomInit();
	ECC_Start();
	globalVerifyHandle.reset(new ECCVerifyHandle());

	// Sanity check
	if (!InitSanityCheck()) {
	return InitError(strprintf(
	_("Initialization sanity check failed. %s is shutting down."),
	PACKAGE_NAME));
	}

	// Probe the data directory lock to give an early error message, if possible
	// We cannot hold the data directory lock here, as the forking for daemon()
	// hasn't yet happened, and a fork will cause weird behavior to it.
	return LockDataDirectory(true);
	}

	bool AppInitLockDataDirectory() {
	// After daemonization get the data directory lock again and hold on to it
	// until exit. This creates a slight window for a race condition to happen,
	// however this condition is harmless: it will at most make us exit without
	// printing a message to console.
	if (!LockDataDirectory(false)) {
	// Detailed error printed inside LockDataDirectory
	return false;
	}
	return true;
	}

	bool AppInitInterfaces(NodeContext &node) {
	node.chain = interfaces::MakeChain(node, Params());
	// Create client interfaces for wallets that are supposed to be loaded
	// according to -wallet and -disablewallet options. This only constructs
	// the interfaces, it doesn't load wallet data. Wallets actually get loaded
	// when load() and start() interface methods are called below.
	g_wallet_init_interface.Construct(node);
	return true;
	}

	bool AppInitMain(Config &config, RPCServer &rpcServer,
	HTTPRPCRequestProcessor &httpRPCRequestProcessor,
	NodeContext &node,
	interfaces::BlockAndHeaderTipInfo *tip_info) {
	// Step 4a: application initialization
	const ArgsManager &args = *Assert(node.args);
	const CChainParams &chainparams = config.GetChainParams();

	if (!CreatePidFile(args)) {
	// Detailed error printed inside CreatePidFile().
	return false;
	}

	BCLog::Logger &logger = LogInstance();
	if (logger.m_print_to_file) {
	if (args.GetBoolArg("-shrinkdebugfile",
	logger.DefaultShrinkDebugFile())) {
	// Do this first since it both loads a bunch of debug.log into
	// memory, and because this needs to happen before any other
	// debug.log printing.
	logger.ShrinkDebugFile();
	}
	}

	if (!logger.StartLogging()) {
	return InitError(
	strprintf(Untranslated("Could not open debug log file %s"),
	fs::PathToString(logger.m_file_path)));
	}

	if (!logger.m_log_timestamps) {
	LogPrintf("Startup time: %s\n", FormatISO8601DateTime(GetTime()));
	}
	LogPrintf("Default data directory %s\n",
	fs::PathToString(GetDefaultDataDir()));
	LogPrintf("Using data directory %s\n",
	fs::PathToString(gArgs.GetDataDirNet()));

	// Only log conf file usage message if conf file actually exists.
	fs::path config_file_path =
	GetConfigFile(args.GetArg("-conf", BITCOIN_CONF_FILENAME));
	if (fs::exists(config_file_path)) {
	LogPrintf("Config file: %s\n", fs::PathToString(config_file_path));
	} else if (args.IsArgSet("-conf")) {
	// Warn if no conf file exists at path provided by user
	InitWarning(
	strprintf(_("The specified config file %s does not exist\n"),
	fs::PathToString(config_file_path)));
	} else {
	// Not categorizing as "Warning" because it's the default behavior
	LogPrintf("Config file: %s (not found, skipping)\n",
	fs::PathToString(config_file_path));
	}

	// Log the config arguments to debug.log
	args.LogArgs();

	LogPrintf("Using at most %i automatic connections (%i file descriptors "
	"available)\n",
	nMaxConnections, nFD);

	// Warn about relative -datadir path.
	if (args.IsArgSet("-datadir") &&
	!fs::PathFromString(args.GetArg("-datadir", "")).is_absolute()) {
	LogPrintf("Warning: relative datadir option '%s' specified, which will "
	"be interpreted relative to the current working directory "
	"'%s'. This is fragile, because if bitcoin is started in the "
	"future from a different location, it will be unable to "
	"locate the current data files. There could also be data "
	"loss if bitcoin is started while in a temporary "
	"directory.\n",
	args.GetArg("-datadir", ""),
	fs::PathToString(fs::current_path()));
	}

	InitSignatureCache();
	InitScriptExecutionCache();

	int script_threads = args.GetIntArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
	if (script_threads <= 0) {
	// -par=0 means autodetect (number of cores - 1 script threads)
	// -par=-n means "leave n cores free" (number of cores - n - 1 script
	// threads)
	script_threads += GetNumCores();
	}

	// Subtract 1 because the main thread counts towards the par threads
	script_threads = std::max(script_threads - 1, 0);

	// Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
	script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);

	LogPrintf("Script verification uses %d additional threads\n",
	script_threads);
	if (script_threads >= 1) {
	StartScriptCheckWorkerThreads(script_threads);
	}

	assert(!node.scheduler);
	node.scheduler = std::make_unique<CScheduler>();

	// Start the lightweight task scheduler thread
	node.scheduler->m_service_thread =
	std::thread(&util::TraceThread, "scheduler",
	[&] { node.scheduler->serviceQueue(); });

	// Gather some entropy once per minute.
	node.scheduler->scheduleEvery(
	[] {
	RandAddPeriodic();
	return true;
	},
	std::chrono::minutes{1});

	GetMainSignals().RegisterBackgroundSignalScheduler(*node.scheduler);

	/**
	* Register RPC commands regardless of -server setting so they will be
	* available in the GUI RPC console even if external calls are disabled.
	*/
	RegisterAllRPCCommands(config, rpcServer, tableRPC);
	for (const auto &client : node.chain_clients) {
	client->registerRpcs();
	}
	#if ENABLE_ZMQ
	RegisterZMQRPCCommands(tableRPC);
	#endif

	/**
	* Start the RPC server. It will be started in "warmup" mode and not
	* process calls yet (but it will verify that the server is there and will
	* be ready later). Warmup mode will be completed when initialisation is
	* finished.
	*/
	if (args.GetBoolArg("-server", false)) {
	uiInterface.InitMessage_connect(SetRPCWarmupStatus);
	if (!AppInitServers(config, httpRPCRequestProcessor, node)) {
	return InitError(
	_("Unable to start HTTP server. See debug log for details."));
	}
	}

	// Step 5: verify wallet database integrity
	for (const auto &client : node.chain_clients) {
	if (!client->verify()) {
	return false;
	}
	}

	// Step 6: network initialization

	// Note that we absolutely cannot open any actual connections
	// until the very end ("start node") as the UTXO/block state
	// is not yet setup and may end up being set up twice if we
	// need to reindex later.

	fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
	fDiscover = args.GetBoolArg("-discover", true);

	{
	// Initialize addrman
	assert(!node.addrman);

	// Read asmap file if configured
	std::vector<bool> asmap;
	if (args.IsArgSet("-asmap")) {
	fs::path asmap_path = fs::PathFromString(args.GetArg("-asmap", ""));
	if (asmap_path.empty()) {
	asmap_path = fs::PathFromString(DEFAULT_ASMAP_FILENAME);
	}
	if (!asmap_path.is_absolute()) {
	asmap_path = gArgs.GetDataDirNet() / asmap_path;
	}
	if (!fs::exists(asmap_path)) {
	InitError(strprintf(_("Could not find asmap file %s"),
	fs::quoted(fs::PathToString(asmap_path))));
	return false;
	}
	asmap = DecodeAsmap(asmap_path);
	if (asmap.size() == 0) {
	InitError(strprintf(_("Could not parse asmap file %s"),
	fs::quoted(fs::PathToString(asmap_path))));
	return false;
	}
	const uint256 asmap_version = SerializeHash(asmap);
	LogPrintf("Using asmap version %s for IP bucketing\n",
	asmap_version.ToString());
	} else {
	LogPrintf("Using /16 prefix for IP bucketing\n");
	}

	uiInterface.InitMessage(_("Loading P2P addresses...").translated);
	if (const auto error{
	LoadAddrman(chainparams, asmap, args, node.addrman)}) {
	return InitError(*error);
	}
	}

	assert(!node.banman);
	node.banman = std::make_unique<BanMan>(
	gArgs.GetDataDirNet() / "banlist.dat", config.GetChainParams(),
	&uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
	assert(!node.connman);
	node.connman = std::make_unique<CConnman>(
	config, GetRand(std::numeric_limits<uint64_t>::max()),
	GetRand(std::numeric_limits<uint64_t>::max()), *node.addrman,
	gArgs.GetBoolArg("-networkactive", true));

	assert(!node.mempool);
	int check_ratio = std::min<int>(
	std::max<int>(
	args.GetIntArg("-checkmempool",
	chainparams.DefaultConsistencyChecks() ? 1 : 0),
	0),
	1000000);
	node.mempool = std::make_unique<CTxMemPool>(check_ratio);

	assert(!node.chainman);
	node.chainman = std::make_unique<ChainstateManager>();
	ChainstateManager &chainman = *node.chainman;

	assert(!node.peerman);
	node.peerman = PeerManager::make(
	chainparams, node.connman, node.addrman, node.banman.get(), chainman,
	*node.mempool, args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY));
	RegisterValidationInterface(node.peerman.get());

	// sanitize comments per BIP-0014, format user agent and check total size
	std::vector<std::string> uacomments;
	for (const std::string &cmt : args.GetArgs("-uacomment")) {
	if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) {
	return InitError(strprintf(
	_("User Agent comment (%s) contains unsafe characters."), cmt));
	}
	uacomments.push_back(cmt);
	}
	const std::string client_name = args.GetArg("-uaclientname", CLIENT_NAME);
	const std::string client_version =
	args.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));
	if (client_name != SanitizeString(client_name, SAFE_CHARS_UA_COMMENT)) {
	return InitError(strprintf(
	_("-uaclientname (%s) contains invalid characters."), client_name));
	}
	if (client_version !=
	SanitizeString(client_version, SAFE_CHARS_UA_COMMENT)) {
	return InitError(
	strprintf(_("-uaclientversion (%s) contains invalid characters."),
	client_version));
	}
	const std::string strSubVersion =
	FormatUserAgent(client_name, client_version, uacomments);
	if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
	return InitError(strprintf(
	_("Total length of network version string (%i) exceeds maximum "
	"length (%i). Reduce the number or size of uacomments."),
	strSubVersion.size(), MAX_SUBVERSION_LENGTH));
	}

	if (args.IsArgSet("-onlynet")) {
	std::set<enum Network> nets;
	for (const std::string &snet : args.GetArgs("-onlynet")) {
	enum Network net = ParseNetwork(snet);
	if (net == NET_UNROUTABLE) {
	return InitError(strprintf(
	_("Unknown network specified in -onlynet: '%s'"), snet));
	}
	nets.insert(net);
	}
	for (int n = 0; n < NET_MAX; n++) {
	enum Network net = (enum Network)n;
	if (!nets.count(net)) {
	SetReachable(net, false);
	}
	}
	}

	// Check for host lookup allowed before parsing any network related
	// parameters
	fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);

	bool proxyRandomize =
	args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
	// -proxy sets a proxy for all outgoing network traffic
	// -noproxy (or -proxy=0) as well as the empty string can be used to not set
	// a proxy, this is the default
	std::string proxyArg = args.GetArg("-proxy", "");
	SetReachable(NET_ONION, false);
	if (proxyArg != "" && proxyArg != "0") {
	CService proxyAddr;
	if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
	return InitError(strprintf(
	_("Invalid -proxy address or hostname: '%s'"), proxyArg));
	}

	proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
	if (!addrProxy.IsValid()) {
	return InitError(strprintf(
	_("Invalid -proxy address or hostname: '%s'"), proxyArg));
	}

	SetProxy(NET_IPV4, addrProxy);
	SetProxy(NET_IPV6, addrProxy);
	SetProxy(NET_ONION, addrProxy);
	SetNameProxy(addrProxy);
	// by default, -proxy sets onion as reachable, unless -noonion later
	SetReachable(NET_ONION, true);
	}

	// -onion can be used to set only a proxy for .onion, or override normal
	// proxy for .onion addresses.
	// -noonion (or -onion=0) disables connecting to .onion entirely. An empty
	// string is used to not override the onion proxy (in which case it defaults
	// to -proxy set above, or none)
	std::string onionArg = args.GetArg("-onion", "");
	if (onionArg != "") {
	if (onionArg == "0") {
	// Handle -noonion/-onion=0
	SetReachable(NET_ONION, false);
	} else {
	CService onionProxy;
	if (!Lookup(onionArg, onionProxy, 9050, fNameLookup)) {
	return InitError(strprintf(
	_("Invalid -onion address or hostname: '%s'"), onionArg));
	}
	proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
	if (!addrOnion.IsValid()) {
	return InitError(strprintf(
	_("Invalid -onion address or hostname: '%s'"), onionArg));
	}
	SetProxy(NET_ONION, addrOnion);
	SetReachable(NET_ONION, true);
	}
	}

	for (const std::string &strAddr : args.GetArgs("-externalip")) {
	CService addrLocal;
	if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) &&
	addrLocal.IsValid()) {
	AddLocal(addrLocal, LOCAL_MANUAL);
	} else {
	return InitError(ResolveErrMsg("externalip", strAddr));
	}
	}

	#if ENABLE_ZMQ
	g_zmq_notification_interface = CZMQNotificationInterface::Create();

	if (g_zmq_notification_interface) {
	RegisterValidationInterface(g_zmq_notification_interface);
	}
	#endif

	// Step 6.5 (I guess ?): Initialize Avalanche.
	bilingual_str avalancheError;
	g_avalanche = avalanche::Processor::MakeProcessor(
	args, node.chain, node.connman.get(), chainman, node.scheduler,
	avalancheError);
	if (!g_avalanche) {
	InitError(avalancheError);
	return false;
	}

	if (isAvalancheEnabled(args) &&
	g_avalanche->isAvalancheServiceAvailable()) {
	nLocalServices = ServiceFlags(nLocalServices \| NODE_AVALANCHE);
	}

	// Step 7: load block chain

	fReindex = args.GetBoolArg("-reindex", false);
	bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);

	// cache size calculations
	int64_t nTotalCache =
	(args.GetIntArg("-dbcache", DEFAULT_DB_CACHE_MB) << 20);
	// total cache cannot be less than MIN_DB_CACHE_MB
	nTotalCache = std::max(nTotalCache, MIN_DB_CACHE_MB << 20);
	// total cache cannot be greater than MAX_DB_CACHE_MB
	nTotalCache = std::min(nTotalCache, MAX_DB_CACHE_MB << 20);
	int64_t nBlockTreeDBCache =
	std::min(nTotalCache / 8, MAX_BLOCK_DB_CACHE_MB << 20);
	nTotalCache -= nBlockTreeDBCache;
	int64_t nTxIndexCache =
	std::min(nTotalCache / 8, args.GetBoolArg("-txindex", DEFAULT_TXINDEX)
	? MAX_TX_INDEX_CACHE_MB << 20
	: 0);
	nTotalCache -= nTxIndexCache;
	int64_t filter_index_cache = 0;
	if (!g_enabled_filter_types.empty()) {
	size_t n_indexes = g_enabled_filter_types.size();
	int64_t max_cache =
	std::min(nTotalCache / 8, MAX_FILTER_INDEX_CACHE_MB << 20);
	filter_index_cache = max_cache / n_indexes;
	nTotalCache -= filter_index_cache * n_indexes;
	}
	// use 25%-50% of the remainder for disk cache
	int64_t nCoinDBCache =
	std::min(nTotalCache / 2, (nTotalCache / 4) + (1 << 23));
	// cap total coins db cache
	nCoinDBCache = std::min(nCoinDBCache, MAX_COINS_DB_CACHE_MB << 20);
	nTotalCache -= nCoinDBCache;
	// the rest goes to in-memory cache
	int64_t nCoinCacheUsage = nTotalCache;
	int64_t nMempoolSizeMax =
	args.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
	LogPrintf("Cache configuration:\n");
	LogPrintf("* Using %.1f MiB for block index database\n",
	nBlockTreeDBCache * (1.0 / 1024 / 1024));
	if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	LogPrintf("* Using %.1f MiB for transaction index database\n",
	nTxIndexCache * (1.0 / 1024 / 1024));
	}
	for (BlockFilterType filter_type : g_enabled_filter_types) {
	LogPrintf("* Using %.1f MiB for %s block filter index database\n",
	filter_index_cache * (1.0 / 1024 / 1024),
	BlockFilterTypeName(filter_type));
	}
	LogPrintf("* Using %.1f MiB for chain state database\n",
	nCoinDBCache * (1.0 / 1024 / 1024));
	LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
	"unused mempool space)\n",
	nCoinCacheUsage * (1.0 / 1024 / 1024),
	nMempoolSizeMax * (1.0 / 1024 / 1024));

	bool fLoaded = false;
	while (!fLoaded && !ShutdownRequested()) {
	const bool fReset = fReindex;
	auto is_coinsview_empty =
	[&](CChainState *chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
	return fReset \|\| fReindexChainState \|\|
	chainstate->CoinsTip().GetBestBlock().IsNull();
	};
	bilingual_str strLoadError;

	uiInterface.InitMessage(_("Loading block index...").translated);
	do {
	bool failed_verification = false;
	const int64_t load_block_index_start_time = GetTimeMillis();
	try {
	LOCK(cs_main);
	chainman.InitializeChainstate(Assert(node.mempool.get()));
	chainman.m_total_coinstip_cache = nCoinCacheUsage;
	chainman.m_total_coinsdb_cache = nCoinDBCache;

	UnloadBlockIndex(node.mempool.get(), chainman);

	auto &pblocktree{chainman.m_blockman.m_block_tree_db};
	// new CBlockTreeDB tries to delete the existing file, which
	// fails if it's still open from the previous loop. Close it
	// first:
	pblocktree.reset();
	pblocktree.reset(
	new CBlockTreeDB(nBlockTreeDBCache, false, fReset));

	if (fReset) {
	pblocktree->WriteReindexing(true);
	// If we're reindexing in prune mode, wipe away unusable
	// block files and all undo data files
	if (fPruneMode) {
	CleanupBlockRevFiles();
	}
	}

	const Consensus::Params &params = chainparams.GetConsensus();

	// If necessary, upgrade from older database format.
	// This is a no-op if we cleared the block tree db with -reindex
	// or -reindex-chainstate
	if (!pblocktree->Upgrade(params)) {
	strLoadError = _("Error upgrading block index database");
	break;
	}

	if (ShutdownRequested()) {
	break;
	}

	// LoadBlockIndex will load fHavePruned if we've ever removed a
	// block file from disk.
	// Note that it also sets fReindex based on the disk flag!
	// From here on out fReindex and fReset mean something
	// different!
	if (!chainman.LoadBlockIndex()) {
	if (ShutdownRequested()) {
	break;
	}
	strLoadError = _("Error loading block database");
	break;
	}

	// If the loaded chain has a wrong genesis, bail out immediately
	// (we're likely using a testnet datadir, or the other way
	// around).
	if (!chainman.BlockIndex().empty() &&
	!chainman.m_blockman.LookupBlockIndex(
	params.hashGenesisBlock)) {
	return InitError(_("Incorrect or no genesis block found. "
	"Wrong datadir for network?"));
	}

	// Check for changed -prune state. What we are concerned about
	// is a user who has pruned blocks in the past, but is now
	// trying to run unpruned.
	if (fHavePruned && !fPruneMode) {
	strLoadError =
	_("You need to rebuild the database using -reindex to "
	"go back to unpruned mode. This will redownload the "
	"entire blockchain");
	break;
	}

	// At this point blocktree args are consistent with what's on
	// disk. If we're not mid-reindex (based on disk + args), add a
	// genesis block on disk (otherwise we use the one already on
	// disk).
	// This is called again in ThreadImport after the reindex
	// completes.
	if (!fReindex &&
	!chainman.ActiveChainstate().LoadGenesisBlock()) {
	strLoadError = _("Error initializing block database");
	break;
	}

	// At this point we're either in reindex or we've loaded a
	// useful block tree into BlockIndex()!

	bool failed_chainstate_init = false;

	for (CChainState *chainstate : chainman.GetAll()) {
	chainstate->InitCoinsDB(
	/* cache_size_bytes */ nCoinDBCache,
	/* in_memory */ false,
	/* should_wipe */ fReset \|\| fReindexChainState);

	chainstate->CoinsErrorCatcher().AddReadErrCallback([]() {
	uiInterface.ThreadSafeMessageBox(
	_("Error reading from database, shutting down."),
	"", CClientUIInterface::MSG_ERROR);
	});

	// If necessary, upgrade from older database format.
	// This is a no-op if we cleared the coinsviewdb with
	// -reindex or -reindex-chainstate
	if (!chainstate->CoinsDB().Upgrade()) {
	strLoadError = _("Error upgrading chainstate database");
	failed_chainstate_init = true;
	break;
	}

	// ReplayBlocks is a no-op if we cleared the coinsviewdb
	// with -reindex or -reindex-chainstate
	if (!chainstate->ReplayBlocks()) {
	strLoadError = _(
	"Unable to replay blocks. You will need to rebuild "
	"the database using -reindex-chainstate.");
	failed_chainstate_init = true;
	break;
	}

	// The on-disk coinsdb is now in a good state, create the
	// cache
	chainstate->InitCoinsCache(nCoinCacheUsage);
	assert(chainstate->CanFlushToDisk());

	if (!is_coinsview_empty(chainstate)) {
	// LoadChainTip initializes the chain based on
	// CoinsTip()'s best block
	if (!chainstate->LoadChainTip()) {
	strLoadError =
	_("Error initializing block database");
	failed_chainstate_init = true;
	// out of the per-chainstate loop
	break;
	}
	assert(chainstate->m_chain.Tip() != nullptr);
	}
	}

	if (failed_chainstate_init) {
	// out of the chainstate activation do-while
	break;
	}

	for (CChainState *chainstate : chainman.GetAll()) {
	if (!is_coinsview_empty(chainstate)) {
	uiInterface.InitMessage(
	_("Verifying blocks...").translated);
	if (fHavePruned && args.GetIntArg("-checkblocks",
	DEFAULT_CHECKBLOCKS) >
	MIN_BLOCKS_TO_KEEP) {
	LogPrintf(
	"Prune: pruned datadir may not have more than "
	"%d blocks; only checking available blocks\n",
	MIN_BLOCKS_TO_KEEP);
	}

	const CBlockIndex *tip = chainstate->m_chain.Tip();
	RPCNotifyBlockChange(tip);
	if (tip &&
	tip->nTime > GetAdjustedTime() + 2 * 60 * 60) {
	strLoadError =
	_("The block database contains a block which "
	"appears to be from the future. "
	"This may be due to your computer's date and "
	"time being set incorrectly. "
	"Only rebuild the block database if you are "
	"sure that your computer's date and time are "
	"correct");
	failed_verification = true;
	break;
	}

	if (!CVerifyDB().VerifyDB(
	*chainstate, config, chainstate->CoinsDB(),
	args.GetIntArg("-checklevel",
	DEFAULT_CHECKLEVEL),
	args.GetIntArg("-checkblocks",
	DEFAULT_CHECKBLOCKS))) {
	strLoadError =
	_("Corrupted block database detected");
	failed_verification = true;
	break;
	}
	}
	}
	} catch (const std::exception &e) {
	LogPrintf("%s\n", e.what());
	strLoadError = _("Error opening block database");
	failed_verification = true;
	break;
	}

	if (!failed_verification) {
	fLoaded = true;
	LogPrintf(" block index %15dms\n",
	GetTimeMillis() - load_block_index_start_time);
	}
	} while (false);

	if (!fLoaded && !ShutdownRequested()) {
	// first suggest a reindex
	if (!fReset) {
	bool fRet = uiInterface.ThreadSafeQuestion(
	strLoadError + Untranslated(".\n\n") +
	_("Do you want to rebuild the block database now?"),
	strLoadError.original +
	".\nPlease restart with -reindex or "
	"-reindex-chainstate to recover.",
	"",
	CClientUIInterface::MSG_ERROR \|
	CClientUIInterface::BTN_ABORT);
	if (fRet) {
	fReindex = true;
	AbortShutdown();
	} else {
	LogPrintf("Aborted block database rebuild. Exiting.\n");
	return false;
	}
	} else {
	return InitError(strLoadError);
	}
	}
	}

	// As LoadBlockIndex can take several minutes, it's possible the user
	// requested to kill the GUI during the last operation. If so, exit.
	// As the program has not fully started yet, Shutdown() is possibly
	// overkill.
	if (ShutdownRequested()) {
	LogPrintf("Shutdown requested. Exiting.\n");
	return false;
	}

	// Encoded addresses using cashaddr instead of base58.
	// We do this by default to avoid confusion with BTC addresses.
	config.SetCashAddrEncoding(args.GetBoolArg("-usecashaddr", true));

	// Step 8: load indexers
	if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	if (const auto error{CheckLegacyTxindex(
	*Assert(chainman.m_blockman.m_block_tree_db))}) {
	return InitError(*error);
	}

	g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);
	g_txindex->Start(chainman.ActiveChainstate());
	}

	for (const auto &filter_type : g_enabled_filter_types) {
	InitBlockFilterIndex(filter_type, filter_index_cache, false, fReindex);
	GetBlockFilterIndex(filter_type)->Start(chainman.ActiveChainstate());
	}

	if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
	g_coin_stats_index = std::make_unique<CoinStatsIndex>(
	/* cache size */ 0, false, fReindex);
	g_coin_stats_index->Start(chainman.ActiveChainstate());
	}

	#if ENABLE_CHRONIK
	chronik::Start(config, node);
	#endif

	// Step 9: load wallet
	for (const auto &client : node.chain_clients) {
	if (!client->load()) {
	return false;
	}
	}

	// Step 10: data directory maintenance

	// if pruning, unset the service bit and perform the initial blockstore
	// prune after any wallet rescanning has taken place.
	if (fPruneMode) {
	LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
	nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
	if (!fReindex) {
	LOCK(cs_main);
	for (CChainState *chainstate : chainman.GetAll()) {
	uiInterface.InitMessage(_("Pruning blockstore...").translated);
	chainstate->PruneAndFlush();
	}
	}
	}

	// Step 11: import blocks
	if (!CheckDiskSpace(gArgs.GetDataDirNet())) {
	InitError(
	strprintf(_("Error: Disk space is low for %s"),
	fs::quoted(fs::PathToString(gArgs.GetDataDirNet()))));
	return false;
	}
	if (!CheckDiskSpace(gArgs.GetBlocksDirPath())) {
	InitError(
	strprintf(_("Error: Disk space is low for %s"),
	fs::quoted(fs::PathToString(gArgs.GetBlocksDirPath()))));
	return false;
	}

	// Either install a handler to notify us when genesis activates, or set
	// fHaveGenesis directly.
	// No locking, as this happens before any background thread is started.
	boost::signals2::connection block_notify_genesis_wait_connection;
	if (chainman.ActiveTip() == nullptr) {
	block_notify_genesis_wait_connection =
	uiInterface.NotifyBlockTip_connect(
	std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
	} else {
	fHaveGenesis = true;
	}

	#if defined(HAVE_SYSTEM)
	const std::string block_notify = args.GetArg("-blocknotify", "");
	if (!block_notify.empty()) {
	uiInterface.NotifyBlockTip_connect([block_notify](
	SynchronizationState sync_state,
	const CBlockIndex *pBlockIndex) {
	if (sync_state != SynchronizationState::POST_INIT \|\| !pBlockIndex) {
	return;
	}
	std::string command = block_notify;
	boost::replace_all(command, "%s",
	pBlockIndex->GetBlockHash().GetHex());
	std::thread t(runCommand, command);
	// thread runs free
	t.detach();
	});
	}
	#endif

	std::vector<fs::path> vImportFiles;
	for (const std::string &strFile : args.GetArgs("-loadblock")) {
	vImportFiles.push_back(fs::PathFromString(strFile));
	}

	chainman.m_load_block = std::thread(
	&util::TraceThread, "loadblk", [=, &config, &chainman, &args] {
	ThreadImport(config, chainman, vImportFiles, args);
	});

	// Wait for genesis block to be processed
	{
	WAIT_LOCK(g_genesis_wait_mutex, lock);
	// We previously could hang here if StartShutdown() is called prior to
	// ThreadImport getting started, so instead we just wait on a timer to
	// check ShutdownRequested() regularly.
	while (!fHaveGenesis && !ShutdownRequested()) {
	g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
	}
	block_notify_genesis_wait_connection.disconnect();
	}

	if (ShutdownRequested()) {
	return false;
	}

	// Step 12: start node

	int chain_active_height;

	//// debug print
	{
	LOCK(cs_main);
	LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
	chain_active_height = chainman.ActiveChain().Height();
	if (tip_info) {
	tip_info->block_height = chain_active_height;
	tip_info->block_time =
	chainman.ActiveChain().Tip()
	? chainman.ActiveChain().Tip()->GetBlockTime()
	: Params().GenesisBlock().GetBlockTime();
	tip_info->verification_progress = GuessVerificationProgress(
	Params().TxData(), chainman.ActiveChain().Tip());
	}
	if (tip_info && ::pindexBestHeader) {
	tip_info->header_height = ::pindexBestHeader->nHeight;
	tip_info->header_time = ::pindexBestHeader->GetBlockTime();
	}
	}
	LogPrintf("nBestHeight = %d\n", chain_active_height);
	if (node.peerman) {
	node.peerman->SetBestHeight(chain_active_height);
	}

	Discover();

	// Map ports with UPnP or NAT-PMP.
	StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP),
	gArgs.GetBoolArg("-natpmp", DEFAULT_NATPMP));

	CConnman::Options connOptions;
	connOptions.nLocalServices = nLocalServices;
	connOptions.nMaxConnections = nMaxConnections;
	connOptions.m_max_avalanche_outbound = std::min<int64_t>(
	g_avalanche && isAvalancheEnabled(args)
	? args.GetIntArg("-maxavalancheoutbound",
	DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS)
	: 0,
	connOptions.nMaxConnections);
	connOptions.m_max_outbound_full_relay = std::min(
	MAX_OUTBOUND_FULL_RELAY_CONNECTIONS,
	connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound);
	connOptions.m_max_outbound_block_relay = std::min(
	MAX_BLOCK_RELAY_ONLY_CONNECTIONS,
	connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound -
	connOptions.m_max_outbound_full_relay);
	connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
	connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
	connOptions.uiInterface = &uiInterface;
	connOptions.m_banman = node.banman.get();
	connOptions.m_msgproc.push_back(node.peerman.get());
	if (g_avalanche) {
	connOptions.m_msgproc.push_back(g_avalanche.get());
	}
	connOptions.nSendBufferMaxSize =
	1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
	connOptions.nReceiveFloodSize =
	1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
	connOptions.m_added_nodes = args.GetArgs("-addnode");

	connOptions.nMaxOutboundLimit =
	1024 * 1024 *
	args.GetIntArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
	connOptions.m_peer_connect_timeout = peer_connect_timeout;

	+ const auto BadPortWarning = [](const char *prefix, uint16_t port) {
	+ return strprintf(_("%s request to listen on port %u. This port is "
	+ "considered \"bad\" and "
	+ "thus it is unlikely that any Bitcoin ABC peers "
	+ "connect to it. See "
	+ "doc/p2p-bad-ports.md for details and a full list."),
	+ prefix, port);
	+ };
	+
	for (const std::string &bind_arg : args.GetArgs("-bind")) {
	CService bind_addr;
	const size_t index = bind_arg.rfind('=');
	if (index == std::string::npos) {
	if (Lookup(bind_arg, bind_addr, GetListenPort(), false)) {
	connOptions.vBinds.push_back(bind_addr);
	+ if (IsBadPort(bind_addr.GetPort())) {
	+ InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
	+ }
	continue;
	}
	} else {
	const std::string network_type = bind_arg.substr(index + 1);
	if (network_type == "onion") {
	const std::string truncated_bind_arg =
	bind_arg.substr(0, index);
	if (Lookup(truncated_bind_arg, bind_addr,
	BaseParams().OnionServiceTargetPort(), false)) {
	connOptions.onion_binds.push_back(bind_addr);
	continue;
	}
	}
	}
	return InitError(ResolveErrMsg("bind", bind_arg));
	}

	for (const std::string &strBind : args.GetArgs("-whitebind")) {
	NetWhitebindPermissions whitebind;
	bilingual_str error;
	if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) {
	return InitError(error);
	}
	connOptions.vWhiteBinds.push_back(whitebind);
	}

	// If the user did not specify -bind= or -whitebind= then we bind
	// on any address - 0.0.0.0 (IPv4) and :: (IPv6).
	connOptions.bind_on_any =
	args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();

	+ // Emit a warning if a bad port is given to -port= but only if -bind and
	+ // -whitebind are not given, because if they are, then -port= is ignored.
	+ if (connOptions.bind_on_any && args.IsArgSet("-port")) {
	+ const uint16_t port_arg = args.GetIntArg("-port", 0);
	+ if (IsBadPort(port_arg)) {
	+ InitWarning(BadPortWarning("-port", port_arg));
	+ }
	+ }
	+
	CService onion_service_target;
	if (!connOptions.onion_binds.empty()) {
	onion_service_target = connOptions.onion_binds.front();
	} else {
	onion_service_target = DefaultOnionServiceTarget();
	connOptions.onion_binds.push_back(onion_service_target);
	}

	if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
	if (connOptions.onion_binds.size() > 1) {
	InitWarning(strprintf(
	_("More than one onion bind address is provided. Using %s "
	"for the automatically created Tor onion service."),
	onion_service_target.ToStringIPPort()));
	}
	StartTorControl(onion_service_target);
	}

	for (const auto &net : args.GetArgs("-whitelist")) {
	NetWhitelistPermissions subnet;
	bilingual_str error;
	if (!NetWhitelistPermissions::TryParse(net, subnet, error)) {
	return InitError(error);
	}
	connOptions.vWhitelistedRange.push_back(subnet);
	}

	connOptions.vSeedNodes = args.GetArgs("-seednode");

	// Initiate outbound connections unless connect=0
	connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
	if (!connOptions.m_use_addrman_outgoing) {
	const auto connect = args.GetArgs("-connect");
	if (connect.size() != 1 \|\| connect[0] != "0") {
	connOptions.m_specified_outgoing = connect;
	}
	}

	const std::string &i2psam_arg = args.GetArg("-i2psam", "");
	if (!i2psam_arg.empty()) {
	CService addr;
	if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) \|\| !addr.IsValid()) {
	return InitError(strprintf(
	_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
	}
	SetReachable(NET_I2P, true);
	SetProxy(NET_I2P, proxyType{addr});
	} else {
	SetReachable(NET_I2P, false);
	}

	connOptions.m_i2p_accept_incoming =
	args.GetBoolArg("-i2pacceptincoming", true);

	if (!node.connman->Start(*node.scheduler, connOptions)) {
	return false;
	}

	// Step 13: finished

	SetRPCWarmupFinished();
	uiInterface.InitMessage(_("Done loading").translated);

	for (const auto &client : node.chain_clients) {
	client->start(*node.scheduler);
	}

	BanMan *banman = node.banman.get();
	node.scheduler->scheduleEvery(
	[banman] {
	banman->DumpBanlist();
	return true;
	},
	DUMP_BANS_INTERVAL);

	if (node.peerman) {
	node.peerman->StartScheduledTasks(*node.scheduler);
	}

	// Start Avalanche's event loop.
	g_avalanche->startEventLoop(*node.scheduler);

	#if HAVE_SYSTEM
	StartupNotify(args);
	#endif

	return true;
	}
	diff --git a/src/net.cpp b/src/net.cpp
	index e7e5c9caf..442aae616 100644
	--- a/src/net.cpp
	+++ b/src/net.cpp
	@@ -1,3634 +1,3630 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2019 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#if defined(HAVE_CONFIG_H)
	#include <config/bitcoin-config.h>
	#endif

	#include <net.h>

	#include <addrdb.h>
	#include <avalanche/avalanche.h>
	#include <banman.h>
	#include <clientversion.h>
	#include <compat.h>
	#include <config.h>
	#include <consensus/consensus.h>
	#include <crypto/sha256.h>
	#include <dnsseeds.h>
	#include <i2p.h>
	#include <netaddress.h>
	#include <netbase.h>
	#include <node/ui_interface.h>
	#include <protocol.h>
	#include <random.h>
	#include <scheduler.h>
	#include <util/sock.h>
	#include <util/strencodings.h>
	#include <util/system.h>
	#include <util/thread.h>
	#include <util/translation.h>

	#ifdef WIN32
	#include <cstring>
	#else
	#include <fcntl.h>
	#endif

	#ifdef USE_POLL
	#include <poll.h>
	#endif

	#include <algorithm>
	#include <array>
	#include <cmath>
	#include <cstdint>
	#include <functional>
	#include <limits>
	#include <optional>
	#include <unordered_map>

	/** Maximum number of block-relay-only anchor connections */
	static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;
	static_assert(MAX_BLOCK_RELAY_ONLY_ANCHORS <=
	static_cast<size_t>(MAX_BLOCK_RELAY_ONLY_CONNECTIONS),
	"MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed "
	"MAX_BLOCK_RELAY_ONLY_CONNECTIONS.");
	/** Anchor IP address database file name */
	const char *const ANCHORS_DATABASE_FILENAME = "anchors.dat";

	// How often to dump addresses to peers.dat
	static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};

	/**
	* Number of DNS seeds to query when the number of connections is low.
	*/
	static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3;

	/**
	* How long to delay before querying DNS seeds
	*
	* If we have more than THRESHOLD entries in addrman, then it's likely
	* that we got those addresses from having previously connected to the P2P
	* network, and that we'll be able to successfully reconnect to the P2P
	* network via contacting one of them. So if that's the case, spend a
	* little longer trying to connect to known peers before querying the
	* DNS seeds.
	*/
	static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11};
	static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5};
	// "many" vs "few" peers
	static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000;

	/** The default timeframe for -maxuploadtarget. 1 day. */
	static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24};

	// We add a random period time (0 to 1 seconds) to feeler connections to prevent
	// synchronization.
	#define FEELER_SLEEP_WINDOW 1

	/** Used to pass flags to the Bind() function */
	enum BindFlags {
	BF_NONE = 0,
	BF_EXPLICIT = (1U << 0),
	BF_REPORT_ERROR = (1U << 1),
	/**
	* Do not call AddLocal() for our special addresses, e.g., for incoming
	* Tor connections, to prevent gossiping them over the network.
	*/
	BF_DONT_ADVERTISE = (1U << 2),
	};

	// The set of sockets cannot be modified while waiting
	// The sleep time needs to be small to avoid new sockets stalling
	static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50;

	const std::string NET_MESSAGE_COMMAND_OTHER = "other";

	// SHA256("netgroup")[0:8]
	static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL;
	// SHA256("localhostnonce")[0:8]
	static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL;
	// SHA256("localhostnonce")[8:16]
	static const uint64_t RANDOMIZER_ID_EXTRAENTROPY = 0x94b05d41679a4ff7ULL;
	// SHA256("addrcache")[0:8]
	static const uint64_t RANDOMIZER_ID_ADDRCACHE = 0x1cf2e4ddd306dda9ULL;
	//
	// Global state variables
	//
	bool fDiscover = true;
	bool fListen = true;
	RecursiveMutex cs_mapLocalHost;
	std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(cs_mapLocalHost);
	static bool vfLimited[NET_MAX] GUARDED_BY(cs_mapLocalHost) = {};

	void CConnman::AddAddrFetch(const std::string &strDest) {
	LOCK(m_addr_fetches_mutex);
	m_addr_fetches.push_back(strDest);
	}

	uint16_t GetListenPort() {
	return static_cast<uint16_t>(
	gArgs.GetIntArg("-port", Params().GetDefaultPort()));
	}

	// find 'best' local address for a particular peer
	bool GetLocal(CService &addr, const CNetAddr *paddrPeer) {
	if (!fListen) {
	return false;
	}

	int nBestScore = -1;
	int nBestReachability = -1;
	{
	LOCK(cs_mapLocalHost);
	for (const auto &entry : mapLocalHost) {
	int nScore = entry.second.nScore;
	int nReachability = entry.first.GetReachabilityFrom(paddrPeer);
	if (nReachability > nBestReachability \|\|
	(nReachability == nBestReachability && nScore > nBestScore)) {
	addr = CService(entry.first, entry.second.nPort);
	nBestReachability = nReachability;
	nBestScore = nScore;
	}
	}
	}
	return nBestScore >= 0;
	}

	//! Convert the pnSeed6 array into usable address objects.
	static std::vector<CAddress>
	convertSeed6(const std::vector<SeedSpec6> &vSeedsIn) {
	// It'll only connect to one or two seed nodes because once it connects,
	// it'll get a pile of addresses with newer timestamps. Seed nodes are given
	// a random 'last seen time' of between one and two weeks ago.
	const int64_t nOneWeek = 7 * 24 * 60 * 60;
	std::vector<CAddress> vSeedsOut;
	vSeedsOut.reserve(vSeedsIn.size());
	FastRandomContext rng;
	for (const auto &seed_in : vSeedsIn) {
	struct in6_addr ip;
	memcpy(&ip, seed_in.addr, sizeof(ip));
	CAddress addr(CService(ip, seed_in.port),
	GetDesirableServiceFlags(NODE_NONE));
	addr.nTime = GetTime() - rng.randrange(nOneWeek) - nOneWeek;
	vSeedsOut.push_back(addr);
	}
	return vSeedsOut;
	}

	// Get best local address for a particular peer as a CAddress. Otherwise, return
	// the unroutable 0.0.0.0 but filled in with the normal parameters, since the IP
	// may be changed to a useful one by discovery.
	CAddress GetLocalAddress(const CNetAddr *paddrPeer,
	ServiceFlags nLocalServices) {
	CAddress ret(CService(CNetAddr(), GetListenPort()), nLocalServices);
	CService addr;
	if (GetLocal(addr, paddrPeer)) {
	ret = CAddress(addr, nLocalServices);
	}
	ret.nTime = GetAdjustedTime();
	return ret;
	}

	static int GetnScore(const CService &addr) {
	LOCK(cs_mapLocalHost);
	if (mapLocalHost.count(addr) == 0) {
	return 0;
	}
	return mapLocalHost[addr].nScore;
	}

	// Is our peer's addrLocal potentially useful as an external IP source?
	bool IsPeerAddrLocalGood(CNode *pnode) {
	CService addrLocal = pnode->GetAddrLocal();
	return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&
	IsReachable(addrLocal.GetNetwork());
	}

	std::optional<CAddress> GetLocalAddrForPeer(CNode *pnode) {
	CAddress addrLocal =
	GetLocalAddress(&pnode->addr, pnode->GetLocalServices());
	if (gArgs.GetBoolArg("-addrmantest", false)) {
	// use IPv4 loopback during addrmantest
	addrLocal =
	CAddress(CService(LookupNumeric("127.0.0.1", GetListenPort())),
	pnode->GetLocalServices());
	}
	// If discovery is enabled, sometimes give our peer the address it
	// tells us that it sees us as in case it has a better idea of our
	// address than we do.
	FastRandomContext rng;
	if (IsPeerAddrLocalGood(pnode) &&
	(!addrLocal.IsRoutable() \|\|
	rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0)) {
	addrLocal.SetIP(pnode->GetAddrLocal());
	}
	if (addrLocal.IsRoutable() \|\| gArgs.GetBoolArg("-addrmantest", false)) {
	LogPrint(BCLog::NET, "Advertising address %s to peer=%d\n",
	addrLocal.ToString(), pnode->GetId());
	return addrLocal;
	}
	// Address is unroutable. Don't advertise.
	return std::nullopt;
	}

	// Learn a new local address.
	bool AddLocal(const CService &addr, int nScore) {
	if (!addr.IsRoutable()) {
	return false;
	}

	if (!fDiscover && nScore < LOCAL_MANUAL) {
	return false;
	}

	if (!IsReachable(addr)) {
	return false;
	}

	LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore);

	{
	LOCK(cs_mapLocalHost);
	bool fAlready = mapLocalHost.count(addr) > 0;
	LocalServiceInfo &info = mapLocalHost[addr];
	if (!fAlready \|\| nScore >= info.nScore) {
	info.nScore = nScore + (fAlready ? 1 : 0);
	info.nPort = addr.GetPort();
	}
	}

	return true;
	}

	bool AddLocal(const CNetAddr &addr, int nScore) {
	return AddLocal(CService(addr, GetListenPort()), nScore);
	}

	void RemoveLocal(const CService &addr) {
	LOCK(cs_mapLocalHost);
	LogPrintf("RemoveLocal(%s)\n", addr.ToString());
	mapLocalHost.erase(addr);
	}

	void SetReachable(enum Network net, bool reachable) {
	if (net == NET_UNROUTABLE \|\| net == NET_INTERNAL) {
	return;
	}
	LOCK(cs_mapLocalHost);
	vfLimited[net] = !reachable;
	}

	bool IsReachable(enum Network net) {
	LOCK(cs_mapLocalHost);
	return !vfLimited[net];
	}

	bool IsReachable(const CNetAddr &addr) {
	return IsReachable(addr.GetNetwork());
	}

	/** vote for a local address */
	bool SeenLocal(const CService &addr) {
	LOCK(cs_mapLocalHost);
	if (mapLocalHost.count(addr) == 0) {
	return false;
	}
	mapLocalHost[addr].nScore++;
	return true;
	}

	/** check whether a given address is potentially local */
	bool IsLocal(const CService &addr) {
	LOCK(cs_mapLocalHost);
	return mapLocalHost.count(addr) > 0;
	}

	CNode *CConnman::FindNode(const CNetAddr &ip) {
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (static_cast<CNetAddr>(pnode->addr) == ip) {
	return pnode;
	}
	}
	return nullptr;
	}

	CNode *CConnman::FindNode(const CSubNet &subNet) {
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (subNet.Match(static_cast<CNetAddr>(pnode->addr))) {
	return pnode;
	}
	}
	return nullptr;
	}

	CNode *CConnman::FindNode(const std::string &addrName) {
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (pnode->GetAddrName() == addrName) {
	return pnode;
	}
	}
	return nullptr;
	}

	CNode *CConnman::FindNode(const CService &addr) {
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (static_cast<CService>(pnode->addr) == addr) {
	return pnode;
	}
	}
	return nullptr;
	}

	bool CConnman::AlreadyConnectedToAddress(const CAddress &addr) {
	return FindNode(static_cast<CNetAddr>(addr)) \|\|
	FindNode(addr.ToStringIPPort());
	}

	bool CConnman::CheckIncomingNonce(uint64_t nonce) {
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() &&
	pnode->GetLocalNonce() == nonce) {
	return false;
	}
	}
	return true;
	}

	/** Get the bind address for a socket as CAddress */
	static CAddress GetBindAddress(SOCKET sock) {
	CAddress addr_bind;
	struct sockaddr_storage sockaddr_bind;
	socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);
	if (sock != INVALID_SOCKET) {
	if (!getsockname(sock, (struct sockaddr *)&sockaddr_bind,
	&sockaddr_bind_len)) {
	addr_bind.SetSockAddr((const struct sockaddr *)&sockaddr_bind);
	} else {
	LogPrint(BCLog::NET, "Warning: getsockname failed\n");
	}
	}
	return addr_bind;
	}

	CNode CConnman::ConnectNode(CAddress addrConnect, const char pszDest,
	bool fCountFailure, ConnectionType conn_type) {
	assert(conn_type != ConnectionType::INBOUND);

	if (pszDest == nullptr) {
	if (IsLocal(addrConnect)) {
	return nullptr;
	}

	// Look for an existing connection
	CNode *pnode = FindNode(static_cast<CService>(addrConnect));
	if (pnode) {
	LogPrintf("Failed to open new connection, already connected\n");
	return nullptr;
	}
	}

	/// debug print
	LogPrint(BCLog::NET, "trying connection %s lastseen=%.1fhrs\n",
	pszDest ? pszDest : addrConnect.ToString(),
	pszDest
	? 0.0
	: (double)(GetAdjustedTime() - addrConnect.nTime) / 3600.0);

	// Resolve
	const uint16_t default_port{pszDest != nullptr
	? Params().GetDefaultPort(pszDest)
	: Params().GetDefaultPort()};
	if (pszDest) {
	std::vector<CService> resolved;
	if (Lookup(pszDest, resolved, default_port,
	fNameLookup && !HaveNameProxy(), 256) &&
	!resolved.empty()) {
	addrConnect =
	CAddress(resolved[GetRand(resolved.size())], NODE_NONE);
	if (!addrConnect.IsValid()) {
	LogPrint(BCLog::NET,
	"Resolver returned invalid address %s for %s\n",
	addrConnect.ToString(), pszDest);
	return nullptr;
	}
	// It is possible that we already have a connection to the IP/port
	// pszDest resolved to. In that case, drop the connection that was
	// just created, and return the existing CNode instead. Also store
	// the name we used to connect in that CNode, so that future
	// FindNode() calls to that name catch this early.
	LOCK(cs_vNodes);
	CNode *pnode = FindNode(static_cast<CService>(addrConnect));
	if (pnode) {
	pnode->MaybeSetAddrName(std::string(pszDest));
	LogPrintf("Failed to open new connection, already connected\n");
	return nullptr;
	}
	}
	}

	// Connect
	bool connected = false;
	std::unique_ptr<Sock> sock;
	proxyType proxy;
	CAddress addr_bind;
	assert(!addr_bind.IsValid());

	if (addrConnect.IsValid()) {
	bool proxyConnectionFailed = false;

	if (addrConnect.GetNetwork() == NET_I2P &&
	m_i2p_sam_session.get() != nullptr) {
	i2p::Connection conn;
	if (m_i2p_sam_session->Connect(addrConnect, conn,
	proxyConnectionFailed)) {
	connected = true;
	sock = std::move(conn.sock);
	addr_bind = CAddress{conn.me, NODE_NONE};
	}
	} else if (GetProxy(addrConnect.GetNetwork(), proxy)) {
	sock = CreateSock(proxy.proxy);
	if (!sock) {
	return nullptr;
	}
	connected = ConnectThroughProxy(
	proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), *sock,
	nConnectTimeout, proxyConnectionFailed);
	} else {
	// no proxy needed (none set for target network)
	sock = CreateSock(addrConnect);
	if (!sock) {
	return nullptr;
	}
	connected =
	ConnectSocketDirectly(addrConnect, *sock, nConnectTimeout,
	conn_type == ConnectionType::MANUAL);
	}
	if (!proxyConnectionFailed) {
	// If a connection to the node was attempted, and failure (if any)
	// is not caused by a problem connecting to the proxy, mark this as
	// an attempt.
	addrman.Attempt(addrConnect, fCountFailure);
	}
	} else if (pszDest && GetNameProxy(proxy)) {
	sock = CreateSock(proxy.proxy);
	if (!sock) {
	return nullptr;
	}
	std::string host;
	uint16_t port{default_port};
	SplitHostPort(std::string(pszDest), port, host);
	bool proxyConnectionFailed;
	connected = ConnectThroughProxy(proxy, host, port, *sock,
	nConnectTimeout, proxyConnectionFailed);
	}
	if (!connected) {
	return nullptr;
	}

	// Add node
	NodeId id = GetNewNodeId();
	uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE)
	.Write(id)
	.Finalize();
	uint64_t extra_entropy =
	GetDeterministicRandomizer(RANDOMIZER_ID_EXTRAENTROPY)
	.Write(id)
	.Finalize();
	if (!addr_bind.IsValid()) {
	addr_bind = GetBindAddress(sock->Get());
	}
	CNode *pnode =
	new CNode(id, nLocalServices, sock->Release(), addrConnect,
	CalculateKeyedNetGroup(addrConnect), nonce, extra_entropy,
	addr_bind, pszDest ? pszDest : "", conn_type,
	/* inbound_onion */ false);
	pnode->AddRef();

	// We're making a new connection, harvest entropy from the time (and our
	// peer count)
	RandAddEvent(uint32_t(id));

	return pnode;
	}

	void CNode::CloseSocketDisconnect() {
	fDisconnect = true;
	LOCK(cs_hSocket);
	if (hSocket != INVALID_SOCKET) {
	LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);
	CloseSocket(hSocket);
	}
	}

	void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags &flags,
	const CNetAddr &addr) const {
	for (const auto &subnet : vWhitelistedRange) {
	if (subnet.m_subnet.Match(addr)) {
	NetPermissions::AddFlag(flags, subnet.m_flags);
	}
	}
	}

	std::string CNode::ConnectionTypeAsString() const {
	switch (m_conn_type) {
	case ConnectionType::INBOUND:
	return "inbound";
	case ConnectionType::MANUAL:
	return "manual";
	case ConnectionType::FEELER:
	return "feeler";
	case ConnectionType::OUTBOUND_FULL_RELAY:
	return "outbound-full-relay";
	case ConnectionType::BLOCK_RELAY:
	return "block-relay-only";
	case ConnectionType::ADDR_FETCH:
	return "addr-fetch";
	case ConnectionType::AVALANCHE_OUTBOUND:
	return "avalanche";
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	std::string CNode::GetAddrName() const {
	LOCK(cs_addrName);
	return addrName;
	}

	void CNode::MaybeSetAddrName(const std::string &addrNameIn) {
	LOCK(cs_addrName);
	if (addrName.empty()) {
	addrName = addrNameIn;
	}
	}

	CService CNode::GetAddrLocal() const {
	LOCK(cs_addrLocal);
	return addrLocal;
	}

	void CNode::SetAddrLocal(const CService &addrLocalIn) {
	LOCK(cs_addrLocal);
	if (addrLocal.IsValid()) {
	error("Addr local already set for node: %i. Refusing to change from %s "
	"to %s",
	id, addrLocal.ToString(), addrLocalIn.ToString());
	} else {
	addrLocal = addrLocalIn;
	}
	}

	Network CNode::ConnectedThroughNetwork() const {
	return m_inbound_onion ? NET_ONION : addr.GetNetClass();
	}

	void CNode::copyStats(CNodeStats &stats) {
	stats.nodeid = this->GetId();
	stats.nServices = nServices;
	stats.addr = addr;
	stats.addrBind = addrBind;
	stats.m_network = ConnectedThroughNetwork();
	if (m_tx_relay != nullptr) {
	LOCK(m_tx_relay->cs_filter);
	stats.fRelayTxes = m_tx_relay->fRelayTxes;
	} else {
	stats.fRelayTxes = false;
	}
	stats.m_last_send = m_last_send;
	stats.m_last_recv = m_last_recv;
	stats.m_last_tx_time = m_last_tx_time;
	stats.m_last_proof_time = m_last_proof_time;
	stats.m_last_block_time = m_last_block_time;
	stats.m_connected = m_connected;
	stats.nTimeOffset = nTimeOffset;
	stats.addrName = GetAddrName();
	stats.nVersion = nVersion;
	{
	LOCK(cs_SubVer);
	stats.cleanSubVer = cleanSubVer;
	}
	stats.fInbound = IsInboundConn();
	stats.m_manual_connection = IsManualConn();
	stats.m_bip152_highbandwidth_to = m_bip152_highbandwidth_to;
	stats.m_bip152_highbandwidth_from = m_bip152_highbandwidth_from;
	{
	LOCK(cs_vSend);
	stats.mapSendBytesPerMsgCmd = mapSendBytesPerMsgCmd;
	stats.nSendBytes = nSendBytes;
	}
	{
	LOCK(cs_vRecv);
	stats.mapRecvBytesPerMsgCmd = mapRecvBytesPerMsgCmd;
	stats.nRecvBytes = nRecvBytes;
	}
	stats.m_legacyWhitelisted = m_legacyWhitelisted;
	stats.m_permissionFlags = m_permissionFlags;
	if (m_tx_relay != nullptr) {
	LOCK(m_tx_relay->cs_feeFilter);
	stats.minFeeFilter = m_tx_relay->minFeeFilter;
	} else {
	stats.minFeeFilter = Amount::zero();
	}

	stats.m_last_ping_time = m_last_ping_time;
	stats.m_min_ping_time = m_min_ping_time;

	// Leave string empty if addrLocal invalid (not filled in yet)
	CService addrLocalUnlocked = GetAddrLocal();
	stats.addrLocal =
	addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : "";

	stats.m_conn_type_string = ConnectionTypeAsString();

	stats.m_availabilityScore =
	m_avalanche_state
	? std::make_optional(m_avalanche_state->getAvailabilityScore())
	: std::nullopt;
	}

	bool CNode::ReceiveMsgBytes(const Config &config, Span<const uint8_t> msg_bytes,
	bool &complete) {
	complete = false;
	const auto time = GetTime<std::chrono::microseconds>();
	LOCK(cs_vRecv);
	m_last_recv = std::chrono::duration_cast<std::chrono::seconds>(time);
	nRecvBytes += msg_bytes.size();
	while (msg_bytes.size() > 0) {
	// Absorb network data.
	int handled = m_deserializer->Read(config, msg_bytes);
	if (handled < 0) {
	return false;
	}

	if (m_deserializer->Complete()) {
	// decompose a transport agnostic CNetMessage from the deserializer
	CNetMessage msg = m_deserializer->GetMessage(config, time);

	// Store received bytes per message command to prevent a memory DOS,
	// only allow valid commands.
	mapMsgCmdSize::iterator i =
	mapRecvBytesPerMsgCmd.find(msg.m_command);
	if (i == mapRecvBytesPerMsgCmd.end()) {
	i = mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER);
	}

	assert(i != mapRecvBytesPerMsgCmd.end());
	i->second += msg.m_raw_message_size;

	// push the message to the process queue,
	vRecvMsg.push_back(std::move(msg));

	complete = true;
	}
	}

	return true;
	}

	int V1TransportDeserializer::readHeader(const Config &config,
	Span<const uint8_t> msg_bytes) {
	// copy data to temporary parsing buffer
	uint32_t nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;
	uint32_t nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());

	memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);
	nHdrPos += nCopy;

	// if header incomplete, exit
	if (nHdrPos < CMessageHeader::HEADER_SIZE) {
	return nCopy;
	}

	// deserialize to CMessageHeader
	try {
	hdrbuf >> hdr;
	} catch (const std::exception &) {
	return -1;
	}

	// Reject oversized messages
	if (hdr.IsOversized(config)) {
	LogPrint(BCLog::NET, "Oversized header detected\n");
	return -1;
	}

	// switch state to reading message data
	in_data = true;

	return nCopy;
	}

	int V1TransportDeserializer::readData(Span<const uint8_t> msg_bytes) {
	unsigned int nRemaining = hdr.nMessageSize - nDataPos;
	unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());

	if (vRecv.size() < nDataPos + nCopy) {
	// Allocate up to 256 KiB ahead, but never more than the total message
	// size.
	vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
	}

	hasher.Write(msg_bytes.first(nCopy));
	memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
	nDataPos += nCopy;

	return nCopy;
	}

	const uint256 &V1TransportDeserializer::GetMessageHash() const {
	assert(Complete());
	if (data_hash.IsNull()) {
	hasher.Finalize(data_hash);
	}
	return data_hash;
	}

	CNetMessage
	V1TransportDeserializer::GetMessage(const Config &config,
	const std::chrono::microseconds time) {
	// decompose a single CNetMessage from the TransportDeserializer
	CNetMessage msg(std::move(vRecv));

	// store state about valid header, netmagic and checksum
	msg.m_valid_header = hdr.IsValid(config);
	// FIXME Split CheckHeaderMagicAndCommand() into CheckHeaderMagic() and
	// CheckCommand() to prevent the net magic check code duplication.
	msg.m_valid_netmagic =
	(memcmp(std::begin(hdr.pchMessageStart),
	std::begin(config.GetChainParams().NetMagic()),
	CMessageHeader::MESSAGE_START_SIZE) == 0);
	uint256 hash = GetMessageHash();

	// store command string, payload size
	msg.m_command = hdr.GetCommand();
	msg.m_message_size = hdr.nMessageSize;
	msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;

	// We just received a message off the wire, harvest entropy from the time
	// (and the message checksum)
	RandAddEvent(ReadLE32(hash.begin()));

	msg.m_valid_checksum = (memcmp(hash.begin(), hdr.pchChecksum,
	CMessageHeader::CHECKSUM_SIZE) == 0);

	if (!msg.m_valid_checksum) {
	LogPrint(
	BCLog::NET, "CHECKSUM ERROR (%s, %u bytes), expected %s was %s\n",
	SanitizeString(msg.m_command), msg.m_message_size,
	HexStr(Span<uint8_t>(hash.begin(),
	hash.begin() + CMessageHeader::CHECKSUM_SIZE)),
	HexStr(hdr.pchChecksum));
	}

	// store receive time
	msg.m_time = time;

	// reset the network deserializer (prepare for the next message)
	Reset();
	return msg;
	}

	void V1TransportSerializer::prepareForTransport(const Config &config,
	CSerializedNetMsg &msg,
	std::vector<uint8_t> &header) {
	// create dbl-sha256 checksum
	uint256 hash = Hash(msg.data);

	// create header
	CMessageHeader hdr(config.GetChainParams().NetMagic(), msg.m_type.c_str(),
	msg.data.size());
	memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);

	// serialize header
	header.reserve(CMessageHeader::HEADER_SIZE);
	CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, header, 0, hdr};
	}

	size_t CConnman::SocketSendData(CNode &node) const {
	size_t nSentSize = 0;
	size_t nMsgCount = 0;

	for (const auto &data : node.vSendMsg) {
	assert(data.size() > node.nSendOffset);
	int nBytes = 0;

	{
	LOCK(node.cs_hSocket);
	if (node.hSocket == INVALID_SOCKET) {
	break;
	}

	nBytes = send(
	node.hSocket,
	reinterpret_cast<const char *>(data.data()) + node.nSendOffset,
	data.size() - node.nSendOffset, MSG_NOSIGNAL \| MSG_DONTWAIT);
	}

	if (nBytes == 0) {
	// couldn't send anything at all
	break;
	}

	if (nBytes < 0) {
	// error
	int nErr = WSAGetLastError();
	if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE &&
	nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
	LogPrint(BCLog::NET, "socket send error for peer=%d: %s\n",
	node.GetId(), NetworkErrorString(nErr));
	node.CloseSocketDisconnect();
	}

	break;
	}

	assert(nBytes > 0);
	node.m_last_send = GetTime<std::chrono::seconds>();
	node.nSendBytes += nBytes;
	node.nSendOffset += nBytes;
	nSentSize += nBytes;
	if (node.nSendOffset != data.size()) {
	// could not send full message; stop sending more
	break;
	}

	node.nSendOffset = 0;
	node.nSendSize -= data.size();
	node.fPauseSend = node.nSendSize > nSendBufferMaxSize;
	nMsgCount++;
	}

	node.vSendMsg.erase(node.vSendMsg.begin(),
	node.vSendMsg.begin() + nMsgCount);

	if (node.vSendMsg.empty()) {
	assert(node.nSendOffset == 0);
	assert(node.nSendSize == 0);
	}

	return nSentSize;
	}

	static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	return a.m_min_ping_time > b.m_min_ping_time;
	}

	static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	return a.m_connected > b.m_connected;
	}

	static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	return a.nKeyedNetGroup < b.nKeyedNetGroup;
	}

	static bool CompareNodeBlockTime(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	// There is a fall-through here because it is common for a node to have many
	// peers which have not yet relayed a block.
	if (a.m_last_block_time != b.m_last_block_time) {
	return a.m_last_block_time < b.m_last_block_time;
	}

	if (a.fRelevantServices != b.fRelevantServices) {
	return b.fRelevantServices;
	}

	return a.m_connected > b.m_connected;
	}

	static bool CompareNodeTXTime(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	// There is a fall-through here because it is common for a node to have more
	// than a few peers that have not yet relayed txn.
	if (a.m_last_tx_time != b.m_last_tx_time) {
	return a.m_last_tx_time < b.m_last_tx_time;
	}

	if (a.fRelayTxes != b.fRelayTxes) {
	return b.fRelayTxes;
	}

	if (a.fBloomFilter != b.fBloomFilter) {
	return a.fBloomFilter;
	}

	return a.m_connected > b.m_connected;
	}

	static bool CompareNodeProofTime(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	// There is a fall-through here because it is common for a node to have more
	// than a few peers that have not yet relayed proofs. This fallback is also
	// used in the case avalanche is not enabled.
	if (a.m_last_proof_time != b.m_last_proof_time) {
	return a.m_last_proof_time < b.m_last_proof_time;
	}

	return a.m_connected > b.m_connected;
	}

	// Pick out the potential block-relay only peers, and sort them by last block
	// time.
	static bool CompareNodeBlockRelayOnlyTime(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	if (a.fRelayTxes != b.fRelayTxes) {
	return a.fRelayTxes;
	}

	if (a.m_last_block_time != b.m_last_block_time) {
	return a.m_last_block_time < b.m_last_block_time;
	}

	if (a.fRelevantServices != b.fRelevantServices) {
	return b.fRelevantServices;
	}

	return a.m_connected > b.m_connected;
	}

	static bool CompareNodeAvailabilityScore(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) {
	// Equality can happen if the nodes have no score or it has not been
	// computed yet.
	if (a.availabilityScore != b.availabilityScore) {
	return a.availabilityScore < b.availabilityScore;
	}

	return a.m_connected > b.m_connected;
	}

	/**
	* Sort eviction candidates by network/localhost and connection uptime.
	* Candidates near the beginning are more likely to be evicted, and those
	* near the end are more likely to be protected, e.g. less likely to be evicted.
	* - First, nodes that are not `is_local` and that do not belong to `network`,
	* sorted by increasing uptime (from most recently connected to connected
	* longer).
	* - Then, nodes that are `is_local` or belong to `network`, sorted by
	* increasing uptime.
	*/
	struct CompareNodeNetworkTime {
	const bool m_is_local;
	const Network m_network;
	CompareNodeNetworkTime(bool is_local, Network network)
	: m_is_local(is_local), m_network(network) {}
	bool operator()(const NodeEvictionCandidate &a,
	const NodeEvictionCandidate &b) const {
	if (m_is_local && a.m_is_local != b.m_is_local) {
	return b.m_is_local;
	}
	if ((a.m_network == m_network) != (b.m_network == m_network)) {
	return b.m_network == m_network;
	}
	return a.m_connected > b.m_connected;
	};
	};

	//! Sort an array by the specified comparator, then erase the last K elements
	//! where predicate is true.
	template <typename T, typename Comparator>
	static void EraseLastKElements(
	std::vector<T> &elements, Comparator comparator, size_t k,
	std::function<bool(const NodeEvictionCandidate &)> predicate =
	[](const NodeEvictionCandidate &n) { return true; }) {
	std::sort(elements.begin(), elements.end(), comparator);
	size_t eraseSize = std::min(k, elements.size());
	elements.erase(
	std::remove_if(elements.end() - eraseSize, elements.end(), predicate),
	elements.end());
	}

	void ProtectEvictionCandidatesByRatio(
	std::vector<NodeEvictionCandidate> &eviction_candidates) {
	// Protect the half of the remaining nodes which have been connected the
	// longest. This replicates the non-eviction implicit behavior, and
	// precludes attacks that start later.
	// To promote the diversity of our peer connections, reserve up to half of
	// these protected spots for Tor/onion, localhost and I2P peers, even if
	// they're not the longest uptime overall. This helps protect these
	// higher-latency peers that tend to be otherwise disadvantaged under our
	// eviction criteria.
	const size_t initial_size = eviction_candidates.size();
	const size_t total_protect_size{initial_size / 2};

	// Disadvantaged networks to protect: I2P, localhost and Tor/onion. In case
	// of equal counts, earlier array members have first opportunity to recover
	// unused slots from the previous iteration.
	struct Net {
	bool is_local;
	Network id;
	size_t count;
	};
	std::array<Net, 3> networks{{{false, NET_I2P, 0},
	{/* localhost */ true, NET_MAX, 0},
	{false, NET_ONION, 0}}};

	// Count and store the number of eviction candidates per network.
	for (Net &n : networks) {
	n.count = std::count_if(
	eviction_candidates.cbegin(), eviction_candidates.cend(),
	[&n](const NodeEvictionCandidate &c) {
	return n.is_local ? c.m_is_local : c.m_network == n.id;
	});
	}
	// Sort `networks` by ascending candidate count, to give networks having
	// fewer candidates the first opportunity to recover unused protected slots
	// from the previous iteration.
	std::stable_sort(networks.begin(), networks.end(),
	[](Net a, Net b) { return a.count < b.count; });

	// Protect up to 25% of the eviction candidates by disadvantaged network.
	const size_t max_protect_by_network{total_protect_size / 2};
	size_t num_protected{0};

	while (num_protected < max_protect_by_network) {
	// Count the number of disadvantaged networks from which we have peers
	// to protect.
	auto num_networks = std::count_if(networks.begin(), networks.end(),
	[](const Net &n) { return n.count; });
	if (num_networks == 0) {
	break;
	}
	const size_t disadvantaged_to_protect{max_protect_by_network -
	num_protected};
	const size_t protect_per_network{std::max(
	disadvantaged_to_protect / num_networks, static_cast<size_t>(1))};

	// Early exit flag if there are no remaining candidates by disadvantaged
	// network.
	bool protected_at_least_one{false};

	for (Net &n : networks) {
	if (n.count == 0) {
	continue;
	}
	const size_t before = eviction_candidates.size();
	EraseLastKElements(
	eviction_candidates, CompareNodeNetworkTime(n.is_local, n.id),
	protect_per_network, [&n](const NodeEvictionCandidate &c) {
	return n.is_local ? c.m_is_local : c.m_network == n.id;
	});
	const size_t after = eviction_candidates.size();
	if (before > after) {
	protected_at_least_one = true;
	const size_t delta{before - after};
	num_protected += delta;
	if (num_protected >= max_protect_by_network) {
	break;
	}
	n.count -= delta;
	}
	}
	if (!protected_at_least_one) {
	break;
	}
	}

	// Calculate how many we removed, and update our total number of peers that
	// we want to protect based on uptime accordingly.
	assert(num_protected == initial_size - eviction_candidates.size());
	const size_t remaining_to_protect{total_protect_size - num_protected};
	EraseLastKElements(eviction_candidates, ReverseCompareNodeTimeConnected,
	remaining_to_protect);
	}

	[[nodiscard]] std::optional<NodeId>
	SelectNodeToEvict(std::vector<NodeEvictionCandidate> &&vEvictionCandidates) {
	// Protect connections with certain characteristics

	// Deterministically select 4 peers to protect by netgroup.
	// An attacker cannot predict which netgroups will be protected
	EraseLastKElements(vEvictionCandidates, CompareNetGroupKeyed, 4);
	// Protect the 8 nodes with the lowest minimum ping time.
	// An attacker cannot manipulate this metric without physically moving nodes
	// closer to the target.
	EraseLastKElements(vEvictionCandidates, ReverseCompareNodeMinPingTime, 8);
	// Protect 4 nodes that most recently sent us novel transactions accepted
	// into our mempool. An attacker cannot manipulate this metric without
	// performing useful work.
	EraseLastKElements(vEvictionCandidates, CompareNodeTXTime, 4);
	// Protect 4 nodes that most recently sent us novel proofs accepted
	// into our proof pool. An attacker cannot manipulate this metric without
	// performing useful work.
	// TODO this filter must happen before the last tx time once avalanche is
	// enabled for pre-consensus.
	EraseLastKElements(vEvictionCandidates, CompareNodeProofTime, 4);
	// Protect up to 8 non-tx-relay peers that have sent us novel blocks.
	EraseLastKElements(vEvictionCandidates, CompareNodeBlockRelayOnlyTime, 8,
	[](const NodeEvictionCandidate &n) {
	return !n.fRelayTxes && n.fRelevantServices;
	});

	// Protect 4 nodes that most recently sent us novel blocks.
	// An attacker cannot manipulate this metric without performing useful work.
	EraseLastKElements(vEvictionCandidates, CompareNodeBlockTime, 4);

	// Protect up to 128 nodes that have the highest avalanche availability
	// score.
	EraseLastKElements(vEvictionCandidates, CompareNodeAvailabilityScore, 128,
	[](NodeEvictionCandidate const &n) {
	return n.availabilityScore > 0.;
	});

	// Protect some of the remaining eviction candidates by ratios of desirable
	// or disadvantaged characteristics.
	ProtectEvictionCandidatesByRatio(vEvictionCandidates);

	if (vEvictionCandidates.empty()) {
	return std::nullopt;
	}

	// If any remaining peers are preferred for eviction consider only them.
	// This happens after the other preferences since if a peer is really the
	// best by other criteria (esp relaying blocks)
	// then we probably don't want to evict it no matter what.
	if (std::any_of(
	vEvictionCandidates.begin(), vEvictionCandidates.end(),
	[](NodeEvictionCandidate const &n) { return n.prefer_evict; })) {
	vEvictionCandidates.erase(
	std::remove_if(
	vEvictionCandidates.begin(), vEvictionCandidates.end(),
	[](NodeEvictionCandidate const &n) { return !n.prefer_evict; }),
	vEvictionCandidates.end());
	}

	// Identify the network group with the most connections and youngest member.
	// (vEvictionCandidates is already sorted by reverse connect time)
	uint64_t naMostConnections;
	unsigned int nMostConnections = 0;
	std::chrono::seconds nMostConnectionsTime{0};
	std::map<uint64_t, std::vector<NodeEvictionCandidate>> mapNetGroupNodes;
	for (const NodeEvictionCandidate &node : vEvictionCandidates) {
	std::vector<NodeEvictionCandidate> &group =
	mapNetGroupNodes[node.nKeyedNetGroup];
	group.push_back(node);
	const auto grouptime{group[0].m_connected};
	size_t group_size = group.size();
	if (group_size > nMostConnections \|\|
	(group_size == nMostConnections &&
	grouptime > nMostConnectionsTime)) {
	nMostConnections = group_size;
	nMostConnectionsTime = grouptime;
	naMostConnections = node.nKeyedNetGroup;
	}
	}

	// Reduce to the network group with the most connections
	vEvictionCandidates = std::move(mapNetGroupNodes[naMostConnections]);

	// Disconnect from the network group with the most connections
	return vEvictionCandidates.front().id;
	}

	/** Try to find a connection to evict when the node is full.
	* Extreme care must be taken to avoid opening the node to attacker
	* triggered network partitioning.
	* The strategy used here is to protect a small number of peers
	* for each of several distinct characteristics which are difficult
	* to forge. In order to partition a node the attacker must be
	* simultaneously better at all of them than honest peers.
	*/
	bool CConnman::AttemptToEvictConnection() {
	std::vector<NodeEvictionCandidate> vEvictionCandidates;
	{
	LOCK(cs_vNodes);
	for (const CNode *node : vNodes) {
	if (node->HasPermission(PF_NOBAN)) {
	continue;
	}
	if (!node->IsInboundConn()) {
	continue;
	}
	if (node->fDisconnect) {
	continue;
	}
	bool peer_relay_txes = false;
	bool peer_filter_not_null = false;
	if (node->m_tx_relay != nullptr) {
	LOCK(node->m_tx_relay->cs_filter);
	peer_relay_txes = node->m_tx_relay->fRelayTxes;
	peer_filter_not_null = node->m_tx_relay->pfilter != nullptr;
	}

	NodeEvictionCandidate candidate = {
	node->GetId(),
	node->m_connected,
	node->m_min_ping_time,
	node->m_last_block_time,
	node->m_last_proof_time,
	node->m_last_tx_time,
	HasAllDesirableServiceFlags(node->nServices),
	peer_relay_txes,
	peer_filter_not_null,
	node->nKeyedNetGroup,
	node->m_prefer_evict,
	node->addr.IsLocal(),
	node->ConnectedThroughNetwork(),
	node->m_avalanche_state
	? node->m_avalanche_state->getAvailabilityScore()
	: -std::numeric_limits<double>::infinity()};
	vEvictionCandidates.push_back(candidate);
	}
	}
	const std::optional<NodeId> node_id_to_evict =
	SelectNodeToEvict(std::move(vEvictionCandidates));
	if (!node_id_to_evict) {
	return false;
	}
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (pnode->GetId() == *node_id_to_evict) {
	LogPrint(
	BCLog::NET,
	"selected %s connection for eviction peer=%d; disconnecting\n",
	pnode->ConnectionTypeAsString(), pnode->GetId());
	pnode->fDisconnect = true;
	return true;
	}
	}
	return false;
	}

	void CConnman::AcceptConnection(const ListenSocket &hListenSocket) {
	struct sockaddr_storage sockaddr;
	socklen_t len = sizeof(sockaddr);
	SOCKET hSocket =
	accept(hListenSocket.socket, (struct sockaddr *)&sockaddr, &len);
	CAddress addr;

	if (hSocket == INVALID_SOCKET) {
	const int nErr = WSAGetLastError();
	if (nErr != WSAEWOULDBLOCK) {
	LogPrintf("socket error accept failed: %s\n",
	NetworkErrorString(nErr));
	}
	return;
	}

	if (!addr.SetSockAddr((const struct sockaddr *)&sockaddr)) {
	LogPrintf("Warning: Unknown socket family\n");
	}

	const CAddress addr_bind = GetBindAddress(hSocket);

	NetPermissionFlags permissionFlags = NetPermissionFlags::PF_NONE;
	hListenSocket.AddSocketPermissionFlags(permissionFlags);

	CreateNodeFromAcceptedSocket(hSocket, permissionFlags, addr_bind, addr);
	}

	void CConnman::CreateNodeFromAcceptedSocket(SOCKET hSocket,
	NetPermissionFlags permissionFlags,
	const CAddress &addr_bind,
	const CAddress &addr) {
	int nInbound = 0;
	int nMaxInbound = nMaxConnections - m_max_outbound;

	AddWhitelistPermissionFlags(permissionFlags, addr);
	bool legacyWhitelisted = false;
	if (NetPermissions::HasFlag(permissionFlags,
	NetPermissionFlags::PF_ISIMPLICIT)) {
	NetPermissions::ClearFlag(permissionFlags, PF_ISIMPLICIT);
	if (gArgs.GetBoolArg("-whitelistforcerelay",
	DEFAULT_WHITELISTFORCERELAY)) {
	NetPermissions::AddFlag(permissionFlags, PF_FORCERELAY);
	}
	if (gArgs.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY)) {
	NetPermissions::AddFlag(permissionFlags, PF_RELAY);
	}
	NetPermissions::AddFlag(permissionFlags, PF_MEMPOOL);
	NetPermissions::AddFlag(permissionFlags, PF_NOBAN);
	legacyWhitelisted = true;
	}

	{
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->IsInboundConn()) {
	nInbound++;
	}
	}
	}

	if (!fNetworkActive) {
	LogPrint(BCLog::NET,
	"connection from %s dropped: not accepting new connections\n",
	addr.ToString());
	CloseSocket(hSocket);
	return;
	}

	if (!IsSelectableSocket(hSocket)) {
	LogPrintf("connection from %s dropped: non-selectable socket\n",
	addr.ToString());
	CloseSocket(hSocket);
	return;
	}

	// According to the internet TCP_NODELAY is not carried into accepted
	// sockets on all platforms. Set it again here just to be sure.
	SetSocketNoDelay(hSocket);

	// Don't accept connections from banned peers.
	bool banned = m_banman && m_banman->IsBanned(addr);
	if (!NetPermissions::HasFlag(permissionFlags,
	NetPermissionFlags::PF_NOBAN) &&
	banned) {
	LogPrint(BCLog::NET, "connection from %s dropped (banned)\n",
	addr.ToString());
	CloseSocket(hSocket);
	return;
	}

	// Only accept connections from discouraged peers if our inbound slots
	// aren't (almost) full.
	bool discouraged = m_banman && m_banman->IsDiscouraged(addr);
	if (!NetPermissions::HasFlag(permissionFlags,
	NetPermissionFlags::PF_NOBAN) &&
	nInbound + 1 >= nMaxInbound && discouraged) {
	LogPrint(BCLog::NET, "connection from %s dropped (discouraged)\n",
	addr.ToString());
	CloseSocket(hSocket);
	return;
	}

	if (nInbound >= nMaxInbound) {
	if (!AttemptToEvictConnection()) {
	// No connection to evict, disconnect the new connection
	LogPrint(BCLog::NET, "failed to find an eviction candidate - "
	"connection dropped (full)\n");
	CloseSocket(hSocket);
	return;
	}
	}

	NodeId id = GetNewNodeId();
	uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE)
	.Write(id)
	.Finalize();
	uint64_t extra_entropy =
	GetDeterministicRandomizer(RANDOMIZER_ID_EXTRAENTROPY)
	.Write(id)
	.Finalize();

	ServiceFlags nodeServices = nLocalServices;
	if (NetPermissions::HasFlag(permissionFlags, PF_BLOOMFILTER)) {
	nodeServices = static_cast<ServiceFlags>(nodeServices \| NODE_BLOOM);
	}

	const bool inbound_onion =
	std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) !=
	m_onion_binds.end();
	CNode *pnode = new CNode(
	id, nodeServices, hSocket, addr, CalculateKeyedNetGroup(addr), nonce,
	extra_entropy, addr_bind, "", ConnectionType::INBOUND, inbound_onion);
	pnode->AddRef();
	pnode->m_permissionFlags = permissionFlags;
	// If this flag is present, the user probably expect that RPC and QT report
	// it as whitelisted (backward compatibility)
	pnode->m_legacyWhitelisted = legacyWhitelisted;
	pnode->m_prefer_evict = discouraged;
	for (auto interface : m_msgproc) {
	interface->InitializeNode(*config, pnode);
	}

	LogPrint(BCLog::NET, "connection from %s accepted\n", addr.ToString());

	{
	LOCK(cs_vNodes);
	vNodes.push_back(pnode);
	}

	// We received a new connection, harvest entropy from the time (and our peer
	// count)
	RandAddEvent(uint32_t(id));
	}

	bool CConnman::AddConnection(const std::string &address,
	ConnectionType conn_type) {
	std::optional<int> max_connections;
	switch (conn_type) {
	case ConnectionType::INBOUND:
	case ConnectionType::MANUAL:
	return false;
	case ConnectionType::OUTBOUND_FULL_RELAY:
	max_connections = m_max_outbound_full_relay;
	break;
	case ConnectionType::BLOCK_RELAY:
	max_connections = m_max_outbound_block_relay;
	break;
	// no limit for ADDR_FETCH because -seednode has no limit either
	case ConnectionType::ADDR_FETCH:
	break;
	// no limit for FEELER connections since they're short-lived
	case ConnectionType::FEELER:
	break;
	case ConnectionType::AVALANCHE_OUTBOUND:
	max_connections = m_max_avalanche_outbound;
	break;
	} // no default case, so the compiler can warn about missing cases

	// Count existing connections
	int existing_connections = WITH_LOCK(
	cs_vNodes, return std::count_if(
	vNodes.begin(), vNodes.end(), [conn_type](CNode *node) {
	return node->m_conn_type == conn_type;
	}););

	// Max connections of specified type already exist
	if (max_connections != std::nullopt &&
	existing_connections >= max_connections) {
	return false;
	}

	// Max total outbound connections already exist
	CSemaphoreGrant grant(*semOutbound, true);
	if (!grant) {
	return false;
	}

	OpenNetworkConnection(CAddress(), false, &grant, address.c_str(),
	conn_type);
	return true;
	}

	void CConnman::DisconnectNodes() {
	{
	LOCK(cs_vNodes);

	if (!fNetworkActive) {
	// Disconnect any connected nodes
	for (CNode *pnode : vNodes) {
	if (!pnode->fDisconnect) {
	LogPrint(BCLog::NET,
	"Network not active, dropping peer=%d\n",
	pnode->GetId());
	pnode->fDisconnect = true;
	}
	}
	}

	// Disconnect unused nodes
	std::vector<CNode *> vNodesCopy = vNodes;
	for (CNode *pnode : vNodesCopy) {
	if (pnode->fDisconnect) {
	// remove from vNodes
	vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode),
	vNodes.end());

	// release outbound grant (if any)
	pnode->grantOutbound.Release();

	// close socket and cleanup
	pnode->CloseSocketDisconnect();

	// hold in disconnected pool until all refs are released
	pnode->Release();
	vNodesDisconnected.push_back(pnode);
	}
	}
	}
	{
	// Delete disconnected nodes
	std::list<CNode *> vNodesDisconnectedCopy = vNodesDisconnected;
	for (CNode *pnode : vNodesDisconnectedCopy) {
	// wait until threads are done using it
	if (pnode->GetRefCount() <= 0) {
	bool fDelete = false;
	{
	TRY_LOCK(pnode->cs_vSend, lockSend);
	if (lockSend) {
	fDelete = true;
	}
	}
	if (fDelete) {
	vNodesDisconnected.remove(pnode);
	DeleteNode(pnode);
	}
	}
	}
	}
	}

	void CConnman::NotifyNumConnectionsChanged() {
	size_t vNodesSize;
	{
	LOCK(cs_vNodes);
	vNodesSize = vNodes.size();
	}
	if (vNodesSize != nPrevNodeCount) {
	nPrevNodeCount = vNodesSize;
	if (clientInterface) {
	clientInterface->NotifyNumConnectionsChanged(vNodesSize);
	}
	}
	}

	bool CConnman::ShouldRunInactivityChecks(const CNode &node,
	std::chrono::seconds now) const {
	return node.m_connected + m_peer_connect_timeout < now;
	}

	bool CConnman::InactivityCheck(const CNode &node) const {
	// Tests that see disconnects after using mocktime can start nodes with a
	// large timeout. For example, -peertimeout=999999999.
	const auto now{GetTime<std::chrono::seconds>()};
	const auto last_send{node.m_last_send.load()};
	const auto last_recv{node.m_last_recv.load()};

	if (!ShouldRunInactivityChecks(node, now)) {
	return false;
	}

	if (last_recv.count() == 0 \|\| last_send.count() == 0) {
	LogPrint(BCLog::NET,
	"socket no message in first %i seconds, %d %d peer=%d\n",
	count_seconds(m_peer_connect_timeout), last_recv.count() != 0,
	last_send.count() != 0, node.GetId());
	return true;
	}

	if (now > last_send + TIMEOUT_INTERVAL) {
	LogPrint(BCLog::NET, "socket sending timeout: %is peer=%d\n",
	count_seconds(now - last_send), node.GetId());
	return true;
	}

	if (now > last_recv + TIMEOUT_INTERVAL) {
	LogPrint(BCLog::NET, "socket receive timeout: %is peer=%d\n",
	count_seconds(now - last_recv), node.GetId());
	return true;
	}

	if (!node.fSuccessfullyConnected) {
	LogPrint(BCLog::NET, "version handshake timeout peer=%d\n",
	node.GetId());
	return true;
	}

	return false;
	}

	bool CConnman::GenerateSelectSet(std::set<SOCKET> &recv_set,
	std::set<SOCKET> &send_set,
	std::set<SOCKET> &error_set) {
	for (const ListenSocket &hListenSocket : vhListenSocket) {
	recv_set.insert(hListenSocket.socket);
	}

	{
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	// Implement the following logic:
	// * If there is data to send, select() for sending data. As this
	// only happens when optimistic write failed, we choose to first
	// drain the write buffer in this case before receiving more. This
	// avoids needlessly queueing received data, if the remote peer is
	// not themselves receiving data. This means properly utilizing
	// TCP flow control signalling.
	// * Otherwise, if there is space left in the receive buffer,
	// select() for receiving data.
	// * Hand off all complete messages to the processor, to be handled
	// without blocking here.

	bool select_recv = !pnode->fPauseRecv;
	bool select_send;
	{
	LOCK(pnode->cs_vSend);
	select_send = !pnode->vSendMsg.empty();
	}

	LOCK(pnode->cs_hSocket);
	if (pnode->hSocket == INVALID_SOCKET) {
	continue;
	}

	error_set.insert(pnode->hSocket);
	if (select_send) {
	send_set.insert(pnode->hSocket);
	continue;
	}
	if (select_recv) {
	recv_set.insert(pnode->hSocket);
	}
	}
	}

	return !recv_set.empty() \|\| !send_set.empty() \|\| !error_set.empty();
	}

	#ifdef USE_POLL
	void CConnman::SocketEvents(std::set<SOCKET> &recv_set,
	std::set<SOCKET> &send_set,
	std::set<SOCKET> &error_set) {
	std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
	if (!GenerateSelectSet(recv_select_set, send_select_set,
	error_select_set)) {
	interruptNet.sleep_for(
	std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS));
	return;
	}

	std::unordered_map<SOCKET, struct pollfd> pollfds;
	for (SOCKET socket_id : recv_select_set) {
	pollfds[socket_id].fd = socket_id;
	pollfds[socket_id].events \|= POLLIN;
	}

	for (SOCKET socket_id : send_select_set) {
	pollfds[socket_id].fd = socket_id;
	pollfds[socket_id].events \|= POLLOUT;
	}

	for (SOCKET socket_id : error_select_set) {
	pollfds[socket_id].fd = socket_id;
	// These flags are ignored, but we set them for clarity
	pollfds[socket_id].events \|= POLLERR \| POLLHUP;
	}

	std::vector<struct pollfd> vpollfds;
	vpollfds.reserve(pollfds.size());
	for (auto it : pollfds) {
	vpollfds.push_back(std::move(it.second));
	}

	if (poll(vpollfds.data(), vpollfds.size(), SELECT_TIMEOUT_MILLISECONDS) <
	0) {
	return;
	}

	if (interruptNet) {
	return;
	}

	for (struct pollfd pollfd_entry : vpollfds) {
	if (pollfd_entry.revents & POLLIN) {
	recv_set.insert(pollfd_entry.fd);
	}
	if (pollfd_entry.revents & POLLOUT) {
	send_set.insert(pollfd_entry.fd);
	}
	if (pollfd_entry.revents & (POLLERR \| POLLHUP)) {
	error_set.insert(pollfd_entry.fd);
	}
	}
	}
	#else
	void CConnman::SocketEvents(std::set<SOCKET> &recv_set,
	std::set<SOCKET> &send_set,
	std::set<SOCKET> &error_set) {
	std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
	if (!GenerateSelectSet(recv_select_set, send_select_set,
	error_select_set)) {
	interruptNet.sleep_for(
	std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS));
	return;
	}

	//
	// Find which sockets have data to receive
	//
	struct timeval timeout;
	timeout.tv_sec = 0;
	// frequency to poll pnode->vSend
	timeout.tv_usec = SELECT_TIMEOUT_MILLISECONDS * 1000;

	fd_set fdsetRecv;
	fd_set fdsetSend;
	fd_set fdsetError;
	FD_ZERO(&fdsetRecv);
	FD_ZERO(&fdsetSend);
	FD_ZERO(&fdsetError);
	SOCKET hSocketMax = 0;

	for (SOCKET hSocket : recv_select_set) {
	FD_SET(hSocket, &fdsetRecv);
	hSocketMax = std::max(hSocketMax, hSocket);
	}

	for (SOCKET hSocket : send_select_set) {
	FD_SET(hSocket, &fdsetSend);
	hSocketMax = std::max(hSocketMax, hSocket);
	}

	for (SOCKET hSocket : error_select_set) {
	FD_SET(hSocket, &fdsetError);
	hSocketMax = std::max(hSocketMax, hSocket);
	}

	int nSelect =
	select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);

	if (interruptNet) {
	return;
	}

	if (nSelect == SOCKET_ERROR) {
	int nErr = WSAGetLastError();
	LogPrintf("socket select error %s\n", NetworkErrorString(nErr));
	for (unsigned int i = 0; i <= hSocketMax; i++) {
	FD_SET(i, &fdsetRecv);
	}
	FD_ZERO(&fdsetSend);
	FD_ZERO(&fdsetError);
	if (!interruptNet.sleep_for(
	std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS))) {
	return;
	}
	}

	for (SOCKET hSocket : recv_select_set) {
	if (FD_ISSET(hSocket, &fdsetRecv)) {
	recv_set.insert(hSocket);
	}
	}

	for (SOCKET hSocket : send_select_set) {
	if (FD_ISSET(hSocket, &fdsetSend)) {
	send_set.insert(hSocket);
	}
	}

	for (SOCKET hSocket : error_select_set) {
	if (FD_ISSET(hSocket, &fdsetError)) {
	error_set.insert(hSocket);
	}
	}
	}
	#endif

	void CConnman::SocketHandler() {
	std::set<SOCKET> recv_set, send_set, error_set;
	SocketEvents(recv_set, send_set, error_set);

	if (interruptNet) {
	return;
	}

	//
	// Accept new connections
	//
	for (const ListenSocket &hListenSocket : vhListenSocket) {
	if (hListenSocket.socket != INVALID_SOCKET &&
	recv_set.count(hListenSocket.socket) > 0) {
	AcceptConnection(hListenSocket);
	}
	}

	//
	// Service each socket
	//
	std::vector<CNode *> vNodesCopy;
	{
	LOCK(cs_vNodes);
	vNodesCopy = vNodes;
	for (CNode *pnode : vNodesCopy) {
	pnode->AddRef();
	}
	}
	for (CNode *pnode : vNodesCopy) {
	if (interruptNet) {
	return;
	}

	//
	// Receive
	//
	bool recvSet = false;
	bool sendSet = false;
	bool errorSet = false;
	{
	LOCK(pnode->cs_hSocket);
	if (pnode->hSocket == INVALID_SOCKET) {
	continue;
	}
	recvSet = recv_set.count(pnode->hSocket) > 0;
	sendSet = send_set.count(pnode->hSocket) > 0;
	errorSet = error_set.count(pnode->hSocket) > 0;
	}
	if (recvSet \|\| errorSet) {
	// typical socket buffer is 8K-64K
	uint8_t pchBuf[0x10000];
	int32_t nBytes = 0;
	{
	LOCK(pnode->cs_hSocket);
	if (pnode->hSocket == INVALID_SOCKET) {
	continue;
	}
	nBytes = recv(pnode->hSocket, (char *)pchBuf, sizeof(pchBuf),
	MSG_DONTWAIT);
	}
	if (nBytes > 0) {
	bool notify = false;
	if (!pnode->ReceiveMsgBytes(
	*config, Span<const uint8_t>(pchBuf, nBytes), notify)) {
	pnode->CloseSocketDisconnect();
	}
	RecordBytesRecv(nBytes);
	if (notify) {
	size_t nSizeAdded = 0;
	auto it(pnode->vRecvMsg.begin());
	for (; it != pnode->vRecvMsg.end(); ++it) {
	// vRecvMsg contains only completed CNetMessage
	// the single possible partially deserialized message
	// are held by TransportDeserializer
	nSizeAdded += it->m_raw_message_size;
	}
	{
	LOCK(pnode->cs_vProcessMsg);
	pnode->vProcessMsg.splice(pnode->vProcessMsg.end(),
	pnode->vRecvMsg,
	pnode->vRecvMsg.begin(), it);
	pnode->nProcessQueueSize += nSizeAdded;
	pnode->fPauseRecv =
	pnode->nProcessQueueSize > nReceiveFloodSize;
	}
	WakeMessageHandler();
	}
	} else if (nBytes == 0) {
	// socket closed gracefully
	if (!pnode->fDisconnect) {
	LogPrint(BCLog::NET, "socket closed for peer=%d\n",
	pnode->GetId());
	}
	pnode->CloseSocketDisconnect();
	} else if (nBytes < 0) {
	// error
	int nErr = WSAGetLastError();
	if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE &&
	nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
	if (!pnode->fDisconnect) {
	LogPrint(BCLog::NET,
	"socket recv error for peer=%d: %s\n",
	pnode->GetId(), NetworkErrorString(nErr));
	}
	pnode->CloseSocketDisconnect();
	}
	}
	}

	//
	// Send
	//
	if (sendSet) {
	LOCK(pnode->cs_vSend);
	size_t nBytes = SocketSendData(*pnode);
	if (nBytes) {
	RecordBytesSent(nBytes);
	}
	}

	if (InactivityCheck(*pnode)) {
	pnode->fDisconnect = true;
	}
	}
	{
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodesCopy) {
	pnode->Release();
	}
	}
	}

	void CConnman::ThreadSocketHandler() {
	while (!interruptNet) {
	DisconnectNodes();
	NotifyNumConnectionsChanged();
	SocketHandler();
	}
	}

	void CConnman::WakeMessageHandler() {
	{
	LOCK(mutexMsgProc);
	fMsgProcWake = true;
	}
	condMsgProc.notify_one();
	}

	void CConnman::ThreadDNSAddressSeed() {
	FastRandomContext rng;
	std::vector<std::string> seeds =
	GetRandomizedDNSSeeds(config->GetChainParams());
	// Number of seeds left before testing if we have enough connections
	int seeds_right_now = 0;
	int found = 0;

	if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
	// When -forcednsseed is provided, query all.
	seeds_right_now = seeds.size();
	} else if (addrman.size() == 0) {
	// If we have no known peers, query all.
	// This will occur on the first run, or if peers.dat has been
	// deleted.
	seeds_right_now = seeds.size();
	}

	// goal: only query DNS seed if address need is acute
	// * If we have a reasonable number of peers in addrman, spend
	// some time trying them first. This improves user privacy by
	// creating fewer identifying DNS requests, reduces trust by
	// giving seeds less influence on the network topology, and
	// reduces traffic to the seeds.
	// * When querying DNS seeds query a few at once, this ensures
	// that we don't give DNS seeds the ability to eclipse nodes
	// that query them.
	// * If we continue having problems, eventually query all the
	// DNS seeds, and if that fails too, also try the fixed seeds.
	// (done in ThreadOpenConnections)
	const std::chrono::seconds seeds_wait_time =
	(addrman.size() >= DNSSEEDS_DELAY_PEER_THRESHOLD
	? DNSSEEDS_DELAY_MANY_PEERS
	: DNSSEEDS_DELAY_FEW_PEERS);

	for (const std::string &seed : seeds) {
	if (seeds_right_now == 0) {
	seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;

	if (addrman.size() > 0) {
	LogPrintf("Waiting %d seconds before querying DNS seeds.\n",
	seeds_wait_time.count());
	std::chrono::seconds to_wait = seeds_wait_time;
	while (to_wait.count() > 0) {
	// if sleeping for the MANY_PEERS interval, wake up
	// early to see if we have enough peers and can stop
	// this thread entirely freeing up its resources
	std::chrono::seconds w =
	std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
	if (!interruptNet.sleep_for(w)) {
	return;
	}
	to_wait -= w;

	int nRelevant = 0;
	{
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->fSuccessfullyConnected &&
	pnode->IsOutboundOrBlockRelayConn()) {
	++nRelevant;
	}
	}
	}
	if (nRelevant >= 2) {
	if (found > 0) {
	LogPrintf("%d addresses found from DNS seeds\n",
	found);
	LogPrintf(
	"P2P peers available. Finished DNS seeding.\n");
	} else {
	LogPrintf(
	"P2P peers available. Skipped DNS seeding.\n");
	}
	return;
	}
	}
	}
	}

	if (interruptNet) {
	return;
	}

	// hold off on querying seeds if P2P network deactivated
	if (!fNetworkActive) {
	LogPrintf("Waiting for network to be reactivated before querying "
	"DNS seeds.\n");
	do {
	if (!interruptNet.sleep_for(std::chrono::seconds{1})) {
	return;
	}
	} while (!fNetworkActive);
	}

	LogPrintf("Loading addresses from DNS seed %s\n", seed);
	if (HaveNameProxy()) {
	AddAddrFetch(seed);
	} else {
	std::vector<CNetAddr> vIPs;
	std::vector<CAddress> vAdd;
	ServiceFlags requiredServiceBits =
	GetDesirableServiceFlags(NODE_NONE);
	std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
	CNetAddr resolveSource;
	if (!resolveSource.SetInternal(host)) {
	continue;
	}

	// Limits number of IPs learned from a DNS seed
	unsigned int nMaxIPs = 256;
	if (LookupHost(host, vIPs, nMaxIPs, true)) {
	for (const CNetAddr &ip : vIPs) {
	int nOneDay = 24 * 3600;
	CAddress addr = CAddress(
	CService(ip, config->GetChainParams().GetDefaultPort()),
	requiredServiceBits);
	// Use a random age between 3 and 7 days old.
	addr.nTime =
	GetTime() - 3 * nOneDay - rng.randrange(4 * nOneDay);
	vAdd.push_back(addr);
	found++;
	}
	addrman.Add(vAdd, resolveSource);
	} else {
	// We now avoid directly using results from DNS Seeds which do
	// not support service bit filtering, instead using them as a
	// addrfetch to get nodes with our desired service bits.
	AddAddrFetch(seed);
	}
	}
	--seeds_right_now;
	}
	LogPrintf("%d addresses found from DNS seeds\n", found);
	}

	void CConnman::DumpAddresses() {
	int64_t nStart = GetTimeMillis();

	DumpPeerAddresses(config->GetChainParams(), ::gArgs, addrman);

	LogPrint(BCLog::NET, "Flushed %d addresses to peers.dat %dms\n",
	addrman.size(), GetTimeMillis() - nStart);
	}

	void CConnman::ProcessAddrFetch() {
	std::string strDest;
	{
	LOCK(m_addr_fetches_mutex);
	if (m_addr_fetches.empty()) {
	return;
	}
	strDest = m_addr_fetches.front();
	m_addr_fetches.pop_front();
	}
	CAddress addr;
	CSemaphoreGrant grant(*semOutbound, true);
	if (grant) {
	OpenNetworkConnection(addr, false, &grant, strDest.c_str(),
	ConnectionType::ADDR_FETCH);
	}
	}

	bool CConnman::GetTryNewOutboundPeer() {
	return m_try_another_outbound_peer;
	}

	void CConnman::SetTryNewOutboundPeer(bool flag) {
	m_try_another_outbound_peer = flag;
	LogPrint(BCLog::NET, "net: setting try another outbound peer=%s\n",
	flag ? "true" : "false");
	}

	// Return the number of peers we have over our outbound connection limit.
	// Exclude peers that are marked for disconnect, or are going to be disconnected
	// soon (eg ADDR_FETCH and FEELER).
	// Also exclude peers that haven't finished initial connection handshake yet (so
	// that we don't decide we're over our desired connection limit, and then evict
	// some peer that has finished the handshake).
	int CConnman::GetExtraFullOutboundCount() {
	int full_outbound_peers = 0;
	{
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->fSuccessfullyConnected && !pnode->fDisconnect &&
	pnode->IsFullOutboundConn()) {
	++full_outbound_peers;
	}
	}
	}
	return std::max(full_outbound_peers - m_max_outbound_full_relay -
	m_max_avalanche_outbound,
	0);
	}

	int CConnman::GetExtraBlockRelayCount() {
	int block_relay_peers = 0;
	{
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->fSuccessfullyConnected && !pnode->fDisconnect &&
	pnode->IsBlockOnlyConn()) {
	++block_relay_peers;
	}
	}
	}
	return std::max(block_relay_peers - m_max_outbound_block_relay, 0);
	}

	void CConnman::ThreadOpenConnections(
	const std::vector<std::string> connect,
	std::function<void(const CAddress &, ConnectionType)> mockOpenConnection) {
	// Connect to specific addresses
	if (!connect.empty()) {
	for (int64_t nLoop = 0;; nLoop++) {
	ProcessAddrFetch();
	for (const std::string &strAddr : connect) {
	CAddress addr(CService(), NODE_NONE);
	OpenNetworkConnection(addr, false, nullptr, strAddr.c_str(),
	ConnectionType::MANUAL);
	for (int i = 0; i < 10 && i < nLoop; i++) {
	if (!interruptNet.sleep_for(
	std::chrono::milliseconds(500))) {
	return;
	}
	}
	}
	if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) {
	return;
	}
	}
	}

	// Initiate network connections
	auto start = GetTime<std::chrono::microseconds>();

	// Minimum time before next feeler connection (in microseconds).
	auto next_feeler = PoissonNextSend(start, FEELER_INTERVAL);
	auto next_extra_block_relay =
	PoissonNextSend(start, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
	const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED);
	bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS);

	if (!add_fixed_seeds) {
	LogPrintf("Fixed seeds are disabled\n");
	}

	while (!interruptNet) {
	ProcessAddrFetch();

	// No need to sleep the thread if we are mocking the network connection
	if (!mockOpenConnection &&
	!interruptNet.sleep_for(std::chrono::milliseconds(500))) {
	return;
	}

	CSemaphoreGrant grant(*semOutbound);
	if (interruptNet) {
	return;
	}

	if (add_fixed_seeds && addrman.size() == 0) {
	// When the node starts with an empty peers.dat, there are a few
	// other sources of peers before we fallback on to fixed seeds:
	// -dnsseed, -seednode, -addnode If none of those are available, we
	// fallback on to fixed seeds immediately, else we allow 60 seconds
	// for any of those sources to populate addrman.
	bool add_fixed_seeds_now = false;
	// It is cheapest to check if enough time has passed first.
	if (GetTime<std::chrono::seconds>() >
	start + std::chrono::minutes{1}) {
	add_fixed_seeds_now = true;
	LogPrintf("Adding fixed seeds as 60 seconds have passed and "
	"addrman is empty\n");
	}

	// Checking !dnsseed is cheaper before locking 2 mutexes.
	if (!add_fixed_seeds_now && !dnsseed) {
	LOCK2(m_addr_fetches_mutex, cs_vAddedNodes);
	if (m_addr_fetches.empty() && vAddedNodes.empty()) {
	add_fixed_seeds_now = true;
	LogPrintf(
	"Adding fixed seeds as -dnsseed=0, -addnode is not "
	"provided and all -seednode(s) attempted\n");
	}
	}

	if (add_fixed_seeds_now) {
	CNetAddr local;
	local.SetInternal("fixedseeds");
	addrman.Add(convertSeed6(config->GetChainParams().FixedSeeds()),
	local);
	add_fixed_seeds = false;
	}
	}

	//
	// Choose an address to connect to based on most recently seen
	//
	CAddress addrConnect;

	// Only connect out to one peer per network group (/16 for IPv4).
	int nOutboundFullRelay = 0;
	int nOutboundBlockRelay = 0;
	int nOutboundAvalanche = 0;
	std::set<std::vector<uint8_t>> setConnected;

	{
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->IsAvalancheOutboundConnection()) {
	nOutboundAvalanche++;
	} else if (pnode->IsFullOutboundConn()) {
	nOutboundFullRelay++;
	} else if (pnode->IsBlockOnlyConn()) {
	nOutboundBlockRelay++;
	}

	// Netgroups for inbound and manual peers are not excluded
	// because our goal here is to not use multiple of our
	// limited outbound slots on a single netgroup but inbound
	// and manual peers do not use our outbound slots. Inbound
	// peers also have the added issue that they could be attacker
	// controlled and could be used to prevent us from connecting
	// to particular hosts if we used them here.
	switch (pnode->m_conn_type) {
	case ConnectionType::INBOUND:
	case ConnectionType::MANUAL:
	break;
	case ConnectionType::AVALANCHE_OUTBOUND:
	case ConnectionType::OUTBOUND_FULL_RELAY:
	case ConnectionType::BLOCK_RELAY:
	case ConnectionType::ADDR_FETCH:
	case ConnectionType::FEELER:
	setConnected.insert(
	pnode->addr.GetGroup(addrman.GetAsmap()));
	} // no default case, so the compiler can warn about missing
	// cases
	}
	}

	ConnectionType conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
	auto now = GetTime<std::chrono::microseconds>();
	bool anchor = false;
	bool fFeeler = false;

	// Determine what type of connection to open. Opening
	// BLOCK_RELAY connections to addresses from anchors.dat gets the
	// highest priority. Then we open AVALANCHE_OUTBOUND connection until we
	// hit our avalanche outbound peer limit, which is 0 if avalanche is not
	// enabled. We fallback after 50 retries to OUTBOUND_FULL_RELAY if the
	// peer is not avalanche capable until we meet our full-relay capacity.
	// Then we open BLOCK_RELAY connection until we hit our block-relay-only
	// peer limit.
	// GetTryNewOutboundPeer() gets set when a stale tip is detected, so we
	// try opening an additional OUTBOUND_FULL_RELAY connection. If none of
	// these conditions are met, check to see if it's time to try an extra
	// block-relay-only peer (to confirm our tip is current, see below) or
	// the next_feeler timer to decide if we should open a FEELER.

	if (!m_anchors.empty() &&
	(nOutboundBlockRelay < m_max_outbound_block_relay)) {
	conn_type = ConnectionType::BLOCK_RELAY;
	anchor = true;
	} else if (g_avalanche &&
	(nOutboundAvalanche < m_max_avalanche_outbound)) {
	conn_type = ConnectionType::AVALANCHE_OUTBOUND;
	} else if (nOutboundFullRelay < m_max_outbound_full_relay) {
	// OUTBOUND_FULL_RELAY
	} else if (nOutboundBlockRelay < m_max_outbound_block_relay) {
	conn_type = ConnectionType::BLOCK_RELAY;
	} else if (GetTryNewOutboundPeer()) {
	// OUTBOUND_FULL_RELAY
	} else if (now > next_extra_block_relay &&
	m_start_extra_block_relay_peers) {
	// Periodically connect to a peer (using regular outbound selection
	// methodology from addrman) and stay connected long enough to sync
	// headers, but not much else.
	//
	// Then disconnect the peer, if we haven't learned anything new.
	//
	// The idea is to make eclipse attacks very difficult to pull off,
	// because every few minutes we're finding a new peer to learn
	// headers from.
	//
	// This is similar to the logic for trying extra outbound
	// (full-relay) peers, except:
	// - we do this all the time on a poisson timer, rather than just
	// when our tip is stale
	// - we potentially disconnect our next-youngest block-relay-only
	// peer, if our newest block-relay-only peer delivers a block more
	// recently.
	// See the eviction logic in net_processing.cpp.
	//
	// Because we can promote these connections to block-relay-only
	// connections, they do not get their own ConnectionType enum
	// (similar to how we deal with extra outbound peers).
	next_extra_block_relay =
	PoissonNextSend(now, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
	conn_type = ConnectionType::BLOCK_RELAY;
	} else if (now > next_feeler) {
	next_feeler = PoissonNextSend(now, FEELER_INTERVAL);
	conn_type = ConnectionType::FEELER;
	fFeeler = true;
	} else {
	// skip to next iteration of while loop
	continue;
	}

	addrman.ResolveCollisions();

	int64_t nANow = GetAdjustedTime();
	int nTries = 0;
	while (!interruptNet) {
	if (anchor && !m_anchors.empty()) {
	const CAddress addr = m_anchors.back();
	m_anchors.pop_back();
	if (!addr.IsValid() \|\| IsLocal(addr) \|\| !IsReachable(addr) \|\|
	!HasAllDesirableServiceFlags(addr.nServices) \|\|
	setConnected.count(addr.GetGroup(addrman.GetAsmap()))) {
	continue;
	}
	addrConnect = addr;
	LogPrint(BCLog::NET,
	"Trying to make an anchor connection to %s\n",
	addrConnect.ToString());
	break;
	}
	// If we didn't find an appropriate destination after trying 100
	// addresses fetched from addrman, stop this loop, and let the outer
	// loop run again (which sleeps, adds seed nodes, recalculates
	// already-connected network ranges, ...) before trying new addrman
	// addresses.
	nTries++;
	if (nTries > 100) {
	break;
	}

	CAddress addr;
	int64_t addr_last_try{0};

	if (fFeeler) {
	// First, try to get a tried table collision address. This
	// returns an empty (invalid) address if there are no collisions
	// to try.
	std::tie(addr, addr_last_try) = addrman.SelectTriedCollision();

	if (!addr.IsValid()) {
	// No tried table collisions. Select a new table address
	// for our feeler.
	std::tie(addr, addr_last_try) = addrman.Select(true);
	} else if (AlreadyConnectedToAddress(addr)) {
	// If test-before-evict logic would have us connect to a
	// peer that we're already connected to, just mark that
	// address as Good(). We won't be able to initiate the
	// connection anyway, so this avoids inadvertently evicting
	// a currently-connected peer.
	addrman.Good(addr);
	// Select a new table address for our feeler instead.
	std::tie(addr, addr_last_try) = addrman.Select(true);
	}
	} else {
	// Not a feeler
	std::tie(addr, addr_last_try) = addrman.Select();
	}

	// Require outbound connections, other than feelers and avalanche,
	// to be to distinct network groups
	if (!fFeeler && conn_type != ConnectionType::AVALANCHE_OUTBOUND &&
	setConnected.count(addr.GetGroup(addrman.GetAsmap()))) {
	break;
	}

	// if we selected an invalid or local address, restart
	if (!addr.IsValid() \|\| IsLocal(addr)) {
	break;
	}

	if (!IsReachable(addr)) {
	continue;
	}

	// only consider very recently tried nodes after 30 failed attempts
	if (nANow - addr_last_try < 600 && nTries < 30) {
	continue;
	}

	// for non-feelers, require all the services we'll want,
	// for feelers, only require they be a full node (only because most
	// SPV clients don't have a good address DB available)
	if (!fFeeler && !HasAllDesirableServiceFlags(addr.nServices)) {
	continue;
	}

	if (fFeeler && !MayHaveUsefulAddressDB(addr.nServices)) {
	continue;
	}

	- // Do not allow non-default ports, unless after 50 invalid
	- // addresses selected already. This is to prevent malicious peers
	- // from advertising themselves as a service on another host and
	- // port, causing a DoS attack as nodes around the network attempt
	- // to connect to it fruitlessly.
	- if (addr.GetPort() != config->GetChainParams().GetDefaultPort(
	- addr.GetNetwork()) &&
	- nTries < 50) {
	+ // Do not connect to bad ports, unless 50 invalid addresses have
	+ // been selected already.
	+ if (nTries < 50 && (addr.IsIPv4() \|\| addr.IsIPv6()) &&
	+ IsBadPort(addr.GetPort())) {
	continue;
	}

	// For avalanche peers, check they have the avalanche service bit
	// set.
	if (conn_type == ConnectionType::AVALANCHE_OUTBOUND &&
	!(addr.nServices & NODE_AVALANCHE)) {
	// If this peer is not suitable as an avalanche one and we tried
	// over 50 addresses already, see if we can fallback to a non
	// avalanche full outbound.
	if (nTries < 50 \|\|
	nOutboundFullRelay >= m_max_outbound_full_relay \|\|
	setConnected.count(addr.GetGroup(addrman.GetAsmap()))) {
	// Fallback is not desirable or possible, try another one
	continue;
	}

	// Fallback is possible, update the connection type accordingly
	conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
	}

	addrConnect = addr;
	break;
	}

	if (addrConnect.IsValid()) {
	if (fFeeler) {
	// Add small amount of random noise before connection to avoid
	// synchronization.
	int randsleep = GetRandInt(FEELER_SLEEP_WINDOW * 1000);
	if (!interruptNet.sleep_for(
	std::chrono::milliseconds(randsleep))) {
	return;
	}
	LogPrint(BCLog::NET, "Making feeler connection to %s\n",
	addrConnect.ToString());
	}

	// This mock is for testing purpose only. It prevents the thread
	// from attempting the connection which is useful for testing.
	if (mockOpenConnection) {
	mockOpenConnection(addrConnect, conn_type);
	} else {
	OpenNetworkConnection(addrConnect,
	int(setConnected.size()) >=
	std::min(nMaxConnections - 1, 2),
	&grant, nullptr, conn_type);
	}
	}
	}
	}

	std::vector<CAddress> CConnman::GetCurrentBlockRelayOnlyConns() const {
	std::vector<CAddress> ret;
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->IsBlockOnlyConn()) {
	ret.push_back(pnode->addr);
	}
	}

	return ret;
	}

	std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo() {
	std::vector<AddedNodeInfo> ret;

	std::list<std::string> lAddresses(0);
	{
	LOCK(cs_vAddedNodes);
	ret.reserve(vAddedNodes.size());
	std::copy(vAddedNodes.cbegin(), vAddedNodes.cend(),
	std::back_inserter(lAddresses));
	}

	// Build a map of all already connected addresses (by IP:port and by name)
	// to inbound/outbound and resolved CService
	std::map<CService, bool> mapConnected;
	std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
	{
	LOCK(cs_vNodes);
	for (const CNode *pnode : vNodes) {
	if (pnode->addr.IsValid()) {
	mapConnected[pnode->addr] = pnode->IsInboundConn();
	}
	std::string addrName = pnode->GetAddrName();
	if (!addrName.empty()) {
	mapConnectedByName[std::move(addrName)] =
	std::make_pair(pnode->IsInboundConn(),
	static_cast<const CService &>(pnode->addr));
	}
	}
	}

	for (const std::string &strAddNode : lAddresses) {
	CService service(
	LookupNumeric(strAddNode, Params().GetDefaultPort(strAddNode)));
	AddedNodeInfo addedNode{strAddNode, CService(), false, false};
	if (service.IsValid()) {
	// strAddNode is an IP:port
	auto it = mapConnected.find(service);
	if (it != mapConnected.end()) {
	addedNode.resolvedAddress = service;
	addedNode.fConnected = true;
	addedNode.fInbound = it->second;
	}
	} else {
	// strAddNode is a name
	auto it = mapConnectedByName.find(strAddNode);
	if (it != mapConnectedByName.end()) {
	addedNode.resolvedAddress = it->second.second;
	addedNode.fConnected = true;
	addedNode.fInbound = it->second.first;
	}
	}
	ret.emplace_back(std::move(addedNode));
	}

	return ret;
	}

	void CConnman::ThreadOpenAddedConnections() {
	while (true) {
	CSemaphoreGrant grant(*semAddnode);
	std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo();
	bool tried = false;
	for (const AddedNodeInfo &info : vInfo) {
	if (!info.fConnected) {
	if (!grant.TryAcquire()) {
	// If we've used up our semaphore and need a new one, let's
	// not wait here since while we are waiting the
	// addednodeinfo state might change.
	break;
	}
	tried = true;
	CAddress addr(CService(), NODE_NONE);
	OpenNetworkConnection(addr, false, &grant,
	info.strAddedNode.c_str(),
	ConnectionType::MANUAL);
	if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) {
	return;
	}
	}
	}
	// Retry every 60 seconds if a connection was attempted, otherwise two
	// seconds.
	if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2))) {
	return;
	}
	}
	}

	// If successful, this moves the passed grant to the constructed node.
	void CConnman::OpenNetworkConnection(const CAddress &addrConnect,
	bool fCountFailure,
	CSemaphoreGrant *grantOutbound,
	const char *pszDest,
	ConnectionType conn_type) {
	assert(conn_type != ConnectionType::INBOUND);

	//
	// Initiate outbound network connection
	//
	if (interruptNet) {
	return;
	}
	if (!fNetworkActive) {
	return;
	}
	if (!pszDest) {
	bool banned_or_discouraged =
	m_banman && (m_banman->IsDiscouraged(addrConnect) \|\|
	m_banman->IsBanned(addrConnect));
	if (IsLocal(addrConnect) \|\| banned_or_discouraged \|\|
	AlreadyConnectedToAddress(addrConnect)) {
	return;
	}
	} else if (FindNode(std::string(pszDest))) {
	return;
	}

	CNode *pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type);

	if (!pnode) {
	return;
	}
	if (grantOutbound) {
	grantOutbound->MoveTo(pnode->grantOutbound);
	}

	for (auto interface : m_msgproc) {
	interface->InitializeNode(*config, pnode);
	}

	{
	LOCK(cs_vNodes);
	vNodes.push_back(pnode);
	}
	}

	void CConnman::ThreadMessageHandler() {
	while (!flagInterruptMsgProc) {
	std::vector<CNode *> vNodesCopy;
	{
	LOCK(cs_vNodes);
	vNodesCopy = vNodes;
	for (CNode *pnode : vNodesCopy) {
	pnode->AddRef();
	}
	}

	bool fMoreWork = false;

	for (CNode *pnode : vNodesCopy) {
	if (pnode->fDisconnect) {
	continue;
	}

	bool fMoreNodeWork = false;
	// Receive messages
	for (auto interface : m_msgproc) {
	fMoreNodeWork \|= interface->ProcessMessages(
	*config, pnode, flagInterruptMsgProc);
	}
	fMoreWork \|= (fMoreNodeWork && !pnode->fPauseSend);
	if (flagInterruptMsgProc) {
	return;
	}

	// Send messages
	{
	LOCK(pnode->cs_sendProcessing);
	for (auto interface : m_msgproc) {
	interface->SendMessages(*config, pnode);
	}
	}

	if (flagInterruptMsgProc) {
	return;
	}
	}

	{
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodesCopy) {
	pnode->Release();
	}
	}

	WAIT_LOCK(mutexMsgProc, lock);
	if (!fMoreWork) {
	condMsgProc.wait_until(lock,
	std::chrono::steady_clock::now() +
	std::chrono::milliseconds(100),
	[this]() EXCLUSIVE_LOCKS_REQUIRED(
	mutexMsgProc) { return fMsgProcWake; });
	}
	fMsgProcWake = false;
	}
	}

	void CConnman::ThreadI2PAcceptIncoming() {
	static constexpr auto err_wait_begin = 1s;
	static constexpr auto err_wait_cap = 5min;
	auto err_wait = err_wait_begin;

	bool advertising_listen_addr = false;
	i2p::Connection conn;

	while (!interruptNet) {
	if (!m_i2p_sam_session->Listen(conn)) {
	if (advertising_listen_addr && conn.me.IsValid()) {
	RemoveLocal(conn.me);
	advertising_listen_addr = false;
	}

	interruptNet.sleep_for(err_wait);
	if (err_wait < err_wait_cap) {
	err_wait *= 2;
	}

	continue;
	}

	if (!advertising_listen_addr) {
	AddLocal(conn.me, LOCAL_MANUAL);
	advertising_listen_addr = true;
	}

	if (!m_i2p_sam_session->Accept(conn)) {
	continue;
	}

	CreateNodeFromAcceptedSocket(
	conn.sock->Release(), NetPermissionFlags::PF_NONE,
	CAddress{conn.me, NODE_NONE}, CAddress{conn.peer, NODE_NONE});
	}
	}

	bool CConnman::BindListenPort(const CService &addrBind, bilingual_str &strError,
	NetPermissionFlags permissions) {
	int nOne = 1;

	// Create socket for listening for incoming connections
	struct sockaddr_storage sockaddr;
	socklen_t len = sizeof(sockaddr);
	if (!addrBind.GetSockAddr((struct sockaddr *)&sockaddr, &len)) {
	strError = strprintf(
	Untranslated("Error: Bind address family for %s not supported"),
	addrBind.ToString());
	LogPrintf("%s\n", strError.original);
	return false;
	}

	std::unique_ptr<Sock> sock = CreateSock(addrBind);
	if (!sock) {
	strError =
	strprintf(Untranslated("Error: Couldn't open socket for incoming "
	"connections (socket returned error %s)"),
	NetworkErrorString(WSAGetLastError()));
	LogPrintf("%s\n", strError.original);
	return false;
	}

	// Allow binding if the port is still in TIME_WAIT state after
	// the program was closed and restarted.
	setsockopt(sock->Get(), SOL_SOCKET, SO_REUSEADDR, (sockopt_arg_type)&nOne,
	sizeof(int));

	// Some systems don't have IPV6_V6ONLY but are always v6only; others do have
	// the option and enable it by default or not. Try to enable it, if
	// possible.
	if (addrBind.IsIPv6()) {
	#ifdef IPV6_V6ONLY
	setsockopt(sock->Get(), IPPROTO_IPV6, IPV6_V6ONLY,
	(sockopt_arg_type)&nOne, sizeof(int));
	#endif
	#ifdef WIN32
	int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
	setsockopt(sock->Get(), IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
	(sockopt_arg_type)&nProtLevel, sizeof(int));
	#endif
	}

	if (::bind(sock->Get(), (struct sockaddr *)&sockaddr, len) ==
	SOCKET_ERROR) {
	int nErr = WSAGetLastError();
	if (nErr == WSAEADDRINUSE) {
	strError = strprintf(_("Unable to bind to %s on this computer. %s "
	"is probably already running."),
	addrBind.ToString(), PACKAGE_NAME);
	} else {
	strError = strprintf(_("Unable to bind to %s on this computer "
	"(bind returned error %s)"),
	addrBind.ToString(), NetworkErrorString(nErr));
	}
	LogPrintf("%s\n", strError.original);
	return false;
	}
	LogPrintf("Bound to %s\n", addrBind.ToString());

	// Listen for incoming connections
	if (listen(sock->Get(), SOMAXCONN) == SOCKET_ERROR) {
	strError = strprintf(_("Error: Listening for incoming connections "
	"failed (listen returned error %s)"),
	NetworkErrorString(WSAGetLastError()));
	LogPrintf("%s\n", strError.original);
	return false;
	}

	vhListenSocket.push_back(ListenSocket(sock->Release(), permissions));
	return true;
	}

	void Discover() {
	if (!fDiscover) {
	return;
	}

	#ifdef WIN32
	// Get local host IP
	char pszHostName[256] = "";
	if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR) {
	std::vector<CNetAddr> vaddr;
	if (LookupHost(pszHostName, vaddr, 0, true)) {
	for (const CNetAddr &addr : vaddr) {
	if (AddLocal(addr, LOCAL_IF)) {
	LogPrintf("%s: %s - %s\n", __func__, pszHostName,
	addr.ToString());
	}
	}
	}
	}
	#elif (HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS)
	// Get local host ip
	struct ifaddrs *myaddrs;
	if (getifaddrs(&myaddrs) == 0) {
	for (struct ifaddrs *ifa = myaddrs; ifa != nullptr;
	ifa = ifa->ifa_next) {
	if (ifa->ifa_addr == nullptr \|\| (ifa->ifa_flags & IFF_UP) == 0 \|\|
	strcmp(ifa->ifa_name, "lo") == 0 \|\|
	strcmp(ifa->ifa_name, "lo0") == 0) {
	continue;
	}
	if (ifa->ifa_addr->sa_family == AF_INET) {
	struct sockaddr_in *s4 =
	reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
	CNetAddr addr(s4->sin_addr);
	if (AddLocal(addr, LOCAL_IF)) {
	LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name,
	addr.ToString());
	}
	} else if (ifa->ifa_addr->sa_family == AF_INET6) {
	struct sockaddr_in6 *s6 =
	reinterpret_cast<struct sockaddr_in6 *>(ifa->ifa_addr);
	CNetAddr addr(s6->sin6_addr);
	if (AddLocal(addr, LOCAL_IF)) {
	LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name,
	addr.ToString());
	}
	}
	}
	freeifaddrs(myaddrs);
	}
	#endif
	}

	void CConnman::SetNetworkActive(bool active) {
	LogPrintf("%s: %s\n", __func__, active);

	if (fNetworkActive == active) {
	return;
	}

	fNetworkActive = active;
	uiInterface.NotifyNetworkActiveChanged(fNetworkActive);
	}

	CConnman::CConnman(const Config &configIn, uint64_t nSeed0In, uint64_t nSeed1In,
	AddrMan &addrmanIn, bool network_active)
	: config(&configIn), addrman(addrmanIn), nSeed0(nSeed0In),
	nSeed1(nSeed1In) {
	SetTryNewOutboundPeer(false);

	Options connOptions;
	Init(connOptions);
	SetNetworkActive(network_active);
	}

	NodeId CConnman::GetNewNodeId() {
	return nLastNodeId.fetch_add(1);
	}

	bool CConnman::Bind(const CService &addr, unsigned int flags,
	NetPermissionFlags permissions) {
	if (!(flags & BF_EXPLICIT) && !IsReachable(addr)) {
	return false;
	}
	bilingual_str strError;
	if (!BindListenPort(addr, strError, permissions)) {
	if ((flags & BF_REPORT_ERROR) && clientInterface) {
	clientInterface->ThreadSafeMessageBox(
	strError, "", CClientUIInterface::MSG_ERROR);
	}
	return false;
	}

	if (addr.IsRoutable() && fDiscover && !(flags & BF_DONT_ADVERTISE) &&
	!(permissions & PF_NOBAN)) {
	AddLocal(addr, LOCAL_BIND);
	}

	return true;
	}

	bool CConnman::InitBinds(const Options &options) {
	bool fBound = false;
	for (const auto &addrBind : options.vBinds) {
	fBound \|= Bind(addrBind, (BF_EXPLICIT \| BF_REPORT_ERROR),
	NetPermissionFlags::PF_NONE);
	}
	for (const auto &addrBind : options.vWhiteBinds) {
	fBound \|= Bind(addrBind.m_service, (BF_EXPLICIT \| BF_REPORT_ERROR),
	addrBind.m_flags);
	}
	for (const auto &addr_bind : options.onion_binds) {
	fBound \|= Bind(addr_bind, BF_EXPLICIT \| BF_DONT_ADVERTISE,
	NetPermissionFlags::PF_NONE);
	}
	if (options.bind_on_any) {
	struct in_addr inaddr_any;
	inaddr_any.s_addr = htonl(INADDR_ANY);
	struct in6_addr inaddr6_any = IN6ADDR_ANY_INIT;
	fBound \|= Bind(CService(inaddr6_any, GetListenPort()), BF_NONE,
	NetPermissionFlags::PF_NONE);
	fBound \|= Bind(CService(inaddr_any, GetListenPort()),
	!fBound ? BF_REPORT_ERROR : BF_NONE,
	NetPermissionFlags::PF_NONE);
	}
	return fBound;
	}

	bool CConnman::Start(CScheduler &scheduler, const Options &connOptions) {
	Init(connOptions);

	if (fListen && !InitBinds(connOptions)) {
	if (clientInterface) {
	clientInterface->ThreadSafeMessageBox(
	_("Failed to listen on any port. Use -listen=0 if you want "
	"this."),
	"", CClientUIInterface::MSG_ERROR);
	}
	return false;
	}

	proxyType i2p_sam;
	if (GetProxy(NET_I2P, i2p_sam)) {
	m_i2p_sam_session = std::make_unique<i2p::sam::Session>(
	gArgs.GetDataDirNet() / "i2p_private_key", i2p_sam.proxy,
	&interruptNet);
	}

	for (const auto &strDest : connOptions.vSeedNodes) {
	AddAddrFetch(strDest);
	}

	if (m_use_addrman_outgoing) {
	// Load addresses from anchors.dat
	m_anchors =
	ReadAnchors(config->GetChainParams(),
	gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME);
	if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
	m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
	}
	LogPrintf(
	"%i block-relay-only anchors will be tried for connections.\n",
	m_anchors.size());
	}

	uiInterface.InitMessage(_("Starting network threads...").translated);

	fAddressesInitialized = true;

	if (semOutbound == nullptr) {
	// initialize semaphore
	semOutbound = std::make_unique<CSemaphore>(
	std::min(m_max_outbound, nMaxConnections));
	}
	if (semAddnode == nullptr) {
	// initialize semaphore
	semAddnode = std::make_unique<CSemaphore>(nMaxAddnode);
	}

	//
	// Start threads
	//
	assert(m_msgproc.size() > 0);
	InterruptSocks5(false);
	interruptNet.reset();
	flagInterruptMsgProc = false;

	{
	LOCK(mutexMsgProc);
	fMsgProcWake = false;
	}

	// Send and receive from sockets, accept connections
	threadSocketHandler = std::thread(&util::TraceThread, "net",
	[this] { ThreadSocketHandler(); });

	if (!gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)) {
	LogPrintf("DNS seeding disabled\n");
	} else {
	threadDNSAddressSeed = std::thread(&util::TraceThread, "dnsseed",
	[this] { ThreadDNSAddressSeed(); });
	}

	// Initiate manual connections
	threadOpenAddedConnections = std::thread(
	&util::TraceThread, "addcon", [this] { ThreadOpenAddedConnections(); });

	if (connOptions.m_use_addrman_outgoing &&
	!connOptions.m_specified_outgoing.empty()) {
	if (clientInterface) {
	clientInterface->ThreadSafeMessageBox(
	_("Cannot provide specific connections and have addrman find "
	"outgoing connections at the same."),
	"", CClientUIInterface::MSG_ERROR);
	}
	return false;
	}
	if (connOptions.m_use_addrman_outgoing \|\|
	!connOptions.m_specified_outgoing.empty()) {
	threadOpenConnections =
	std::thread(&util::TraceThread, "opencon",
	[this, connect = connOptions.m_specified_outgoing] {
	ThreadOpenConnections(connect, nullptr);
	});
	}

	// Process messages
	threadMessageHandler = std::thread(&util::TraceThread, "msghand",
	[this] { ThreadMessageHandler(); });

	if (connOptions.m_i2p_accept_incoming &&
	m_i2p_sam_session.get() != nullptr) {
	threadI2PAcceptIncoming =
	std::thread(&util::TraceThread, "i2paccept",
	[this] { ThreadI2PAcceptIncoming(); });
	}

	// Dump network addresses
	scheduler.scheduleEvery(
	[this]() {
	this->DumpAddresses();
	return true;
	},
	DUMP_PEERS_INTERVAL);

	return true;
	}

	class CNetCleanup {
	public:
	CNetCleanup() {}

	~CNetCleanup() {
	#ifdef WIN32
	// Shutdown Windows Sockets
	WSACleanup();
	#endif
	}
	};
	static CNetCleanup instance_of_cnetcleanup;

	void CConnman::Interrupt() {
	{
	LOCK(mutexMsgProc);
	flagInterruptMsgProc = true;
	}
	condMsgProc.notify_all();

	interruptNet();
	InterruptSocks5(true);

	if (semOutbound) {
	for (int i = 0; i < m_max_outbound; i++) {
	semOutbound->post();
	}
	}

	if (semAddnode) {
	for (int i = 0; i < nMaxAddnode; i++) {
	semAddnode->post();
	}
	}
	}

	void CConnman::StopThreads() {
	if (threadI2PAcceptIncoming.joinable()) {
	threadI2PAcceptIncoming.join();
	}
	if (threadMessageHandler.joinable()) {
	threadMessageHandler.join();
	}
	if (threadOpenConnections.joinable()) {
	threadOpenConnections.join();
	}
	if (threadOpenAddedConnections.joinable()) {
	threadOpenAddedConnections.join();
	}
	if (threadDNSAddressSeed.joinable()) {
	threadDNSAddressSeed.join();
	}
	if (threadSocketHandler.joinable()) {
	threadSocketHandler.join();
	}
	}

	void CConnman::StopNodes() {
	if (fAddressesInitialized) {
	DumpAddresses();
	fAddressesInitialized = false;

	if (m_use_addrman_outgoing) {
	// Anchor connections are only dumped during clean shutdown.
	std::vector<CAddress> anchors_to_dump =
	GetCurrentBlockRelayOnlyConns();
	if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
	anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
	}
	DumpAnchors(config->GetChainParams(),
	gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME,
	anchors_to_dump);
	}
	}

	// Delete peer connections.
	std::vector<CNode *> nodes;
	WITH_LOCK(cs_vNodes, nodes.swap(vNodes));
	for (CNode *pnode : nodes) {
	pnode->CloseSocketDisconnect();
	DeleteNode(pnode);
	}

	// Close listening sockets.
	for (ListenSocket &hListenSocket : vhListenSocket) {
	if (hListenSocket.socket != INVALID_SOCKET) {
	if (!CloseSocket(hListenSocket.socket)) {
	LogPrintf("CloseSocket(hListenSocket) failed with error %s\n",
	NetworkErrorString(WSAGetLastError()));
	}
	}
	}

	for (CNode *pnode : vNodesDisconnected) {
	DeleteNode(pnode);
	}
	vNodesDisconnected.clear();
	vhListenSocket.clear();
	semOutbound.reset();
	semAddnode.reset();
	}

	void CConnman::DeleteNode(CNode *pnode) {
	assert(pnode);
	for (auto interface : m_msgproc) {
	interface->FinalizeNode(config, pnode);
	}
	delete pnode;
	}

	CConnman::~CConnman() {
	Interrupt();
	Stop();
	}

	std::vector<CAddress> CConnman::GetAddresses(size_t max_addresses,
	size_t max_pct,
	std::optional<Network> network) {
	std::vector<CAddress> addresses =
	addrman.GetAddr(max_addresses, max_pct, network);
	if (m_banman) {
	addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
	[this](const CAddress &addr) {
	return m_banman->IsDiscouraged(
	addr) \|\|
	m_banman->IsBanned(addr);
	}),
	addresses.end());
	}
	return addresses;
	}

	std::vector<CAddress>
	CConnman::GetAddresses(CNode &requestor, size_t max_addresses, size_t max_pct) {
	auto local_socket_bytes = requestor.addrBind.GetAddrBytes();
	uint64_t cache_id =
	GetDeterministicRandomizer(RANDOMIZER_ID_ADDRCACHE)
	.Write(requestor.addr.GetNetwork())
	.Write(local_socket_bytes.data(), local_socket_bytes.size())
	.Finalize();
	const auto current_time = GetTime<std::chrono::microseconds>();
	auto r = m_addr_response_caches.emplace(cache_id, CachedAddrResponse{});
	CachedAddrResponse &cache_entry = r.first->second;
	// New CachedAddrResponse have expiration 0.
	if (cache_entry.m_cache_entry_expiration < current_time) {
	cache_entry.m_addrs_response_cache =
	GetAddresses(max_addresses, max_pct, /* network */ std::nullopt);
	// Choosing a proper cache lifetime is a trade-off between the privacy
	// leak minimization and the usefulness of ADDR responses to honest
	// users.
	//
	// Longer cache lifetime makes it more difficult for an attacker to
	// scrape enough AddrMan data to maliciously infer something useful. By
	// the time an attacker scraped enough AddrMan records, most of the
	// records should be old enough to not leak topology info by e.g.
	// analyzing real-time changes in timestamps.
	//
	// It takes only several hundred requests to scrape everything from an
	// AddrMan containing 100,000 nodes, so ~24 hours of cache lifetime
	// indeed makes the data less inferable by the time most of it could be
	// scraped (considering that timestamps are updated via ADDR
	// self-announcements and when nodes communicate). We also should be
	// robust to those attacks which may not require scraping full
	// victim's AddrMan (because even several timestamps of the same handful
	// of nodes may leak privacy).
	//
	// On the other hand, longer cache lifetime makes ADDR responses
	// outdated and less useful for an honest requestor, e.g. if most nodes
	// in the ADDR response are no longer active.
	//
	// However, the churn in the network is known to be rather low. Since we
	// consider nodes to be "terrible" (see IsTerrible()) if the timestamps
	// are older than 30 days, max. 24 hours of "penalty" due to cache
	// shouldn't make any meaningful difference in terms of the freshness of
	// the response.
	cache_entry.m_cache_entry_expiration =
	current_time + std::chrono::hours(21) +
	GetRandMillis(std::chrono::hours(6));
	}
	return cache_entry.m_addrs_response_cache;
	}

	bool CConnman::AddNode(const std::string &strNode) {
	LOCK(cs_vAddedNodes);
	for (const std::string &it : vAddedNodes) {
	if (strNode == it) {
	return false;
	}
	}

	vAddedNodes.push_back(strNode);
	return true;
	}

	bool CConnman::RemoveAddedNode(const std::string &strNode) {
	LOCK(cs_vAddedNodes);
	for (std::vector<std::string>::iterator it = vAddedNodes.begin();
	it != vAddedNodes.end(); ++it) {
	if (strNode == *it) {
	vAddedNodes.erase(it);
	return true;
	}
	}
	return false;
	}

	size_t CConnman::GetNodeCount(NumConnections flags) {
	LOCK(cs_vNodes);
	// Shortcut if we want total
	if (flags == CConnman::CONNECTIONS_ALL) {
	return vNodes.size();
	}

	int nNum = 0;
	for (const auto &pnode : vNodes) {
	if (flags &
	(pnode->IsInboundConn() ? CONNECTIONS_IN : CONNECTIONS_OUT)) {
	nNum++;
	}
	}

	return nNum;
	}

	void CConnman::GetNodeStats(std::vector<CNodeStats> &vstats) {
	vstats.clear();
	LOCK(cs_vNodes);
	vstats.reserve(vNodes.size());
	for (CNode *pnode : vNodes) {
	vstats.emplace_back();
	pnode->copyStats(vstats.back());
	vstats.back().m_mapped_as = pnode->addr.GetMappedAS(addrman.GetAsmap());
	}
	}

	bool CConnman::DisconnectNode(const std::string &strNode) {
	LOCK(cs_vNodes);
	if (CNode *pnode = FindNode(strNode)) {
	LogPrint(BCLog::NET,
	"disconnect by address%s matched peer=%d; disconnecting\n",
	(fLogIPs ? strprintf("=%s", strNode) : ""), pnode->GetId());
	pnode->fDisconnect = true;
	return true;
	}
	return false;
	}

	bool CConnman::DisconnectNode(const CSubNet &subnet) {
	bool disconnected = false;
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (subnet.Match(pnode->addr)) {
	LogPrint(BCLog::NET,
	"disconnect by subnet%s matched peer=%d; disconnecting\n",
	(fLogIPs ? strprintf("=%s", subnet.ToString()) : ""),
	pnode->GetId());
	pnode->fDisconnect = true;
	disconnected = true;
	}
	}
	return disconnected;
	}

	bool CConnman::DisconnectNode(const CNetAddr &addr) {
	return DisconnectNode(CSubNet(addr));
	}

	bool CConnman::DisconnectNode(NodeId id) {
	LOCK(cs_vNodes);
	for (CNode *pnode : vNodes) {
	if (id == pnode->GetId()) {
	LogPrint(BCLog::NET, "disconnect by id peer=%d; disconnecting\n",
	pnode->GetId());
	pnode->fDisconnect = true;
	return true;
	}
	}
	return false;
	}

	void CConnman::RecordBytesRecv(uint64_t bytes) {
	LOCK(cs_totalBytesRecv);
	nTotalBytesRecv += bytes;
	}

	void CConnman::RecordBytesSent(uint64_t bytes) {
	LOCK(cs_totalBytesSent);
	nTotalBytesSent += bytes;

	const auto now = GetTime<std::chrono::seconds>();
	if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now) {
	// timeframe expired, reset cycle
	nMaxOutboundCycleStartTime = now;
	nMaxOutboundTotalBytesSentInCycle = 0;
	}

	// TODO, exclude peers with download permission
	nMaxOutboundTotalBytesSentInCycle += bytes;
	}

	uint64_t CConnman::GetMaxOutboundTarget() {
	LOCK(cs_totalBytesSent);
	return nMaxOutboundLimit;
	}

	std::chrono::seconds CConnman::GetMaxOutboundTimeframe() {
	return MAX_UPLOAD_TIMEFRAME;
	}

	std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle() {
	LOCK(cs_totalBytesSent);
	if (nMaxOutboundLimit == 0) {
	return 0s;
	}

	if (nMaxOutboundCycleStartTime.count() == 0) {
	return MAX_UPLOAD_TIMEFRAME;
	}

	const std::chrono::seconds cycleEndTime =
	nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME;
	const auto now = GetTime<std::chrono::seconds>();
	return (cycleEndTime < now) ? 0s : cycleEndTime - now;
	}

	bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit) {
	LOCK(cs_totalBytesSent);
	if (nMaxOutboundLimit == 0) {
	return false;
	}

	if (historicalBlockServingLimit) {
	// keep a large enough buffer to at least relay each block once.
	const std::chrono::seconds timeLeftInCycle =
	GetMaxOutboundTimeLeftInCycle();
	const uint64_t buffer =
	timeLeftInCycle / std::chrono::minutes{10} * ONE_MEGABYTE;
	if (buffer >= nMaxOutboundLimit \|\|
	nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer) {
	return true;
	}
	} else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) {
	return true;
	}

	return false;
	}

	uint64_t CConnman::GetOutboundTargetBytesLeft() {
	LOCK(cs_totalBytesSent);
	if (nMaxOutboundLimit == 0) {
	return 0;
	}

	return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
	? 0
	: nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
	}

	uint64_t CConnman::GetTotalBytesRecv() {
	LOCK(cs_totalBytesRecv);
	return nTotalBytesRecv;
	}

	uint64_t CConnman::GetTotalBytesSent() {
	LOCK(cs_totalBytesSent);
	return nTotalBytesSent;
	}

	ServiceFlags CConnman::GetLocalServices() const {
	return nLocalServices;
	}

	unsigned int CConnman::GetReceiveFloodSize() const {
	return nReceiveFloodSize;
	}

	void CNode::AvalancheState::invsPolled(uint32_t count) {
	invCounters += count;
	}

	void CNode::AvalancheState::invsVoted(uint32_t count) {
	invCounters += uint64_t(count) << 32;
	}

	void CNode::AvalancheState::updateAvailabilityScore() {
	LOCK(cs_statistics);

	uint64_t windowInvCounters = invCounters.exchange(0);
	double previousScore = availabilityScore;

	int64_t polls = windowInvCounters & std::numeric_limits<uint32_t>::max();
	int64_t votes = windowInvCounters >> 32;

	availabilityScore =
	AVALANCHE_STATISTICS_DECAY_FACTOR * (2 * votes - polls) +
	(1. - AVALANCHE_STATISTICS_DECAY_FACTOR) * previousScore;
	}

	double CNode::AvalancheState::getAvailabilityScore() const {
	// The score is set atomically so there is no need to lock the statistics
	// when reading.
	return availabilityScore;
	}

	CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, SOCKET hSocketIn,
	const CAddress &addrIn, uint64_t nKeyedNetGroupIn,
	uint64_t nLocalHostNonceIn, uint64_t nLocalExtraEntropyIn,
	const CAddress &addrBindIn, const std::string &addrNameIn,
	ConnectionType conn_type_in, bool inbound_onion)
	: m_connected(GetTime<std::chrono::seconds>()), addr(addrIn),
	addrBind(addrBindIn), m_inbound_onion(inbound_onion),
	nKeyedNetGroup(nKeyedNetGroupIn),
	m_tx_relay(conn_type_in != ConnectionType::BLOCK_RELAY
	? std::make_unique<TxRelay>()
	: nullptr),
	m_proof_relay(isAvalancheEnabled(gArgs) ? std::make_unique<ProofRelay>()
	: nullptr),
	// Don't relay addr messages to peers that we connect to as
	// block-relay-only peers (to prevent adversaries from inferring these
	// links from addr traffic).
	id(idIn), nLocalHostNonce(nLocalHostNonceIn),
	nLocalExtraEntropy(nLocalExtraEntropyIn), m_conn_type(conn_type_in),
	nLocalServices(nLocalServicesIn) {
	if (inbound_onion) {
	assert(conn_type_in == ConnectionType::INBOUND);
	}
	hSocket = hSocketIn;
	addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;

	for (const std::string &msg : getAllNetMessageTypes()) {
	mapRecvBytesPerMsgCmd[msg] = 0;
	}
	mapRecvBytesPerMsgCmd[NET_MESSAGE_COMMAND_OTHER] = 0;

	if (fLogIPs) {
	LogPrint(BCLog::NET, "Added connection to %s peer=%d\n", addrName, id);
	} else {
	LogPrint(BCLog::NET, "Added connection peer=%d\n", id);
	}

	m_deserializer = std::make_unique<V1TransportDeserializer>(
	V1TransportDeserializer(GetConfig().GetChainParams().NetMagic(),
	SER_NETWORK, INIT_PROTO_VERSION));
	m_serializer =
	std::make_unique<V1TransportSerializer>(V1TransportSerializer());
	}

	CNode::~CNode() {
	CloseSocket(hSocket);
	}

	bool CConnman::NodeFullyConnected(const CNode *pnode) {
	return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect;
	}

	void CConnman::PushMessage(CNode *pnode, CSerializedNetMsg &&msg) {
	size_t nMessageSize = msg.data.size();
	LogPrint(BCLog::NET, "sending %s (%d bytes) peer=%d\n",
	SanitizeString(msg.m_type), nMessageSize, pnode->GetId());

	// make sure we use the appropriate network transport format
	std::vector<uint8_t> serializedHeader;
	pnode->m_serializer->prepareForTransport(*config, msg, serializedHeader);
	size_t nTotalSize = nMessageSize + serializedHeader.size();

	size_t nBytesSent = 0;
	{
	LOCK(pnode->cs_vSend);
	bool optimisticSend(pnode->vSendMsg.empty());

	// log total amount of bytes per message type
	pnode->mapSendBytesPerMsgCmd[msg.m_type] += nTotalSize;
	pnode->nSendSize += nTotalSize;

	if (pnode->nSendSize > nSendBufferMaxSize) {
	pnode->fPauseSend = true;
	}
	pnode->vSendMsg.push_back(std::move(serializedHeader));
	if (nMessageSize) {
	pnode->vSendMsg.push_back(std::move(msg.data));
	}

	// If write queue empty, attempt "optimistic write"
	if (optimisticSend == true) {
	nBytesSent = SocketSendData(*pnode);
	}
	}
	if (nBytesSent) {
	RecordBytesSent(nBytesSent);
	}
	}

	bool CConnman::ForNode(NodeId id, std::function<bool(CNode *pnode)> func) {
	CNode *found = nullptr;
	LOCK(cs_vNodes);
	for (auto &&pnode : vNodes) {
	if (pnode->GetId() == id) {
	found = pnode;
	break;
	}
	}
	return found != nullptr && NodeFullyConnected(found) && func(found);
	}

	std::chrono::microseconds
	CConnman::PoissonNextSendInbound(std::chrono::microseconds now,
	std::chrono::seconds average_interval) {
	if (m_next_send_inv_to_incoming.load() < now) {
	// If this function were called from multiple threads simultaneously
	// it would be possible that both update the next send variable, and
	// return a different result to their caller. This is not possible in
	// practice as only the net processing thread invokes this function.
	m_next_send_inv_to_incoming = PoissonNextSend(now, average_interval);
	}
	return m_next_send_inv_to_incoming;
	}

	std::chrono::microseconds
	PoissonNextSend(std::chrono::microseconds now,
	std::chrono::seconds average_interval) {
	double unscaled = -log1p(GetRand(1ULL << 48) *
	-0.0000000000000035527136788 /* -1/2^48 */);
	return now + std::chrono::duration_cast<std::chrono::microseconds>(
	unscaled * average_interval + 0.5us);
	}

	CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const {
	return CSipHasher(nSeed0, nSeed1).Write(id);
	}

	uint64_t CConnman::CalculateKeyedNetGroup(const CAddress &ad) const {
	std::vector<uint8_t> vchNetGroup(ad.GetGroup(addrman.GetAsmap()));

	return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP)
	.Write(vchNetGroup.data(), vchNetGroup.size())
	.Finalize();
	}

	/**
	* This function convert MaxBlockSize from byte to
	* MB with a decimal precision one digit rounded down
	* E.g.
	* 1660000 -> 1.6
	* 2010000 -> 2.0
	* 1000000 -> 1.0
	* 230000 -> 0.2
	* 50000 -> 0.0
	*
	* NB behavior for EB<1MB not standardized yet still
	* the function applies the same algo used for
	* EB greater or equal to 1MB
	*/
	std::string getSubVersionEB(uint64_t MaxBlockSize) {
	// Prepare EB string we are going to add to SubVer:
	// 1) translate from byte to MB and convert to string
	// 2) limit the EB string to the first decimal digit (floored)
	std::stringstream ebMBs;
	ebMBs << (MaxBlockSize / (ONE_MEGABYTE / 10));
	std::string eb = ebMBs.str();
	eb.insert(eb.size() - 1, ".", 1);
	if (eb.substr(0, 1) == ".") {
	eb = "0" + eb;
	}
	return eb;
	}

	std::string userAgent(const Config &config) {
	// format excessive blocksize value
	std::string eb = getSubVersionEB(config.GetMaxBlockSize());
	std::vector<std::string> uacomments;
	uacomments.push_back("EB" + eb);

	// Comments are checked for char compliance at startup, it is safe to add
	// them to the user agent string
	for (const std::string &cmt : gArgs.GetArgs("-uacomment")) {
	uacomments.push_back(cmt);
	}

	const std::string client_name = gArgs.GetArg("-uaclientname", CLIENT_NAME);
	const std::string client_version =
	gArgs.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));

	// Size compliance is checked at startup, it is safe to not check it again
	return FormatUserAgent(client_name, client_version, uacomments);
	}
	diff --git a/src/net_processing.cpp b/src/net_processing.cpp
	index 83e9fd1e3..fb3cecc59 100644
	--- a/src/net_processing.cpp
	+++ b/src/net_processing.cpp
	@@ -1,7169 +1,7169 @@
	// 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/compactproofs.h>
	#include <avalanche/peermanager.h>
	#include <avalanche/processor.h>
	#include <avalanche/proof.h>
	#include <avalanche/validation.h>
	#include <banman.h>
	#include <blockencodings.h>
	#include <blockfilter.h>
	#include <blockvalidity.h>
	#include <chain.h>
	#include <chainparams.h>
	#include <config.h>
	#include <consensus/amount.h>
	#include <consensus/validation.h>
	#include <hash.h>
	#include <index/blockfilterindex.h>
	#include <invrequest.h>
	#include <merkleblock.h>
	#include <netbase.h>
	#include <netmessagemaker.h>
	#include <node/blockstorage.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 <txorphanage.h>
	#include <util/check.h> // For NDEBUG compile time check
	#include <util/strencodings.h>
	#include <util/system.h>
	#include <validation.h>

	#include <algorithm>
	#include <functional>
	#include <memory>
	#include <typeinfo>

	/** How long to cache transactions in mapRelay for normal relay */
	static constexpr auto RELAY_TX_CACHE_TIME = 15min;
	/**
	* How long a transaction has to be in the mempool before it can
	* unconditionally be relayed (even when not in mapRelay).
	*/
	static constexpr auto UNCONDITIONAL_RELAY_DELAY = 2min;
	/**
	* Headers download timeout.
	* Timeout = base + per_header * (expected number of headers)
	*/
	static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_BASE = 15min;
	static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER = 1ms;
	/**
	* 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 std::chrono::seconds 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");

	/** Minimum time between 2 successives getavaaddr messages from the same peer */
	static constexpr std::chrono::minutes GETAVAADDR_INTERVAL{2};

	/**
	* If no proof was requested from a compact proof message after this timeout
	* expired, the proof radix tree can be cleaned up.
	*/
	static constexpr std::chrono::minutes AVALANCHE_AVAPROOFS_TIMEOUT{2};

	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;
	/**
	* Time during which a peer must stall block download progress before being
	* disconnected.
	*/
	static constexpr auto BLOCK_STALLING_TIMEOUT = 2s;
	/**
	* 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 multiples of the block interval
	* (i.e. 10 min)
	*/
	static constexpr double BLOCK_DOWNLOAD_TIMEOUT_BASE = 1;
	/**
	* Additional block download timeout per parallel downloading peer (i.e. 5 min)
	*/
	static constexpr double BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 0.5;
	/**
	* 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 auto AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL = 24h;
	/**
	* Average delay between peer address broadcasts.
	*/
	static constexpr auto AVG_ADDRESS_BROADCAST_INTERVAL = 30s;
	/**
	* Average delay between trickled inventory transmissions for inbound peers.
	* Blocks and peers with noban permission bypass this.
	*/
	static constexpr auto INBOUND_INVENTORY_BROADCAST_INTERVAL = 5s;
	/**
	* 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 *
	count_seconds(INBOUND_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 auto AVG_FEEFILTER_BROADCAST_INTERVAL = 10min;
	/**
	* Maximum feefilter broadcast delay after significant change.
	*/
	static constexpr auto MAX_FEEFILTER_CHANGE_DELAY = 5min;
	/**
	* 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;
	/**
	* the maximum percentage of addresses from our addrman to return in response
	* to a getaddr message.
	*/
	static constexpr size_t MAX_PCT_ADDR_TO_SEND = 23;
	/** The maximum number of address records permitted in an ADDR message. */
	static constexpr size_t MAX_ADDR_TO_SEND{1000};
	/**
	* The maximum rate of address records we're willing to process on average. Can
	* be bypassed using the NetPermissionFlags::Addr permission.
	*/
	static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
	/**
	* The soft limit of the address processing token bucket (the regular
	* MAX_ADDR_RATE_PER_SECOND based increments won't go above this, but the
	* MAX_ADDR_TO_SEND increment following GETADDR is exempt from this limit).
	*/
	static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};

	inline size_t GetMaxAddrToSend() {
	return gArgs.GetIntArg("-maxaddrtosend", MAX_ADDR_TO_SEND);
	}

	// Internal stuff
	namespace {
	/**
	* 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;
	};

	/**
	* 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.
	*
	* Mutexes inside this struct must not be held when locking m_peer_mutex.
	*
	* 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};

	/** Protects block inventory data members */
	Mutex m_block_inv_mutex;
	/**
	* List of blocks that we'll anounce via an `inv` message.
	* There is no final sorting before sending, as they are always sent
	* immediately and in the order requested.
	*/
	std::vector<BlockHash> m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex);
	/**
	* Unfiltered list of blocks that we'd like to announce via a `headers`
	* message. If we can't announce via a `headers` message, we'll fall back to
	* announcing via `inv`.
	*/
	std::vector<BlockHash>
	m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex);

	/**
	* The final block hash that we sent in an `inv` message to this peer.
	* When the peer requests this block, we send an `inv` message to trigger
	* the peer to request the next sequence of block hashes.
	* Most peers use headers-first syncing, which doesn't use this mechanism
	*/
	BlockHash m_continuation_block GUARDED_BY(m_block_inv_mutex){};

	/** This peer's reported block height when we connected */
	std::atomic<int> m_starting_height{-1};

	/** The pong reply we're expecting, or 0 if no pong expected. */
	std::atomic<uint64_t> m_ping_nonce_sent{0};
	/** When the last ping was sent, or 0 if no ping was ever sent */
	std::atomic<std::chrono::microseconds> m_ping_start{0us};
	/** Whether a ping has been requested by the user */
	std::atomic<bool> m_ping_queued{false};

	/**
	* A vector of addresses to send to the peer, limited to MAX_ADDR_TO_SEND.
	*/
	std::vector<CAddress> m_addrs_to_send;
	/**
	* Probabilistic filter to track recent addr messages relayed with this
	* peer. Used to avoid relaying redundant addresses to this peer.
	*
	* We initialize this filter for outbound peers (other than
	* block-relay-only connections) or when an inbound peer sends us an
	* address related message (ADDR, ADDRV2, GETADDR).
	*
	* Presence of this filter must correlate with m_addr_relay_enabled.
	**/
	std::unique_ptr<CRollingBloomFilter> m_addr_known;
	/**
	* Whether we are participating in address relay with this connection.
	*
	* We set this bool to true for outbound peers (other than
	* block-relay-only connections), or when an inbound peer sends us an
	* address related message (ADDR, ADDRV2, GETADDR).
	*
	* We use this bool to decide whether a peer is eligible for gossiping
	* addr messages. This avoids relaying to peers that are unlikely to
	* forward them, effectively blackholing self announcements. Reasons
	* peers might support addr relay on the link include that they connected
	* to us as a block-relay-only peer or they are a light client.
	*
	* This field must correlate with whether m_addr_known has been
	* initialized.
	*/
	std::atomic_bool m_addr_relay_enabled{false};
	/** Whether a getaddr request to this peer is outstanding. */
	bool m_getaddr_sent{false};
	/** Guards address sending timers. */
	mutable Mutex m_addr_send_times_mutex;
	/** Time point to send the next ADDR message to this peer. */
	std::chrono::microseconds
	m_next_addr_send GUARDED_BY(m_addr_send_times_mutex){0};
	/** Time point to possibly re-announce our local address to this peer. */
	std::chrono::microseconds
	m_next_local_addr_send GUARDED_BY(m_addr_send_times_mutex){0};
	/**
	* Whether the peer has signaled support for receiving ADDRv2 (BIP155)
	* messages, indicating a preference to receive ADDRv2 instead of ADDR ones.
	*/
	std::atomic_bool m_wants_addrv2{false};
	/** Whether this peer has already sent us a getaddr message. */
	bool m_getaddr_recvd{false};
	/** Guards m_addr_token_bucket */
	mutable Mutex m_addr_token_bucket_mutex;
	/**
	* Number of addresses that can be processed from this peer. Start at 1
	* to permit self-announcement.
	*/
	double m_addr_token_bucket GUARDED_BY(m_addr_token_bucket_mutex){1.0};
	/** When m_addr_token_bucket was last updated */
	std::chrono::microseconds m_addr_token_timestamp{
	GetTime<std::chrono::microseconds>()};
	/** Total number of addresses that were dropped due to rate limiting. */
	std::atomic<uint64_t> m_addr_rate_limited{0};
	/**
	* Total number of addresses that were processed (excludes rate-limited
	* ones).
	*/
	std::atomic<uint64_t> m_addr_processed{0};

	/**
	* Set of txids to reconsider once their parent transactions have been
	* accepted
	*/
	std::set<TxId> m_orphan_work_set GUARDED_BY(g_cs_orphans);

	/ Protects m_getdata_requests /
	Mutex m_getdata_requests_mutex;
	/ Work queue of items requested by this peer /
	std::deque<CInv> m_getdata_requests GUARDED_BY(m_getdata_requests_mutex);

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

	using PeerRef = std::shared_ptr<Peer>;

	class PeerManagerImpl final : public PeerManager {
	public:
	PeerManagerImpl(const CChainParams &chainparams, CConnman &connman,
	AddrMan &addrman, BanMan *banman,
	ChainstateManager &chainman, CTxMemPool &pool,
	bool ignore_incoming_txs);

	/** Overridden from CValidationInterface. */
	void BlockConnected(const std::shared_ptr<const CBlock> &pblock,
	const CBlockIndex *pindexConnected) override;
	void BlockDisconnected(const std::shared_ptr<const CBlock> &block,
	const CBlockIndex *pindex) override;
	void UpdatedBlockTip(const CBlockIndex *pindexNew,
	const CBlockIndex *pindexFork,
	bool fInitialDownload) override;
	void BlockChecked(const CBlock &block,
	const BlockValidationState &state) override;
	void NewPoWValidBlock(const CBlockIndex *pindex,
	const std::shared_ptr<const CBlock> &pblock) override;

	/** Implement NetEventsInterface */
	void InitializeNode(const Config &config, CNode *pnode) override;
	void FinalizeNode(const Config &config, const CNode &node) override;
	bool ProcessMessages(const Config &config, CNode *pfrom,
	std::atomic<bool> &interrupt) override;
	bool SendMessages(const Config &config, CNode *pto) override
	EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing);

	/** Implement PeerManager */
	void StartScheduledTasks(CScheduler &scheduler) override;
	void CheckForStaleTipAndEvictPeers() override;
	bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) override;
	bool IgnoresIncomingTxs() override { return m_ignore_incoming_txs; }
	void SendPings() override;
	void RelayTransaction(const TxId &txid) override;
	void RelayProof(const avalanche::ProofId &proofid) override;
	void SetBestHeight(int height) override { m_best_height = height; };
	void Misbehaving(const NodeId pnode, const int howmuch,
	const std::string &message) override;
	void ProcessMessage(const Config &config, CNode &pfrom,
	const std::string &msg_type, CDataStream &vRecv,
	const std::chrono::microseconds time_received,
	const std::atomic<bool> &interruptMsgProc) override;

	private:
	/**
	* Consider evicting an outbound peer based on the amount of time they've
	* been behind our tip.
	*/
	void ConsiderEviction(CNode &pto, int64_t time_in_seconds)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	/**
	* If we have extra outbound peers, try to disconnect the one with the
	* oldest block announcement.
	*/
	void EvictExtraOutboundPeers(std::chrono::seconds now)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Retrieve unbroadcast transactions from the mempool and reattempt
	* sending to peers
	*/
	void ReattemptInitialBroadcast(CScheduler &scheduler);

	/**
	* Update the avalanche statistics for all the nodes
	*/
	void UpdateAvalancheStatistics() const;

	/**
	* Process periodic avalanche network messaging and cleanups.
	*/
	void AvalanchePeriodicNetworking(CScheduler &scheduler) const;

	/**
	* Get a shared pointer to the Peer object.
	* May return an empty shared_ptr if the Peer object can't be found.
	*/
	PeerRef GetPeerRef(NodeId id) const;

	/**
	* Get a shared pointer to the Peer object and remove it from m_peer_map.
	* May return an empty shared_ptr if the Peer object can't be found.
	*/
	PeerRef RemovePeer(NodeId id);

	// overloaded variant of above to operate on CNode*s
	void Misbehaving(const CNode &node, int howmuch,
	const std::string &message) {
	Misbehaving(node.GetId(), howmuch, message);
	}

	/**
	* Potentially mark a node discouraged based on the contents of a
	* BlockValidationState object
	*
	* @param[in] via_compact_block this bool is passed in because
	* net_processing should punish peers differently depending on whether the
	* data was provided in a compact block message or not. If the compact block
	* had a valid header, but contained invalid txs, the peer should not be
	* punished. See BIP 152.
	*
	* @return Returns true if the peer was punished (probably disconnected)
	*/
	bool MaybePunishNodeForBlock(NodeId nodeid,
	const BlockValidationState &state,
	bool via_compact_block,
	const std::string &message = "");

	/**
	* Potentially disconnect and discourage a node based on the contents of a
	* TxValidationState object
	*
	* @return Returns true if the peer was punished (probably disconnected)
	*/
	bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState &state,
	const std::string &message = "");

	/**
	* Maybe disconnect a peer and discourage future connections from its
	* address.
	*
	* @param[in] pnode The node to check.
	* @param[in] peer The peer object to check.
	* @return True if the peer was marked for disconnection in
	* this function
	*/
	bool MaybeDiscourageAndDisconnect(CNode &pnode, Peer &peer);

	void ProcessOrphanTx(const Config &config, std::set<TxId> &orphan_work_set)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans);
	/** Process a single headers message from a peer. */
	void ProcessHeadersMessage(const Config &config, CNode &pfrom,
	const Peer &peer,
	const std::vector<CBlockHeader> &headers,
	bool via_compact_block);

	void SendBlockTransactions(CNode &pfrom, const CBlock &block,
	const BlockTransactionsRequest &req);

	/**
	* Register with InvRequestTracker that a TX INV has been received from a
	* peer. The announcement parameters are decided in PeerManager and then
	* passed to InvRequestTracker.
	*/
	void AddTxAnnouncement(const CNode &node, const TxId &txid,
	std::chrono::microseconds current_time)
	EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	/**
	* Register with InvRequestTracker that a PROOF INV has been received from a
	* peer. The announcement parameters are decided in PeerManager and then
	* passed to InvRequestTracker.
	*/
	void
	AddProofAnnouncement(const CNode &node, const avalanche::ProofId &proofid,
	std::chrono::microseconds current_time, bool preferred)
	EXCLUSIVE_LOCKS_REQUIRED(cs_proofrequest);

	/** Send a version message to a peer */
	void PushNodeVersion(const Config &config, CNode &pnode, int64_t nTime);

	/**
	* Send a ping message every PING_INTERVAL or if requested via RPC. May mark
	* the peer to be disconnected if a ping has timed out.
	* We use mockable time for ping timeouts, so setmocktime may cause pings
	* to time out.
	*/
	void MaybeSendPing(CNode &node_to, Peer &peer,
	std::chrono::microseconds now);

	/** Send `addr` messages on a regular schedule. */
	void MaybeSendAddr(CNode &node, Peer &peer,
	std::chrono::microseconds current_time);

	/** Send `feefilter` message. */
	void MaybeSendFeefilter(CNode &node,
	std::chrono::microseconds current_time);

	/**
	* Relay (gossip) an address to a few randomly chosen nodes.
	*
	* @param[in] originator The id of the peer that sent us the address. We
	* don't want to relay it back.
	* @param[in] addr Address to relay.
	* @param[in] fReachable Whether the address' network is reachable. We
	* relay unreachable addresses less.
	*/
	void RelayAddress(NodeId originator, const CAddress &addr, bool fReachable);

	const CChainParams &m_chainparams;
	CConnman &m_connman;
	AddrMan &m_addrman;
	/**
	* Pointer to this node's banman. May be nullptr - check existence before
	* dereferencing.
	*/
	BanMan *const m_banman;
	ChainstateManager &m_chainman;
	CTxMemPool &m_mempool;
	InvRequestTracker<TxId> m_txrequest GUARDED_BY(::cs_main);

	Mutex cs_proofrequest;
	InvRequestTracker<avalanche::ProofId>
	m_proofrequest GUARDED_BY(cs_proofrequest);

	/** The height of the best chain */
	std::atomic<int> m_best_height{-1};

	//! Next time to check for stale tip
	int64_t m_stale_tip_check_time;

	/** Whether this node is running in blocks only mode */
	const bool m_ignore_incoming_txs;

	/**
	* Whether we've completed initial sync yet, for determining when to turn
	* on extra block-relay-only peers.
	*/
	bool m_initial_sync_finished{false};

	/**
	* Protects m_peer_map. This mutex must not be locked while holding a lock
	* on any of the mutexes inside a Peer object.
	*/
	mutable Mutex m_peer_mutex;
	/**
	* Map of all Peer objects, keyed by peer id. This map is protected
	* by the m_peer_mutex. Once a shared pointer reference is
	* taken, the lock may be released. Individual fields are protected by
	* their own locks.
	*/
	std::map<NodeId, PeerRef> m_peer_map GUARDED_BY(m_peer_mutex);

	/** 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);

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

	bool AlreadyHaveTx(const TxId &txid) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Filter for transactions that were recently rejected by the mempool.
	* 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 transactions that have been recently confirmed.
	* We use this to avoid requesting transactions that have already been
	* confirmed.
	*/
	Mutex m_recent_confirmed_transactions_mutex;
	std::unique_ptr<CRollingBloomFilter> m_recent_confirmed_transactions
	GUARDED_BY(m_recent_confirmed_transactions_mutex);

	/**
	* 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
	*/
	bool MarkBlockAsReceived(const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Mark a block as in flight
	* 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
	*/
	bool MarkBlockAsInFlight(const Config &config, NodeId nodeid,
	const BlockHash &hash,
	const CBlockIndex *pindex = nullptr,
	std::list<QueuedBlock>::iterator **pit = nullptr)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	bool TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main);

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

	std::map<BlockHash, std::pair<NodeId, std::list<QueuedBlock>::iterator>>
	mapBlocksInFlight GUARDED_BY(cs_main);

	/** When our tip was last updated. */
	std::atomic<int64_t> m_last_tip_update{0};

	/**
	* Determine whether or not a peer can request a transaction, and return it
	* (or nullptr if not found or not allowed).
	*/
	CTransactionRef FindTxForGetData(const CNode &peer, const TxId &txid,
	const std::chrono::seconds mempool_req,
	const std::chrono::seconds now)
	LOCKS_EXCLUDED(cs_main);

	void ProcessGetData(const Config &config, CNode &pfrom, Peer &peer,
	const std::atomic<bool> &interruptMsgProc)
	EXCLUSIVE_LOCKS_REQUIRED(peer.m_getdata_requests_mutex)
	LOCKS_EXCLUDED(cs_main);

	/** Process a new block. Perform any post-processing housekeeping */
	void ProcessBlock(const Config &config, CNode &node,
	const std::shared_ptr<const CBlock> &block,
	bool force_processing);

	/** Relay map. */
	typedef std::map<TxId, 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<std::chrono::microseconds, MapRelay::iterator>>
	g_relay_expiration GUARDED_BY(cs_main);

	/**
	* 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.
	*/
	void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

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

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

	/** Storage for orphan information */
	TxOrphanage m_orphanage;

	void AddToCompactExtraTransactions(const CTransactionRef &tx)
	EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans);

	/**
	* Orphan/conflicted/etc transactions that are kept for compact block
	* reconstruction.
	* The last
	* -blockreconstructionextratxn/DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN of
	* these are kept in a ring buffer
	*/
	std::vector<std::pair<TxHash, CTransactionRef>>
	vExtraTxnForCompact GUARDED_BY(g_cs_orphans);
	/** Offset into vExtraTxnForCompact to insert the next tx */
	size_t vExtraTxnForCompactIt GUARDED_BY(g_cs_orphans) = 0;

	/**
	* Check whether the last unknown block a peer advertised is not yet known.
	*/
	void ProcessBlockAvailability(NodeId nodeid)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	/**
	* Update tracking information about which blocks a peer is assumed to have.
	*/
	void UpdateBlockAvailability(NodeId nodeid, const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	bool CanDirectFetch(const Consensus::Params &consensusParams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* 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.
	*/
	bool BlockRequestAllowed(const CBlockIndex *pindex,
	const Consensus::Params &consensusParams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	bool AlreadyHaveBlock(const BlockHash &block_hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	bool AlreadyHaveProof(const avalanche::ProofId &proofid);
	void ProcessGetBlockData(const Config &config, CNode &pfrom, Peer &peer,
	const CInv &inv, CConnman &connman);

	/**
	* 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.
	*/
	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);

	/**
	* 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
	*/
	void ProcessGetCFilters(CNode &peer, CDataStream &vRecv,
	const CChainParams &chain_params,
	CConnman &connman);
	/**
	* 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
	*/
	void ProcessGetCFHeaders(CNode &peer, CDataStream &vRecv,
	const CChainParams &chain_params,
	CConnman &connman);

	/**
	* 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
	*/
	void ProcessGetCFCheckPt(CNode &peer, CDataStream &vRecv,
	const CChainParams &chain_params,
	CConnman &connman);

	/**
	* Decide a response for an Avalanche poll about the given block.
	*
	* @param[in] hash The hash of the block being polled for
	* @return Our current vote for the block
	*/
	uint32_t GetAvalancheVoteForBlock(const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Checks if address relay is permitted with peer. If needed, initializes
	* the m_addr_known bloom filter and sets m_addr_relay_enabled to true.
	*
	* @return True if address relay is enabled with peer
	* False if address relay is disallowed
	*/
	bool SetupAddressRelay(CNode &node, Peer &peer);

	/**
	* Manage reception of an avalanche proof.
	*
	* @return False if the peer is misbehaving, true otherwise
	*/
	bool ReceivedAvalancheProof(CNode &peer, const avalanche::ProofRef &proof);
	};
	} // namespace

	namespace {
	/**
	* Filter for proofs that are consensus-invalid or were recently invalidated
	* by avalanche (finalized rejection). 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_invalidProofs;
	std::unique_ptr<CRollingBloomFilter> invalidProofs GUARDED_BY(cs_invalidProofs);

	/** Number of preferable block download peers. */
	int nPreferredDownload GUARDED_BY(cs_main) = 0;
	} // 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;
	//! 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
	std::chrono::microseconds m_headers_sync_timeout{0us};
	//! Since when we're stalling block download progress (in microseconds), or
	//! 0.
	std::chrono::microseconds m_stalling_since{0us};
	std::list<QueuedBlock> vBlocksInFlight;
	//! When the first entry in vBlocksInFlight started downloading. Don't care
	//! when vBlocksInFlight is empty.
	std::chrono::microseconds m_downloading_since{0us};
	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 and EXTRA_PEER_CHECK_INTERVAL
	* logic.
	*
	* Both are only in effect for outbound, non-manual, non-protected
	* connections. Any peer protected (m_protect = true) is not chosen for
	* eviction. A peer is marked as protected if all of these are true:
	* - its connection type is IsBlockOnlyConn() == false
	* - it gave us a valid connecting header
	* - we haven't reached MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT yet
	* - it has a better chain than we have
	*
	* CHAIN_SYNC_TIMEOUT: 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.
	*
	* EXTRA_PEER_CHECK_INTERVAL: after each interval, if we have too many
	* outbound peers, drop the outbound one that least recently announced us a
	* new block.
	*/
	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;

	//! 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)
	: address(addrIn), m_is_inbound(is_inbound) {
	pindexBestKnownBlock = nullptr;
	hashLastUnknownBlock = BlockHash();
	pindexLastCommonBlock = nullptr;
	pindexBestHeaderSent = nullptr;
	nUnconnectingHeaders = 0;
	fSyncStarted = false;
	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;
	}

	/**
	* Whether the peer supports the address. For example, a peer that does not
	* implement BIP155 cannot receive Tor v3 addresses because it requires
	* ADDRv2 (BIP155) encoding.
	*/
	static bool IsAddrCompatible(const Peer &peer, const CAddress &addr) {
	return peer.m_wants_addrv2 \|\| addr.IsAddrV1Compatible();
	}

	static void AddAddressKnown(Peer &peer, const CAddress &addr) {
	assert(peer.m_addr_known);
	peer.m_addr_known->insert(addr.GetKey());
	}

	static void PushAddress(Peer &peer, const CAddress &addr,
	FastRandomContext &insecure_rand) {
	// Known checking here is only to save space from duplicates.
	// Before sending, we'll filter it again for known addresses that were
	// added after addresses were pushed.
	assert(peer.m_addr_known);
	if (addr.IsValid() && !peer.m_addr_known->contains(addr.GetKey()) &&
	IsAddrCompatible(peer, addr)) {
	if (peer.m_addrs_to_send.size() >= GetMaxAddrToSend()) {
	peer.m_addrs_to_send[insecure_rand.randrange(
	peer.m_addrs_to_send.size())] = addr;
	} else {
	peer.m_addrs_to_send.push_back(addr);
	}
	}
	}

	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;
	}

	bool PeerManagerImpl::MarkBlockAsReceived(const BlockHash &hash) {
	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->m_downloading_since =
	std::max(state->m_downloading_since,
	GetTime<std::chrono::microseconds>());
	}
	state->vBlocksInFlight.erase(itInFlight->second.second);
	state->nBlocksInFlight--;
	state->m_stalling_since = 0us;
	mapBlocksInFlight.erase(itInFlight);
	return true;
	}

	return false;
	}

	bool PeerManagerImpl::MarkBlockAsInFlight(
	const Config &config, NodeId nodeid, const BlockHash &hash,
	const CBlockIndex pindex, std::list<QueuedBlock>::iterator *pit) {
	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, &m_mempool)
	: nullptr)});
	state->nBlocksInFlight++;
	state->nBlocksInFlightValidHeaders += it->fValidatedHeaders;
	if (state->nBlocksInFlight == 1) {
	// We're starting a block download (batch) from this peer.
	state->m_downloading_since = GetTime<std::chrono::microseconds>();
	}

	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;
	}

	void PeerManagerImpl::MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid) {
	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;
	}
	}
	m_connman.ForNode(nodeid, [this](CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED(
	::cs_main) {
	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.
	m_connman.ForNode(
	lNodesAnnouncingHeaderAndIDs.front(),
	[this, nCMPCTBLOCKVersion](CNode *pnodeStop) {
	m_connman.PushMessage(
	pnodeStop, CNetMsgMaker(pnodeStop->GetCommonVersion())
	.Make(NetMsgType::SENDCMPCT,
	/fAnnounceUsingCMPCTBLOCK=/false,
	nCMPCTBLOCKVersion));
	// save BIP152 bandwidth state: we select peer to be
	// low-bandwidth
	pnodeStop->m_bip152_highbandwidth_to = false;
	return true;
	});
	lNodesAnnouncingHeaderAndIDs.pop_front();
	}
	m_connman.PushMessage(pfrom,
	CNetMsgMaker(pfrom->GetCommonVersion())
	.Make(NetMsgType::SENDCMPCT,
	/fAnnounceUsingCMPCTBLOCK=/true,
	nCMPCTBLOCKVersion));
	// save BIP152 bandwidth state: we select peer to be high-bandwidth
	pfrom->m_bip152_highbandwidth_to = true;
	lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());
	return true;
	});
	}

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

	bool PeerManagerImpl::CanDirectFetch(const Consensus::Params &consensusParams) {
	return m_chainman.ActiveChain().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;
	}

	void PeerManagerImpl::ProcessBlockAvailability(NodeId nodeid) {
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

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

	void PeerManagerImpl::UpdateBlockAvailability(NodeId nodeid,
	const BlockHash &hash) {
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

	ProcessBlockAvailability(nodeid);

	const CBlockIndex *pindex = m_chainman.m_blockman.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;
	}
	}

	void PeerManagerImpl::FindNextBlocksToDownload(
	NodeId nodeid, unsigned int count,
	std::vector<const CBlockIndex *> &vBlocks, NodeId &nodeStaller) {
	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 <
	m_chainman.ActiveChain().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 =
	m_chainman
	.ActiveChain()[std::min(state->pindexBestKnownBlock->nHeight,
	m_chainman.ActiveChain().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() \|\|
	m_chainman.ActiveChain().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 PeerManagerImpl::PushNodeVersion(const Config &config, CNode &pnode,
	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();
	const int nNodeStartingHeight{m_best_height};
	NodeId nodeid = pnode.GetId();
	CAddress addr = pnode.addr;
	uint64_t extraEntropy = pnode.GetLocalExtraEntropy();

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

	const bool tx_relay = !m_ignore_incoming_txs &&
	pnode.m_tx_relay != nullptr && !pnode.IsFeelerConn();
	m_connman.PushMessage(
	&pnode, CNetMsgMaker(INIT_PROTO_VERSION)
	.Make(NetMsgType::VERSION, PROTOCOL_VERSION,
	uint64_t(nLocalNodeServices), nTime, addrYou, addrMe,
	nonce, userAgent(config), nNodeStartingHeight,
	tx_relay, extraEntropy));

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

	void PeerManagerImpl::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 PeerManagerImpl::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 PeerManagerImpl::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()));
	assert(m_txrequest.Count(nodeid) == 0);
	}
	{
	PeerRef peer = std::make_shared<Peer>(nodeid);
	LOCK(m_peer_mutex);
	m_peer_map.emplace_hint(m_peer_map.end(), nodeid, std::move(peer));
	}
	if (!pnode->IsInboundConn()) {
	PushNodeVersion(config, *pnode, GetTime());
	}
	}

	void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler &scheduler) {
	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);
	} else {
	m_mempool.RemoveUnbroadcastTx(txid, true);
	}
	}

	if (g_avalanche && isAvalancheEnabled(gArgs)) {
	// Get and sanitize the list of proofids to broadcast. The RelayProof
	// call is done in a second loop to avoid locking cs_vNodes while
	// cs_peerManager is locked which would cause a potential deadlock due
	// to reversed lock order.
	auto unbroadcasted_proofids =
	g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
	auto unbroadcasted_proofids = pm.getUnbroadcastProofs();

	auto it = unbroadcasted_proofids.begin();
	while (it != unbroadcasted_proofids.end()) {
	// Sanity check: all unbroadcast proofs should be bound to a
	// peer in the peermanager
	if (!pm.isBoundToPeer(*it)) {
	pm.removeUnbroadcastProof(*it);
	it = unbroadcasted_proofids.erase(it);
	continue;
	}

	++it;
	}

	return unbroadcasted_proofids;
	});

	// Remaining proofids are the ones to broadcast
	for (const auto &proofid : unbroadcasted_proofids) {
	RelayProof(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 auto reattemptBroadcastInterval = 10min + GetRandMillis(5min);
	scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); },
	reattemptBroadcastInterval);
	}

	void PeerManagerImpl::UpdateAvalancheStatistics() const {
	m_connman.ForEachNode([](CNode *pnode) {
	if (pnode->m_avalanche_state) {
	pnode->m_avalanche_state->updateAvailabilityScore();
	}
	});
	}

	void PeerManagerImpl::AvalanchePeriodicNetworking(CScheduler &scheduler) const {
	const auto now = GetTime<std::chrono::seconds>();
	std::vector<NodeId> avanode_ids;
	bool fQuorumEstablished;
	bool fShouldRequestMoreNodes;

	if (!g_avalanche) {
	// Not enabled or not ready yet, retry later
	goto scheduleLater;
	}

	fQuorumEstablished = g_avalanche->isQuorumEstablished();
	fShouldRequestMoreNodes =
	g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
	return pm.shouldRequestMoreNodes();
	});

	m_connman.ForEachNode([&](CNode *pnode) {
	// Build a list of the avalanche peers nodeids
	if (pnode->m_avalanche_state &&
	(!fQuorumEstablished \|\| !pnode->IsInboundConn())) {
	avanode_ids.push_back(pnode->GetId());
	}

	// If a proof radix tree timed out, cleanup
	if (pnode->m_proof_relay &&
	now > (pnode->m_proof_relay->lastSharedProofsUpdate.load() +
	AVALANCHE_AVAPROOFS_TIMEOUT)) {
	pnode->m_proof_relay->sharedProofs = {};
	}
	});

	if (avanode_ids.empty()) {
	// No node is available for messaging, retry later
	goto scheduleLater;
	}

	Shuffle(avanode_ids.begin(), avanode_ids.end(), FastRandomContext());

	// Request avalanche addresses from our peers
	for (NodeId avanodeId : avanode_ids) {
	m_connman.ForNode(avanodeId, [&](CNode *pavanode) {
	LogPrint(BCLog::AVALANCHE,
	"Requesting more avalanche addresses from peer %d\n",
	avanodeId);
	m_connman.PushMessage(pavanode,
	CNetMsgMaker(pavanode->GetCommonVersion())
	.Make(NetMsgType::GETAVAADDR));
	PeerRef peer = GetPeerRef(avanodeId);
	WITH_LOCK(peer->m_addr_token_bucket_mutex,
	peer->m_addr_token_bucket += GetMaxAddrToSend());
	return true;
	});

	// If we have no reason to believe that we need more nodes, only request
	// addresses from one of our peers.
	if (fQuorumEstablished && !fShouldRequestMoreNodes) {
	break;
	}
	}

	if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
	// Don't request proofs while in IBD. We're likely to orphan them
	// because we don't have the UTXOs.
	goto scheduleLater;
	}

	// If we never had an avaproofs message yet, be kind and only request to a
	// subset of our peers as we expect a ton of avaproofs message in the
	// process.
	if (g_avalanche->getAvaproofsNodeCounter() == 0) {
	avanode_ids.resize(std::min<size_t>(avanode_ids.size(), 3));
	}

	for (NodeId nodeid : avanode_ids) {
	// Send a getavaproofs to one of our peers
	m_connman.ForNode(nodeid, [&](CNode *pavanode) {
	LogPrint(BCLog::AVALANCHE,
	"Requesting compact proofs from peer %d\n",
	pavanode->GetId());
	if (pavanode->m_proof_relay) {
	m_connman.PushMessage(pavanode,
	CNetMsgMaker(pavanode->GetCommonVersion())
	.Make(NetMsgType::GETAVAPROOFS));

	pavanode->m_proof_relay->compactproofs_requested = true;
	}
	return true;
	});
	}

	scheduleLater:
	// Schedule next run for 2-5 minutes in the future.
	// We add randomness on every cycle to avoid the possibility of P2P
	// fingerprinting.
	const auto avalanchePeriodicNetworkingInterval = 2min + GetRandMillis(3min);
	scheduler.scheduleFromNow([&] { AvalanchePeriodicNetworking(scheduler); },
	avalanchePeriodicNetworkingInterval);
	}

	void PeerManagerImpl::FinalizeNode(const Config &config, const CNode &node) {
	NodeId nodeid = node.GetId();
	int misbehavior{0};
	{
	LOCK(cs_main);
	{
	// We remove the PeerRef from g_peer_map here, but we don't always
	// destruct the Peer. Sometimes another thread is still holding a
	// PeerRef, so the refcount is >= 1. Be careful not to do any
	// processing here that assumes Peer won't be changed before it's
	// destructed.
	PeerRef peer = RemovePeer(nodeid);
	assert(peer != nullptr);
	misbehavior = WITH_LOCK(peer->m_misbehavior_mutex,
	return peer->m_misbehavior_score);
	LOCK(m_peer_mutex);
	m_peer_map.erase(nodeid);
	}
	CNodeState *state = State(nodeid);
	assert(state != nullptr);

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

	for (const QueuedBlock &entry : state->vBlocksInFlight) {
	mapBlocksInFlight.erase(entry.hash);
	}
	WITH_LOCK(g_cs_orphans, m_orphanage.EraseForPeer(nodeid));
	m_txrequest.DisconnectedPeer(nodeid);
	nPreferredDownload -= state->fPreferredDownload;
	nPeersWithValidatedDownloads -=
	(state->nBlocksInFlightValidHeaders != 0);
	assert(nPeersWithValidatedDownloads >= 0);
	m_outbound_peers_with_protect_from_disconnect -=
	state->m_chain_sync.m_protect;
	assert(m_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(m_outbound_peers_with_protect_from_disconnect == 0);
	assert(m_txrequest.Size() == 0);
	}
	}

	if (node.fSuccessfullyConnected && misbehavior == 0 &&
	!node.IsBlockOnlyConn() && !node.IsInboundConn()) {
	// Only change visible addrman state for full outbound peers. We don't
	// call Connected() for feeler connections since they don't have
	// fSuccessfullyConnected set.
	m_addrman.Connected(node.addr);
	}

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

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

	PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const {
	LOCK(m_peer_mutex);
	auto it = m_peer_map.find(id);
	return it != m_peer_map.end() ? it->second : nullptr;
	}

	PeerRef PeerManagerImpl::RemovePeer(NodeId id) {
	PeerRef ret;
	LOCK(m_peer_mutex);
	auto it = m_peer_map.find(id);
	if (it != m_peer_map.end()) {
	ret = std::move(it->second);
	m_peer_map.erase(it);
	}
	return ret;
	}

	bool PeerManagerImpl::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_starting_height = peer->m_starting_height;
	// It is common for nodes with good ping times to suddenly become lagged,
	// due to a new block arriving or other large transfer.
	// Merely reporting pingtime might fool the caller into thinking the node
	// was still responsive, since pingtime does not update until the ping is
	// complete, which might take a while. So, if a ping is taking an unusually
	// long time in flight, the caller can immediately detect that this is
	// happening.
	std::chrono::microseconds ping_wait{0};
	if ((0 != peer->m_ping_nonce_sent) &&
	(0 != peer->m_ping_start.load().count())) {
	ping_wait =
	GetTime<std::chrono::microseconds>() - peer->m_ping_start.load();
	}

	stats.m_ping_wait = ping_wait;
	stats.m_addr_processed = peer->m_addr_processed.load();
	stats.m_addr_rate_limited = peer->m_addr_rate_limited.load();
	stats.m_addr_relay_enabled = peer->m_addr_relay_enabled.load();

	return true;
	}

	void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef &tx) {
	size_t max_extra_txn = gArgs.GetIntArg(
	"-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;
	}

	void PeerManagerImpl::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);
	}
	}

	bool PeerManagerImpl::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. Manual connections are always
	// protected from discouragement.
	if (!via_compact_block && !node_state->m_is_inbound) {
	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 PeerManagerImpl::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_INPUTS_NOT_STANDARD:
	case TxValidationResult::TX_NOT_STANDARD:
	case TxValidationResult::TX_MISSING_INPUTS:
	case TxValidationResult::TX_PREMATURE_SPEND:
	case TxValidationResult::TX_CONFLICT:
	case TxValidationResult::TX_MEMPOOL_POLICY:
	case TxValidationResult::TX_NO_MEMPOOL:
	break;
	}
	if (message != "") {
	LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
	}
	return false;
	}

	bool PeerManagerImpl::BlockRequestAllowed(
	const CBlockIndex *pindex, const Consensus::Params &consensusParams) {
	AssertLockHeld(cs_main);
	if (m_chainman.ActiveChain().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);
	}

	std::unique_ptr<PeerManager>
	PeerManager::make(const CChainParams &chainparams, CConnman &connman,
	AddrMan &addrman, BanMan *banman, ChainstateManager &chainman,
	CTxMemPool &pool, bool ignore_incoming_txs) {
	return std::make_unique<PeerManagerImpl>(chainparams, connman, addrman,
	banman, chainman, pool,
	ignore_incoming_txs);
	}

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

	{
	LOCK(cs_invalidProofs);
	invalidProofs = 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).
	m_recent_confirmed_transactions.reset(
	new CRollingBloomFilter(24000, 0.000001));
	}

	void PeerManagerImpl::StartScheduledTasks(CScheduler &scheduler) {
	// 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]() {
	this->CheckForStaleTipAndEvictPeers();
	return true;
	},
	std::chrono::seconds{EXTRA_PEER_CHECK_INTERVAL});

	// schedule next run for 10-15 minutes in the future
	const auto reattemptBroadcastInterval = 10min + GetRandMillis(5min);
	scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); },
	reattemptBroadcastInterval);

	// Update the avalanche statistics on a schedule
	scheduler.scheduleEvery(
	[this]() {
	UpdateAvalancheStatistics();
	return true;
	},
	AVALANCHE_STATISTICS_REFRESH_PERIOD);

	// schedule next run for 2-5 minutes in the future
	const auto avalanchePeriodicNetworkingInterval = 2min + GetRandMillis(3min);
	scheduler.scheduleFromNow([&] { AvalanchePeriodicNetworking(scheduler); },
	avalanchePeriodicNetworkingInterval);
	}

	/**
	* Evict orphan txn pool entries 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 PeerManagerImpl::BlockConnected(
	const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
	m_orphanage.EraseForBlock(*pblock);
	m_last_tip_update = GetTime();

	{
	LOCK(m_recent_confirmed_transactions_mutex);
	for (const CTransactionRef &ptx : pblock->vtx) {
	m_recent_confirmed_transactions->insert(ptx->GetId());
	}
	}
	{
	LOCK(cs_main);
	for (const auto &ptx : pblock->vtx) {
	m_txrequest.ForgetInvId(ptx->GetId());
	}
	}
	}

	void PeerManagerImpl::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(m_recent_confirmed_transactions_mutex);
	m_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 PeerManagerImpl::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) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
	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 m_chainman.ActiveChain() to our peers.
	*/
	void PeerManagerImpl::UpdatedBlockTip(const CBlockIndex *pindexNew,
	const CBlockIndex *pindexFork,
	bool fInitialDownload) {
	SetBestHeight(pindexNew->nHeight);
	SetServiceFlagsIBDCache(!fInitialDownload);

	// Don't relay inventory during initial block download.
	if (fInitialDownload) {
	return;
	}

	// 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;
	}
	}

	{
	LOCK(m_peer_mutex);
	for (auto &it : m_peer_map) {
	Peer &peer = *it.second;
	LOCK(peer.m_block_inv_mutex);
	for (const BlockHash &hash : reverse_iterate(vHashes)) {
	peer.m_blocks_for_headers_relay.push_back(hash);
	}
	}
	}

	m_connman.WakeMessageHandler();
	}

	/**
	* Handle invalid block rejection and consequent peer banning, maintain which
	* peers announce compact blocks.
	*/
	void PeerManagerImpl::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() &&
	!m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
	mapBlocksInFlight.count(hash) == mapBlocksInFlight.size()) {
	if (it != mapBlockSource.end()) {
	MaybeSetPeerAsAnnouncingHeaderAndIDs(it->second.first);
	}
	}

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

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

	bool PeerManagerImpl::AlreadyHaveTx(const TxId &txid) {
	assert(recentRejects);
	if (m_chainman.ActiveChain().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 =
	m_chainman.ActiveChain().Tip()->GetBlockHash();
	recentRejects->reset();
	}

	if (m_orphanage.HaveTx(txid)) {
	return true;
	}

	{
	LOCK(m_recent_confirmed_transactions_mutex);
	if (m_recent_confirmed_transactions->contains(txid)) {
	return true;
	}
	}

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

	bool PeerManagerImpl::AlreadyHaveBlock(const BlockHash &block_hash) {
	return m_chainman.m_blockman.LookupBlockIndex(block_hash) != nullptr;
	}

	bool PeerManagerImpl::AlreadyHaveProof(const avalanche::ProofId &proofid) {
	assert(g_avalanche);

	auto localProof = g_avalanche->getLocalProof();
	if (localProof && localProof->getId() == proofid) {
	return true;
	}

	const bool hasProof = g_avalanche->withPeerManager(
	[&proofid](avalanche::PeerManager &pm) { return pm.exists(proofid); });

	LOCK(cs_invalidProofs);
	return hasProof \|\| invalidProofs->contains(proofid);
	}

	void PeerManagerImpl::SendPings() {
	LOCK(m_peer_mutex);
	for (auto &it : m_peer_map) {
	it.second->m_ping_queued = true;
	}
	}

	void PeerManagerImpl::RelayTransaction(const TxId &txid) {
	m_connman.ForEachNode(
	[&txid](CNode *pnode) { pnode->PushTxInventory(txid); });
	}

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

	void PeerManagerImpl::RelayAddress(NodeId originator, const CAddress &addr,
	bool fReachable) {
	// We choose the same nodes within a given 24h window (if the list of
	// connected nodes does not change) and we don't relay to nodes that already
	// know an address. So within 24h we will likely relay a given address once.
	// This is to prevent a peer from unjustly giving their address better
	// propagation by sending it to us repeatedly.

	if (!fReachable && !addr.IsRelayable()) {
	return;
	}

	// 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 =
	+ const uint64_t hash_addr{CServiceHash(0, 0)(addr)};
	+ const CSipHasher hasher{
	m_connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY)
	- .Write(hashAddr << 32)
	- .Write((GetTime() + hashAddr) / (24 * 60 * 60));
	+ .Write(hash_addr)
	+ .Write((GetTime() + hash_addr) / (24 * 60 * 60))};
	FastRandomContext insecure_rand;

	// Relay reachable addresses to 2 peers. Unreachable addresses are relayed
	// randomly to 1 or 2 peers.
	unsigned int nRelayNodes = (fReachable \|\| (hasher.Finalize() & 1)) ? 2 : 1;
	std::array<std::pair<uint64_t, Peer *>, 2> best{
	{{0, nullptr}, {0, nullptr}}};
	assert(nRelayNodes <= best.size());

	LOCK(m_peer_mutex);

	for (auto &[id, peer] : m_peer_map) {
	if (peer->m_addr_relay_enabled && id != originator &&
	IsAddrCompatible(*peer, addr)) {
	uint64_t hashKey = CSipHasher(hasher).Write(id).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, peer.get());
	break;
	}
	}
	}
	};

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

	void PeerManagerImpl::ProcessGetBlockData(const Config &config, CNode &pfrom,
	Peer &peer, const CInv &inv,
	CConnman &connman) {
	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 =
	m_chainman.m_blockman.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 (!m_chainman.ActiveChainstate().ActivateBestChain(config, state,
	a_recent_block)) {
	LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
	state.ToString());
	}
	}

	LOCK(cs_main);
	const CBlockIndex *pindex = m_chainman.m_blockman.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) &&
	(m_chainman.ActiveChain().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 >=
	m_chainman.ActiveChain().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));
	}
	}

	{
	LOCK(peer.m_block_inv_mutex);
	// Trigger the peer node to send a getblocks request for the next
	// batch of inventory.
	if (hash == peer.m_continuation_block) {
	// 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, m_chainman.ActiveChain().Tip()->GetBlockHash()));
	connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::INV, vInv));
	peer.m_continuation_block = BlockHash();
	}
	}
	}
	}

	CTransactionRef
	PeerManagerImpl::FindTxForGetData(const CNode &peer, const TxId &txid,
	const std::chrono::seconds mempool_req,
	const std::chrono::seconds now) {
	auto txinfo = m_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 avalanche::ProofRef
	FindProofForGetData(const CNode &peer, const avalanche::ProofId &proofid,
	const std::chrono::seconds now) {
	avalanche::ProofRef proof;

	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;
	});
	});

	if (!proof) {
	// Always send our local proof if it gets requested, assuming it's
	// valid. This will make it easier to bind with peers upon startup where
	// the status of our proof is unknown pending for a block. Note that it
	// still needs to have been announced first (presumably via an avahello
	// message).
	proof = g_avalanche->getLocalProof();
	}

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

	if (send_unconditionally) {
	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 avalanche::ProofRef();
	}

	void PeerManagerImpl::ProcessGetData(
	const Config &config, CNode &pfrom, Peer &peer,
	const std::atomic<bool> &interruptMsgProc) {
	AssertLockNotHeld(cs_main);

	std::deque<CInv>::iterator it = peer.m_getdata_requests.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 != peer.m_getdata_requests.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(inv.hash);
	auto proof = FindProofForGetData(pfrom, proofid, now);
	if (proof) {
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof));
	g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
	pm.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;
	}

	const TxId txid(inv.hash);
	CTransactionRef tx =
	FindTxForGetData(pfrom, txid, mempool_req, now);
	if (tx) {
	int nSendFlags = 0;
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(nSendFlags, NetMsgType::TX, *tx));
	m_mempool.RemoveUnbroadcastTx(txid);
	// As we're going to send tx, make sure its unconfirmed parents
	// are made requestable.
	std::vector<TxId> parent_ids_to_add;
	{
	LOCK(m_mempool.cs);
	auto txiter = m_mempool.GetIter(tx->GetId());
	if (txiter) {
	const CTxMemPoolEntry::Parents &parents =
	(*txiter)->GetMemPoolParentsConst();
	parent_ids_to_add.reserve(parents.size());
	for (const CTxMemPoolEntry &parent : parents) {
	if (parent.GetTime() >
	now - UNCONDITIONAL_RELAY_DELAY) {
	parent_ids_to_add.push_back(
	parent.GetTx().GetId());
	}
	}
	}
	}
	for (const TxId &parent_txid : parent_ids_to_add) {
	// 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(parent_txid))) {
	LOCK(cs_main);
	State(pfrom.GetId())
	->m_recently_announced_invs.insert(parent_txid);
	}
	}
	} 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 != peer.m_getdata_requests.end() && !pfrom.fPauseSend) {
	const CInv &inv = *it++;
	if (inv.IsGenBlkMsg()) {
	ProcessGetBlockData(config, pfrom, peer, inv, m_connman);
	}
	// else: If the first item on the queue is an unknown type, we erase it
	// and continue processing the queue on the next call.
	}

	peer.m_getdata_requests.erase(peer.m_getdata_requests.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.
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::NOTFOUND, vNotFound));
	}
	}

	void PeerManagerImpl::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 PeerManagerImpl::ProcessHeadersMessage(
	const Config &config, CNode &pfrom, const Peer &peer,
	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 (!m_chainman.m_blockman.LookupBlockIndex(headers[0].hashPrevBlock) &&
	nCount < MAX_BLOCKS_TO_ANNOUNCE) {
	nodestate->nUnconnectingHeaders++;
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::GETHEADERS,
	m_chainman.ActiveChain().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 (!m_chainman.m_blockman.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 >
	m_chainman.ActiveChain().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
	// m_chainman.ActiveChain().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(), peer.m_starting_height);
	m_connman.PushMessage(
	&pfrom,
	msgMaker.Make(NetMsgType::GETHEADERS,
	m_chainman.ActiveChain().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) &&
	m_chainman.ActiveChain().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 &&
	!m_chainman.ActiveChain().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 (!m_chainman.ActiveChain().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, pfrom.GetId(),
	pindex->GetBlockHash(), 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 (m_chainman.ActiveChainstate().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 it is an outbound disconnection
	// candidate.
	// Note: We compare their tip to nMinimumChainWork (rather than
	// m_chainman.ActiveChain().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 this is an outbound full-relay peer, check to see if we should
	// protect it from the bad/lagging chain logic.
	// Note that outbound block-relay peers are excluded from this
	// protection, and thus always subject to eviction under the bad/lagging
	// chain logic.
	// See ChainSyncTimeoutState.
	if (!pfrom.fDisconnect && pfrom.IsFullOutboundConn() &&
	nodestate->pindexBestKnownBlock != nullptr) {
	if (m_outbound_peers_with_protect_from_disconnect <
	MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT &&
	nodestate->pindexBestKnownBlock->nChainWork >=
	m_chainman.ActiveChain().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;
	++m_outbound_peers_with_protect_from_disconnect;
	}
	}
	}
	}

	/**
	* Reconsider orphan transactions after a parent has been accepted to the
	* mempool.
	*
	* @param[in,out] orphan_work_set The set of orphan transactions to
	* reconsider. Generally only one orphan will be reconsidered on each call of
	* this function. This set may be added to if accepting an orphan causes its
	* children to be reconsidered.
	*/
	void PeerManagerImpl::ProcessOrphanTx(const Config &config,
	std::set<TxId> &orphan_work_set) {
	AssertLockHeld(cs_main);
	AssertLockHeld(g_cs_orphans);
	while (!orphan_work_set.empty()) {
	const TxId orphanTxId = *orphan_work_set.begin();
	orphan_work_set.erase(orphan_work_set.begin());

	const auto [porphanTx, from_peer] = m_orphanage.GetTx(orphanTxId);
	if (porphanTx == nullptr) {
	continue;
	}

	const MempoolAcceptResult result =
	m_chainman.ProcessTransaction(porphanTx);
	const TxValidationState &state = result.m_state;
	if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
	LogPrint(BCLog::MEMPOOL, " accepted orphan tx %s\n",
	orphanTxId.ToString());
	RelayTransaction(orphanTxId);
	m_orphanage.AddChildrenToWorkSet(*porphanTx, orphan_work_set);
	m_orphanage.EraseTx(orphanTxId);
	break;
	} else if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) {
	if (state.IsInvalid()) {
	LogPrint(BCLog::MEMPOOL,
	" invalid orphan tx %s from peer=%d. %s\n",
	orphanTxId.ToString(), from_peer, state.ToString());
	// Punish peer that gave us an invalid orphan tx
	MaybePunishNodeForTx(from_peer, state);
	}
	// 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);

	m_orphanage.EraseTx(orphanTxId);
	break;
	}
	}
	}

	bool PeerManagerImpl::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 = m_chainman.m_blockman.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;
	}

	void PeerManagerImpl::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));
	}
	}

	void PeerManagerImpl::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));
	}

	void PeerManagerImpl::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 \|\|
	msg_type == NetMsgType::GETAVAADDR \|\|
	msg_type == NetMsgType::GETAVAPROOFS \|\|
	msg_type == NetMsgType::AVAPROOFS \|\|
	msg_type == NetMsgType::AVAPROOFSREQ;
	}

	uint32_t PeerManagerImpl::GetAvalancheVoteForBlock(const BlockHash &hash) {
	AssertLockHeld(cs_main);

	const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash);

	// Unknown block.
	if (!pindex) {
	return -1;
	}

	// Invalid block
	if (pindex->nStatus.isInvalid()) {
	return 1;
	}

	// Parked block
	if (pindex->nStatus.isOnParkedChain()) {
	return 2;
	}

	const CBlockIndex *pindexTip = m_chainman.ActiveChain().Tip();
	const CBlockIndex *pindexFork = LastCommonAncestor(pindex, pindexTip);

	// Active block.
	if (pindex == pindexFork) {
	return 0;
	}

	// Fork block.
	if (pindexFork != pindexTip) {
	return 3;
	}

	// Missing block data.
	if (!pindex->nStatus.hasData()) {
	return -2;
	}

	// This block is built on top of the tip, we have the data, it
	// is pending connection or rejection.
	return -3;
	};

	/**
	* Decide a response for an Avalanche poll about the given transaction.
	*
	* FIXME This function should be expanded to return different vote responses
	* based on inspection of mempool.
	*
	* @param[in] mempool The mempool to base our votes on
	* @param[in] id The id of the transaction being polled for
	* @return Our current vote for the proof
	*/
	static uint32_t getAvalancheVoteForTx(CTxMemPool &mempool, const TxId &id) {
	return -1;
	};

	/**
	* Decide a response for an Avalanche poll about the given proof.
	*
	* @param[in] id The id of the proof being polled for
	* @return Our current vote for the proof
	*/
	static uint32_t getAvalancheVoteForProof(const avalanche::ProofId &id) {
	assert(g_avalanche);

	// Rejected proof
	if (WITH_LOCK(cs_invalidProofs, return invalidProofs->contains(id))) {
	return 1;
	}

	return g_avalanche->withPeerManager([&id](avalanche::PeerManager &pm) {
	// The proof is actively bound to a peer
	if (pm.isBoundToPeer(id)) {
	return 0;
	}

	// Unknown proof
	if (!pm.exists(id)) {
	return -1;
	}

	// Immature proof
	if (pm.isImmature(id)) {
	return 2;
	}

	// Not immature, but in conflict with an actively bound proof
	if (pm.isInConflictingPool(id)) {
	return 3;
	}

	// The proof is known, not rejected, not immature, not a conflict, but
	// for some reason unbound. This should not happen if the above pools
	// are managed correctly, but added for robustness.
	return -2;
	});
	};

	void PeerManagerImpl::ProcessBlock(const Config &config, CNode &node,
	const std::shared_ptr<const CBlock> &block,
	bool force_processing) {
	bool new_block{false};
	m_chainman.ProcessNewBlock(config, block, force_processing, &new_block);
	if (new_block) {
	node.m_last_block_time = GetTime<std::chrono::seconds>();
	} else {
	LOCK(cs_main);
	mapBlockSource.erase(block->GetHash());
	}
	}

	void PeerManagerImpl::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());

	PeerRef peer = GetPeerRef(pfrom.GetId());
	if (peer == nullptr) {
	return;
	}

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

	if (!isAvalancheEnabled(gArgs)) {
	// If avalanche is not enabled, ignore avalanche messages
	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 starting_height = -1;
	bool fRelay = true;
	uint64_t nExtraEntropy = 1;

	vRecv >> nVersion >> nServiceInt >> nTime >> addrMe;
	if (nTime < 0) {
	nTime = 0;
	}
	nServices = ServiceFlags(nServiceInt);
	if (!pfrom.IsInboundConn()) {
	m_addrman.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 (pfrom.IsAvalancheOutboundConnection() &&
	!(nServices & NODE_AVALANCHE)) {
	LogPrint(
	BCLog::AVALANCHE,
	"peer=%d does not offer the avalanche service; disconnecting\n",
	pfrom.GetId());
	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 >> starting_height;
	}
	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);
	}

	// Inbound peers send us their version message when they connect.
	// We send our version message in response.
	if (pfrom.IsInboundConn()) {
	PushNodeVersion(config, pfrom, 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;
	}
	peer->m_starting_height = starting_height;

	// 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()));
	}

	// Self advertisement & GETADDR logic
	if (!pfrom.IsInboundConn() && SetupAddressRelay(pfrom, *peer)) {
	// For outbound peers, we try to relay our address (so that other
	// nodes can try to find us more quickly, as we have no guarantee
	// that an outbound peer is even aware of how to reach us) and do a
	// one-time address fetch (to help populate/update our addrman). If
	// we're starting up for the first time, our addrman may be pretty
	// empty and no one will know who we are, so these mechanisms are
	// important to help us connect to the network.
	//
	// We skip this for block-relay-only peers. We want to avoid
	// potentially leaking addr information and we do not want to
	// indicate to the peer that we will participate in addr relay.
	if (fListen &&
	!m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
	CAddress addr =
	GetLocalAddress(&pfrom.addr, pfrom.GetLocalServices());
	FastRandomContext insecure_rand;
	if (addr.IsRoutable()) {
	LogPrint(BCLog::NET,
	"ProcessMessages: advertising address %s\n",
	addr.ToString());
	PushAddress(*peer, addr, insecure_rand);
	} else if (IsPeerAddrLocalGood(&pfrom)) {
	addr.SetIP(addrMe);
	LogPrint(BCLog::NET,
	"ProcessMessages: advertising address %s\n",
	addr.ToString());
	PushAddress(*peer, addr, insecure_rand);
	}
	}

	// Get recent addresses
	m_connman.PushMessage(&pfrom, CNetMsgMaker(greatest_common_version)
	.Make(NetMsgType::GETADDR));
	peer->m_getaddr_sent = true;
	// When requesting a getaddr, accept an additional MAX_ADDR_TO_SEND
	// addresses in response (bypassing the
	// MAX_ADDR_PROCESSING_TOKEN_BUCKET limit).
	WITH_LOCK(peer->m_addr_token_bucket_mutex,
	peer->m_addr_token_bucket += GetMaxAddrToSend());
	}

	if (!pfrom.IsInboundConn()) {
	// For non-inbound connections, we update the addrman to record
	// connection success so that addrman will have an up-to-date
	// notion of which peers are online and available.
	//
	// While we strive to not leak information about block-relay-only
	// connections via the addrman, not moving an address to the tried
	// table is also potentially detrimental because new-table entries
	// are subject to eviction in the event of addrman collisions. We
	// mitigate the information-leak by never calling
	// AddrMan::Connected() on block-relay-only peers; see
	// FinalizeNode().
	//
	// This moves an address from New to Tried table in Addrman,
	// resolves tried-table collisions, etc.
	m_addrman.Good(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, txrelay=%d, peer=%d%s\n",
	pfrom.addr.ToString(), cleanSubVer, pfrom.nVersion,
	peer->m_starting_height, addrMe.ToString(), fRelay,
	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()) {
	LogPrint(BCLog::NET,
	"feeler connection completed peer=%d; disconnecting\n",
	pfrom.GetId());
	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.fSuccessfullyConnected) {
	LogPrint(BCLog::NET,
	"ignoring redundant verack message from peer=%d\n",
	pfrom.GetId());
	return;
	}

	if (!pfrom.IsInboundConn()) {
	LogPrintf(
	"New outbound peer connected: version: %d, blocks=%d, "
	"peer=%d%s (%s)\n",
	pfrom.nVersion.load(), peer->m_starting_height, pfrom.GetId(),
	(fLogIPs ? strprintf(", peeraddr=%s", pfrom.addr.ToString())
	: ""),
	pfrom.ConnectionTypeAsString());
	}

	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 (g_avalanche && isAvalancheEnabled(gArgs)) {
	if (g_avalanche->sendHello(&pfrom)) {
	LogPrint(BCLog::AVALANCHE, "Send avahello to peer %d\n",
	pfrom.GetId());

	auto localProof = g_avalanche->getLocalProof();

	if (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 (!SetupAddressRelay(pfrom, *peer)) {
	LogPrint(BCLog::NET, "ignoring %s message from %s peer=%d\n",
	msg_type, pfrom.ConnectionTypeAsString(), pfrom.GetId());
	return;
	}

	if (vAddr.size() > GetMaxAddrToSend()) {
	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;

	// Update/increment addr rate limiting bucket.
	const auto current_time = GetTime<std::chrono::microseconds>();
	{
	LOCK(peer->m_addr_token_bucket_mutex);
	if (peer->m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) {
	// Don't increment bucket if it's already full
	const auto time_diff =
	std::max(current_time - peer->m_addr_token_timestamp, 0us);
	const double increment =
	CountSecondsDouble(time_diff) * MAX_ADDR_RATE_PER_SECOND;
	peer->m_addr_token_bucket =
	std::min<double>(peer->m_addr_token_bucket + increment,
	MAX_ADDR_PROCESSING_TOKEN_BUCKET);
	}
	}
	peer->m_addr_token_timestamp = current_time;

	const bool rate_limited =
	!pfrom.HasPermission(NetPermissionFlags::PF_ADDR);
	uint64_t num_proc = 0;
	uint64_t num_rate_limit = 0;
	Shuffle(vAddr.begin(), vAddr.end(), FastRandomContext());
	for (CAddress &addr : vAddr) {
	if (interruptMsgProc) {
	return;
	}

	{
	LOCK(peer->m_addr_token_bucket_mutex);
	// Apply rate limiting.
	if (peer->m_addr_token_bucket < 1.0) {
	if (rate_limited) {
	++num_rate_limit;
	continue;
	}
	} else {
	peer->m_addr_token_bucket -= 1.0;
	}
	}

	// 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;
	}
	AddAddressKnown(*peer, addr);
	if (m_banman &&
	(m_banman->IsDiscouraged(addr) \|\| m_banman->IsBanned(addr))) {
	// Do not process banned/discouraged addresses beyond
	// remembering we received them
	continue;
	}
	++num_proc;
	bool fReachable = IsReachable(addr);
	if (addr.nTime > nSince && !peer->m_getaddr_sent &&
	vAddr.size() <= 10 && addr.IsRoutable()) {
	// Relay to a limited number of other nodes
	RelayAddress(pfrom.GetId(), addr, fReachable);
	}
	// Do not store addresses outside our network
	if (fReachable) {
	vAddrOk.push_back(addr);
	}
	}
	peer->m_addr_processed += num_proc;
	peer->m_addr_rate_limited += num_rate_limit;
	LogPrint(BCLog::NET,
	"Received addr: %u addresses (%u processed, %u rate-limited) "
	"from peer=%d\n",
	vAddr.size(), num_proc, num_rate_limit, pfrom.GetId());

	m_addrman.Add(vAddrOk, pfrom.addr, 2 * 60 * 60);
	if (vAddr.size() < 1000) {
	peer->m_getaddr_sent = false;
	}

	// AddrFetch: Require multiple addresses to avoid disconnecting on
	// self-announcements
	if (pfrom.IsAddrFetchConn() && vAddr.size() > 1) {
	LogPrint(BCLog::NET,
	"addrfetch connection completed peer=%d; disconnecting\n",
	pfrom.GetId());
	pfrom.fDisconnect = true;
	}
	return;
	}

	if (msg_type == NetMsgType::SENDADDRV2) {
	peer->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;
	// save whether peer selects us as BIP152 high-bandwidth peer
	// (receiving sendcmpct(1) signals high-bandwidth,
	// sendcmpct(0) low-bandwidth)
	pfrom.m_bip152_highbandwidth_from = 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 =
	m_ignore_incoming_txs \|\| (pfrom.m_tx_relay == nullptr);

	// Allow peers with relay permission to send data other than blocks
	// in blocks only mode
	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) &&
	!m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
	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);
	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,
	m_chainman.ActiveChain().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());
	}

	{
	LOCK(peer->m_getdata_requests_mutex);
	peer->m_getdata_requests.insert(peer->m_getdata_requests.end(),
	vInv.begin(), vInv.end());
	ProcessGetData(config, pfrom, *peer, 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 (!m_chainman.ActiveChainstate().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 = m_chainman.m_blockman.FindForkInGlobalIndex(
	m_chainman.ActiveChain(), locator);

	// Send the rest of the chain
	if (pindex) {
	pindex = m_chainman.ActiveChain().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 = m_chainman.ActiveChain().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 <= m_chainman.ActiveChain().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(
	peer->m_block_inv_mutex,
	peer->m_blocks_for_inv_relay.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());
	WITH_LOCK(peer->m_block_inv_mutex, {
	peer->m_continuation_block = 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 =
	m_chainman.m_blockman.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 >=
	m_chainman.ActiveChain().Height() - MAX_BLOCKTXN_DEPTH) {
	CBlock block;
	bool ret = ReadBlockFromDisk(block, pindex,
	m_chainparams.GetConsensus());
	assert(ret);

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

	// 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;
	WITH_LOCK(peer->m_getdata_requests_mutex,
	peer->m_getdata_requests.push_back(inv));
	// The message processing loop will go around again (without pausing)
	// and we'll respond then (without cs_main)
	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 (m_chainman.ActiveChainstate().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 = m_chainman.m_blockman.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 = m_chainman.m_blockman.FindForkInGlobalIndex(
	m_chainman.ActiveChain(), locator);
	if (pindex) {
	pindex = m_chainman.ActiveChain().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 = m_chainman.ActiveChain().Next(pindex)) {
	vHeaders.push_back(pindex->GetBlockHeader());
	if (--nLimit <= 0 \|\| pindex->GetBlockHash() == hashStop) {
	break;
	}
	}
	// pindex can be nullptr either if we sent
	// m_chainman.ActiveChain().Tip() OR if our peer has
	// m_chainman.ActiveChain().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 : m_chainman.ActiveChain().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 ((m_ignore_incoming_txs && !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);

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

	if (AlreadyHaveTx(txid)) {
	if (pfrom.HasPermission(PF_FORCERELAY)) {
	// Always relay transactions received from peers with
	// forcerelay permission, even if they were already in the
	// mempool, allowing the node to function as a gateway for
	// nodes hidden behind it.
	if (!m_mempool.exists(tx.GetId())) {
	LogPrintf("Not relaying non-mempool transaction %s from "
	"forcerelay peer=%d\n",
	tx.GetId().ToString(), pfrom.GetId());
	} else {
	LogPrintf("Force relaying tx %s from peer=%d\n",
	tx.GetId().ToString(), pfrom.GetId());
	RelayTransaction(tx.GetId());
	}
	}
	return;
	}

	const MempoolAcceptResult result = m_chainman.ProcessTransaction(ptx);
	const TxValidationState &state = result.m_state;

	if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
	// 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_orphanage.AddChildrenToWorkSet(tx, peer->m_orphan_work_set);

	pfrom.m_last_tx_time = GetTime<std::chrono::seconds>();

	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, peer->m_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;

	// Deduplicate parent txids, so that we don't have to loop over
	// the same parent txid more than once down below.
	std::vector<TxId> unique_parents;
	unique_parents.reserve(tx.vin.size());
	for (const CTxIn &txin : tx.vin) {
	// We start with all parents, and then remove duplicates below.
	unique_parents.push_back(txin.prevout.GetTxId());
	}
	std::sort(unique_parents.begin(), unique_parents.end());
	unique_parents.erase(
	std::unique(unique_parents.begin(), unique_parents.end()),
	unique_parents.end());
	for (const TxId &parent_txid : unique_parents) {
	if (recentRejects->contains(parent_txid)) {
	fRejectedParents = true;
	break;
	}
	}
	if (!fRejectedParents) {
	const auto current_time = GetTime<std::chrono::microseconds>();

	for (const TxId &parent_txid : unique_parents) {
	// FIXME: MSG_TX should use a TxHash, not a TxId.
	pfrom.AddKnownTx(parent_txid);
	if (!AlreadyHaveTx(parent_txid)) {
	AddTxAnnouncement(pfrom, parent_txid, current_time);
	}
	}

	if (m_orphanage.AddTx(ptx, pfrom.GetId())) {
	AddToCompactExtraTransactions(ptx);
	}

	// 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 m_orphanage to grow
	// unbounded (see CVE-2012-3789)
	unsigned int nMaxOrphanTx = (unsigned int)std::max(
	int64_t(0),
	gArgs.GetIntArg("-maxorphantx",
	DEFAULT_MAX_ORPHAN_TRANSACTIONS));
	unsigned int nEvicted = m_orphanage.LimitOrphans(nMaxOrphanTx);
	if (nEvicted > 0) {
	LogPrint(BCLog::MEMPOOL,
	"orphanage 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 a tx has been detected by recentRejects, we will have reached
	// this point and the tx will have been ignored. Because we haven't
	// submitted the tx to our mempool, 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;
	try {
	vRecv >> cmpctblock;
	} catch (std::ios_base::failure &e) {
	// This block has non contiguous or overflowing indexes
	Misbehaving(pfrom, 100, "cmpctblock-bad-indexes");
	return;
	}

	bool received_new_header = false;

	{
	LOCK(cs_main);

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

	if (!m_chainman.m_blockman.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 >
	m_chainman.ActiveChain().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 <=
	m_chainman.ActiveChain()
	.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 <= m_chainman.ActiveChain().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, pfrom.GetId(),
	pindex->GetBlockHash(), 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 Misbehaving does not
	// result in a disconnect
	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, *peer,
	{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));
	}
	// Setting force_processing 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.
	ProcessBlock(config, pfrom, pblock, /force_processing=/true);
	// 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 Misbehaving does not
	// result in a disconnect.
	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) {
	// 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.
	ProcessBlock(config, pfrom, pblock, /force_processing=/true);
	}
	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, *peer, 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) &&
	!m_chainman.ActiveChainstate().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));
	}
	ProcessBlock(config, pfrom, pblock, forceProcessing);
	return;
	}

	if (msg_type == NetMsgType::AVAHELLO) {
	if (pfrom.m_avalanche_state) {
	LogPrint(
	BCLog::AVALANCHE,
	"Ignoring avahello from peer %d: already in our node set\n",
	pfrom.GetId());
	return;
	}

	pfrom.m_avalanche_state = std::make_unique<CNode::AvalancheState>();

	avalanche::Delegation delegation;
	vRecv >> delegation;

	// A delegation with an all zero limited id indicates that the peer has
	// no proof, so we're done.
	if (delegation.getLimitedProofId() != uint256::ZERO) {
	avalanche::DelegationState state;
	CPubKey pubkey;
	if (!delegation.verify(state, pubkey)) {
	Misbehaving(pfrom, 100, "invalid-delegation");
	return;
	}
	pfrom.m_avalanche_pubkey = std::move(pubkey);

	CHashWriter sighasher(SER_GETHASH, 0);
	sighasher << delegation.getId();
	sighasher << pfrom.nRemoteHostNonce;
	sighasher << pfrom.GetLocalNonce();
	sighasher << pfrom.nRemoteExtraEntropy;
	sighasher << pfrom.GetLocalExtraEntropy();

	SchnorrSig sig;
	vRecv >> sig;
	if (!(*pfrom.m_avalanche_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);
	}

	// Don't check the return value. If it fails we probably don't
	// know about the proof yet.
	g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
	return pm.addNode(pfrom.GetId(), proofid);
	});
	}

	// Send getavaaddr and getavaproofs to our avalanche outbound or
	// manual connections
	if (!pfrom.IsInboundConn()) {
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::GETAVAADDR));
	WITH_LOCK(peer->m_addr_token_bucket_mutex,
	peer->m_addr_token_bucket += GetMaxAddrToSend());

	if (pfrom.m_proof_relay &&
	!m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::GETAVAPROOFS));
	pfrom.m_proof_relay->compactproofs_requested = true;
	}
	}

	return;
	}

	if (msg_type == NetMsgType::AVAPOLL) {
	auto now = std::chrono::steady_clock::now();
	int64_t cooldown =
	gArgs.GetIntArg("-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;
	}

	const bool quorum_established =
	g_avalanche && g_avalanche->isQuorumEstablished();

	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);

	for (unsigned int n = 0; n < nCount; n++) {
	CInv inv;
	vRecv >> inv;

	// Default vote for unknown inv type
	uint32_t vote = -1;

	// We don't vote definitively until we have an established quorum
	if (!quorum_established) {
	votes.emplace_back(vote, inv.hash);
	continue;
	}

	// If inv's type is known, get a vote for its hash
	switch (inv.type) {
	case MSG_TX: {
	vote = getAvalancheVoteForTx(m_mempool, TxId(inv.hash));
	} break;
	case MSG_BLOCK: {
	vote = WITH_LOCK(cs_main, return GetAvalancheVoteForBlock(
	BlockHash(inv.hash)));
	} break;
	case MSG_AVA_PROOF: {
	vote =
	getAvalancheVoteForProof(avalanche::ProofId(inv.hash));
	} break;
	default: {
	LogPrint(BCLog::AVALANCHE,
	"poll inv type unknown from peer=%d\n", inv.type);
	}
	}

	votes.emplace_back(vote, inv.hash);
	}

	// 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_pubkey.has_value() \|\|
	!(*pfrom.m_avalanche_pubkey)
	.VerifySchnorr(verifier.GetHash(), sig)) {
	Misbehaving(pfrom, 100, "invalid-ava-response-signature");
	return;
	}

	std::vector<avalanche::BlockUpdate> blockUpdates;
	std::vector<avalanche::ProofUpdate> proofUpdates;
	int banscore;
	std::string error;
	if (!g_avalanche->registerVotes(pfrom.GetId(), response, blockUpdates,
	proofUpdates, banscore, error)) {
	Misbehaving(pfrom, banscore, error);
	return;
	}

	pfrom.m_avalanche_state->invsVoted(response.GetVotes().size());

	auto logVoteUpdate = [](const auto &voteUpdate,
	const std::string &voteItemTypeStr,
	const auto &voteItemId) {
	std::string voteOutcome;
	switch (voteUpdate.getStatus()) {
	case avalanche::VoteStatus::Invalid:
	voteOutcome = "invalidated";
	break;
	case avalanche::VoteStatus::Rejected:
	voteOutcome = "rejected";
	break;
	case avalanche::VoteStatus::Accepted:
	voteOutcome = "accepted";
	break;
	case avalanche::VoteStatus::Finalized:
	voteOutcome = "finalized";
	break;
	case avalanche::VoteStatus::Stale:
	voteOutcome = "stalled";
	break;

	// No default case, so the compiler can warn about missing
	// cases
	}

	LogPrint(BCLog::AVALANCHE, "Avalanche %s %s %s\n", voteOutcome,
	voteItemTypeStr, voteItemId.ToString());
	};

	for (avalanche::ProofUpdate &u : proofUpdates) {
	avalanche::ProofRef proof = u.getVoteItem();
	const avalanche::ProofId &proofid = proof->getId();

	logVoteUpdate(u, "proof", proofid);

	auto rejectionMode = avalanche::PeerManager::RejectionMode::DEFAULT;
	auto nextCooldownTimePoint = GetTime<std::chrono::seconds>();
	switch (u.getStatus()) {
	case avalanche::VoteStatus::Invalid:
	WITH_LOCK(cs_invalidProofs, invalidProofs->insert(proofid));
	// Fallthrough
	case avalanche::VoteStatus::Stale:
	// Invalidate mode removes the proof from all proof pools
	rejectionMode =
	avalanche::PeerManager::RejectionMode::INVALIDATE;
	// Fallthrough
	case avalanche::VoteStatus::Rejected:
	if (!g_avalanche->withPeerManager(
	[&](avalanche::PeerManager &pm) {
	return pm.rejectProof(proofid, rejectionMode);
	})) {
	LogPrint(BCLog::AVALANCHE,
	"ERROR: Failed to reject proof: %s\n",
	proofid.GetHex());
	}
	break;
	case avalanche::VoteStatus::Finalized:
	nextCooldownTimePoint +=
	std::chrono::seconds(gArgs.GetIntArg(
	"-avalanchepeerreplacementcooldown",
	AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN));
	case avalanche::VoteStatus::Accepted:
	if (!g_avalanche->withPeerManager(
	[&](avalanche::PeerManager &pm) {
	pm.registerProof(
	proof, avalanche::PeerManager::
	RegistrationMode::FORCE_ACCEPT);
	return pm.forPeer(
	proofid, [&](const avalanche::Peer &peer) {
	pm.updateNextPossibleConflictTime(
	peer.peerid, nextCooldownTimePoint);
	if (u.getStatus() ==
	avalanche::VoteStatus::Finalized) {
	pm.setFinalized(peer.peerid);
	}
	// Only fail if the peer was not
	// created
	return true;
	});
	})) {
	LogPrint(BCLog::AVALANCHE,
	"ERROR: Failed to accept proof: %s\n",
	proofid.GetHex());
	}
	break;
	}
	}

	if (blockUpdates.size()) {
	for (avalanche::BlockUpdate &u : blockUpdates) {
	CBlockIndex *pindex = u.getVoteItem();

	logVoteUpdate(u, "block", pindex->GetBlockHash());

	switch (u.getStatus()) {
	case avalanche::VoteStatus::Invalid:
	case avalanche::VoteStatus::Rejected: {
	BlockValidationState state;
	m_chainman.ActiveChainstate().ParkBlock(config, state,
	pindex);
	if (!state.IsValid()) {
	LogPrintf("ERROR: Database error: %s\n",
	state.GetRejectReason());
	return;
	}
	} break;
	case avalanche::VoteStatus::Accepted: {
	LOCK(cs_main);
	m_chainman.ActiveChainstate().UnparkBlock(pindex);
	} break;
	case avalanche::VoteStatus::Finalized: {
	{
	LOCK(cs_main);
	m_chainman.ActiveChainstate().UnparkBlock(pindex);
	}
	m_chainman.ActiveChainstate().AvalancheFinalizeBlock(
	pindex);
	} break;
	case avalanche::VoteStatus::Stale:
	// Fall back on Nakamoto consensus in the absence of
	// Avalanche votes for other competing or descendant
	// blocks.
	break;
	}
	}

	BlockValidationState state;
	if (!m_chainman.ActiveChainstate().ActivateBestChain(config,
	state)) {
	LogPrintf("failed to activate chain (%s)\n", state.ToString());
	}
	}

	return;
	}

	if (msg_type == NetMsgType::AVAPROOF) {
	auto proof = RCUPtr<avalanche::Proof>::make();
	vRecv >> *proof;

	ReceivedAvalancheProof(pfrom, proof);

	return;
	}

	if (msg_type == NetMsgType::GETAVAPROOFS) {
	if (pfrom.m_proof_relay == nullptr) {
	return;
	}

	pfrom.m_proof_relay->lastSharedProofsUpdate =
	GetTime<std::chrono::seconds>();

	pfrom.m_proof_relay->sharedProofs =
	g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
	return pm.getShareableProofsSnapshot();
	});

	avalanche::CompactProofs compactProofs(
	pfrom.m_proof_relay->sharedProofs);
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::AVAPROOFS, compactProofs));

	return;
	}

	if (msg_type == NetMsgType::AVAPROOFS) {
	if (pfrom.m_proof_relay == nullptr) {
	return;
	}

	// Only process the compact proofs if we requested them
	if (!pfrom.m_proof_relay->compactproofs_requested) {
	LogPrint(BCLog::AVALANCHE, "Ignoring unsollicited avaproofs\n");
	return;
	}
	pfrom.m_proof_relay->compactproofs_requested = false;

	avalanche::CompactProofs compactProofs;
	try {
	vRecv >> compactProofs;
	} catch (std::ios_base::failure &e) {
	// This compact proofs have non contiguous or overflowing indexes
	Misbehaving(pfrom, 100, "avaproofs-bad-indexes");
	return;
	}

	// If there are prefilled proofs, process them first
	std::set<uint32_t> prefilledIndexes;
	for (const auto &prefilledProof : compactProofs.getPrefilledProofs()) {
	if (!ReceivedAvalancheProof(pfrom, prefilledProof.proof)) {
	// If we got an invalid proof, the peer is getting banned and we
	// can bail out.
	return;
	}
	}

	// If there is no shortid, avoid parsing/responding/accounting for the
	// message.
	if (compactProofs.getShortIDs().size() == 0) {
	LogPrint(BCLog::AVALANCHE,
	"Got an avaproofs message with no shortid (peer %d)\n",
	pfrom.GetId());
	return;
	}

	// To determine the chance that the number of entries in a bucket
	// exceeds N, we use the fact that the number of elements in a single
	// bucket is binomially distributed (with n = the number of shorttxids
	// S, and p = 1 / the number of buckets), that in the worst case the
	// number of buckets is equal to S (due to std::unordered_map having a
	// default load factor of 1.0), and that the chance for any bucket to
	// exceed N elements is at most buckets * (the chance that any given
	// bucket is above N elements). Thus:
	// P(max_elements_per_bucket > N) <=
	// S * (1 - cdf(binomial(n=S,p=1/S), N))
	// If we assume up to 21000000, allowing 15 elements per bucket should
	// only fail once per ~2.5 million avaproofs transfers (per peer and
	// connection).
	// TODO re-evaluate the bucket count to a more realistic value.
	// TODO: In the case of a shortid-collision, we should request all the
	// proofs which collided. For now, we only request one, which is not
	// that bad considering this event is expected to be very rare.
	auto shortIdProcessor =
	avalanche::ProofShortIdProcessor(compactProofs.getPrefilledProofs(),
	compactProofs.getShortIDs(), 15);

	if (shortIdProcessor.hasOutOfBoundIndex()) {
	// This should be catched by deserialization, but catch it here as
	// well as a good measure.
	Misbehaving(pfrom, 100, "avaproofs-bad-indexes");
	return;
	}
	if (!shortIdProcessor.isEvenlyDistributed()) {
	// This is suspicious, don't ban but bail out
	return;
	}

	const auto &proofs =
	g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) {
	return pm.getShareableProofsSnapshot();
	});

	size_t proofCount = 0;
	proofs.forEachLeaf([&](const avalanche::ProofRef &proof) {
	uint64_t shortid = compactProofs.getShortID(proof->getId());

	proofCount += shortIdProcessor.matchKnownItem(shortid, proof);

	// Though ideally we'd continue scanning for the
	// two-proofs-match-shortid case, the performance win of an early
	// exit here is too good to pass up and worth the extra risk.
	return proofCount != shortIdProcessor.getShortIdCount();
	});

	avalanche::ProofsRequest req;
	for (size_t i = 0; i < compactProofs.size(); i++) {
	if (shortIdProcessor.getItem(i) == nullptr) {
	req.indices.push_back(i);
	}
	}

	m_connman.PushMessage(&pfrom,
	msgMaker.Make(NetMsgType::AVAPROOFSREQ, req));

	// We want to keep a count of how many nodes we successfully requested
	// avaproofs from as this is used to determine when we are confident our
	// quorum is close enough to the other participants.
	g_avalanche->avaproofsSent(pfrom.GetId());

	return;
	}

	if (msg_type == NetMsgType::AVAPROOFSREQ) {
	if (pfrom.m_proof_relay == nullptr) {
	return;
	}

	avalanche::ProofsRequest proofreq;
	vRecv >> proofreq;

	auto requestedIndiceIt = proofreq.indices.begin();
	uint32_t treeIndice = 0;
	pfrom.m_proof_relay->sharedProofs.forEachLeaf([&](const auto &proof) {
	if (requestedIndiceIt == proofreq.indices.end()) {
	// No more indice to process
	return false;
	}

	if (treeIndice++ == *requestedIndiceIt) {
	m_connman.PushMessage(
	&pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof));
	requestedIndiceIt++;
	}

	return true;
	});

	pfrom.m_proof_relay->sharedProofs = {};
	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 %s connection. peer=%d\n",
	pfrom.ConnectionTypeAsString(), pfrom.GetId());
	return;
	}

	// Since this must be an inbound connection, SetupAddressRelay will
	// never fail.
	Assume(SetupAddressRelay(pfrom, *peer));

	// Only send one GetAddr response per connection to reduce resource
	// waste and discourage addr stamping of INV announcements.
	if (peer->m_getaddr_recvd) {
	LogPrint(BCLog::NET, "Ignoring repeated \"getaddr\". peer=%d\n",
	pfrom.GetId());
	return;
	}
	peer->m_getaddr_recvd = true;

	peer->m_addrs_to_send.clear();
	std::vector<CAddress> vAddr;
	const size_t maxAddrToSend = GetMaxAddrToSend();
	if (pfrom.HasPermission(PF_ADDR)) {
	vAddr = m_connman.GetAddresses(maxAddrToSend, MAX_PCT_ADDR_TO_SEND,
	/* network */ std::nullopt);
	} else {
	vAddr = m_connman.GetAddresses(pfrom, maxAddrToSend,
	MAX_PCT_ADDR_TO_SEND);
	}
	FastRandomContext insecure_rand;
	for (const CAddress &addr : vAddr) {
	PushAddress(*peer, addr, insecure_rand);
	}
	return;
	}

	if (msg_type == NetMsgType::GETAVAADDR) {
	auto now = GetTime<std::chrono::seconds>();
	if (now < pfrom.m_nextGetAvaAddr) {
	// Prevent a peer from exhausting our resources by spamming
	// getavaaddr messages.
	LogPrint(BCLog::AVALANCHE,
	"Ignoring repeated getavaaddr from peer %d\n",
	pfrom.GetId());
	return;
	}

	// Only accept a getavaaddr every GETAVAADDR_INTERVAL at most
	pfrom.m_nextGetAvaAddr = now + GETAVAADDR_INTERVAL;

	if (!SetupAddressRelay(pfrom, *peer)) {
	LogPrint(BCLog::AVALANCHE,
	"Ignoring getavaaddr message from %s peer=%d\n",
	pfrom.ConnectionTypeAsString(), pfrom.GetId());
	return;
	}

	auto availabilityScoreComparator = [](const CNode *lhs,
	const CNode *rhs) {
	double scoreLhs = lhs->m_avalanche_state->getAvailabilityScore();
	double scoreRhs = rhs->m_avalanche_state->getAvailabilityScore();

	if (scoreLhs != scoreRhs) {
	return scoreLhs > scoreRhs;
	}

	return lhs < rhs;
	};

	// Get up to MAX_ADDR_TO_SEND addresses of the nodes which are the
	// most active in the avalanche network. Account for 0 availability as
	// well so we can send addresses even if we did not start polling yet.
	std::set<const CNode *, decltype(availabilityScoreComparator)> avaNodes(
	availabilityScoreComparator);
	m_connman.ForEachNode([&](const CNode *pnode) {
	if (pnode && pnode->m_avalanche_state &&
	!(pnode->m_avalanche_state->getAvailabilityScore() < 0.)) {
	avaNodes.insert(pnode);
	if (avaNodes.size() > GetMaxAddrToSend()) {
	avaNodes.erase(std::prev(avaNodes.end()));
	}
	}
	});

	peer->m_addrs_to_send.clear();
	FastRandomContext insecure_rand;
	for (const CNode *pnode : avaNodes) {
	PushAddress(*peer, pnode->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 (peer->m_ping_nonce_sent != 0) {
	if (nonce == peer->m_ping_nonce_sent) {
	// Matching pong received, this ping is no longer
	// outstanding
	bPingFinished = true;
	const auto ping_time = ping_end - peer->m_ping_start.load();
	if (ping_time.count() >= 0) {
	// Let connman know about this successful ping-pong
	pfrom.PongReceived(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, peer->m_ping_nonce_sent, nonce,
	nAvail);
	}
	if (bPingFinished) {
	peer->m_ping_nonce_sent = 0;
	}
	return;
	}

	if (msg_type == NetMsgType::FILTERLOAD) {
	if (!(pfrom.GetLocalServices() & NODE_BLOOM)) {
	LogPrint(BCLog::NET,
	"filterload received despite not offering bloom services "
	"from peer=%d; disconnecting\n",
	pfrom.GetId());
	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)) {
	LogPrint(BCLog::NET,
	"filteradd received despite not offering bloom services "
	"from peer=%d; disconnecting\n",
	pfrom.GetId());
	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)) {
	LogPrint(BCLog::NET,
	"filterclear received despite not offering bloom services "
	"from peer=%d; disconnecting\n",
	pfrom.GetId());
	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 PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode &pnode, Peer &peer) {
	{
	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.m_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.m_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.m_id);
	pnode.fDisconnect = true;
	return true;
	}

	// Normal case: Disconnect the peer and discourage all nodes sharing the
	// address
	LogPrint(BCLog::NET, "Disconnecting and discouraging peer %d!\n",
	peer.m_id);
	if (m_banman) {
	m_banman->Discourage(pnode.addr);
	}
	m_connman.DisconnectNode(pnode.addr);
	return true;
	}

	bool PeerManagerImpl::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;

	PeerRef peer = GetPeerRef(pfrom->GetId());
	if (peer == nullptr) {
	return false;
	}

	{
	LOCK(peer->m_getdata_requests_mutex);
	if (!peer->m_getdata_requests.empty()) {
	ProcessGetData(config, pfrom, peer, interruptMsgProc);
	}
	}

	{
	LOCK2(cs_main, g_cs_orphans);
	if (!peer->m_orphan_work_set.empty()) {
	ProcessOrphanTx(config, peer->m_orphan_work_set);
	}
	}

	if (pfrom->fDisconnect) {
	return false;
	}

	// this maintains the order of responses and prevents m_getdata_requests
	// from growing unbounded
	{
	LOCK(peer->m_getdata_requests_mutex);
	if (!peer->m_getdata_requests.empty()) {
	return true;
	}
	}

	{
	LOCK(g_cs_orphans);
	if (!peer->m_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;
	}

	{
	LOCK(peer->m_getdata_requests_mutex);
	if (!peer->m_getdata_requests.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 PeerManagerImpl::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 >=
	m_chainman.ActiveChain().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 = m_chainman.ActiveChain().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,
	m_chainman.ActiveChain().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 PeerManagerImpl::EvictExtraOutboundPeers(std::chrono::seconds now) {
	// If we have any extra block-relay-only peers, disconnect the youngest
	// unless it's given us a block -- in which case, compare with the
	// second-youngest, and out of those two, disconnect the peer who least
	// recently gave us a block.
	// The youngest block-relay-only peer would be the extra peer we connected
	// to temporarily in order to sync our tip; see net.cpp.
	// Note that we use higher nodeid as a measure for most recent connection.
	if (m_connman.GetExtraBlockRelayCount() > 0) {
	std::pair<NodeId, std::chrono::seconds> youngest_peer{-1, 0},
	next_youngest_peer{-1, 0};

	m_connman.ForEachNode([&](CNode *pnode) {
	if (!pnode->IsBlockOnlyConn() \|\| pnode->fDisconnect) {
	return;
	}
	if (pnode->GetId() > youngest_peer.first) {
	next_youngest_peer = youngest_peer;
	youngest_peer.first = pnode->GetId();
	youngest_peer.second = pnode->m_last_block_time;
	}
	});

	NodeId to_disconnect = youngest_peer.first;
	if (youngest_peer.second > next_youngest_peer.second) {
	// Our newest block-relay-only peer gave us a block more recently;
	// disconnect our second youngest.
	to_disconnect = next_youngest_peer.first;
	}

	m_connman.ForNode(
	to_disconnect,
	[&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
	AssertLockHeld(::cs_main);
	// Make sure we're not getting a block right now, and that we've
	// been connected long enough for this eviction to happen at
	// all. Note that we only request blocks from a peer if we learn
	// of a valid headers chain with at least as much work as our
	// tip.
	CNodeState *node_state = State(pnode->GetId());
	if (node_state == nullptr \|\|
	(now - pnode->m_connected >= MINIMUM_CONNECT_TIME &&
	node_state->nBlocksInFlight == 0)) {
	pnode->fDisconnect = true;
	LogPrint(BCLog::NET,
	"disconnecting extra block-relay-only peer=%d "
	"(last block received at time %d)\n",
	pnode->GetId(),
	count_seconds(pnode->m_last_block_time));
	return true;
	} else {
	LogPrint(
	BCLog::NET,
	"keeping block-relay-only peer=%d chosen for eviction "
	"(connect time: %d, blocks_in_flight: %d)\n",
	pnode->GetId(), count_seconds(pnode->m_connected),
	node_state->nBlocksInFlight);
	}
	return false;
	});
	}

	// Check whether we have too many OUTBOUND_FULL_RELAY peers
	if (m_connman.GetExtraFullOutboundCount() <= 0) {
	return;
	}

	// If we have more OUTBOUND_FULL_RELAY peers than we target, disconnect one.
	// Pick the OUTBOUND_FULL_RELAY 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) EXCLUSIVE_LOCKS_REQUIRED(
	::cs_main) {
	AssertLockHeld(::cs_main);

	// Only consider OUTBOUND_FULL_RELAY peers that are not already marked
	// for disconnection
	if (!pnode->IsFullOutboundConn() \|\| 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;
	}
	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) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
	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 (now - pnode->m_connected > 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(), count_seconds(pnode->m_connected),
	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 PeerManagerImpl::CheckForStaleTipAndEvictPeers() {
	LOCK(cs_main);

	int64_t time_in_seconds = GetTime();

	EvictExtraOutboundPeers(std::chrono::seconds{time_in_seconds});

	if (time_in_seconds > m_stale_tip_check_time) {
	// 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()) {
	LogPrintf("Potential stale tip detected, will try using extra "
	"outbound peer (last tip update: %d seconds ago)\n",
	time_in_seconds - m_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;
	}

	if (!m_initial_sync_finished &&
	CanDirectFetch(m_chainparams.GetConsensus())) {
	m_connman.StartExtraBlockRelayPeers();
	m_initial_sync_finished = true;
	}
	}

	void PeerManagerImpl::MaybeSendPing(CNode &node_to, Peer &peer,
	std::chrono::microseconds now) {
	if (m_connman.ShouldRunInactivityChecks(
	node_to, std::chrono::duration_cast<std::chrono::seconds>(now)) &&
	peer.m_ping_nonce_sent &&
	now > peer.m_ping_start.load() + TIMEOUT_INTERVAL) {
	// The ping timeout is using mocktime. To disable the check during
	// testing, increase -peertimeout.
	LogPrint(BCLog::NET, "ping timeout: %fs peer=%d\n",
	0.000001 * count_microseconds(now - peer.m_ping_start.load()),
	peer.m_id);
	node_to.fDisconnect = true;
	return;
	}

	const CNetMsgMaker msgMaker(node_to.GetCommonVersion());
	bool pingSend = false;

	if (peer.m_ping_queued) {
	// RPC ping request by user
	pingSend = true;
	}

	if (peer.m_ping_nonce_sent == 0 &&
	now > peer.m_ping_start.load() + PING_INTERVAL) {
	// 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));
	}
	peer.m_ping_queued = false;
	peer.m_ping_start = now;
	if (node_to.GetCommonVersion() > BIP0031_VERSION) {
	peer.m_ping_nonce_sent = nonce;
	m_connman.PushMessage(&node_to,
	msgMaker.Make(NetMsgType::PING, nonce));
	} else {
	// Peer is too old to support ping command with nonce, pong will
	// never arrive.
	peer.m_ping_nonce_sent = 0;
	m_connman.PushMessage(&node_to, msgMaker.Make(NetMsgType::PING));
	}
	}
	}

	void PeerManagerImpl::MaybeSendAddr(CNode &node, Peer &peer,
	std::chrono::microseconds current_time) {
	// Nothing to do for non-address-relay peers
	if (!peer.m_addr_relay_enabled) {
	return;
	}

	LOCK(peer.m_addr_send_times_mutex);
	if (fListen && !m_chainman.ActiveChainstate().IsInitialBlockDownload() &&
	peer.m_next_local_addr_send < current_time) {
	// If we've sent before, clear the bloom filter for the peer, so
	// that our self-announcement will actually go out. This might
	// be unnecessary if the bloom filter has already rolled over
	// since our last self-announcement, but there is only a small
	// bandwidth cost that we can incur by doing this (which happens
	// once a day on average).
	if (peer.m_next_local_addr_send != 0us) {
	peer.m_addr_known->reset();
	}
	if (std::optional<CAddress> local_addr = GetLocalAddrForPeer(&node)) {
	FastRandomContext insecure_rand;
	PushAddress(peer, *local_addr, insecure_rand);
	}
	peer.m_next_local_addr_send =
	PoissonNextSend(current_time, AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL);
	}

	// We sent an `addr` message to this peer recently. Nothing more to do.
	if (current_time <= peer.m_next_addr_send) {
	return;
	}

	peer.m_next_addr_send =
	PoissonNextSend(current_time, AVG_ADDRESS_BROADCAST_INTERVAL);

	const size_t max_addr_to_send = GetMaxAddrToSend();
	if (!Assume(peer.m_addrs_to_send.size() <= max_addr_to_send)) {
	// Should be impossible since we always check size before adding to
	// m_addrs_to_send. Recover by trimming the vector.
	peer.m_addrs_to_send.resize(max_addr_to_send);
	}

	// Remove addr records that the peer already knows about, and add new
	// addrs to the m_addr_known filter on the same pass.
	auto addr_already_known = [&peer](const CAddress &addr) {
	bool ret = peer.m_addr_known->contains(addr.GetKey());
	if (!ret) {
	peer.m_addr_known->insert(addr.GetKey());
	}
	return ret;
	};
	peer.m_addrs_to_send.erase(std::remove_if(peer.m_addrs_to_send.begin(),
	peer.m_addrs_to_send.end(),
	addr_already_known),
	peer.m_addrs_to_send.end());

	// No addr messages to send
	if (peer.m_addrs_to_send.empty()) {
	return;
	}

	const char *msg_type;
	int make_flags;
	if (peer.m_wants_addrv2) {
	msg_type = NetMsgType::ADDRV2;
	make_flags = ADDRV2_FORMAT;
	} else {
	msg_type = NetMsgType::ADDR;
	make_flags = 0;
	}
	m_connman.PushMessage(
	&node, CNetMsgMaker(node.GetCommonVersion())
	.Make(make_flags, msg_type, peer.m_addrs_to_send));
	peer.m_addrs_to_send.clear();

	// we only send the big addr message once
	if (peer.m_addrs_to_send.capacity() > 40) {
	peer.m_addrs_to_send.shrink_to_fit();
	}
	}

	void PeerManagerImpl::MaybeSendFeefilter(
	CNode &pto, std::chrono::microseconds current_time) {
	if (m_ignore_incoming_txs) {
	return;
	}
	if (!pto.m_tx_relay) {
	return;
	}
	if (pto.GetCommonVersion() < FEEFILTER_VERSION) {
	return;
	}
	// peers with the forcerelay permission should not filter txs to us
	if (pto.HasPermission(PF_FORCERELAY)) {
	return;
	}

	Amount currentFilter =
	m_mempool
	.GetMinFee(
	gArgs.GetIntArg("-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->m_next_send_feefilter = 0us;
	}
	}
	if (current_time > pto.m_tx_relay->m_next_send_feefilter) {
	Amount filterToSend = g_filter_rounder.round(currentFilter);
	// We always have a fee filter of at least minRelayTxFee
	filterToSend = std::max(filterToSend, ::minRelayTxFee.GetFeePerK());
	if (filterToSend != pto.m_tx_relay->lastSentFeeFilter) {
	m_connman.PushMessage(
	&pto, CNetMsgMaker(pto.GetCommonVersion())
	.Make(NetMsgType::FEEFILTER, filterToSend));
	pto.m_tx_relay->lastSentFeeFilter = filterToSend;
	}
	pto.m_tx_relay->m_next_send_feefilter =
	PoissonNextSend(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 (current_time + MAX_FEEFILTER_CHANGE_DELAY <
	pto.m_tx_relay->m_next_send_feefilter &&
	(currentFilter < 3 * pto.m_tx_relay->lastSentFeeFilter / 4 \|\|
	currentFilter > 4 * pto.m_tx_relay->lastSentFeeFilter / 3)) {
	pto.m_tx_relay->m_next_send_feefilter =
	current_time + GetRandomDuration<std::chrono::microseconds>(
	MAX_FEEFILTER_CHANGE_DELAY);
	}
	}

	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 PeerManagerImpl::SetupAddressRelay(CNode &node, Peer &peer) {
	// We don't participate in addr relay with outbound block-relay-only
	// connections to prevent providing adversaries with the additional
	// information of addr traffic to infer the link.
	if (node.IsBlockOnlyConn()) {
	return false;
	}

	if (!peer.m_addr_relay_enabled.exchange(true)) {
	// First addr message we have received from the peer, initialize
	// m_addr_known
	peer.m_addr_known = std::make_unique<CRollingBloomFilter>(5000, 0.001);
	}

	return true;
	}

	bool PeerManagerImpl::SendMessages(const Config &config, CNode *pto) {
	PeerRef peer = GetPeerRef(pto->GetId());
	if (!peer) {
	return false;
	}
	const Consensus::Params &consensusParams = m_chainparams.GetConsensus();

	// We must call MaybeDiscourageAndDisconnect first, to ensure that we'll
	// disconnect misbehaving peers even before the version handshake is
	// complete.
	if (MaybeDiscourageAndDisconnect(pto, peer)) {
	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());

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

	if (pto->IsAddrFetchConn() &&
	current_time - pto->m_connected > 10 * AVG_ADDRESS_BROADCAST_INTERVAL) {
	LogPrint(BCLog::NET,
	"addrfetch connection timeout; disconnecting peer=%d\n",
	pto->GetId());
	pto->fDisconnect = true;
	return true;
	}

	MaybeSendPing(pto, peer, current_time);

	// MaybeSendPing may have marked peer for disconnection
	if (pto->fDisconnect) {
	return true;
	}

	bool fFetch;

	MaybeSendAddr(pto, peer, current_time);

	{
	LOCK(cs_main);

	CNodeState &state = *State(pto->GetId());

	// Start block sync
	if (pindexBestHeader == nullptr) {
	pindexBestHeader = m_chainman.ActiveChain().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.m_headers_sync_timeout =
	current_time + HEADERS_DOWNLOAD_TIMEOUT_BASE +
	(
	// Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to
	// microseconds before scaling to maintain precision
	std::chrono::microseconds{
	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(),
	peer->m_starting_height);
	m_connman.PushMessage(
	pto, msgMaker.Make(
	NetMsgType::GETHEADERS,
	m_chainman.ActiveChain().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(peer->m_block_inv_mutex);
	std::vector<CBlock> vHeaders;
	bool fRevertToInv =
	((!state.fPreferHeaders &&
	(!state.fPreferHeaderAndIDs \|\|
	peer->m_blocks_for_headers_relay.size() > 1)) \|\|
	peer->m_blocks_for_headers_relay.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 m_chainman.ActiveChain(), give up.
	for (const BlockHash &hash : peer->m_blocks_for_headers_relay) {
	const CBlockIndex *pindex =
	m_chainman.m_blockman.LookupBlockIndex(hash);
	assert(pindex);
	if (m_chainman.ActiveChain()[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
	// m_blocks_for_headers_relay. 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 m_blocks_for_headers_relay was our tip at some
	// point in the past.
	if (!peer->m_blocks_for_headers_relay.empty()) {
	const BlockHash &hashToAnnounce =
	peer->m_blocks_for_headers_relay.back();
	const CBlockIndex *pindex =
	m_chainman.m_blockman.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 (m_chainman.ActiveChain()[pindex->nHeight] != pindex) {
	LogPrint(
	BCLog::NET,
	"Announcing block %s not on main chain (tip=%s)\n",
	hashToAnnounce.ToString(),
	m_chainman.ActiveChain()
	.Tip()
	->GetBlockHash()
	.ToString());
	}

	// If the peer's chain has this block, don't inv it back.
	if (!PeerHasHeader(&state, pindex)) {
	peer->m_blocks_for_inv_relay.push_back(hashToAnnounce);
	LogPrint(BCLog::NET,
	"%s: sending inv peer=%d hash=%s\n", __func__,
	pto->GetId(), hashToAnnounce.ToString());
	}
	}
	}
	peer->m_blocks_for_headers_relay.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();
	}
	};

	{
	LOCK(cs_main);

	{
	LOCK(peer->m_block_inv_mutex);

	vInv.reserve(std::max<size_t>(peer->m_blocks_for_inv_relay.size(),
	INVENTORY_BROADCAST_MAX_PER_MB *
	config.GetMaxBlockSize() /
	1000000));

	// Add blocks
	for (const BlockHash &hash : peer->m_blocks_for_inv_relay) {
	addInvAndMaybeFlush(MSG_BLOCK, hash);
	}
	peer->m_blocks_for_inv_relay.clear();
	}

	auto computeNextInvSendTime =
	[&](std::chrono::microseconds &next) -> bool {
	bool fSendTrickle = pto->HasPermission(PF_NOBAN);

	if (next < current_time) {
	fSendTrickle = true;
	if (pto->IsInboundConn()) {
	next = m_connman.PoissonNextSendInbound(
	current_time, INBOUND_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);
	State(pto->GetId())
	->m_recently_announced_proofs.insert(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 =
	std::chrono::duration_cast<std::chrono::seconds>(
	current_time);
	}

	// 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 (!g_relay_expiration.empty() &&
	g_relay_expiration.front().first <
	current_time) {
	mapRelay.erase(g_relay_expiration.front().second);
	g_relay_expiration.pop_front();
	}

	auto ret = mapRelay.insert(
	std::make_pair(txid, std::move(txinfo.tx)));
	if (ret.second) {
	g_relay_expiration.push_back(std::make_pair(
	current_time + RELAY_TX_CACHE_TIME, ret.first));
	}
	}
	pto->m_tx_relay->filterInventoryKnown.insert(txid);
	}
	}
	}
	} // release cs_main

	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
	if (state.m_stalling_since.count() &&
	state.m_stalling_since < current_time - 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
	// block_interval * (1 + 0.5 * N) (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 (current_time >
	state.m_downloading_since +
	std::chrono::seconds{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.m_headers_sync_timeout < std::chrono::microseconds::max()) {
	// Detect whether this is a stalling initial-headers-sync peer
	if (pindexBestHeader->GetBlockTime() <=
	GetAdjustedTime() - 24 * 60 * 60) {
	if (current_time > state.m_headers_sync_timeout &&
	nSyncStarted == 1 &&
	(nPreferredDownload - state.fPreferredDownload >= 1)) {
	// Disconnect a peer (without the noban permission) 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 noban "
	"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.m_headers_sync_timeout = 0us;
	}
	}
	} else {
	// After we've caught up once, reset the timeout so we can't
	// trigger disconnect later.
	state.m_headers_sync_timeout = std::chrono::microseconds::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) \|\|
	!m_chainman.ActiveChainstate().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);
	for (const CBlockIndex *pindex : vToDownload) {
	vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
	MarkBlockAsInFlight(config, pto->GetId(),
	pindex->GetBlockHash(), 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)->m_stalling_since == 0us) {
	State(staller)->m_stalling_since = 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::AVALANCHE,
	"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 proof 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)) {
	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));
	}

	} // release cs_main
	MaybeSendFeefilter(*pto, current_time);
	return true;
	}

	bool PeerManagerImpl::ReceivedAvalancheProof(CNode &peer,
	const avalanche::ProofRef &proof) {
	assert(proof != nullptr);

	const avalanche::ProofId &proofid = proof->getId();

	peer.AddKnownProof(proofid);

	if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) {
	// We cannot reliably verify proofs during IBD, so bail out early and
	// keep the inventory as pending so it can be requested when the node
	// has synced.
	return true;
	}

	const NodeId nodeid = peer.GetId();

	{
	LOCK(cs_proofrequest);
	m_proofrequest.ReceivedResponse(nodeid, proofid);

	if (AlreadyHaveProof(proofid)) {
	m_proofrequest.ForgetInvId(proofid);
	return true;
	}
	}

	// registerProof should not be called while cs_proofrequest because it
	// holds cs_main and that creates a potential deadlock during shutdown

	avalanche::ProofRegistrationState state;
	if (g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
	return pm.registerProof(proof, state);
	})) {
	WITH_LOCK(cs_proofrequest, m_proofrequest.ForgetInvId(proofid));
	RelayProof(proofid);

	peer.m_last_proof_time = GetTime<std::chrono::seconds>();

	LogPrint(BCLog::NET, "New avalanche proof: peer=%d, proofid %s\n",
	nodeid, proofid.ToString());
	}

	if (state.GetResult() == avalanche::ProofRegistrationResult::INVALID) {
	WITH_LOCK(cs_invalidProofs, invalidProofs->insert(proofid));
	Misbehaving(nodeid, 100, state.GetRejectReason());
	return false;
	}

	if (state.GetResult() == avalanche::ProofRegistrationResult::MISSING_UTXO) {
	// This is possible that a proof contains a utxo we don't know yet, so
	// don't ban for this.
	return false;
	}

	if (!g_avalanche->addProofToReconcile(proof)) {
	LogPrint(BCLog::AVALANCHE,
	"Not polling the avalanche proof (%s): peer=%d, proofid %s\n",
	state.IsValid() ? "not-worth-polling"
	: state.GetRejectReason(),
	nodeid, proofid.ToString());
	}

	return true;
	}
	diff --git a/src/netaddress.cpp b/src/netaddress.cpp
	index be10d4869..985c188e2 100644
	--- a/src/netaddress.cpp
	+++ b/src/netaddress.cpp
	@@ -1,1229 +1,1222 @@
	// 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 <netaddress.h>

	#include <crypto/common.h>
	#include <crypto/sha3.h>
	#include <hash.h>
	#include <prevector.h>
	#include <util/asmap.h>
	#include <util/strencodings.h>
	#include <util/string.h>

	#include <tinyformat.h>

	#include <algorithm>
	#include <array>
	#include <cstdint>
	#include <ios>
	#include <iterator>
	#include <tuple>

	constexpr size_t CNetAddr::V1_SERIALIZATION_SIZE;
	constexpr size_t CNetAddr::MAX_ADDRV2_SIZE;

	CNetAddr::BIP155Network CNetAddr::GetBIP155Network() const {
	switch (m_net) {
	case NET_IPV4:
	return BIP155Network::IPV4;
	case NET_IPV6:
	return BIP155Network::IPV6;
	case NET_ONION:
	switch (m_addr.size()) {
	case ADDR_TORV2_SIZE:
	return BIP155Network::TORV2;
	case ADDR_TORV3_SIZE:
	return BIP155Network::TORV3;
	default:
	assert(false);
	}
	case NET_I2P:
	return BIP155Network::I2P;
	case NET_CJDNS:
	return BIP155Network::CJDNS;
	case NET_INTERNAL:
	// should have been handled before calling this function
	case NET_UNROUTABLE:
	// m_net is never and should not be set to NET_UNROUTABLE
	case NET_MAX:
	// m_net is never and should not be set to NET_MAX
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	bool CNetAddr::SetNetFromBIP155Network(uint8_t possible_bip155_net,
	size_t address_size) {
	switch (possible_bip155_net) {
	case BIP155Network::IPV4:
	if (address_size == ADDR_IPV4_SIZE) {
	m_net = NET_IPV4;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 IPv4 address with length %u (should be %u)",
	address_size, ADDR_IPV4_SIZE));
	case BIP155Network::IPV6:
	if (address_size == ADDR_IPV6_SIZE) {
	m_net = NET_IPV6;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 IPv6 address with length %u (should be %u)",
	address_size, ADDR_IPV6_SIZE));
	case BIP155Network::TORV2:
	if (address_size == ADDR_TORV2_SIZE) {
	m_net = NET_ONION;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 TORv2 address with length %u (should be %u)",
	address_size, ADDR_TORV2_SIZE));
	case BIP155Network::TORV3:
	if (address_size == ADDR_TORV3_SIZE) {
	m_net = NET_ONION;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 TORv3 address with length %u (should be %u)",
	address_size, ADDR_TORV3_SIZE));
	case BIP155Network::I2P:
	if (address_size == ADDR_I2P_SIZE) {
	m_net = NET_I2P;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 I2P address with length %u (should be %u)",
	address_size, ADDR_I2P_SIZE));
	case BIP155Network::CJDNS:
	if (address_size == ADDR_CJDNS_SIZE) {
	m_net = NET_CJDNS;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 CJDNS address with length %u (should be %u)",
	address_size, ADDR_CJDNS_SIZE));
	}

	// Don't throw on addresses with unknown network ids (maybe from the
	// future). Instead silently drop them and have the unserialization code
	// consume subsequent ones which may be known to us.
	return false;
	}

	/**
	* Construct an unspecified IPv6 network address (::/128).
	*
	* @note This address is considered invalid by CNetAddr::IsValid()
	*/
	CNetAddr::CNetAddr() {}

	void CNetAddr::SetIP(const CNetAddr &ipIn) {
	// Size check.
	switch (ipIn.m_net) {
	case NET_IPV4:
	assert(ipIn.m_addr.size() == ADDR_IPV4_SIZE);
	break;
	case NET_IPV6:
	assert(ipIn.m_addr.size() == ADDR_IPV6_SIZE);
	break;
	case NET_ONION:
	assert(ipIn.m_addr.size() == ADDR_TORV2_SIZE \|\|
	ipIn.m_addr.size() == ADDR_TORV3_SIZE);
	break;
	case NET_I2P:
	assert(ipIn.m_addr.size() == ADDR_I2P_SIZE);
	break;
	case NET_CJDNS:
	assert(ipIn.m_addr.size() == ADDR_CJDNS_SIZE);
	break;
	case NET_INTERNAL:
	assert(ipIn.m_addr.size() == ADDR_INTERNAL_SIZE);
	break;
	case NET_UNROUTABLE:
	case NET_MAX:
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	m_net = ipIn.m_net;
	m_addr = ipIn.m_addr;
	}

	void CNetAddr::SetLegacyIPv6(Span<const uint8_t> ipv6) {
	assert(ipv6.size() == ADDR_IPV6_SIZE);

	size_t skip{0};

	if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
	// IPv4-in-IPv6
	m_net = NET_IPV4;
	skip = sizeof(IPV4_IN_IPV6_PREFIX);
	} else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
	// TORv2-in-IPv6
	m_net = NET_ONION;
	skip = sizeof(TORV2_IN_IPV6_PREFIX);
	} else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
	// Internal-in-IPv6
	m_net = NET_INTERNAL;
	skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
	} else {
	// IPv6
	m_net = NET_IPV6;
	}

	m_addr.assign(ipv6.begin() + skip, ipv6.end());
	}

	/**
	* Create an "internal" address that represents a name or FQDN. AddrMan uses
	* these fake addresses to keep track of which DNS seeds were used.
	* @returns Whether or not the operation was successful.
	* @see NET_INTERNAL, INTERNAL_IN_IPV6_PREFIX, CNetAddr::IsInternal(),
	* CNetAddr::IsRFC4193()
	*/
	bool CNetAddr::SetInternal(const std::string &name) {
	if (name.empty()) {
	return false;
	}
	m_net = NET_INTERNAL;
	uint8_t hash[32] = {};
	CSHA256().Write((const uint8_t *)name.data(), name.size()).Finalize(hash);
	m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
	return true;
	}

	namespace torv3 {
	// https://gitweb.torproject.org/torspec.git/tree/rend-spec-v3.txt#n2135
	static constexpr size_t CHECKSUM_LEN = 2;
	static const uint8_t VERSION[] = {3};
	static constexpr size_t TOTAL_LEN =
	ADDR_TORV3_SIZE + CHECKSUM_LEN + sizeof(VERSION);

	static void Checksum(Span<const uint8_t> addr_pubkey,
	uint8_t (&checksum)[CHECKSUM_LEN]) {
	// TORv3 CHECKSUM = H(".onion checksum" \| PUBKEY \| VERSION)[:2]
	static const uint8_t prefix[] = ".onion checksum";
	static constexpr size_t prefix_len = 15;

	SHA3_256 hasher;

	hasher.Write(MakeSpan(prefix).first(prefix_len));
	hasher.Write(addr_pubkey);
	hasher.Write(VERSION);

	uint8_t checksum_full[SHA3_256::OUTPUT_SIZE];

	hasher.Finalize(checksum_full);

	memcpy(checksum, checksum_full, sizeof(checksum));
	}

	}; // namespace torv3

	bool CNetAddr::SetSpecial(const std::string &addr) {
	if (!ValidAsCString(addr)) {
	return false;
	}

	if (SetTor(addr)) {
	return true;
	}

	if (SetI2P(addr)) {
	return true;
	}

	return false;
	}

	bool CNetAddr::SetTor(const std::string &addr) {
	static const char *suffix{".onion"};
	static constexpr size_t suffix_len{6};

	if (addr.size() <= suffix_len \|\|
	addr.substr(addr.size() - suffix_len) != suffix) {
	return false;
	}

	bool invalid;
	const auto &input = DecodeBase32(
	addr.substr(0, addr.size() - suffix_len).c_str(), &invalid);

	if (invalid) {
	return false;
	}

	switch (input.size()) {
	case ADDR_TORV2_SIZE:
	m_net = NET_ONION;
	m_addr.assign(input.begin(), input.end());
	return true;
	case torv3::TOTAL_LEN: {
	Span<const uint8_t> input_pubkey{input.data(), ADDR_TORV3_SIZE};
	Span<const uint8_t> input_checksum{input.data() + ADDR_TORV3_SIZE,
	torv3::CHECKSUM_LEN};
	Span<const uint8_t> input_version{input.data() + ADDR_TORV3_SIZE +
	torv3::CHECKSUM_LEN,
	sizeof(torv3::VERSION)};

	if (input_version != torv3::VERSION) {
	return false;
	}

	uint8_t calculated_checksum[torv3::CHECKSUM_LEN];
	torv3::Checksum(input_pubkey, calculated_checksum);

	if (input_checksum != calculated_checksum) {
	return false;
	}

	m_net = NET_ONION;
	m_addr.assign(input_pubkey.begin(), input_pubkey.end());
	return true;
	}
	}

	return false;
	}

	bool CNetAddr::SetI2P(const std::string &addr) {
	// I2P addresses that we support consist of 52 base32 characters +
	// ".b32.i2p".
	static constexpr size_t b32_len{52};
	static const char *suffix{".b32.i2p"};
	static constexpr size_t suffix_len{8};

	if (addr.size() != b32_len + suffix_len \|\|
	ToLower(addr.substr(b32_len)) != suffix) {
	return false;
	}

	// Remove the ".b32.i2p" suffix and pad to a multiple of 8 chars, so
	// DecodeBase32() can decode it.
	const std::string b32_padded = addr.substr(0, b32_len) + "====";

	bool invalid;
	const auto &address_bytes = DecodeBase32(b32_padded.c_str(), &invalid);

	if (invalid \|\| address_bytes.size() != ADDR_I2P_SIZE) {
	return false;
	}

	m_net = NET_I2P;
	m_addr.assign(address_bytes.begin(), address_bytes.end());

	return true;
	}

	CNetAddr::CNetAddr(const struct in_addr &ipv4Addr) {
	m_net = NET_IPV4;
	const uint8_t ptr = reinterpret_cast<const uint8_t >(&ipv4Addr);
	m_addr.assign(ptr, ptr + ADDR_IPV4_SIZE);
	}

	CNetAddr::CNetAddr(const struct in6_addr &ipv6Addr, const uint32_t scope) {
	SetLegacyIPv6(Span<const uint8_t>(
	reinterpret_cast<const uint8_t *>(&ipv6Addr), sizeof(ipv6Addr)));
	m_scope_id = scope;
	}

	bool CNetAddr::IsBindAny() const {
	if (!IsIPv4() && !IsIPv6()) {
	return false;
	}
	return std::all_of(m_addr.begin(), m_addr.end(),
	[](uint8_t b) { return b == 0; });
	}

	bool CNetAddr::IsIPv4() const {
	return m_net == NET_IPV4;
	}

	bool CNetAddr::IsIPv6() const {
	return m_net == NET_IPV6;
	}

	bool CNetAddr::IsRFC1918() const {
	return IsIPv4() &&
	(m_addr[0] == 10 \|\| (m_addr[0] == 192 && m_addr[1] == 168) \|\|
	(m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
	}

	bool CNetAddr::IsRFC2544() const {
	return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 \|\| m_addr[1] == 19);
	}

	bool CNetAddr::IsRFC3927() const {
	return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{{169, 254}});
	}

	bool CNetAddr::IsRFC6598() const {
	return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
	}

	bool CNetAddr::IsRFC5737() const {
	return IsIPv4() &&
	(HasPrefix(m_addr, std::array<uint8_t, 3>{{192, 0, 2}}) \|\|
	HasPrefix(m_addr, std::array<uint8_t, 3>{{198, 51, 100}}) \|\|
	HasPrefix(m_addr, std::array<uint8_t, 3>{{203, 0, 113}}));
	}

	bool CNetAddr::IsRFC3849() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x0D, 0xB8}});
	}

	bool CNetAddr::IsRFC3964() const {
	return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{{0x20, 0x02}});
	}

	bool CNetAddr::IsRFC6052() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 12>{{0x00, 0x64, 0xFF, 0x9B,
	0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4380() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4862() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 8>{{0xFE, 0x80, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4193() const {
	return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
	}

	bool CNetAddr::IsRFC6145() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 12>{{0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00,
	0xFF, 0xFF, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4843() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 3>{{0x20, 0x01, 0x00}}) &&
	(m_addr[3] & 0xF0) == 0x10;
	}

	bool CNetAddr::IsRFC7343() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 3>{{0x20, 0x01, 0x00}}) &&
	(m_addr[3] & 0xF0) == 0x20;
	}

	bool CNetAddr::IsHeNet() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x04, 0x70}});
	}

	/**
	* Check whether this object represents a TOR address.
	*
	* @see CNetAddr::SetSpecial(const std::string &)
	*/
	bool CNetAddr::IsTor() const {
	return m_net == NET_ONION;
	}

	/**
	* Check whether this object represents an I2P address.
	*/
	bool CNetAddr::IsI2P() const {
	return m_net == NET_I2P;
	}

	/**
	* Check whether this object represents a CJDNS address.
	*/
	bool CNetAddr::IsCJDNS() const {
	return m_net == NET_CJDNS;
	}

	bool CNetAddr::IsLocal() const {
	// IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
	if (IsIPv4() && (m_addr[0] == 127 \|\| m_addr[0] == 0)) {
	return true;
	}

	// IPv6 loopback (::1/128)
	static const uint8_t pchLocal[16] = {0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 1};
	if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
	return true;
	}

	return false;
	}

	/**
	* @returns Whether or not this network address is a valid address that @a could
	* be used to refer to an actual host.
	*
	* @note A valid address may or may not be publicly routable on the global
	* internet. As in, the set of valid addresses is a superset of the set of
	* publicly routable addresses.
	*
	* @see CNetAddr::IsRoutable()
	*/
	bool CNetAddr::IsValid() const {
	// unspecified IPv6 address (::/128)
	uint8_t ipNone6[16] = {};
	if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
	return false;
	}

	// documentation IPv6 address
	if (IsRFC3849()) {
	return false;
	}

	if (IsInternal()) {
	return false;
	}

	if (IsIPv4()) {
	const uint32_t addr = ReadBE32(m_addr.data());
	if (addr == INADDR_ANY \|\| addr == INADDR_NONE) {
	return false;
	}
	}

	return true;
	}

	/**
	* @returns Whether or not this network address is publicly routable on the
	* global internet.
	*
	* @note A routable address is always valid. As in, the set of routable
	* addresses is a subset of the set of valid addresses.
	*
	* @see CNetAddr::IsValid()
	*/
	bool CNetAddr::IsRoutable() const {
	return IsValid() &&
	!(IsRFC1918() \|\| IsRFC2544() \|\| IsRFC3927() \|\| IsRFC4862() \|\|
	IsRFC6598() \|\| IsRFC5737() \|\| (IsRFC4193() && !IsTor()) \|\|
	IsRFC4843() \|\| IsRFC7343() \|\| IsLocal() \|\| IsInternal());
	}

	/**
	* @returns Whether or not this is a dummy address that represents a name.
	*
	* @see CNetAddr::SetInternal(const std::string &)
	*/
	bool CNetAddr::IsInternal() const {
	return m_net == NET_INTERNAL;
	}

	bool CNetAddr::IsAddrV1Compatible() const {
	switch (m_net) {
	case NET_IPV4:
	case NET_IPV6:
	case NET_INTERNAL:
	return true;
	case NET_ONION:
	return m_addr.size() == ADDR_TORV2_SIZE;
	case NET_I2P:
	case NET_CJDNS:
	return false;
	case NET_UNROUTABLE:
	// m_net is never and should not be set to NET_UNROUTABLE
	case NET_MAX:
	// m_net is never and should not be set to NET_MAX
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	enum Network CNetAddr::GetNetwork() const {
	if (IsInternal()) {
	return NET_INTERNAL;
	}

	if (!IsRoutable()) {
	return NET_UNROUTABLE;
	}

	return m_net;
	}

	static std::string IPv6ToString(Span<const uint8_t> a) {
	assert(a.size() == ADDR_IPV6_SIZE);
	// clang-format off
	return strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
	ReadBE16(&a[0]),
	ReadBE16(&a[2]),
	ReadBE16(&a[4]),
	ReadBE16(&a[6]),
	ReadBE16(&a[8]),
	ReadBE16(&a[10]),
	ReadBE16(&a[12]),
	ReadBE16(&a[14]));
	// clang-format on
	}

	std::string CNetAddr::ToStringIP() const {
	switch (m_net) {
	case NET_IPV4:
	case NET_IPV6: {
	CService serv(*this, 0);
	struct sockaddr_storage sockaddr;
	socklen_t socklen = sizeof(sockaddr);
	if (serv.GetSockAddr((struct sockaddr *)&sockaddr, &socklen)) {
	char name[1025] = "";
	if (!getnameinfo((const struct sockaddr *)&sockaddr, socklen,
	name, sizeof(name), nullptr, 0,
	NI_NUMERICHOST)) {
	return std::string(name);
	}
	}
	if (m_net == NET_IPV4) {
	return strprintf("%u.%u.%u.%u", m_addr[0], m_addr[1], m_addr[2],
	m_addr[3]);
	}
	return IPv6ToString(m_addr);
	}
	case NET_ONION:
	switch (m_addr.size()) {
	case ADDR_TORV2_SIZE:
	return EncodeBase32(m_addr) + ".onion";
	case ADDR_TORV3_SIZE: {
	uint8_t checksum[torv3::CHECKSUM_LEN];
	torv3::Checksum(m_addr, checksum);

	// TORv3 onion_address = base32(PUBKEY \| CHECKSUM \| VERSION)
	// + ".onion"
	prevector<torv3::TOTAL_LEN, uint8_t> address{m_addr.begin(),
	m_addr.end()};
	address.insert(address.end(), checksum,
	checksum + torv3::CHECKSUM_LEN);
	address.insert(address.end(), torv3::VERSION,
	torv3::VERSION + sizeof(torv3::VERSION));

	return EncodeBase32(address) + ".onion";
	}
	default:
	assert(false);
	}
	case NET_I2P:
	return EncodeBase32(m_addr, false /* don't pad with = */) +
	".b32.i2p";
	case NET_CJDNS:
	return IPv6ToString(m_addr);
	case NET_INTERNAL:
	return EncodeBase32(m_addr) + ".internal";
	case NET_UNROUTABLE:
	// m_net is never and should not be set to NET_UNROUTABLE
	case NET_MAX:
	// m_net is never and should not be set to NET_MAX
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	std::string CNetAddr::ToString() const {
	return ToStringIP();
	}

	bool operator==(const CNetAddr &a, const CNetAddr &b) {
	return a.m_net == b.m_net && a.m_addr == b.m_addr;
	}

	bool operator<(const CNetAddr &a, const CNetAddr &b) {
	return std::tie(a.m_net, a.m_addr) < std::tie(b.m_net, b.m_addr);
	}

	/**
	* Try to get our IPv4 address.
	*
	* @param[out] pipv4Addr The in_addr struct to which to copy.
	*
	* @returns Whether or not the operation was successful, in particular, whether
	* or not our address was an IPv4 address.
	*
	* @see CNetAddr::IsIPv4()
	*/
	bool CNetAddr::GetInAddr(struct in_addr *pipv4Addr) const {
	if (!IsIPv4()) {
	return false;
	}
	assert(sizeof(*pipv4Addr) == m_addr.size());
	memcpy(pipv4Addr, m_addr.data(), m_addr.size());
	return true;
	}

	/**
	* Try to get our IPv6 address.
	*
	* @param[out] pipv6Addr The in6_addr struct to which to copy.
	*
	* @returns Whether or not the operation was successful, in particular, whether
	* or not our address was an IPv6 address.
	*
	* @see CNetAddr::IsIPv6()
	*/
	bool CNetAddr::GetIn6Addr(struct in6_addr *pipv6Addr) const {
	if (!IsIPv6()) {
	return false;
	}
	assert(sizeof(*pipv6Addr) == m_addr.size());
	memcpy(pipv6Addr, m_addr.data(), m_addr.size());
	return true;
	}

	bool CNetAddr::HasLinkedIPv4() const {
	return IsRoutable() && (IsIPv4() \|\| IsRFC6145() \|\| IsRFC6052() \|\|
	IsRFC3964() \|\| IsRFC4380());
	}

	uint32_t CNetAddr::GetLinkedIPv4() const {
	if (IsIPv4()) {
	return ReadBE32(m_addr.data());
	} else if (IsRFC6052() \|\| IsRFC6145()) {
	// mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4
	// bytes of the address
	return ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
	} else if (IsRFC3964()) {
	// 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
	return ReadBE32(MakeSpan(m_addr).subspan(2, ADDR_IPV4_SIZE).data());
	} else if (IsRFC4380()) {
	// Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the
	// address, but bitflipped
	return ~ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
	}
	assert(false);
	}

	Network CNetAddr::GetNetClass() const {
	// Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers
	// expect that.

	// Check for "internal" first because such addresses are also !IsRoutable()
	// and we don't want to return NET_UNROUTABLE in that case.
	if (IsInternal()) {
	return NET_INTERNAL;
	}
	if (!IsRoutable()) {
	return NET_UNROUTABLE;
	}
	if (HasLinkedIPv4()) {
	return NET_IPV4;
	}
	return m_net;
	}

	uint32_t CNetAddr::GetMappedAS(const std::vector<bool> &asmap) const {
	uint32_t net_class = GetNetClass();
	if (asmap.size() == 0 \|\| (net_class != NET_IPV4 && net_class != NET_IPV6)) {
	return 0; // Indicates not found, safe because AS0 is reserved per
	// RFC7607.
	}
	std::vector<bool> ip_bits(128);
	if (HasLinkedIPv4()) {
	// For lookup, treat as if it was just an IPv4 address
	// (IPV4_IN_IPV6_PREFIX + IPv4 bits)
	for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
	for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
	ip_bits[byte_i * 8 + bit_i] =
	(IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
	}
	}
	uint32_t ipv4 = GetLinkedIPv4();
	for (int i = 0; i < 32; ++i) {
	ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
	}
	} else {
	// Use all 128 bits of the IPv6 address otherwise
	assert(IsIPv6());
	for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
	uint8_t cur_byte = m_addr[byte_i];
	for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
	ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
	}
	}
	}
	uint32_t mapped_as = Interpret(asmap, ip_bits);
	return mapped_as;
	}

	/**
	* Get the canonical identifier of our network group
	*
	* The groups are assigned in a way where it should be costly for an attacker to
	* obtain addresses with many different group identifiers, even if it is cheap
	* to obtain addresses with the same identifier.
	*
	* @note No two connections will be attempted to addresses with the same network
	* group.
	*/
	std::vector<uint8_t> CNetAddr::GetGroup(const std::vector<bool> &asmap) const {
	std::vector<uint8_t> vchRet;
	uint32_t net_class = GetNetClass();
	// If non-empty asmap is supplied and the address is IPv4/IPv6,
	// return ASN to be used for bucketing.
	uint32_t asn = GetMappedAS(asmap);
	if (asn != 0) { // Either asmap was empty, or address has non-asmappable net
	// class (e.g. TOR).
	vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in
	// the same bucket
	for (int i = 0; i < 4; i++) {
	vchRet.push_back((asn >> (8 * i)) & 0xFF);
	}
	return vchRet;
	}

	vchRet.push_back(net_class);
	int nBits{0};

	if (IsLocal()) {
	// all local addresses belong to the same group
	} else if (IsInternal()) {
	// all internal-usage addresses get their own group
	nBits = ADDR_INTERNAL_SIZE * 8;
	} else if (!IsRoutable()) {
	// all other unroutable addresses belong to the same group
	} else if (HasLinkedIPv4()) {
	// IPv4 addresses (and mapped IPv4 addresses) use /16 groups
	uint32_t ipv4 = GetLinkedIPv4();
	vchRet.push_back((ipv4 >> 24) & 0xFF);
	vchRet.push_back((ipv4 >> 16) & 0xFF);
	return vchRet;
	} else if (IsTor() \|\| IsI2P() \|\| IsCJDNS()) {
	nBits = 4;
	} else if (IsHeNet()) {
	// for he.net, use /36 groups
	nBits = 36;
	} else {
	// for the rest of the IPv6 network, use /32 groups
	nBits = 32;
	}

	// Push our address onto vchRet.
	const size_t num_bytes = nBits / 8;
	vchRet.insert(vchRet.end(), m_addr.begin(), m_addr.begin() + num_bytes);
	nBits %= 8;
	// ...for the last byte, push nBits and for the rest of the byte push 1's
	if (nBits > 0) {
	assert(num_bytes < m_addr.size());
	vchRet.push_back(m_addr[num_bytes] \| ((1 << (8 - nBits)) - 1));
	}

	return vchRet;
	}

	std::vector<uint8_t> CNetAddr::GetAddrBytes() const {
	if (IsAddrV1Compatible()) {
	uint8_t serialized[V1_SERIALIZATION_SIZE];
	SerializeV1Array(serialized);
	return {std::begin(serialized), std::end(serialized)};
	}
	return std::vector<uint8_t>(m_addr.begin(), m_addr.end());
	}

	-uint64_t CNetAddr::GetHash() const {
	- uint256 hash = Hash(m_addr);
	- uint64_t nRet;
	- memcpy(&nRet, &hash, sizeof(nRet));
	- return nRet;
	-}
	-
	// private extensions to enum Network, only returned by GetExtNetwork, and only
	// used in GetReachabilityFrom
	static const int NET_UNKNOWN = NET_MAX + 0;
	static const int NET_TEREDO = NET_MAX + 1;
	static int GetExtNetwork(const CNetAddr *addr) {
	if (addr == nullptr) {
	return NET_UNKNOWN;
	}
	if (addr->IsRFC4380()) {
	return NET_TEREDO;
	}
	return addr->GetNetwork();
	}

	/** Calculates a metric for how reachable (this) is from a given partner /
	int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const {
	enum Reachability {
	REACH_UNREACHABLE,
	REACH_DEFAULT,
	REACH_TEREDO,
	REACH_IPV6_WEAK,
	REACH_IPV4,
	REACH_IPV6_STRONG,
	REACH_PRIVATE
	};

	if (!IsRoutable() \|\| IsInternal()) {
	return REACH_UNREACHABLE;
	}

	int ourNet = GetExtNetwork(this);
	int theirNet = GetExtNetwork(paddrPartner);
	bool fTunnel = IsRFC3964() \|\| IsRFC6052() \|\| IsRFC6145();

	switch (theirNet) {
	case NET_IPV4:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_IPV4:
	return REACH_IPV4;
	}
	case NET_IPV6:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_TEREDO:
	return REACH_TEREDO;
	case NET_IPV4:
	return REACH_IPV4;
	// only prefer giving our IPv6 address if it's not tunnelled
	case NET_IPV6:
	return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG;
	}
	case NET_ONION:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	// Tor users can connect to IPv4 as well
	case NET_IPV4:
	return REACH_IPV4;
	case NET_ONION:
	return REACH_PRIVATE;
	}
	case NET_I2P:
	switch (ourNet) {
	case NET_I2P:
	return REACH_PRIVATE;
	default:
	return REACH_DEFAULT;
	}
	case NET_TEREDO:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_TEREDO:
	return REACH_TEREDO;
	case NET_IPV6:
	return REACH_IPV6_WEAK;
	case NET_IPV4:
	return REACH_IPV4;
	}
	case NET_UNKNOWN:
	case NET_UNROUTABLE:
	default:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_TEREDO:
	return REACH_TEREDO;
	case NET_IPV6:
	return REACH_IPV6_WEAK;
	case NET_IPV4:
	return REACH_IPV4;
	// either from Tor, or don't care about our address
	case NET_ONION:
	return REACH_PRIVATE;
	}
	}
	}

	CService::CService() : port(0) {}

	CService::CService(const CNetAddr &cip, uint16_t portIn)
	: CNetAddr(cip), port(portIn) {}

	CService::CService(const struct in_addr &ipv4Addr, uint16_t portIn)
	: CNetAddr(ipv4Addr), port(portIn) {}

	CService::CService(const struct in6_addr &ipv6Addr, uint16_t portIn)
	: CNetAddr(ipv6Addr), port(portIn) {}

	CService::CService(const struct sockaddr_in &addr)
	: CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port)) {
	assert(addr.sin_family == AF_INET);
	}

	CService::CService(const struct sockaddr_in6 &addr)
	: CNetAddr(addr.sin6_addr, addr.sin6_scope_id),
	port(ntohs(addr.sin6_port)) {
	assert(addr.sin6_family == AF_INET6);
	}

	bool CService::SetSockAddr(const struct sockaddr *paddr) {
	switch (paddr->sa_family) {
	case AF_INET:
	*this =
	CService(reinterpret_cast<const struct sockaddr_in >(paddr));
	return true;
	case AF_INET6:
	*this =
	CService(reinterpret_cast<const struct sockaddr_in6 >(paddr));
	return true;
	default:
	return false;
	}
	}

	uint16_t CService::GetPort() const {
	return port;
	}

	bool operator==(const CService &a, const CService &b) {
	return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
	a.port == b.port;
	}

	bool operator<(const CService &a, const CService &b) {
	return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) \|\|
	(static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
	a.port < b.port);
	}

	/**
	* Obtain the IPv4/6 socket address this represents.
	*
	* @param[out] paddr The obtained socket address.
	* @param[in,out] addrlen The size, in bytes, of the address structure pointed
	* to by paddr. The value that's pointed to by this
	* parameter might change after calling this function if
	* the size of the corresponding address structure
	* changed.
	*
	* @returns Whether or not the operation was successful.
	*/
	bool CService::GetSockAddr(struct sockaddr paddr, socklen_t addrlen) const {
	if (IsIPv4()) {
	if (*addrlen < (socklen_t)sizeof(struct sockaddr_in)) {
	return false;
	}
	*addrlen = sizeof(struct sockaddr_in);
	struct sockaddr_in *paddrin =
	reinterpret_cast<struct sockaddr_in *>(paddr);
	memset(paddrin, 0, *addrlen);
	if (!GetInAddr(&paddrin->sin_addr)) {
	return false;
	}
	paddrin->sin_family = AF_INET;
	paddrin->sin_port = htons(port);
	return true;
	}
	if (IsIPv6()) {
	if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6)) {
	return false;
	}
	*addrlen = sizeof(struct sockaddr_in6);
	struct sockaddr_in6 *paddrin6 =
	reinterpret_cast<struct sockaddr_in6 *>(paddr);
	memset(paddrin6, 0, *addrlen);
	if (!GetIn6Addr(&paddrin6->sin6_addr)) {
	return false;
	}
	paddrin6->sin6_scope_id = m_scope_id;
	paddrin6->sin6_family = AF_INET6;
	paddrin6->sin6_port = htons(port);
	return true;
	}
	return false;
	}

	/**
	* @returns An identifier unique to this service's address and port number.
	*/
	std::vector<uint8_t> CService::GetKey() const {
	auto key = GetAddrBytes();
	// most significant byte of our port
	key.push_back(port / 0x100);
	// least significant byte of our port
	key.push_back(port & 0x0FF);
	return key;
	}

	std::string CService::ToStringPort() const {
	return strprintf("%u", port);
	}

	std::string CService::ToStringIPPort() const {
	if (IsIPv4() \|\| IsTor() \|\| IsI2P() \|\| IsInternal()) {
	return ToStringIP() + ":" + ToStringPort();
	} else {
	return "[" + ToStringIP() + "]:" + ToStringPort();
	}
	}

	std::string CService::ToString() const {
	return ToStringIPPort();
	}

	CSubNet::CSubNet() : valid(false) {
	memset(netmask, 0, sizeof(netmask));
	}

	CSubNet::CSubNet(const CNetAddr &addr, uint8_t mask) : CSubNet() {
	valid = (addr.IsIPv4() && mask <= ADDR_IPV4_SIZE * 8) \|\|
	(addr.IsIPv6() && mask <= ADDR_IPV6_SIZE * 8);
	if (!valid) {
	return;
	}

	assert(mask <= sizeof(netmask) * 8);

	network = addr;

	uint8_t n = mask;
	for (size_t i = 0; i < network.m_addr.size(); ++i) {
	const uint8_t bits = n < 8 ? n : 8;
	// Set first bits.
	netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits));
	// Normalize network according to netmask.
	network.m_addr[i] &= netmask[i];
	n -= bits;
	}
	}

	/**
	* @returns The number of 1-bits in the prefix of the specified subnet mask. If
	* the specified subnet mask is not a valid one, -1.
	*/
	static inline int NetmaskBits(uint8_t x) {
	switch (x) {
	case 0x00:
	return 0;
	case 0x80:
	return 1;
	case 0xc0:
	return 2;
	case 0xe0:
	return 3;
	case 0xf0:
	return 4;
	case 0xf8:
	return 5;
	case 0xfc:
	return 6;
	case 0xfe:
	return 7;
	case 0xff:
	return 8;
	default:
	return -1;
	}
	}

	CSubNet::CSubNet(const CNetAddr &addr, const CNetAddr &mask) : CSubNet() {
	valid = (addr.IsIPv4() \|\| addr.IsIPv6()) && addr.m_net == mask.m_net;
	if (!valid) {
	return;
	}
	// Check if `mask` contains 1-bits after 0-bits (which is an invalid
	// netmask).
	bool zeros_found = false;
	for (auto b : mask.m_addr) {
	const int num_bits = NetmaskBits(b);
	if (num_bits == -1 \|\| (zeros_found && num_bits != 0)) {
	valid = false;
	return;
	}
	if (num_bits < 8) {
	zeros_found = true;
	}
	}

	assert(mask.m_addr.size() <= sizeof(netmask));

	memcpy(netmask, mask.m_addr.data(), mask.m_addr.size());

	network = addr;

	// Normalize network according to netmask
	for (size_t x = 0; x < network.m_addr.size(); ++x) {
	network.m_addr[x] &= netmask[x];
	}
	}

	CSubNet::CSubNet(const CNetAddr &addr) : CSubNet() {
	valid = addr.IsIPv4() \|\| addr.IsIPv6();
	if (!valid) {
	return;
	}

	assert(addr.m_addr.size() <= sizeof(netmask));

	memset(netmask, 0xFF, addr.m_addr.size());

	network = addr;
	}

	/**
	* @returns True if this subnet is valid, the specified address is valid, and
	* the specified address belongs in this subnet.
	*/
	bool CSubNet::Match(const CNetAddr &addr) const {
	if (!valid \|\| !addr.IsValid() \|\| network.m_net != addr.m_net) {
	return false;
	}
	assert(network.m_addr.size() == addr.m_addr.size());
	for (size_t x = 0; x < addr.m_addr.size(); ++x) {
	if ((addr.m_addr[x] & netmask[x]) != network.m_addr[x]) {
	return false;
	}
	}
	return true;
	}

	std::string CSubNet::ToString() const {
	assert(network.m_addr.size() <= sizeof(netmask));

	uint8_t cidr = 0;

	for (size_t i = 0; i < network.m_addr.size(); ++i) {
	if (netmask[i] == 0x00) {
	break;
	}
	cidr += NetmaskBits(netmask[i]);
	}

	return network.ToString() + strprintf("/%u", cidr);
	}

	bool CSubNet::IsValid() const {
	return valid;
	}

	bool CSubNet::SanityCheck() const {
	if (!(network.IsIPv4() \|\| network.IsIPv6())) {
	return false;
	}

	for (size_t x = 0; x < network.m_addr.size(); ++x) {
	if (network.m_addr[x] & ~netmask[x]) {
	return false;
	}
	}

	return true;
	}

	bool operator==(const CSubNet &a, const CSubNet &b) {
	return a.valid == b.valid && a.network == b.network &&
	!memcmp(a.netmask, b.netmask, 16);
	}

	bool operator<(const CSubNet &a, const CSubNet &b) {
	return (a.network < b.network \|\|
	(a.network == b.network && memcmp(a.netmask, b.netmask, 16) < 0));
	}
	diff --git a/src/netaddress.h b/src/netaddress.h
	index 35ddfd3ef..8b38907d6 100644
	--- a/src/netaddress.h
	+++ b/src/netaddress.h
	@@ -1,595 +1,601 @@
	// 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.

	#ifndef BITCOIN_NETADDRESS_H
	#define BITCOIN_NETADDRESS_H

	#if defined(HAVE_CONFIG_H)
	#include <config/bitcoin-config.h>
	#endif

	#include <attributes.h>
	#include <compat.h>
	#include <crypto/siphash.h>
	#include <prevector.h>
	#include <random.h>
	#include <serialize.h>
	#include <util/strencodings.h>
	#include <util/string.h>

	#include <tinyformat.h>

	#include <array>
	#include <cstdint>
	#include <ios>
	#include <string>
	#include <vector>

	/**
	* A flag that is ORed into the protocol version to designate that addresses
	* should be serialized in (unserialized from) v2 format (BIP155).
	* Make sure that this does not collide with any of the values in `version.h`.
	*/
	static constexpr int ADDRV2_FORMAT = 0x20000000;

	/**
	* A network type.
	* @note An address may belong to more than one network, for example `10.0.0.1`
	* belongs to both `NET_UNROUTABLE` and `NET_IPV4`.
	* Keep these sequential starting from 0 and `NET_MAX` as the last entry.
	* We have loops like `for (int i = 0; i < NET_MAX; ++i)` that expect to iterate
	* over all enum values and also `GetExtNetwork()` "extends" this enum by
	* introducing standalone constants starting from `NET_MAX`.
	*/
	enum Network {
	/// Addresses from these networks are not publicly routable on the global
	/// Internet.
	NET_UNROUTABLE = 0,

	/// IPv4
	NET_IPV4,

	/// IPv6
	NET_IPV6,

	/// TOR (v2 or v3)
	NET_ONION,

	/// I2P
	NET_I2P,

	/// CJDNS
	NET_CJDNS,

	/// A set of addresses that represent the hash of a string or FQDN. We use
	/// them in AddrMan to keep track of which DNS seeds were used.
	NET_INTERNAL,

	/// Dummy value to indicate the number of NET_* constants.
	NET_MAX,
	};

	/// Prefix of an IPv6 address when it contains an embedded IPv4 address.
	/// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
	static const std::array<uint8_t, 12> IPV4_IN_IPV6_PREFIX{
	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF}};

	/// Prefix of an IPv6 address when it contains an embedded TORv2 address.
	/// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
	/// Such dummy IPv6 addresses are guaranteed to not be publicly routable as they
	/// fall under RFC4193's fc00::/7 subnet allocated to unique-local addresses.
	static const std::array<uint8_t, 6> TORV2_IN_IPV6_PREFIX{
	{0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43}};

	/// Prefix of an IPv6 address when it contains an embedded "internal" address.
	/// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
	/// The prefix comes from 0xFD + SHA256("bitcoin")[0:5].
	/// Such dummy IPv6 addresses are guaranteed to not be publicly routable as they
	/// fall under RFC4193's fc00::/7 subnet allocated to unique-local addresses.
	static const std::array<uint8_t, 6> INTERNAL_IN_IPV6_PREFIX{
	// 0xFD + sha256("bitcoin")[0:5].
	{0xFD, 0x6B, 0x88, 0xC0, 0x87, 0x24}};

	/// Size of IPv4 address (in bytes).
	static constexpr size_t ADDR_IPV4_SIZE = 4;

	/// Size of IPv6 address (in bytes).
	static constexpr size_t ADDR_IPV6_SIZE = 16;

	/// Size of TORv2 address (in bytes).
	static constexpr size_t ADDR_TORV2_SIZE = 10;

	/// Size of TORv3 address (in bytes). This is the length of just the address
	/// as used in BIP155, without the checksum and the version byte.
	static constexpr size_t ADDR_TORV3_SIZE = 32;

	/// Size of I2P address (in bytes).
	static constexpr size_t ADDR_I2P_SIZE = 32;

	/// Size of CJDNS address (in bytes).
	static constexpr size_t ADDR_CJDNS_SIZE = 16;

	/// Size of "internal" (NET_INTERNAL) address (in bytes).
	static constexpr size_t ADDR_INTERNAL_SIZE = 10;

	/// SAM 3.1 and earlier do not support specifying ports and force the port to 0.
	static constexpr uint16_t I2P_SAM31_PORT{0};

	/**
	* Network address.
	*/
	class CNetAddr {
	protected:
	/**
	* Raw representation of the network address.
	* In network byte order (big endian) for IPv4 and IPv6.
	*/
	prevector<ADDR_IPV6_SIZE, uint8_t> m_addr{ADDR_IPV6_SIZE, 0x0};

	/**
	* Network to which this address belongs.
	*/
	Network m_net{NET_IPV6};

	/**
	* Scope id if scoped/link-local IPV6 address.
	* See https://tools.ietf.org/html/rfc4007
	*/
	uint32_t m_scope_id{0};

	public:
	CNetAddr();
	explicit CNetAddr(const struct in_addr &ipv4Addr);
	void SetIP(const CNetAddr &ip);

	/**
	* Set from a legacy IPv6 address.
	* Legacy IPv6 address may be a normal IPv6 address, or another address
	* (e.g. IPv4) disguised as IPv6. This encoding is used in the legacy
	* `addr` encoding.
	*/
	void SetLegacyIPv6(Span<const uint8_t> ipv6);

	bool SetInternal(const std::string &name);

	/**
	* Parse a Tor or I2P address and set this object to it.
	* @param[in] addr Address to parse, for example
	* pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion or
	* ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
	* @returns Whether the operation was successful.
	* @see CNetAddr::IsTor(), CNetAddr::IsI2P()
	*/
	bool SetSpecial(const std::string &addr);

	// INADDR_ANY equivalent
	bool IsBindAny() const;
	// IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
	bool IsIPv4() const;
	// IPv6 address (not mapped IPv4, not Tor)
	bool IsIPv6() const;
	// IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
	bool IsRFC1918() const;
	// IPv4 inter-network communications (198.18.0.0/15)
	bool IsRFC2544() const;
	// IPv4 ISP-level NAT (100.64.0.0/10)
	bool IsRFC6598() const;
	// IPv4 documentation addresses (192.0.2.0/24, 198.51.100.0/24,
	// 203.0.113.0/24)
	bool IsRFC5737() const;
	// IPv6 documentation address (2001:0DB8::/32)
	bool IsRFC3849() const;
	// IPv4 autoconfig (169.254.0.0/16)
	bool IsRFC3927() const;
	// IPv6 6to4 tunnelling (2002::/16)
	bool IsRFC3964() const;
	// IPv6 unique local (FC00::/7)
	bool IsRFC4193() const;
	// IPv6 Teredo tunnelling (2001::/32)
	bool IsRFC4380() const;
	// IPv6 ORCHID (deprecated) (2001:10::/28)
	bool IsRFC4843() const;
	// IPv6 ORCHIDv2 (2001:20::/28)
	bool IsRFC7343() const;
	// IPv6 autoconfig (FE80::/64)
	bool IsRFC4862() const;
	// IPv6 well-known prefix for IPv4-embedded address (64:FF9B::/96)
	bool IsRFC6052() const;
	// IPv6 IPv4-translated address (::FFFF:0:0:0/96) (actually defined in
	// RFC2765)
	bool IsRFC6145() const;
	// IPv6 Hurricane Electric - https://he.net (2001:0470::/36)
	bool IsHeNet() const;
	bool IsTor() const;
	bool IsI2P() const;
	bool IsCJDNS() const;
	bool IsLocal() const;
	bool IsRoutable() const;
	bool IsInternal() const;
	bool IsValid() const;

	/**
	* Check if the current object can be serialized in pre-ADDRv2/BIP155
	* format.
	*/
	bool IsAddrV1Compatible() const;

	enum Network GetNetwork() const;
	std::string ToString() const;
	std::string ToStringIP() const;
	- uint64_t GetHash() const;
	bool GetInAddr(struct in_addr *pipv4Addr) const;
	Network GetNetClass() const;

	//! For IPv4, mapped IPv4, SIIT translated IPv4, Teredo, 6to4 tunneled
	//! addresses, return the relevant IPv4 address as a uint32.
	uint32_t GetLinkedIPv4() const;
	//! Whether this address has a linked IPv4 address (see GetLinkedIPv4()).
	bool HasLinkedIPv4() const;

	// The AS on the BGP path to the node we use to diversify
	// peers in AddrMan bucketing based on the AS infrastructure.
	// The ip->AS mapping depends on how asmap is constructed.
	uint32_t GetMappedAS(const std::vector<bool> &asmap) const;

	std::vector<uint8_t> GetGroup(const std::vector<bool> &asmap) const;
	std::vector<uint8_t> GetAddrBytes() const;
	int GetReachabilityFrom(const CNetAddr *paddrPartner = nullptr) const;

	explicit CNetAddr(const struct in6_addr &pipv6Addr,
	const uint32_t scope = 0);
	bool GetIn6Addr(struct in6_addr *pipv6Addr) const;

	friend bool operator==(const CNetAddr &a, const CNetAddr &b);
	friend bool operator!=(const CNetAddr &a, const CNetAddr &b) {
	return !(a == b);
	}
	friend bool operator<(const CNetAddr &a, const CNetAddr &b);

	/**
	* Whether this address should be relayed to other peers even if we can't
	* reach it ourselves.
	*/
	bool IsRelayable() const { return IsIPv4() \|\| IsIPv6() \|\| IsTor(); }

	/**
	* Serialize to a stream.
	*/
	template <typename Stream> void Serialize(Stream &s) const {
	if (s.GetVersion() & ADDRV2_FORMAT) {
	SerializeV2Stream(s);
	} else {
	SerializeV1Stream(s);
	}
	}

	/**
	* Unserialize from a stream.
	*/
	template <typename Stream> void Unserialize(Stream &s) {
	if (s.GetVersion() & ADDRV2_FORMAT) {
	UnserializeV2Stream(s);
	} else {
	UnserializeV1Stream(s);
	}
	}

	friend class CSubNet;

	private:
	/**
	* Parse a Tor address and set this object to it.
	* @param[in] addr Address to parse, must be a valid C string, for example
	* pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion or
	* 6hzph5hv6337r6p2.onion.
	* @returns Whether the operation was successful.
	* @see CNetAddr::IsTor()
	*/
	bool SetTor(const std::string &addr);

	/**
	* Parse an I2P address and set this object to it.
	* @param[in] addr Address to parse, must be a valid C string, for example
	* ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p.
	* @returns Whether the operation was successful.
	* @see CNetAddr::IsI2P()
	*/
	bool SetI2P(const std::string &addr);

	/**
	* BIP155 network ids recognized by this software.
	*/
	enum BIP155Network : uint8_t {
	IPV4 = 1,
	IPV6 = 2,
	TORV2 = 3,
	TORV3 = 4,
	I2P = 5,
	CJDNS = 6,
	};

	/**
	* Size of CNetAddr when serialized as ADDRv1 (pre-BIP155) (in bytes).
	*/
	static constexpr size_t V1_SERIALIZATION_SIZE = ADDR_IPV6_SIZE;

	/**
	* Maximum size of an address as defined in BIP155 (in bytes).
	* This is only the size of the address, not the entire CNetAddr object
	* when serialized.
	*/
	static constexpr size_t MAX_ADDRV2_SIZE = 512;

	/**
	* Get the BIP155 network id of this address.
	* Must not be called for IsInternal() objects.
	* @returns BIP155 network id
	*/
	BIP155Network GetBIP155Network() const;

	/**
	* Set `m_net` from the provided BIP155 network id and size after
	* validation.
	* @retval true the network was recognized, is valid and `m_net` was set
	* @retval false not recognised (from future?) and should be silently
	* ignored
	* @throws std::ios_base::failure if the network is one of the BIP155
	* founding networks recognized by this software (id 1..6) with wrong
	* address size.
	*/
	bool SetNetFromBIP155Network(uint8_t possible_bip155_net,
	size_t address_size);

	/**
	* Serialize in pre-ADDRv2/BIP155 format to an array.
	*/
	void SerializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) const {
	size_t prefix_size;

	switch (m_net) {
	case NET_IPV6:
	assert(m_addr.size() == sizeof(arr));
	memcpy(arr, m_addr.data(), m_addr.size());
	return;
	case NET_IPV4:
	prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
	assert(prefix_size + m_addr.size() == sizeof(arr));
	memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
	memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
	return;
	case NET_ONION:
	if (m_addr.size() == ADDR_TORV3_SIZE) {
	break;
	}
	prefix_size = sizeof(TORV2_IN_IPV6_PREFIX);
	assert(prefix_size + m_addr.size() == sizeof(arr));
	memcpy(arr, TORV2_IN_IPV6_PREFIX.data(), prefix_size);
	memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
	return;
	case NET_INTERNAL:
	prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
	assert(prefix_size + m_addr.size() == sizeof(arr));
	memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
	memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
	return;
	case NET_I2P:
	break;
	case NET_CJDNS:
	break;
	case NET_UNROUTABLE:
	case NET_MAX:
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	// Serialize TORv3, I2P and CJDNS as all-zeros.
	memset(arr, 0x0, V1_SERIALIZATION_SIZE);
	}

	/**
	* Serialize in pre-ADDRv2/BIP155 format to a stream.
	*/
	template <typename Stream> void SerializeV1Stream(Stream &s) const {
	uint8_t serialized[V1_SERIALIZATION_SIZE];

	SerializeV1Array(serialized);

	s << serialized;
	}

	/**
	* Serialize as ADDRv2 / BIP155.
	*/
	template <typename Stream> void SerializeV2Stream(Stream &s) const {
	if (IsInternal()) {
	// Serialize NET_INTERNAL as embedded in IPv6. We need to
	// serialize such addresses from addrman.
	s << static_cast<uint8_t>(BIP155Network::IPV6);
	s << COMPACTSIZE(ADDR_IPV6_SIZE);
	SerializeV1Stream(s);
	return;
	}

	s << static_cast<uint8_t>(GetBIP155Network());
	s << m_addr;
	}

	/**
	* Unserialize from a pre-ADDRv2/BIP155 format from an array.
	*/
	void UnserializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) {
	// Use SetLegacyIPv6() so that m_net is set correctly. For example
	// ::FFFF:0102:0304 should be set as m_net=NET_IPV4 (1.2.3.4).
	SetLegacyIPv6(arr);
	}

	/**
	* Unserialize from a pre-ADDRv2/BIP155 format from a stream.
	*/
	template <typename Stream> void UnserializeV1Stream(Stream &s) {
	uint8_t serialized[V1_SERIALIZATION_SIZE];

	s >> serialized;

	UnserializeV1Array(serialized);
	}

	/**
	* Unserialize from a ADDRv2 / BIP155 format.
	*/
	template <typename Stream> void UnserializeV2Stream(Stream &s) {
	uint8_t bip155_net;
	s >> bip155_net;

	size_t address_size;
	s >> COMPACTSIZE(address_size);

	if (address_size > MAX_ADDRV2_SIZE) {
	throw std::ios_base::failure(strprintf(
	"Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
	}

	m_scope_id = 0;

	if (SetNetFromBIP155Network(bip155_net, address_size)) {
	m_addr.resize(address_size);
	s >> MakeSpan(m_addr);

	if (m_net != NET_IPV6) {
	return;
	}

	// Do some special checks on IPv6 addresses.

	// Recognize NET_INTERNAL embedded in IPv6, such addresses are not
	// gossiped but could be coming from addrman, when unserializing
	// from disk.
	if (HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
	m_net = NET_INTERNAL;
	memmove(m_addr.data(),
	m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
	ADDR_INTERNAL_SIZE);
	m_addr.resize(ADDR_INTERNAL_SIZE);
	return;
	}

	if (!HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
	!HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
	return;
	}

	// IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in
	// V1 encoding). Unserialize as !IsValid(), thus ignoring them.
	} else {
	// If we receive an unknown BIP155 network id (from the future?)
	// then ignore the address - unserialize as !IsValid().
	s.ignore(address_size);
	}

	// Mimic a default-constructed CNetAddr object which is !IsValid() and
	// thus will not be gossiped, but continue reading next addresses from
	// the stream.
	m_net = NET_IPV6;
	m_addr.assign(ADDR_IPV6_SIZE, 0x0);
	}
	};

	class CSubNet {
	protected:
	/// Network (base) address
	CNetAddr network;
	/// Netmask, in network byte order
	uint8_t netmask[16];
	/// Is this value valid? (only used to signal parse errors)
	bool valid;

	bool SanityCheck() const;

	public:
	CSubNet();
	CSubNet(const CNetAddr &addr, uint8_t mask);
	CSubNet(const CNetAddr &addr, const CNetAddr &mask);

	// constructor for single ip subnet (<ipv4>/32 or <ipv6>/128)
	explicit CSubNet(const CNetAddr &addr);

	bool Match(const CNetAddr &addr) const;

	std::string ToString() const;
	bool IsValid() const;

	friend bool operator==(const CSubNet &a, const CSubNet &b);
	friend bool operator!=(const CSubNet &a, const CSubNet &b) {
	return !(a == b);
	}
	friend bool operator<(const CSubNet &a, const CSubNet &b);

	SERIALIZE_METHODS(CSubNet, obj) {
	READWRITE(obj.network);
	if (obj.network.IsIPv4()) {
	// Before D9176, CSubNet used the last 4 bytes of netmask to store
	// the relevant bytes for an IPv4 mask. For compatiblity reasons,
	// keep doing so in serialized form.
	uint8_t dummy[12] = {0};
	READWRITE(dummy);
	READWRITE(MakeSpan(obj.netmask).first(4));
	} else {
	READWRITE(obj.netmask);
	}
	READWRITE(obj.valid);
	// Mark invalid if the result doesn't pass sanity checking.
	SER_READ(obj, if (obj.valid) obj.valid = obj.SanityCheck());
	}
	};

	/** A combination of a network address (CNetAddr) and a (TCP) port */
	class CService : public CNetAddr {
	protected:
	// host order
	uint16_t port;

	public:
	CService();
	CService(const CNetAddr &ip, uint16_t port);
	CService(const struct in_addr &ipv4Addr, uint16_t port);
	explicit CService(const struct sockaddr_in &addr);
	uint16_t GetPort() const;
	bool GetSockAddr(struct sockaddr paddr, socklen_t addrlen) const;
	bool SetSockAddr(const struct sockaddr *paddr);
	friend bool operator==(const CService &a, const CService &b);
	friend bool operator!=(const CService &a, const CService &b) {
	return !(a == b);
	}
	friend bool operator<(const CService &a, const CService &b);
	std::vector<uint8_t> GetKey() const;
	std::string ToString() const;
	std::string ToStringPort() const;
	std::string ToStringIPPort() const;

	CService(const struct in6_addr &ipv6Addr, uint16_t port);
	explicit CService(const struct sockaddr_in6 &addr);

	SERIALIZE_METHODS(CService, obj) {
	READWRITEAS(CNetAddr, obj);
	READWRITE(Using<BigEndianFormatter<2>>(obj.port));
	}

	friend class CServiceHash;
	};

	class CServiceHash {
	public:
	+ CServiceHash()
	+ : m_salt_k0{GetRand(std::numeric_limits<uint64_t>::max())},
	+ m_salt_k1{GetRand(std::numeric_limits<uint64_t>::max())} {}
	+
	+ CServiceHash(uint64_t salt_k0, uint64_t salt_k1)
	+ : m_salt_k0{salt_k0}, m_salt_k1{salt_k1} {}
	+
	size_t operator()(const CService &a) const noexcept {
	CSipHasher hasher(m_salt_k0, m_salt_k1);
	hasher.Write(a.m_net);
	hasher.Write(a.port);
	hasher.Write(a.m_addr.data(), a.m_addr.size());
	return static_cast<size_t>(hasher.Finalize());
	}

	private:
	- const uint64_t m_salt_k0 = GetRand(std::numeric_limits<uint64_t>::max());
	- const uint64_t m_salt_k1 = GetRand(std::numeric_limits<uint64_t>::max());
	+ const uint64_t m_salt_k0;
	+ const uint64_t m_salt_k1;
	};

	#endif // BITCOIN_NETADDRESS_H
	diff --git a/src/netbase.cpp b/src/netbase.cpp
	index ecc5715f0..e1b73a05e 100644
	--- a/src/netbase.cpp
	+++ b/src/netbase.cpp
	@@ -1,857 +1,946 @@
	// 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 <netbase.h>

	#include <compat.h>
	#include <sync.h>
	#include <tinyformat.h>
	#include <util/sock.h>
	#include <util/strencodings.h>
	#include <util/string.h>
	#include <util/system.h>
	#include <util/time.h>

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

	#ifndef WIN32
	#include <fcntl.h>
	#else
	#include <codecvt>
	#endif

	#ifdef USE_POLL
	#include <poll.h>
	#endif

	// Settings
	static Mutex g_proxyinfo_mutex;
	static proxyType proxyInfo[NET_MAX] GUARDED_BY(g_proxyinfo_mutex);
	static proxyType nameProxy GUARDED_BY(g_proxyinfo_mutex);
	int nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
	bool fNameLookup = DEFAULT_NAME_LOOKUP;

	// Need ample time for negotiation for very slow proxies such as Tor
	// (milliseconds)
	static const int SOCKS5_RECV_TIMEOUT = 20 * 1000;
	static std::atomic<bool> interruptSocks5Recv(false);

	std::vector<CNetAddr> WrappedGetAddrInfo(const std::string &name,
	bool allow_lookup) {
	addrinfo ai_hint{};
	// We want a TCP port, which is a streaming socket type
	ai_hint.ai_socktype = SOCK_STREAM;
	ai_hint.ai_protocol = IPPROTO_TCP;
	// We don't care which address family (IPv4 or IPv6) is returned
	ai_hint.ai_family = AF_UNSPEC;
	// If we allow lookups of hostnames, use the AI_ADDRCONFIG flag to only
	// return addresses whose family we have an address configured for.
	//
	// If we don't allow lookups, then use the AI_NUMERICHOST flag for
	// getaddrinfo to only decode numerical network addresses and suppress
	// hostname lookups.
	ai_hint.ai_flags = allow_lookup ? AI_ADDRCONFIG : AI_NUMERICHOST;

	addrinfo *ai_res{nullptr};
	const int n_err{getaddrinfo(name.c_str(), nullptr, &ai_hint, &ai_res)};
	if (n_err != 0) {
	return {};
	}

	// Traverse the linked list starting with ai_trav.
	addrinfo *ai_trav{ai_res};
	std::vector<CNetAddr> resolved_addresses;
	while (ai_trav != nullptr) {
	if (ai_trav->ai_family == AF_INET) {
	assert(ai_trav->ai_addrlen >= sizeof(sockaddr_in));
	resolved_addresses.emplace_back(
	reinterpret_cast<sockaddr_in *>(ai_trav->ai_addr)->sin_addr);
	}
	if (ai_trav->ai_family == AF_INET6) {
	assert(ai_trav->ai_addrlen >= sizeof(sockaddr_in6));
	const sockaddr_in6 *s6{
	reinterpret_cast<sockaddr_in6 *>(ai_trav->ai_addr)};
	resolved_addresses.emplace_back(s6->sin6_addr, s6->sin6_scope_id);
	}
	ai_trav = ai_trav->ai_next;
	}
	freeaddrinfo(ai_res);

	return resolved_addresses;
	}

	DNSLookupFn g_dns_lookup{WrappedGetAddrInfo};

	enum Network ParseNetwork(const std::string &net_in) {
	std::string net = ToLower(net_in);
	if (net == "ipv4") {
	return NET_IPV4;
	}
	if (net == "ipv6") {
	return NET_IPV6;
	}
	if (net == "onion") {
	return NET_ONION;
	}
	if (net == "tor") {
	LogPrintf("Warning: net name 'tor' is deprecated and will be removed "
	"in the future. You should use 'onion' instead.\n");
	return NET_ONION;
	}
	if (net == "i2p") {
	return NET_I2P;
	}
	return NET_UNROUTABLE;
	}

	std::string GetNetworkName(enum Network net) {
	switch (net) {
	case NET_UNROUTABLE:
	return "not_publicly_routable";
	case NET_IPV4:
	return "ipv4";
	case NET_IPV6:
	return "ipv6";
	case NET_ONION:
	return "onion";
	case NET_I2P:
	return "i2p";
	case NET_CJDNS:
	return "cjdns";
	case NET_INTERNAL:
	return "internal";
	case NET_MAX:
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	std::vector<std::string> GetNetworkNames(bool append_unroutable) {
	std::vector<std::string> names;
	for (int n = 0; n < NET_MAX; ++n) {
	const enum Network network { static_cast<Network>(n) };
	if (network == NET_UNROUTABLE \|\| network == NET_CJDNS \|\|
	network == NET_INTERNAL) {
	continue;
	}
	names.emplace_back(GetNetworkName(network));
	}
	if (append_unroutable) {
	names.emplace_back(GetNetworkName(NET_UNROUTABLE));
	}
	return names;
	}

	static bool LookupIntern(const std::string &name, std::vector<CNetAddr> &vIP,
	unsigned int nMaxSolutions, bool fAllowLookup,
	DNSLookupFn dns_lookup_function) {
	vIP.clear();

	if (!ValidAsCString(name)) {
	return false;
	}

	{
	CNetAddr addr;
	// From our perspective, onion addresses are not hostnames but rather
	// direct encodings of CNetAddr much like IPv4 dotted-decimal notation
	// or IPv6 colon-separated hextet notation. Since we can't use
	// getaddrinfo to decode them and it wouldn't make sense to resolve
	// them, we return a network address representing it instead. See
	// CNetAddr::SetSpecial(const std::string&) for more details.
	if (addr.SetSpecial(name)) {
	vIP.push_back(addr);
	return true;
	}
	}

	for (const CNetAddr &resolved : dns_lookup_function(name, fAllowLookup)) {
	if (nMaxSolutions > 0 && vIP.size() >= nMaxSolutions) {
	break;
	}

	// Never allow resolving to an internal address. Consider any such
	// result invalid.
	if (!resolved.IsInternal()) {
	vIP.push_back(resolved);
	}
	}

	return (vIP.size() > 0);
	}

	bool LookupHost(const std::string &name, std::vector<CNetAddr> &vIP,
	unsigned int nMaxSolutions, bool fAllowLookup,
	DNSLookupFn dns_lookup_function) {
	if (!ValidAsCString(name)) {
	return false;
	}
	std::string strHost = name;
	if (strHost.empty()) {
	return false;
	}
	if (strHost.front() == '[' && strHost.back() == ']') {
	strHost = strHost.substr(1, strHost.size() - 2);
	}

	return LookupIntern(strHost, vIP, nMaxSolutions, fAllowLookup,
	dns_lookup_function);
	}

	bool LookupHost(const std::string &name, CNetAddr &addr, bool fAllowLookup,
	DNSLookupFn dns_lookup_function) {
	if (!ValidAsCString(name)) {
	return false;
	}
	std::vector<CNetAddr> vIP;
	LookupHost(name, vIP, 1, fAllowLookup, dns_lookup_function);
	if (vIP.empty()) {
	return false;
	}
	addr = vIP.front();
	return true;
	}

	bool Lookup(const std::string &name, std::vector<CService> &vAddr,
	uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions,
	DNSLookupFn dns_lookup_function) {
	if (name.empty() \|\| !ValidAsCString(name)) {
	return false;
	}
	uint16_t port{portDefault};
	std::string hostname;
	SplitHostPort(name, port, hostname);

	std::vector<CNetAddr> vIP;
	bool fRet = LookupIntern(hostname, vIP, nMaxSolutions, fAllowLookup,
	dns_lookup_function);
	if (!fRet) {
	return false;
	}
	vAddr.resize(vIP.size());
	for (unsigned int i = 0; i < vIP.size(); i++) {
	vAddr[i] = CService(vIP[i], port);
	}
	return true;
	}

	bool Lookup(const std::string &name, CService &addr, uint16_t portDefault,
	bool fAllowLookup, DNSLookupFn dns_lookup_function) {
	if (!ValidAsCString(name)) {
	return false;
	}
	std::vector<CService> vService;
	bool fRet = Lookup(name, vService, portDefault, fAllowLookup, 1,
	dns_lookup_function);
	if (!fRet) {
	return false;
	}
	addr = vService[0];
	return true;
	}

	CService LookupNumeric(const std::string &name, uint16_t portDefault,
	DNSLookupFn dns_lookup_function) {
	if (!ValidAsCString(name)) {
	return {};
	}
	CService addr;
	// "1.2:345" will fail to resolve the ip, but will still set the port.
	// If the ip fails to resolve, re-init the result.
	if (!Lookup(name, addr, portDefault, false, dns_lookup_function)) {
	addr = CService();
	}
	return addr;
	}

	/** SOCKS version */
	enum SOCKSVersion : uint8_t { SOCKS4 = 0x04, SOCKS5 = 0x05 };

	/** Values defined for METHOD in RFC1928 */
	enum SOCKS5Method : uint8_t {
	NOAUTH = 0x00, //!< No authentication required
	GSSAPI = 0x01, //!< GSSAPI
	USER_PASS = 0x02, //!< Username/password
	NO_ACCEPTABLE = 0xff, //!< No acceptable methods
	};

	/** Values defined for CMD in RFC1928 */
	enum SOCKS5Command : uint8_t {
	CONNECT = 0x01,
	BIND = 0x02,
	UDP_ASSOCIATE = 0x03
	};

	/** Values defined for REP in RFC1928 */
	enum SOCKS5Reply : uint8_t {
	SUCCEEDED = 0x00, //!< Succeeded
	GENFAILURE = 0x01, //!< General failure
	NOTALLOWED = 0x02, //!< Connection not allowed by ruleset
	NETUNREACHABLE = 0x03, //!< Network unreachable
	HOSTUNREACHABLE = 0x04, //!< Network unreachable
	CONNREFUSED = 0x05, //!< Connection refused
	TTLEXPIRED = 0x06, //!< TTL expired
	CMDUNSUPPORTED = 0x07, //!< Command not supported
	ATYPEUNSUPPORTED = 0x08, //!< Address type not supported
	};

	/** Values defined for ATYPE in RFC1928 */
	enum SOCKS5Atyp : uint8_t {
	IPV4 = 0x01,
	DOMAINNAME = 0x03,
	IPV6 = 0x04,
	};

	/** Status codes that can be returned by InterruptibleRecv */
	enum class IntrRecvError {
	OK,
	Timeout,
	Disconnected,
	NetworkError,
	Interrupted
	};

	/**
	* Try to read a specified number of bytes from a socket. Please read the "see
	* also" section for more detail.
	*
	* @param data The buffer where the read bytes should be stored.
	* @param len The number of bytes to read into the specified buffer.
	* @param timeout The total timeout in milliseconds for this read.
	* @param sock The socket (has to be in non-blocking mode) from which to read
	* bytes.
	*
	* @returns An IntrRecvError indicating the resulting status of this read.
	* IntrRecvError::OK only if all of the specified number of bytes were
	* read.
	*
	* @see This function can be interrupted by calling InterruptSocks5(bool).
	* Sockets can be made non-blocking with SetSocketNonBlocking(const
	* SOCKET&, bool).
	*/
	static IntrRecvError InterruptibleRecv(uint8_t *data, size_t len, int timeout,
	const Sock &sock) {
	int64_t curTime = GetTimeMillis();
	int64_t endTime = curTime + timeout;
	while (len > 0 && curTime < endTime) {
	// Optimistically try the recv first
	ssize_t ret = sock.Recv(data, len, 0);
	if (ret > 0) {
	len -= ret;
	data += ret;
	} else if (ret == 0) {
	// Unexpected disconnection
	return IntrRecvError::Disconnected;
	} else {
	// Other error or blocking
	int nErr = WSAGetLastError();
	if (nErr == WSAEINPROGRESS \|\| nErr == WSAEWOULDBLOCK \|\|
	nErr == WSAEINVAL) {
	// Only wait at most MAX_WAIT_FOR_IO at a time, unless
	// we're approaching the end of the specified total timeout
	const auto remaining =
	std::chrono::milliseconds{endTime - curTime};
	const auto timeout_ = std::min(
	remaining, std::chrono::milliseconds{MAX_WAIT_FOR_IO});
	if (!sock.Wait(timeout_, Sock::RECV)) {
	return IntrRecvError::NetworkError;
	}
	} else {
	return IntrRecvError::NetworkError;
	}
	}
	if (interruptSocks5Recv) {
	return IntrRecvError::Interrupted;
	}
	curTime = GetTimeMillis();
	}
	return len == 0 ? IntrRecvError::OK : IntrRecvError::Timeout;
	}

	/** Credentials for proxy authentication */
	struct ProxyCredentials {
	std::string username;
	std::string password;
	};

	/** Convert SOCKS5 reply to an error message */
	static std::string Socks5ErrorString(uint8_t err) {
	switch (err) {
	case SOCKS5Reply::GENFAILURE:
	return "general failure";
	case SOCKS5Reply::NOTALLOWED:
	return "connection not allowed";
	case SOCKS5Reply::NETUNREACHABLE:
	return "network unreachable";
	case SOCKS5Reply::HOSTUNREACHABLE:
	return "host unreachable";
	case SOCKS5Reply::CONNREFUSED:
	return "connection refused";
	case SOCKS5Reply::TTLEXPIRED:
	return "TTL expired";
	case SOCKS5Reply::CMDUNSUPPORTED:
	return "protocol error";
	case SOCKS5Reply::ATYPEUNSUPPORTED:
	return "address type not supported";
	default:
	return "unknown";
	}
	}

	/**
	* Connect to a specified destination service through an already connected
	* SOCKS5 proxy.
	*
	* @param strDest The destination fully-qualified domain name.
	* @param port The destination port.
	* @param auth The credentials with which to authenticate with the specified
	* SOCKS5 proxy.
	* @param sock The SOCKS5 proxy socket.
	*
	* @returns Whether or not the operation succeeded.
	*
	* @note The specified SOCKS5 proxy socket must already be connected to the
	* SOCKS5 proxy.
	*
	* @see <a href="https://www.ietf.org/rfc/rfc1928.txt">RFC1928: SOCKS Protocol
	* Version 5</a>
	*/
	static bool Socks5(const std::string &strDest, uint16_t port,
	const ProxyCredentials *auth, const Sock &sock) {
	IntrRecvError recvr;
	LogPrint(BCLog::NET, "SOCKS5 connecting %s\n", strDest);
	if (strDest.size() > 255) {
	return error("Hostname too long");
	}
	// Construct the version identifier/method selection message
	std::vector<uint8_t> vSocks5Init;
	// We want the SOCK5 protocol
	vSocks5Init.push_back(SOCKSVersion::SOCKS5);
	if (auth) {
	// 2 method identifiers follow...
	vSocks5Init.push_back(0x02);
	vSocks5Init.push_back(SOCKS5Method::NOAUTH);
	vSocks5Init.push_back(SOCKS5Method::USER_PASS);
	} else {
	// 1 method identifier follows...
	vSocks5Init.push_back(0x01);
	vSocks5Init.push_back(SOCKS5Method::NOAUTH);
	}
	ssize_t ret =
	sock.Send(vSocks5Init.data(), vSocks5Init.size(), MSG_NOSIGNAL);
	if (ret != (ssize_t)vSocks5Init.size()) {
	return error("Error sending to proxy");
	}
	uint8_t pchRet1[2];
	if ((recvr = InterruptibleRecv(pchRet1, 2, SOCKS5_RECV_TIMEOUT, sock)) !=
	IntrRecvError::OK) {
	LogPrintf("Socks5() connect to %s:%d failed: InterruptibleRecv() "
	"timeout or other failure\n",
	strDest, port);
	return false;
	}
	if (pchRet1[0] != SOCKSVersion::SOCKS5) {
	return error("Proxy failed to initialize");
	}
	if (pchRet1[1] == SOCKS5Method::USER_PASS && auth) {
	// Perform username/password authentication (as described in RFC1929)
	std::vector<uint8_t> vAuth;
	// Current (and only) version of user/pass subnegotiation
	vAuth.push_back(0x01);
	if (auth->username.size() > 255 \|\| auth->password.size() > 255) {
	return error("Proxy username or password too long");
	}
	vAuth.push_back(auth->username.size());
	vAuth.insert(vAuth.end(), auth->username.begin(), auth->username.end());
	vAuth.push_back(auth->password.size());
	vAuth.insert(vAuth.end(), auth->password.begin(), auth->password.end());
	ret = sock.Send(vAuth.data(), vAuth.size(), MSG_NOSIGNAL);
	if (ret != (ssize_t)vAuth.size()) {
	return error("Error sending authentication to proxy");
	}
	LogPrint(BCLog::PROXY, "SOCKS5 sending proxy authentication %s:%s\n",
	auth->username, auth->password);
	uint8_t pchRetA[2];
	if ((recvr = InterruptibleRecv(pchRetA, 2, SOCKS5_RECV_TIMEOUT,
	sock)) != IntrRecvError::OK) {
	return error("Error reading proxy authentication response");
	}
	if (pchRetA[0] != 0x01 \|\| pchRetA[1] != 0x00) {
	return error("Proxy authentication unsuccessful");
	}
	} else if (pchRet1[1] == SOCKS5Method::NOAUTH) {
	// Perform no authentication
	} else {
	return error("Proxy requested wrong authentication method %02x",
	pchRet1[1]);
	}
	std::vector<uint8_t> vSocks5;
	// VER protocol version
	vSocks5.push_back(SOCKSVersion::SOCKS5);
	// CMD CONNECT
	vSocks5.push_back(SOCKS5Command::CONNECT);
	// RSV Reserved must be 0
	vSocks5.push_back(0x00);
	// ATYP DOMAINNAME
	vSocks5.push_back(SOCKS5Atyp::DOMAINNAME);
	// Length<=255 is checked at beginning of function
	vSocks5.push_back(strDest.size());
	vSocks5.insert(vSocks5.end(), strDest.begin(), strDest.end());
	vSocks5.push_back((port >> 8) & 0xFF);
	vSocks5.push_back((port >> 0) & 0xFF);
	ret = sock.Send(vSocks5.data(), vSocks5.size(), MSG_NOSIGNAL);
	if (ret != (ssize_t)vSocks5.size()) {
	return error("Error sending to proxy");
	}
	uint8_t pchRet2[4];
	if ((recvr = InterruptibleRecv(pchRet2, 4, SOCKS5_RECV_TIMEOUT, sock)) !=
	IntrRecvError::OK) {
	if (recvr == IntrRecvError::Timeout) {
	/**
	* If a timeout happens here, this effectively means we timed out
	* while connecting to the remote node. This is very common for Tor,
	* so do not print an error message.
	*/
	return false;
	} else {
	return error("Error while reading proxy response");
	}
	}
	if (pchRet2[0] != SOCKSVersion::SOCKS5) {
	return error("Proxy failed to accept request");
	}
	if (pchRet2[1] != SOCKS5Reply::SUCCEEDED) {
	// Failures to connect to a peer that are not proxy errors
	LogPrintf("Socks5() connect to %s:%d failed: %s\n", strDest, port,
	Socks5ErrorString(pchRet2[1]));
	return false;
	}
	// Reserved field must be 0
	if (pchRet2[2] != 0x00) {
	return error("Error: malformed proxy response");
	}
	uint8_t pchRet3[256];
	switch (pchRet2[3]) {
	case SOCKS5Atyp::IPV4:
	recvr = InterruptibleRecv(pchRet3, 4, SOCKS5_RECV_TIMEOUT, sock);
	break;
	case SOCKS5Atyp::IPV6:
	recvr = InterruptibleRecv(pchRet3, 16, SOCKS5_RECV_TIMEOUT, sock);
	break;
	case SOCKS5Atyp::DOMAINNAME: {
	recvr = InterruptibleRecv(pchRet3, 1, SOCKS5_RECV_TIMEOUT, sock);
	if (recvr != IntrRecvError::OK) {
	return error("Error reading from proxy");
	}
	int nRecv = pchRet3[0];
	recvr =
	InterruptibleRecv(pchRet3, nRecv, SOCKS5_RECV_TIMEOUT, sock);
	break;
	}
	default:
	return error("Error: malformed proxy response");
	}
	if (recvr != IntrRecvError::OK) {
	return error("Error reading from proxy");
	}
	if ((recvr = InterruptibleRecv(pchRet3, 2, SOCKS5_RECV_TIMEOUT, sock)) !=
	IntrRecvError::OK) {
	return error("Error reading from proxy");
	}
	LogPrint(BCLog::NET, "SOCKS5 connected %s\n", strDest);
	return true;
	}

	std::unique_ptr<Sock> CreateSockTCP(const CService &address_family) {
	// Create a sockaddr from the specified service.
	struct sockaddr_storage sockaddr;
	socklen_t len = sizeof(sockaddr);
	if (!address_family.GetSockAddr((struct sockaddr *)&sockaddr, &len)) {
	LogPrintf("Cannot create socket for %s: unsupported network\n",
	address_family.ToString());
	return nullptr;
	}

	// Create a TCP socket in the address family of the specified service.
	SOCKET hSocket = socket(((struct sockaddr *)&sockaddr)->sa_family,
	SOCK_STREAM, IPPROTO_TCP);
	if (hSocket == INVALID_SOCKET) {
	return nullptr;
	}

	// Ensure that waiting for I/O on this socket won't result in undefined
	// behavior.
	if (!IsSelectableSocket(hSocket)) {
	CloseSocket(hSocket);
	LogPrintf("Cannot create connection: non-selectable socket created (fd "
	">= FD_SETSIZE ?)\n");
	return nullptr;
	}

	#ifdef SO_NOSIGPIPE
	int set = 1;
	// Set the no-sigpipe option on the socket for BSD systems, other UNIXes
	// should use the MSG_NOSIGNAL flag for every send.
	setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (sockopt_arg_type)&set,
	sizeof(int));
	#endif

	// Set the no-delay option (disable Nagle's algorithm) on the TCP socket.
	SetSocketNoDelay(hSocket);

	// Set the non-blocking option on the socket.
	if (!SetSocketNonBlocking(hSocket, true)) {
	CloseSocket(hSocket);
	LogPrintf("CreateSocket: Setting socket to non-blocking "
	"failed, error %s\n",
	NetworkErrorString(WSAGetLastError()));
	return nullptr;
	}
	return std::make_unique<Sock>(hSocket);
	}

	std::function<std::unique_ptr<Sock>(const CService &)> CreateSock =
	CreateSockTCP;

	template <typename... Args>
	static void LogConnectFailure(bool manual_connection, const char *fmt,
	const Args &...args) {
	std::string error_message = tfm::format(fmt, args...);
	if (manual_connection) {
	LogPrintf("%s\n", error_message);
	} else {
	LogPrint(BCLog::NET, "%s\n", error_message);
	}
	}

	bool ConnectSocketDirectly(const CService &addrConnect, const Sock &sock,
	int nTimeout, bool manual_connection) {
	// Create a sockaddr from the specified service.
	struct sockaddr_storage sockaddr;
	socklen_t len = sizeof(sockaddr);
	if (sock.Get() == INVALID_SOCKET) {
	LogPrintf("Cannot connect to %s: invalid socket\n",
	addrConnect.ToString());
	return false;
	}
	if (!addrConnect.GetSockAddr((struct sockaddr *)&sockaddr, &len)) {
	LogPrintf("Cannot connect to %s: unsupported network\n",
	addrConnect.ToString());
	return false;
	}

	// Connect to the addrConnect service on the hSocket socket.
	if (sock.Connect(reinterpret_cast<struct sockaddr *>(&sockaddr), len) ==
	SOCKET_ERROR) {
	int nErr = WSAGetLastError();
	// WSAEINVAL is here because some legacy version of winsock uses it
	if (nErr == WSAEINPROGRESS \|\| nErr == WSAEWOULDBLOCK \|\|
	nErr == WSAEINVAL) {
	// Connection didn't actually fail, but is being established
	// asynchronously. Thus, use async I/O api (select/poll)
	// synchronously to check for successful connection with a timeout.
	const Sock::Event requested = Sock::RECV \| Sock::SEND;
	Sock::Event occurred;
	if (!sock.Wait(std::chrono::milliseconds{nTimeout}, requested,
	&occurred)) {
	LogPrintf("wait for connect to %s failed: %s\n",
	addrConnect.ToString(),
	NetworkErrorString(WSAGetLastError()));
	return false;
	} else if (occurred == 0) {
	LogPrint(BCLog::NET, "connection attempt to %s timed out\n",
	addrConnect.ToString());
	return false;
	}

	// Even if the wait was successful, the connect might not
	// have been successful. The reason for this failure is hidden away
	// in the SO_ERROR for the socket in modern systems. We read it into
	// sockerr here.
	int sockerr;
	socklen_t sockerr_len = sizeof(sockerr);
	if (sock.GetSockOpt(SOL_SOCKET, SO_ERROR,
	(sockopt_arg_type)&sockerr,
	&sockerr_len) == SOCKET_ERROR) {
	LogPrintf("getsockopt() for %s failed: %s\n",
	addrConnect.ToString(),
	NetworkErrorString(WSAGetLastError()));
	return false;
	}
	if (sockerr != 0) {
	LogConnectFailure(
	manual_connection, "connect() to %s failed after wait: %s",
	addrConnect.ToString(), NetworkErrorString(sockerr));
	return false;
	}
	}
	#ifdef WIN32
	else if (WSAGetLastError() != WSAEISCONN)
	#else
	else
	#endif
	{
	LogConnectFailure(manual_connection, "connect() to %s failed: %s",
	addrConnect.ToString(),
	NetworkErrorString(WSAGetLastError()));
	return false;
	}
	}
	return true;
	}

	bool SetProxy(enum Network net, const proxyType &addrProxy) {
	assert(net >= 0 && net < NET_MAX);
	if (!addrProxy.IsValid()) {
	return false;
	}
	LOCK(g_proxyinfo_mutex);
	proxyInfo[net] = addrProxy;
	return true;
	}

	bool GetProxy(enum Network net, proxyType &proxyInfoOut) {
	assert(net >= 0 && net < NET_MAX);
	LOCK(g_proxyinfo_mutex);
	if (!proxyInfo[net].IsValid()) {
	return false;
	}
	proxyInfoOut = proxyInfo[net];
	return true;
	}

	bool SetNameProxy(const proxyType &addrProxy) {
	if (!addrProxy.IsValid()) {
	return false;
	}
	LOCK(g_proxyinfo_mutex);
	nameProxy = addrProxy;
	return true;
	}

	bool GetNameProxy(proxyType &nameProxyOut) {
	LOCK(g_proxyinfo_mutex);
	if (!nameProxy.IsValid()) {
	return false;
	}
	nameProxyOut = nameProxy;
	return true;
	}

	bool HaveNameProxy() {
	LOCK(g_proxyinfo_mutex);
	return nameProxy.IsValid();
	}

	bool IsProxy(const CNetAddr &addr) {
	LOCK(g_proxyinfo_mutex);
	for (int i = 0; i < NET_MAX; i++) {
	if (addr == static_cast<CNetAddr>(proxyInfo[i].proxy)) {
	return true;
	}
	}
	return false;
	}

	bool ConnectThroughProxy(const proxyType &proxy, const std::string &strDest,
	uint16_t port, const Sock &sock, int nTimeout,
	bool &outProxyConnectionFailed) {
	// first connect to proxy server
	if (!ConnectSocketDirectly(proxy.proxy, sock, nTimeout, true)) {
	outProxyConnectionFailed = true;
	return false;
	}
	// do socks negotiation
	if (proxy.randomize_credentials) {
	ProxyCredentials random_auth;
	static std::atomic_int counter(0);
	random_auth.username = random_auth.password =
	strprintf("%i", counter++);
	if (!Socks5(strDest, port, &random_auth, sock)) {
	return false;
	}
	} else if (!Socks5(strDest, port, 0, sock)) {
	return false;
	}
	return true;
	}

	bool LookupSubNet(const std::string &strSubnet, CSubNet &ret,
	DNSLookupFn dns_lookup_function) {
	if (!ValidAsCString(strSubnet)) {
	return false;
	}
	size_t slash = strSubnet.find_last_of('/');
	std::vector<CNetAddr> vIP;

	std::string strAddress = strSubnet.substr(0, slash);
	// TODO: Use LookupHost(const std::string&, CNetAddr&, bool) instead to just
	if (LookupHost(strAddress, vIP, 1, false, dns_lookup_function)) {
	CNetAddr network = vIP[0];
	if (slash != strSubnet.npos) {
	std::string strNetmask = strSubnet.substr(slash + 1);
	uint8_t n;
	if (ParseUInt8(strNetmask, &n)) {
	// If valid number, assume CIDR variable-length subnet masking
	ret = CSubNet(network, n);
	return ret.IsValid();
	} else {
	// If not a valid number, try full netmask syntax
	// Never allow lookup for netmask
	if (LookupHost(strNetmask, vIP, 1, false,
	dns_lookup_function)) {
	ret = CSubNet(network, vIP[0]);
	return ret.IsValid();
	}
	}
	} else {
	ret = CSubNet(network);
	return ret.IsValid();
	}
	}
	return false;
	}

	bool SetSocketNonBlocking(const SOCKET &hSocket, bool fNonBlocking) {
	if (fNonBlocking) {
	#ifdef WIN32
	u_long nOne = 1;
	if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR) {
	#else
	int fFlags = fcntl(hSocket, F_GETFL, 0);
	if (fcntl(hSocket, F_SETFL, fFlags \| O_NONBLOCK) == SOCKET_ERROR) {
	#endif
	return false;
	}
	} else {
	#ifdef WIN32
	u_long nZero = 0;
	if (ioctlsocket(hSocket, FIONBIO, &nZero) == SOCKET_ERROR) {
	#else
	int fFlags = fcntl(hSocket, F_GETFL, 0);
	if (fcntl(hSocket, F_SETFL, fFlags & ~O_NONBLOCK) == SOCKET_ERROR) {
	#endif
	return false;
	}
	}

	return true;
	}

	bool SetSocketNoDelay(const SOCKET &hSocket) {
	int set = 1;
	int rc = setsockopt(hSocket, IPPROTO_TCP, TCP_NODELAY,
	(sockopt_arg_type)&set, sizeof(int));
	return rc == 0;
	}

	void InterruptSocks5(bool interrupt) {
	interruptSocks5Recv = interrupt;
	}
	+
	+bool IsBadPort(uint16_t port) {
	+ // Don't forget to update doc/p2p-bad-ports.md if you change this list.
	+
	+ switch (port) {
	+ case 1: // tcpmux
	+ case 7: // echo
	+ case 9: // discard
	+ case 11: // systat
	+ case 13: // daytime
	+ case 15: // netstat
	+ case 17: // qotd
	+ case 19: // chargen
	+ case 20: // ftp data
	+ case 21: // ftp access
	+ case 22: // ssh
	+ case 23: // telnet
	+ case 25: // smtp
	+ case 37: // time
	+ case 42: // name
	+ case 43: // nicname
	+ case 53: // domain
	+ case 69: // tftp
	+ case 77: // priv-rjs
	+ case 79: // finger
	+ case 87: // ttylink
	+ case 95: // supdup
	+ case 101: // hostname
	+ case 102: // iso-tsap
	+ case 103: // gppitnp
	+ case 104: // acr-nema
	+ case 109: // pop2
	+ case 110: // pop3
	+ case 111: // sunrpc
	+ case 113: // auth
	+ case 115: // sftp
	+ case 117: // uucp-path
	+ case 119: // nntp
	+ case 123: // NTP
	+ case 135: // loc-srv /epmap
	+ case 137: // netbios
	+ case 139: // netbios
	+ case 143: // imap2
	+ case 161: // snmp
	+ case 179: // BGP
	+ case 389: // ldap
	+ case 427: // SLP (Also used by Apple Filing Protocol)
	+ case 465: // smtp+ssl
	+ case 512: // print / exec
	+ case 513: // login
	+ case 514: // shell
	+ case 515: // printer
	+ case 526: // tempo
	+ case 530: // courier
	+ case 531: // chat
	+ case 532: // netnews
	+ case 540: // uucp
	+ case 548: // AFP (Apple Filing Protocol)
	+ case 554: // rtsp
	+ case 556: // remotefs
	+ case 563: // nntp+ssl
	+ case 587: // smtp (rfc6409)
	+ case 601: // syslog-conn (rfc3195)
	+ case 636: // ldap+ssl
	+ case 989: // ftps-data
	+ case 990: // ftps
	+ case 993: // ldap+ssl
	+ case 995: // pop3+ssl
	+ case 1719: // h323gatestat
	+ case 1720: // h323hostcall
	+ case 1723: // pptp
	+ case 2049: // nfs
	+ case 3659: // apple-sasl / PasswordServer
	+ case 4045: // lockd
	+ case 5060: // sip
	+ case 5061: // sips
	+ case 6000: // X11
	+ case 6566: // sane-port
	+ case 6665: // Alternate IRC
	+ case 6666: // Alternate IRC
	+ case 6667: // Standard IRC
	+ case 6668: // Alternate IRC
	+ case 6669: // Alternate IRC
	+ case 6697: // IRC + TLS
	+ case 10080: // Amanda
	+ return true;
	+ }
	+ return false;
	+}
	diff --git a/src/netbase.h b/src/netbase.h
	index 3cd929e57..dbaea5090 100644
	--- a/src/netbase.h
	+++ b/src/netbase.h
	@@ -1,229 +1,238 @@
	// 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.

	#ifndef BITCOIN_NETBASE_H
	#define BITCOIN_NETBASE_H

	#if defined(HAVE_CONFIG_H)
	#include <config/bitcoin-config.h>
	#endif

	#include <compat.h>
	#include <netaddress.h>
	#include <serialize.h>
	#include <util/sock.h>

	#include <cstdint>
	#include <functional>
	#include <memory>
	#include <string>
	#include <vector>

	extern int nConnectTimeout;
	extern bool fNameLookup;

	//! -timeout default
	static const int DEFAULT_CONNECT_TIMEOUT = 5000;
	//! -dns default
	static const int DEFAULT_NAME_LOOKUP = true;

	class proxyType {
	public:
	proxyType() : randomize_credentials(false) {}
	explicit proxyType(const CService &_proxy,
	bool _randomize_credentials = false)
	: proxy(_proxy), randomize_credentials(_randomize_credentials) {}

	bool IsValid() const { return proxy.IsValid(); }

	CService proxy;
	bool randomize_credentials;
	};

	/**
	* Wrapper for getaddrinfo(3). Do not use directly: call
	* Lookup/LookupHost/LookupNumeric/LookupSubNet.
	*/
	std::vector<CNetAddr> WrappedGetAddrInfo(const std::string &name,
	bool allow_lookup);

	enum Network ParseNetwork(const std::string &net);
	std::string GetNetworkName(enum Network net);
	/**
	* Return a vector of publicly routable Network names; optionally append
	* NET_UNROUTABLE
	*/
	std::vector<std::string> GetNetworkNames(bool append_unroutable = false);
	bool SetProxy(enum Network net, const proxyType &addrProxy);
	bool GetProxy(enum Network net, proxyType &proxyInfoOut);
	bool IsProxy(const CNetAddr &addr);

	/**
	* Set the name proxy to use for all connections to nodes specified by a
	* hostname. After setting this proxy, connecting to a node specified by a
	* hostname won't result in a local lookup of said hostname, rather, connect to
	* the node by asking the name proxy for a proxy connection to the hostname,
	* effectively delegating the hostname lookup to the specified proxy.
	*
	* This delegation increases privacy for those who set the name proxy as they no
	* longer leak their external hostname queries to their DNS servers.
	*
	* @returns Whether or not the operation succeeded.
	*
	* @note SOCKS5's support for UDP-over-SOCKS5 has been considered, but no SOCK5
	* server in common use (most notably Tor) actually implements UDP
	* support, and a DNS resolver is beyond the scope of this project.
	*/
	bool SetNameProxy(const proxyType &addrProxy);
	bool HaveNameProxy();
	bool GetNameProxy(proxyType &nameProxyOut);

	using DNSLookupFn =
	std::function<std::vector<CNetAddr>(const std::string &, bool)>;
	extern DNSLookupFn g_dns_lookup;

	/**
	* Resolve a host string to its corresponding network addresses.
	*
	* @param name The string representing a host. Could be a name or a numerical
	* IP address (IPv6 addresses in their bracketed form are
	* allowed).
	* @param[out] vIP The resulting network addresses to which the specified host
	* string resolved.
	*
	* @returns Whether or not the specified host string successfully resolved to
	* any resulting network addresses.
	*
	* @see Lookup(const std::string&, std::vector<CService>&, uint16_t, bool,
	* unsigned int, DNSLookupFn) for additional parameter descriptions.
	*/
	bool LookupHost(const std::string &name, std::vector<CNetAddr> &vIP,
	unsigned int nMaxSolutions, bool fAllowLookup,
	DNSLookupFn dns_lookup_function = g_dns_lookup);

	/**
	* Resolve a host string to its first corresponding network address.
	*
	* @see LookupHost(const std::string&, std::vector<CNetAddr>&, uint16_t,
	* bool, DNSLookupFn) for additional parameter descriptions.
	*/
	bool LookupHost(const std::string &name, CNetAddr &addr, bool fAllowLookup,
	DNSLookupFn dns_lookup_function = g_dns_lookup);

	/**
	* Resolve a service string to its corresponding service.
	*
	* @param name The string representing a service. Could be a name or a
	* numerical IP address (IPv6 addresses should be in their
	* disambiguated bracketed form), optionally followed by a
	* uint16_t port number. (e.g. example.com:8333 or
	* [2001:db8:85a3:8d3:1319:8a2e:370:7348]:420)
	* @param[out] vAddr The resulting services to which the specified service
	* string resolved.
	* @param portDefault The default port for resulting services if not specified
	* by the service string.
	* @param fAllowLookup Whether or not hostname lookups are permitted. If yes,
	* external queries may be performed.
	* @param nMaxSolutions The maximum number of results we want, specifying 0
	* means "as many solutions as we get."
	*
	* @returns Whether or not the service string successfully resolved to any
	* resulting services.
	*/
	bool Lookup(const std::string &name, std::vector<CService> &vAddr,
	uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions,
	DNSLookupFn dns_lookup_function = g_dns_lookup);

	/**
	* Resolve a service string to its first corresponding service.
	*
	* @see Lookup(const std::string&, std::vector<CService>&, int, bool,
	* unsigned int, DNSLookupFn) for additional parameter descriptions.
	*/
	bool Lookup(const std::string &name, CService &addr, uint16_t portDefault,
	bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);

	/**
	* Resolve a service string with a numeric IP to its first corresponding
	* service.
	*
	* @returns The resulting CService if the resolution was successful, [::]:0
	* otherwise.
	*
	* @see Lookup(const std::string&, CService&, int, bool, DNSLookupFn) for
	* additional parameter descriptions.
	*/
	CService LookupNumeric(const std::string &name, uint16_t portDefault = 0,
	DNSLookupFn dns_lookup_function = g_dns_lookup);

	/**
	* Parse and resolve a specified subnet string into the appropriate internal
	* representation.
	*
	* @param strSubnet A string representation of a subnet of the form `network
	* address [ "/", ( CIDR-style suffix \| netmask ) ]`(e.g.
	* `2001:db8::/32`, `192.0.2.0/255.255.255.0`, or `8.8.8.8`).
	* @param subnet The resulting internal representation of a subnet.
	*
	* @returns Whether the operation succeeded or not.
	*/
	bool LookupSubNet(const std::string &strSubnet, CSubNet &subnet,
	DNSLookupFn dns_lookup_function = g_dns_lookup);

	/**
	* Create a TCP socket in the given address family.
	* @param[in] address_family The socket is created in the same address family as
	* this address.
	* @return pointer to the created Sock object or unique_ptr that owns nothing in
	* case of failure
	*/
	std::unique_ptr<Sock> CreateSockTCP(const CService &address_family);

	/**
	* Socket factory. Defaults to `CreateSockTCP()`, but can be overridden by unit
	* tests.
	*/
	extern std::function<std::unique_ptr<Sock>(const CService &)> CreateSock;

	/**
	* Try to connect to the specified service on the specified socket.
	*
	* @param addrConnect The service to which to connect.
	* @param sock The socket on which to connect.
	* @param nTimeout Wait this many milliseconds for the connection to be
	* established.
	* @param manual_connection Whether or not the connection was manually requested
	* (e.g. through the addnode RPC)
	*
	* @returns Whether or not a connection was successfully made.
	*/
	bool ConnectSocketDirectly(const CService &addrConnect, const Sock &sock,
	int nTimeout, bool manual_connection);

	/**
	* Connect to a specified destination service through a SOCKS5 proxy by first
	* connecting to the SOCKS5 proxy.
	*
	* @param proxy The SOCKS5 proxy.
	* @param strDest The destination service to which to connect.
	* @param port The destination port.
	* @param sock The socket on which to connect to the SOCKS5 proxy.
	* @param nTimeout Wait this many milliseconds for the connection to the SOCKS5
	* proxy to be established.
	* @param[out] outProxyConnectionFailed Whether or not the connection to the
	* SOCKS5 proxy failed.
	*
	* @returns Whether or not the operation succeeded.
	*/
	bool ConnectThroughProxy(const proxyType &proxy, const std::string &strDest,
	uint16_t port, const Sock &sock, int nTimeout,
	bool &outProxyConnectionFailed);

	/** Disable or enable blocking-mode for a socket */
	bool SetSocketNonBlocking(const SOCKET &hSocket, bool fNonBlocking);
	/** Set the TCP_NODELAY flag on a socket */
	bool SetSocketNoDelay(const SOCKET &hSocket);
	void InterruptSocks5(bool interrupt);

	+/**
	+ * Determine if a port is "bad" from the perspective of attempting to connect
	+ * to a node on that port.
	+ * @see doc/p2p-bad-ports.md
	+ * @param[in] port Port to check.
	+ * @returns whether the port is bad
	+ */
	+bool IsBadPort(uint16_t port);
	+
	#endif // BITCOIN_NETBASE_H
	diff --git a/src/test/fuzz/netaddress.cpp b/src/test/fuzz/netaddress.cpp
	index 4743409a9..e6087a1ae 100644
	--- a/src/test/fuzz/netaddress.cpp
	+++ b/src/test/fuzz/netaddress.cpp
	@@ -1,114 +1,115 @@
	// Copyright (c) 2020 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 <netaddress.h>

	#include <test/fuzz/FuzzedDataProvider.h>
	#include <test/fuzz/fuzz.h>
	#include <test/fuzz/util.h>

	#include <cassert>
	#include <cstdint>
	#include <netinet/in.h>
	#include <vector>

	void test_one_input(const std::vector<uint8_t> &buffer) {
	FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());

	const CNetAddr net_addr = ConsumeNetAddr(fuzzed_data_provider);
	- (void)net_addr.GetHash();
	(void)net_addr.GetNetClass();
	if (net_addr.GetNetwork() == Network::NET_IPV4) {
	assert(net_addr.IsIPv4());
	}
	if (net_addr.GetNetwork() == Network::NET_IPV6) {
	assert(net_addr.IsIPv6());
	}
	if (net_addr.GetNetwork() == Network::NET_ONION) {
	assert(net_addr.IsTor());
	}
	if (net_addr.GetNetwork() == Network::NET_INTERNAL) {
	assert(net_addr.IsInternal());
	}
	if (net_addr.GetNetwork() == Network::NET_UNROUTABLE) {
	assert(!net_addr.IsRoutable());
	}
	(void)net_addr.IsBindAny();
	if (net_addr.IsInternal()) {
	assert(net_addr.GetNetwork() == Network::NET_INTERNAL);
	}
	if (net_addr.IsIPv4()) {
	assert(net_addr.GetNetwork() == Network::NET_IPV4 \|\|
	net_addr.GetNetwork() == Network::NET_UNROUTABLE);
	}
	if (net_addr.IsIPv6()) {
	assert(net_addr.GetNetwork() == Network::NET_IPV6 \|\|
	net_addr.GetNetwork() == Network::NET_UNROUTABLE);
	}
	(void)net_addr.IsLocal();
	if (net_addr.IsRFC1918() \|\| net_addr.IsRFC2544() \|\| net_addr.IsRFC6598() \|\|
	net_addr.IsRFC5737() \|\| net_addr.IsRFC3927()) {
	assert(net_addr.IsIPv4());
	}
	(void)net_addr.IsRFC2544();
	if (net_addr.IsRFC3849() \|\| net_addr.IsRFC3964() \|\| net_addr.IsRFC4380() \|\|
	net_addr.IsRFC4843() \|\| net_addr.IsRFC7343() \|\| net_addr.IsRFC4862() \|\|
	net_addr.IsRFC6052() \|\| net_addr.IsRFC6145()) {
	assert(net_addr.IsIPv6());
	}
	(void)net_addr.IsRFC3927();
	(void)net_addr.IsRFC3964();
	if (net_addr.IsRFC4193()) {
	assert(net_addr.GetNetwork() == Network::NET_ONION \|\|
	net_addr.GetNetwork() == Network::NET_INTERNAL \|\|
	net_addr.GetNetwork() == Network::NET_UNROUTABLE);
	}
	(void)net_addr.IsRFC4380();
	(void)net_addr.IsRFC4843();
	(void)net_addr.IsRFC4862();
	(void)net_addr.IsRFC5737();
	(void)net_addr.IsRFC6052();
	(void)net_addr.IsRFC6145();
	(void)net_addr.IsRFC6598();
	(void)net_addr.IsRFC7343();
	if (!net_addr.IsRoutable()) {
	assert(net_addr.GetNetwork() == Network::NET_UNROUTABLE \|\|
	net_addr.GetNetwork() == Network::NET_INTERNAL);
	}
	if (net_addr.IsTor()) {
	assert(net_addr.GetNetwork() == Network::NET_ONION);
	}
	(void)net_addr.IsValid();
	(void)net_addr.ToString();
	(void)net_addr.ToStringIP();

	const CSubNet sub_net{net_addr,
	fuzzed_data_provider.ConsumeIntegral<uint8_t>()};
	(void)sub_net.IsValid();
	(void)sub_net.ToString();

	const CService service{net_addr,
	fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
	(void)service.GetKey();
	(void)service.GetPort();
	(void)service.ToString();
	(void)service.ToStringIPPort();
	(void)service.ToStringPort();
	+ (void)CServiceHash()(service);
	+ (void)CServiceHash(0, 0)(service);

	const CNetAddr other_net_addr = ConsumeNetAddr(fuzzed_data_provider);
	(void)net_addr.GetReachabilityFrom(&other_net_addr);
	(void)sub_net.Match(other_net_addr);

	const CService other_service{
	net_addr, fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
	assert((service == other_service) != (service != other_service));
	(void)(service < other_service);

	const CSubNet sub_net_copy_1{net_addr, other_net_addr};
	const CSubNet sub_net_copy_2{net_addr};

	CNetAddr mutable_net_addr;
	mutable_net_addr.SetIP(net_addr);
	assert(net_addr == mutable_net_addr);
	}
	diff --git a/src/test/netbase_tests.cpp b/src/test/netbase_tests.cpp
	index 94e051571..37b54e9ff 100644
	--- a/src/test/netbase_tests.cpp
	+++ b/src/test/netbase_tests.cpp
	@@ -1,661 +1,681 @@
	// Copyright (c) 2012-2019 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 <netbase.h>

	#include <net_permissions.h>
	#include <netaddress.h>
	#include <protocol.h>
	#include <serialize.h>
	#include <streams.h>
	#include <util/strencodings.h>
	#include <util/translation.h>
	#include <version.h>

	#include <test/util/setup_common.h>

	#include <boost/test/unit_test.hpp>

	#include <string>

	using namespace std::literals;

	BOOST_FIXTURE_TEST_SUITE(netbase_tests, BasicTestingSetup)

	static CNetAddr ResolveIP(const std::string &ip) {
	CNetAddr addr;
	LookupHost(ip, addr, false);
	return addr;
	}

	static CSubNet ResolveSubNet(const std::string &subnet) {
	CSubNet ret;
	LookupSubNet(subnet, ret);
	return ret;
	}

	static CNetAddr CreateInternal(const std::string &host) {
	CNetAddr addr;
	addr.SetInternal(host);
	return addr;
	}

	BOOST_AUTO_TEST_CASE(netbase_networks) {
	BOOST_CHECK(ResolveIP("127.0.0.1").GetNetwork() == NET_UNROUTABLE);
	BOOST_CHECK(ResolveIP("::1").GetNetwork() == NET_UNROUTABLE);
	BOOST_CHECK(ResolveIP("8.8.8.8").GetNetwork() == NET_IPV4);
	BOOST_CHECK(ResolveIP("2001::8888").GetNetwork() == NET_IPV6);
	BOOST_CHECK(
	ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetNetwork() ==
	NET_ONION);
	BOOST_CHECK(CreateInternal("foo.com").GetNetwork() == NET_INTERNAL);
	}

	BOOST_AUTO_TEST_CASE(netbase_properties) {
	BOOST_CHECK(ResolveIP("127.0.0.1").IsIPv4());
	BOOST_CHECK(ResolveIP("::FFFF:192.168.1.1").IsIPv4());
	BOOST_CHECK(ResolveIP("::1").IsIPv6());
	BOOST_CHECK(ResolveIP("10.0.0.1").IsRFC1918());
	BOOST_CHECK(ResolveIP("192.168.1.1").IsRFC1918());
	BOOST_CHECK(ResolveIP("172.31.255.255").IsRFC1918());
	BOOST_CHECK(ResolveIP("198.18.0.0").IsRFC2544());
	BOOST_CHECK(ResolveIP("198.19.255.255").IsRFC2544());
	BOOST_CHECK(ResolveIP("2001:0DB8::").IsRFC3849());
	BOOST_CHECK(ResolveIP("169.254.1.1").IsRFC3927());
	BOOST_CHECK(ResolveIP("2002::1").IsRFC3964());
	BOOST_CHECK(ResolveIP("FC00::").IsRFC4193());
	BOOST_CHECK(ResolveIP("2001::2").IsRFC4380());
	BOOST_CHECK(ResolveIP("2001:10::").IsRFC4843());
	BOOST_CHECK(ResolveIP("2001:20::").IsRFC7343());
	BOOST_CHECK(ResolveIP("FE80::").IsRFC4862());
	BOOST_CHECK(ResolveIP("64:FF9B::").IsRFC6052());
	BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").IsTor());
	BOOST_CHECK(ResolveIP("127.0.0.1").IsLocal());
	BOOST_CHECK(ResolveIP("::1").IsLocal());
	BOOST_CHECK(ResolveIP("8.8.8.8").IsRoutable());
	BOOST_CHECK(ResolveIP("2001::1").IsRoutable());
	BOOST_CHECK(ResolveIP("127.0.0.1").IsValid());
	BOOST_CHECK(
	CreateInternal("FD6B:88C0:8724:edb1:8e4:3588:e546:35ca").IsInternal());
	BOOST_CHECK(CreateInternal("bar.com").IsInternal());
	}

	static bool TestSplitHost(const std::string &test, const std::string &host,
	uint16_t port) {
	std::string hostOut;
	uint16_t portOut{0};
	SplitHostPort(test, portOut, hostOut);
	return hostOut == host && port == portOut;
	}

	BOOST_AUTO_TEST_CASE(netbase_splithost) {
	BOOST_CHECK(TestSplitHost("www.bitcoin.org", "www.bitcoin.org", 0));
	BOOST_CHECK(TestSplitHost("[www.bitcoin.org]", "www.bitcoin.org", 0));
	BOOST_CHECK(TestSplitHost("www.bitcoin.org:80", "www.bitcoin.org", 80));
	BOOST_CHECK(TestSplitHost("[www.bitcoin.org]:80", "www.bitcoin.org", 80));
	BOOST_CHECK(TestSplitHost("127.0.0.1", "127.0.0.1", 0));
	BOOST_CHECK(TestSplitHost("127.0.0.1:8333", "127.0.0.1", 8333));
	BOOST_CHECK(TestSplitHost("[127.0.0.1]", "127.0.0.1", 0));
	BOOST_CHECK(TestSplitHost("[127.0.0.1]:8333", "127.0.0.1", 8333));
	BOOST_CHECK(TestSplitHost("::ffff:127.0.0.1", "::ffff:127.0.0.1", 0));
	BOOST_CHECK(
	TestSplitHost("[::ffff:127.0.0.1]:8333", "::ffff:127.0.0.1", 8333));
	BOOST_CHECK(TestSplitHost("[::]:8333", "::", 8333));
	BOOST_CHECK(TestSplitHost("::8333", "::8333", 0));
	BOOST_CHECK(TestSplitHost(":8333", "", 8333));
	BOOST_CHECK(TestSplitHost("[]:8333", "", 8333));
	BOOST_CHECK(TestSplitHost("", "", 0));
	}

	static bool TestParse(std::string src, std::string canon) {
	CService addr(LookupNumeric(src, 65535));
	return canon == addr.ToString();
	}

	BOOST_AUTO_TEST_CASE(netbase_lookupnumeric) {
	BOOST_CHECK(TestParse("127.0.0.1", "127.0.0.1:65535"));
	BOOST_CHECK(TestParse("127.0.0.1:8333", "127.0.0.1:8333"));
	BOOST_CHECK(TestParse("::ffff:127.0.0.1", "127.0.0.1:65535"));
	BOOST_CHECK(TestParse("::", "[::]:65535"));
	BOOST_CHECK(TestParse("[::]:8333", "[::]:8333"));
	BOOST_CHECK(TestParse("[127.0.0.1]", "127.0.0.1:65535"));
	BOOST_CHECK(TestParse(":::", "[::]:0"));

	// verify that an internal address fails to resolve
	BOOST_CHECK(TestParse("[fd6b:88c0:8724:1:2:3:4:5]", "[::]:0"));
	// and that a one-off resolves correctly
	BOOST_CHECK(TestParse("[fd6c:88c0:8724:1:2:3:4:5]",
	"[fd6c:88c0:8724:1:2:3:4:5]:65535"));
	}

	BOOST_AUTO_TEST_CASE(onioncat_test) {
	// values from
	// https://web.archive.org/web/20121122003543/http://www.cypherpunk.at/onioncat/wiki/OnionCat
	CNetAddr addr1(ResolveIP("5wyqrzbvrdsumnok.onion"));
	CNetAddr addr2(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca"));
	BOOST_CHECK(addr1 == addr2);
	BOOST_CHECK(addr1.IsTor());
	BOOST_CHECK(addr1.ToStringIP() == "5wyqrzbvrdsumnok.onion");
	BOOST_CHECK(addr1.IsRoutable());
	}

	BOOST_AUTO_TEST_CASE(embedded_test) {
	CNetAddr addr1(ResolveIP("1.2.3.4"));
	CNetAddr addr2(ResolveIP("::FFFF:0102:0304"));
	BOOST_CHECK(addr2.IsIPv4());
	BOOST_CHECK_EQUAL(addr1.ToString(), addr2.ToString());
	}

	BOOST_AUTO_TEST_CASE(subnet_test) {
	BOOST_CHECK(ResolveSubNet("1.2.3.0/24") ==
	ResolveSubNet("1.2.3.0/255.255.255.0"));
	BOOST_CHECK(ResolveSubNet("1.2.3.0/24") !=
	ResolveSubNet("1.2.4.0/255.255.255.0"));
	BOOST_CHECK(ResolveSubNet("1.2.3.0/24").Match(ResolveIP("1.2.3.4")));
	BOOST_CHECK(!ResolveSubNet("1.2.2.0/24").Match(ResolveIP("1.2.3.4")));
	BOOST_CHECK(ResolveSubNet("1.2.3.4").Match(ResolveIP("1.2.3.4")));
	BOOST_CHECK(ResolveSubNet("1.2.3.4/32").Match(ResolveIP("1.2.3.4")));
	BOOST_CHECK(!ResolveSubNet("1.2.3.4").Match(ResolveIP("5.6.7.8")));
	BOOST_CHECK(!ResolveSubNet("1.2.3.4/32").Match(ResolveIP("5.6.7.8")));
	BOOST_CHECK(
	ResolveSubNet("::ffff:127.0.0.1").Match(ResolveIP("127.0.0.1")));
	BOOST_CHECK(
	ResolveSubNet("1:2:3:4:5:6:7:8").Match(ResolveIP("1:2:3:4:5:6:7:8")));
	BOOST_CHECK(
	!ResolveSubNet("1:2:3:4:5:6:7:8").Match(ResolveIP("1:2:3:4:5:6:7:9")));
	BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:0/112")
	.Match(ResolveIP("1:2:3:4:5:6:7:1234")));
	BOOST_CHECK(
	ResolveSubNet("192.168.0.1/24").Match(ResolveIP("192.168.0.2")));
	BOOST_CHECK(
	ResolveSubNet("192.168.0.20/29").Match(ResolveIP("192.168.0.18")));
	BOOST_CHECK(ResolveSubNet("1.2.2.1/24").Match(ResolveIP("1.2.2.4")));
	BOOST_CHECK(ResolveSubNet("1.2.2.110/31").Match(ResolveIP("1.2.2.111")));
	BOOST_CHECK(ResolveSubNet("1.2.2.20/26").Match(ResolveIP("1.2.2.63")));
	// All-Matching IPv6 Matches arbitrary IPv6
	BOOST_CHECK(ResolveSubNet("::/0").Match(ResolveIP("1:2:3:4:5:6:7:1234")));
	// But not `::` or `0.0.0.0` because they are considered invalid addresses
	BOOST_CHECK(!ResolveSubNet("::/0").Match(ResolveIP("::")));
	BOOST_CHECK(!ResolveSubNet("::/0").Match(ResolveIP("0.0.0.0")));
	// Addresses from one network (IPv4) don't belong to subnets of another
	// network (IPv6)
	BOOST_CHECK(!ResolveSubNet("::/0").Match(ResolveIP("1.2.3.4")));
	// All-Matching IPv4 does not Match IPv6
	BOOST_CHECK(
	!ResolveSubNet("0.0.0.0/0").Match(ResolveIP("1:2:3:4:5:6:7:1234")));
	// Invalid subnets Match nothing (not even invalid addresses)
	BOOST_CHECK(!CSubNet().Match(ResolveIP("1.2.3.4")));
	BOOST_CHECK(!ResolveSubNet("").Match(ResolveIP("4.5.6.7")));
	BOOST_CHECK(!ResolveSubNet("bloop").Match(ResolveIP("0.0.0.0")));
	BOOST_CHECK(!ResolveSubNet("bloop").Match(ResolveIP("hab")));
	// Check valid/invalid
	BOOST_CHECK(ResolveSubNet("1.2.3.0/0").IsValid());
	BOOST_CHECK(!ResolveSubNet("1.2.3.0/-1").IsValid());
	BOOST_CHECK(ResolveSubNet("1.2.3.0/32").IsValid());
	BOOST_CHECK(!ResolveSubNet("1.2.3.0/33").IsValid());
	BOOST_CHECK(!ResolveSubNet("1.2.3.0/300").IsValid());
	BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8/0").IsValid());
	BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8/33").IsValid());
	BOOST_CHECK(!ResolveSubNet("1:2:3:4:5:6:7:8/-1").IsValid());
	BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8/128").IsValid());
	BOOST_CHECK(!ResolveSubNet("1:2:3:4:5:6:7:8/129").IsValid());
	BOOST_CHECK(!ResolveSubNet("fuzzy").IsValid());

	// CNetAddr constructor test
	BOOST_CHECK(CSubNet(ResolveIP("127.0.0.1")).IsValid());
	BOOST_CHECK(CSubNet(ResolveIP("127.0.0.1")).Match(ResolveIP("127.0.0.1")));
	BOOST_CHECK(!CSubNet(ResolveIP("127.0.0.1")).Match(ResolveIP("127.0.0.2")));
	BOOST_CHECK(CSubNet(ResolveIP("127.0.0.1")).ToString() == "127.0.0.1/32");

	CSubNet subnet = CSubNet(ResolveIP("1.2.3.4"), 32);
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
	subnet = CSubNet(ResolveIP("1.2.3.4"), 8);
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/8");
	subnet = CSubNet(ResolveIP("1.2.3.4"), 0);
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/0");

	subnet = CSubNet(ResolveIP("1.2.3.4"), ResolveIP("255.255.255.255"));
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
	subnet = CSubNet(ResolveIP("1.2.3.4"), ResolveIP("255.0.0.0"));
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/8");
	subnet = CSubNet(ResolveIP("1.2.3.4"), ResolveIP("0.0.0.0"));
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/0");

	BOOST_CHECK(CSubNet(ResolveIP("1:2:3:4:5:6:7:8")).IsValid());
	BOOST_CHECK(CSubNet(ResolveIP("1:2:3:4:5:6:7:8"))
	.Match(ResolveIP("1:2:3:4:5:6:7:8")));
	BOOST_CHECK(!CSubNet(ResolveIP("1:2:3:4:5:6:7:8"))
	.Match(ResolveIP("1:2:3:4:5:6:7:9")));
	BOOST_CHECK(CSubNet(ResolveIP("1:2:3:4:5:6:7:8")).ToString() ==
	"1:2:3:4:5:6:7:8/128");
	// IPv4 address with IPv6 netmask or the other way around.
	BOOST_CHECK(!CSubNet(ResolveIP("1.1.1.1"), ResolveIP("ffff::")).IsValid());
	BOOST_CHECK(!CSubNet(ResolveIP("::1"), ResolveIP("255.0.0.0")).IsValid());
	// Can't subnet TOR (or any other non-IPv4 and non-IPv6 network).
	BOOST_CHECK(
	!CSubNet(ResolveIP("5wyqrzbvrdsumnok.onion"), ResolveIP("255.0.0.0"))
	.IsValid());

	subnet = ResolveSubNet("1.2.3.4/255.255.255.255");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.254");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/31");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.252");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/30");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.248");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/29");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.240");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/28");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.224");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/27");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.192");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/26");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.128");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/25");
	subnet = ResolveSubNet("1.2.3.4/255.255.255.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/24");
	subnet = ResolveSubNet("1.2.3.4/255.255.254.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.2.0/23");
	subnet = ResolveSubNet("1.2.3.4/255.255.252.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/22");
	subnet = ResolveSubNet("1.2.3.4/255.255.248.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/21");
	subnet = ResolveSubNet("1.2.3.4/255.255.240.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/20");
	subnet = ResolveSubNet("1.2.3.4/255.255.224.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/19");
	subnet = ResolveSubNet("1.2.3.4/255.255.192.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/18");
	subnet = ResolveSubNet("1.2.3.4/255.255.128.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/17");
	subnet = ResolveSubNet("1.2.3.4/255.255.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/16");
	subnet = ResolveSubNet("1.2.3.4/255.254.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/15");
	subnet = ResolveSubNet("1.2.3.4/255.252.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/14");
	subnet = ResolveSubNet("1.2.3.4/255.248.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/13");
	subnet = ResolveSubNet("1.2.3.4/255.240.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/12");
	subnet = ResolveSubNet("1.2.3.4/255.224.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/11");
	subnet = ResolveSubNet("1.2.3.4/255.192.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/10");
	subnet = ResolveSubNet("1.2.3.4/255.128.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/9");
	subnet = ResolveSubNet("1.2.3.4/255.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/8");
	subnet = ResolveSubNet("1.2.3.4/254.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/7");
	subnet = ResolveSubNet("1.2.3.4/252.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/6");
	subnet = ResolveSubNet("1.2.3.4/248.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/5");
	subnet = ResolveSubNet("1.2.3.4/240.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/4");
	subnet = ResolveSubNet("1.2.3.4/224.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/3");
	subnet = ResolveSubNet("1.2.3.4/192.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/2");
	subnet = ResolveSubNet("1.2.3.4/128.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/1");
	subnet = ResolveSubNet("1.2.3.4/0.0.0.0");
	BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/0");

	subnet = ResolveSubNet(
	"1:2:3:4:5:6:7:8/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1:2:3:4:5:6:7:8/128");
	subnet = ResolveSubNet(
	"1:2:3:4:5:6:7:8/ffff:0000:0000:0000:0000:0000:0000:0000");
	BOOST_CHECK_EQUAL(subnet.ToString(), "1::/16");
	subnet = ResolveSubNet(
	"1:2:3:4:5:6:7:8/0000:0000:0000:0000:0000:0000:0000:0000");
	BOOST_CHECK_EQUAL(subnet.ToString(), "::/0");
	// Invalid netmasks (with 1-bits after 0-bits)
	subnet = ResolveSubNet("1.2.3.4/255.255.232.0");
	BOOST_CHECK(!subnet.IsValid());
	subnet = ResolveSubNet("1.2.3.4/255.0.255.255");
	BOOST_CHECK(!subnet.IsValid());
	subnet = ResolveSubNet(
	"1:2:3:4:5:6:7:8/ffff:ffff:ffff:fffe:ffff:ffff:ffff:ff0f");
	BOOST_CHECK(!subnet.IsValid());
	}

	BOOST_AUTO_TEST_CASE(netbase_getgroup) {
	// use /16
	std::vector<bool> asmap;
	typedef std::vector<uint8_t> Vec8;
	// Local -> !Routable()
	BOOST_CHECK(ResolveIP("127.0.0.1").GetGroup(asmap) == Vec8{0});
	// !Valid -> !Routable()
	BOOST_CHECK(ResolveIP("257.0.0.1").GetGroup(asmap) == Vec8{0});
	// RFC1918 -> !Routable()
	BOOST_CHECK(ResolveIP("10.0.0.1").GetGroup(asmap) == Vec8{0});
	// RFC3927 -> !Routable()
	BOOST_CHECK(ResolveIP("169.254.1.1").GetGroup(asmap) == Vec8{0});
	// IPv4
	BOOST_CHECK(ResolveIP("1.2.3.4").GetGroup(asmap) == Vec8({NET_IPV4, 1, 2}));
	// RFC6145
	BOOST_CHECK(ResolveIP("::FFFF:0:102:304").GetGroup(asmap) ==
	Vec8({NET_IPV4, 1, 2}));
	// RFC6052
	BOOST_CHECK(ResolveIP("64:FF9B::102:304").GetGroup(asmap) ==
	Vec8({NET_IPV4, 1, 2}));
	// RFC3964
	BOOST_CHECK(
	ResolveIP("2002:102:304:9999:9999:9999:9999:9999").GetGroup(asmap) ==
	Vec8({NET_IPV4, 1, 2}));
	// RFC4380
	BOOST_CHECK(
	ResolveIP("2001:0:9999:9999:9999:9999:FEFD:FCFB").GetGroup(asmap) ==
	Vec8({NET_IPV4, 1, 2}));
	// Tor
	BOOST_CHECK(
	ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetGroup(asmap) ==
	Vec8({NET_ONION, 239}));
	// he.net
	BOOST_CHECK(
	ResolveIP("2001:470:abcd:9999:9999:9999:9999:9999").GetGroup(asmap) ==
	Vec8({NET_IPV6, 32, 1, 4, 112, 175}));
	// IPv6
	BOOST_CHECK(
	ResolveIP("2001:2001:9999:9999:9999:9999:9999:9999").GetGroup(asmap) ==
	Vec8({NET_IPV6, 32, 1, 32, 1}));

	// baz.net sha256 hash:
	// 12929400eb4607c4ac075f087167e75286b179c693eb059a01774b864e8fe505
	Vec8 internal_group = {NET_INTERNAL, 0x12, 0x92, 0x94, 0x00, 0xeb,
	0x46, 0x07, 0xc4, 0xac, 0x07};
	BOOST_CHECK(CreateInternal("baz.net").GetGroup(asmap) == internal_group);
	}

	BOOST_AUTO_TEST_CASE(netbase_parsenetwork) {
	BOOST_CHECK_EQUAL(ParseNetwork("ipv4"), NET_IPV4);
	BOOST_CHECK_EQUAL(ParseNetwork("ipv6"), NET_IPV6);
	BOOST_CHECK_EQUAL(ParseNetwork("onion"), NET_ONION);
	BOOST_CHECK_EQUAL(ParseNetwork("tor"), NET_ONION);

	BOOST_CHECK_EQUAL(ParseNetwork("IPv4"), NET_IPV4);
	BOOST_CHECK_EQUAL(ParseNetwork("IPv6"), NET_IPV6);
	BOOST_CHECK_EQUAL(ParseNetwork("ONION"), NET_ONION);
	BOOST_CHECK_EQUAL(ParseNetwork("TOR"), NET_ONION);

	BOOST_CHECK_EQUAL(ParseNetwork(":)"), NET_UNROUTABLE);
	BOOST_CHECK_EQUAL(ParseNetwork("tÖr"), NET_UNROUTABLE);
	BOOST_CHECK_EQUAL(ParseNetwork("\xfe\xff"), NET_UNROUTABLE);
	BOOST_CHECK_EQUAL(ParseNetwork(""), NET_UNROUTABLE);
	}

	BOOST_AUTO_TEST_CASE(netpermissions_test) {
	bilingual_str error;
	NetWhitebindPermissions whitebindPermissions;
	NetWhitelistPermissions whitelistPermissions;

	// Detect invalid white bind
	BOOST_CHECK(
	!NetWhitebindPermissions::TryParse("", whitebindPermissions, error));
	BOOST_CHECK(error.original.find("Cannot resolve -whitebind address") !=
	std::string::npos);
	BOOST_CHECK(!NetWhitebindPermissions::TryParse(
	"127.0.0.1", whitebindPermissions, error));
	BOOST_CHECK(error.original.find("Need to specify a port with -whitebind") !=
	std::string::npos);
	BOOST_CHECK(
	!NetWhitebindPermissions::TryParse("", whitebindPermissions, error));

	// If no permission flags, assume backward compatibility
	BOOST_CHECK(NetWhitebindPermissions::TryParse("1.2.3.4:32",
	whitebindPermissions, error));
	BOOST_CHECK(error.empty());
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_ISIMPLICIT);
	BOOST_CHECK(
	NetPermissions::HasFlag(whitebindPermissions.m_flags, PF_ISIMPLICIT));
	NetPermissions::ClearFlag(whitebindPermissions.m_flags, PF_ISIMPLICIT);
	BOOST_CHECK(
	!NetPermissions::HasFlag(whitebindPermissions.m_flags, PF_ISIMPLICIT));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_NONE);
	NetPermissions::AddFlag(whitebindPermissions.m_flags, PF_ISIMPLICIT);
	BOOST_CHECK(
	NetPermissions::HasFlag(whitebindPermissions.m_flags, PF_ISIMPLICIT));

	// Can set one permission
	BOOST_CHECK(NetWhitebindPermissions::TryParse("bloom@1.2.3.4:32",
	whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_BLOOMFILTER);
	BOOST_CHECK(NetWhitebindPermissions::TryParse("@1.2.3.4:32",
	whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_NONE);

	// Happy path, can parse flags
	BOOST_CHECK(NetWhitebindPermissions::TryParse("bloom,forcerelay@1.2.3.4:32",
	whitebindPermissions, error));
	// forcerelay should also activate the relay permission
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags,
	PF_BLOOMFILTER \| PF_FORCERELAY \| PF_RELAY);
	BOOST_CHECK(NetWhitebindPermissions::TryParse(
	"bloom,relay,noban@1.2.3.4:32", whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags,
	PF_BLOOMFILTER \| PF_RELAY \| PF_NOBAN);
	BOOST_CHECK(NetWhitebindPermissions::TryParse(
	"bloom,forcerelay,noban@1.2.3.4:32", whitebindPermissions, error));
	BOOST_CHECK(NetWhitebindPermissions::TryParse("all@1.2.3.4:32",
	whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_ALL);

	// Allow dups
	BOOST_CHECK(NetWhitebindPermissions::TryParse(
	"bloom,relay,noban,noban@1.2.3.4:32", whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags,
	PF_BLOOMFILTER \| PF_RELAY \| PF_NOBAN);

	// Allow empty
	BOOST_CHECK(NetWhitebindPermissions::TryParse(
	"bloom,relay,,noban@1.2.3.4:32", whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags,
	PF_BLOOMFILTER \| PF_RELAY \| PF_NOBAN);
	BOOST_CHECK(NetWhitebindPermissions::TryParse(",@1.2.3.4:32",
	whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_NONE);
	BOOST_CHECK(NetWhitebindPermissions::TryParse(",,@1.2.3.4:32",
	whitebindPermissions, error));
	BOOST_CHECK_EQUAL(whitebindPermissions.m_flags, PF_NONE);

	// Detect invalid flag
	BOOST_CHECK(!NetWhitebindPermissions::TryParse(
	"bloom,forcerelay,oopsie@1.2.3.4:32", whitebindPermissions, error));
	BOOST_CHECK(error.original.find("Invalid P2P permission") !=
	std::string::npos);

	// Check netmask error
	BOOST_CHECK(!NetWhitelistPermissions::TryParse(
	"bloom,forcerelay,noban@1.2.3.4:32", whitelistPermissions, error));
	BOOST_CHECK(
	error.original.find("Invalid netmask specified in -whitelist") !=
	std::string::npos);

	// Happy path for whitelist parsing
	BOOST_CHECK(NetWhitelistPermissions::TryParse("noban@1.2.3.4",
	whitelistPermissions, error));
	BOOST_CHECK_EQUAL(whitelistPermissions.m_flags, PF_NOBAN);
	BOOST_CHECK(NetWhitelistPermissions::TryParse(
	"bloom,forcerelay,noban,relay,bypass_proof_request_limits@1.2.3.4/32",
	whitelistPermissions, error));
	BOOST_CHECK_EQUAL(whitelistPermissions.m_flags,
	PF_BLOOMFILTER \| PF_FORCERELAY \| PF_NOBAN \| PF_RELAY \|
	PF_BYPASS_PROOF_REQUEST_LIMITS);
	BOOST_CHECK(error.empty());
	BOOST_CHECK_EQUAL(whitelistPermissions.m_subnet.ToString(), "1.2.3.4/32");
	BOOST_CHECK(NetWhitelistPermissions::TryParse(
	"bloom,forcerelay,noban,relay,mempool@1.2.3.4/32", whitelistPermissions,
	error));

	const auto strings = NetPermissions::ToStrings(PF_ALL);
	BOOST_CHECK_EQUAL(strings.size(), 8U);
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "bloomfilter") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "forcerelay") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "relay") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "noban") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "mempool") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "download") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(), "addr") !=
	strings.end());
	BOOST_CHECK(std::find(strings.begin(), strings.end(),
	"bypass_proof_request_limits") != strings.end());
	}

	BOOST_AUTO_TEST_CASE(
	netbase_dont_resolve_strings_with_embedded_nul_characters) {
	CNetAddr addr;
	BOOST_CHECK(LookupHost("127.0.0.1"s, addr, false));
	BOOST_CHECK(!LookupHost("127.0.0.1\0"s, addr, false));
	BOOST_CHECK(!LookupHost("127.0.0.1\0example.com"s, addr, false));
	BOOST_CHECK(!LookupHost("127.0.0.1\0example.com\0"s, addr, false));
	CSubNet ret;
	BOOST_CHECK(LookupSubNet("1.2.3.0/24"s, ret));
	BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0"s, ret));
	BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0example.com"s, ret));
	BOOST_CHECK(!LookupSubNet("1.2.3.0/24\0example.com\0"s, ret));
	// We only do subnetting for IPv4 and IPv6
	BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion"s, ret));
	BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0"s, ret));
	BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0example.com"s, ret));
	BOOST_CHECK(!LookupSubNet("5wyqrzbvrdsumnok.onion\0example.com\0"s, ret));
	}

	// Since CNetAddr (un)ser is tested separately in net_tests.cpp here we only
	// try a few edge cases for port, service flags and time.

	static const std::vector<CAddress> fixture_addresses(
	{CAddress(CService(CNetAddr(in6_addr(IN6ADDR_LOOPBACK_INIT)), 0 /* port */),
	NODE_NONE, 0x4966bc61U /* Fri Jan 9 02:54:25 UTC 2009 */
	),
	CAddress(CService(CNetAddr(in6_addr(IN6ADDR_LOOPBACK_INIT)),
	0x00f1 /* port */),
	NODE_NETWORK, 0x83766279U /* Tue Nov 22 11:22:33 UTC 2039 */
	),
	CAddress(
	CService(CNetAddr(in6_addr(IN6ADDR_LOOPBACK_INIT)), 0xf1f2 /* port */),
	static_cast<ServiceFlags>(NODE_COMPACT_FILTERS \| NODE_NETWORK_LIMITED),
	0xffffffffU /* Sun Feb 7 06:28:15 UTC 2106 */
	)});

	// fixture_addresses should equal to this when serialized in V1 format.
	// When this is unserialized from V1 format it should equal to
	// fixture_addresses.
	static constexpr const char *stream_addrv1_hex =
	// number of entries
	"03"

	// time, Fri Jan 9 02:54:25 UTC 2009
	"61bc6649"
	// service flags, NODE_NONE
	"0000000000000000"
	// address, fixed 16 bytes (IPv4 embedded in IPv6)
	"00000000000000000000000000000001"
	// port
	"0000"

	// time, Tue Nov 22 11:22:33 UTC 2039
	"79627683"
	// service flags, NODE_NETWORK
	"0100000000000000"
	// address, fixed 16 bytes (IPv6)
	"00000000000000000000000000000001"
	// port
	"00f1"

	// time, Sun Feb 7 06:28:15 UTC 2106
	"ffffffff"
	// service flags, NODE_COMPACT_FILTERS \| NODE_NETWORK_LIMITED
	"4004000000000000"
	// address, fixed 16 bytes (IPv6)
	"00000000000000000000000000000001"
	// port
	"f1f2";

	// fixture_addresses should equal to this when serialized in V2 format.
	// When this is unserialized from V2 format it should equal to
	// fixture_addresses.
	static constexpr const char *stream_addrv2_hex =
	// number of entries
	"03"

	// time, Fri Jan 9 02:54:25 UTC 2009
	"61bc6649"
	// service flags, COMPACTSIZE(NODE_NONE)
	"00"
	// network id, IPv6
	"02"
	// address length, COMPACTSIZE(16)
	"10"
	// address
	"00000000000000000000000000000001"
	// port
	"0000"

	// time, Tue Nov 22 11:22:33 UTC 2039
	"79627683"
	// service flags, COMPACTSIZE(NODE_NETWORK)
	"01"
	// network id, IPv6
	"02"
	// address length, COMPACTSIZE(16)
	"10"
	// address
	"00000000000000000000000000000001"
	// port
	"00f1"

	// time, Sun Feb 7 06:28:15 UTC 2106
	"ffffffff"
	// service flags, COMPACTSIZE(NODE_COMPACT_FILTERS \| NODE_NETWORK_LIMITED)
	"fd4004"
	// network id, IPv6
	"02"
	// address length, COMPACTSIZE(16)
	"10"
	// address
	"00000000000000000000000000000001"
	// port
	"f1f2";

	BOOST_AUTO_TEST_CASE(caddress_serialize_v1) {
	CDataStream s(SER_NETWORK, PROTOCOL_VERSION);

	s << fixture_addresses;
	BOOST_CHECK_EQUAL(HexStr(s), stream_addrv1_hex);
	}

	BOOST_AUTO_TEST_CASE(caddress_unserialize_v1) {
	CDataStream s(ParseHex(stream_addrv1_hex), SER_NETWORK, PROTOCOL_VERSION);
	std::vector<CAddress> addresses_unserialized;

	s >> addresses_unserialized;
	BOOST_CHECK(fixture_addresses == addresses_unserialized);
	}

	BOOST_AUTO_TEST_CASE(caddress_serialize_v2) {
	CDataStream s(SER_NETWORK, PROTOCOL_VERSION \| ADDRV2_FORMAT);

	s << fixture_addresses;
	BOOST_CHECK_EQUAL(HexStr(s), stream_addrv2_hex);
	}

	BOOST_AUTO_TEST_CASE(caddress_unserialize_v2) {
	CDataStream s(ParseHex(stream_addrv2_hex), SER_NETWORK,
	PROTOCOL_VERSION \| ADDRV2_FORMAT);
	std::vector<CAddress> addresses_unserialized;

	s >> addresses_unserialized;
	BOOST_CHECK(fixture_addresses == addresses_unserialized);
	}

	+BOOST_AUTO_TEST_CASE(isbadport) {
	+ BOOST_CHECK(IsBadPort(1));
	+ BOOST_CHECK(IsBadPort(22));
	+ BOOST_CHECK(IsBadPort(6000));
	+
	+ BOOST_CHECK(!IsBadPort(80));
	+ BOOST_CHECK(!IsBadPort(443));
	+ BOOST_CHECK(!IsBadPort(8333));
	+
	+ // Check all ports, there must be 80 bad ports in total.
	+ size_t total_bad_ports{0};
	+ for (uint16_t port = std::numeric_limits<uint16_t>::max(); port > 0;
	+ --port) {
	+ if (IsBadPort(port)) {
	+ ++total_bad_ports;
	+ }
	+ }
	+ BOOST_CHECK_EQUAL(total_bad_ports, 80);
	+}
	+
	BOOST_AUTO_TEST_SUITE_END()

File Metadata

Mime Type: text/x-diff
Expires: Sun, Apr 27, 10:27 (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5567120
Default Alt Text: (699 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions