No OneTemporary
Actions

Size

190 KB

Subscribers

None

View Options

	diff --git a/src/init.cpp b/src/init.cpp
	index b226c109b2..002c59b8bf 100644
	--- a/src/init.cpp
	+++ b/src/init.cpp
	@@ -1,2889 +1,2892 @@
	// 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 <amount.h>
	#include <avalanche/processor.h>
	#include <banman.h>
	#include <blockdb.h>
	#include <blockfilter.h>
	#include <chain.h>
	#include <chainparams.h>
	#include <checkpoints.h>
	#include <compat/sanity.h>
	#include <config.h>
	#include <consensus/validation.h>
	#include <flatfile.h>
	#include <fs.h>
	#include <hash.h>
	#include <httprpc.h>
	#include <httpserver.h>
	#include <index/blockfilterindex.h>
	#include <index/txindex.h>
	#include <interfaces/chain.h>
	#include <key.h>
	#include <miner.h>
	#include <net.h>
	#include <net_permissions.h>
	#include <net_processing.h>
	#include <netbase.h>
	#include <network.h>
	#include <node/context.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 <timedata.h>
	#include <torcontrol.h>
	#include <txdb.h>
	#include <txmempool.h>
	#include <ui_interface.h>
	#include <util/asmap.h>
	#include <util/moneystr.h>
	#include <util/threadnames.h>
	#include <util/translation.h>
	#include <validation.h>
	#include <validationinterface.h>
	#include <walletinitinterface.h>

	#include <boost/algorithm/string/classification.hpp>
	#include <boost/algorithm/string/replace.hpp>
	#include <boost/algorithm/string/split.hpp>
	#include <boost/thread.hpp>

	#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>

	static const bool DEFAULT_PROXYRANDOMIZE = true;
	static const bool DEFAULT_REST_ENABLE = false;
	static const bool DEFAULT_STOPAFTERBLOCKIMPORT = 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() {
	return AbsPathForConfigVal(
	fs::path(gArgs.GetArg("-pid", BITCOIN_PID_FILENAME)));
	}

	NODISCARD static bool CreatePidFile() {
	fsbridge::ofstream file{GetPidFile()};
	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"),
	GetPidFile().string(),
	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;

	static boost::thread_group threadGroup;

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

	void Shutdown(NodeContext &node) {
	LogPrintf("%s: In progress...\n", __func__);
	static RecursiveMutex cs_Shutdown;
	TRY_LOCK(cs_Shutdown, lockShutdown);
	if (!lockShutdown) {
	return;
	}

	/// 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");
	g_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.peer_logic) {
	UnregisterValidationInterface(node.peer_logic.get());
	}
	// Follow the lock order requirements:
	// * CheckForStaleTipAndEvictPeers locks cs_main before indirectly calling
	// GetExtraOutboundCount which locks cs_vNodes.
	// * ProcessMessage locks cs_main and g_cs_orphans before indirectly calling
	// ForEachNode which locks cs_vNodes.
	// * CConnman::Stop calls DeleteNode, which calls FinalizeNode, which locks
	// cs_main and calls EraseOrphansFor, which locks g_cs_orphans.
	//
	// Thus the implicit locking order requirement is:
	// (1) cs_main, (2) g_cs_orphans, (3) cs_vNodes.
	if (node.connman) {
	node.connman->StopThreads();
	LOCK2(::cs_main, ::g_cs_orphans);
	node.connman->StopNodes();
	}
	if (g_txindex) {
	g_txindex->Stop();
	}
	ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Stop(); });

	StopTorControl();

	// After everything has been shut down, but before things get flushed, stop
	// the CScheduler/checkqueue threadGroup
	if (node.scheduler) {
	node.scheduler->stop();
	}
	threadGroup.interrupt_all();
	threadGroup.join_all();

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

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

	if (::g_mempool.IsLoaded() &&
	gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
	DumpMempool(::g_mempool);
	}

	// FlushStateToDisk generates a ChainStateFlushed callback, which we should
	// avoid missing
	- {
	+ if (node.chainman) {
	LOCK(cs_main);
	- for (CChainState *chainstate : g_chainman.GetAll()) {
	+ 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();

	// 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 : g_chainman.GetAll()) {
	+ for (CChainState *chainstate : node.chainman->GetAll()) {
	if (chainstate->CanFlushToDisk()) {
	chainstate->ForceFlushStateToDisk();
	chainstate->ResetCoinsViews();
	}
	}
	pblocktree.reset();
	}
	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

	try {
	if (!fs::remove(GetPidFile())) {
	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.chain_clients.clear();
	UnregisterAllValidationInterfaces();
	GetMainSignals().UnregisterBackgroundSignalScheduler();
	globalVerifyHandle.reset();
	ECC_Stop();
	- if (node.mempool) {
	- node.mempool = nullptr;
	- }
	+ node.mempool = nullptr;
	+ node.chainman = nullptr;
	node.scheduler.reset();
	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() {
	SetupHelpOptions(gArgs);
	// server-only for now
	gArgs.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 = {
	"-dbcrashratio", "-forcecompactdb", "-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 November 2020 upgrade
	"-axionactivationtime"};

	// 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.
	gArgs.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
	OptionsCategory::OPTIONS);
	#if defined(HAVE_SYSTEM)
	gArgs.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
	gArgs.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);
	gArgs.AddArg("-blocksdir=<dir>",
	"Specify directory to hold blocks subdirectory for *.dat "
	"files (default: <datadir>)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#if defined(HAVE_SYSTEM)
	gArgs.AddArg("-blocknotify=<cmd>",
	"Execute command when the best block changes (%s in cmd is "
	"replaced by block hash)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	gArgs.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);
	gArgs.AddArg(
	"-blocksonly",
	strprintf(
	"Whether to reject transactions from network peers. Transactions "
	"from the wallet, RPC and relay whitelisted inbound peers RPC are"
	" not affected. (default: %u)",
	DEFAULT_BLOCKSONLY),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.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);
	gArgs.AddArg("-datadir=<dir>", "Specify data directory",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.AddArg(
	"-dbbatchsize",
	strprintf("Maximum database write batch size in bytes (default: %u)",
	DEFAULT_DB_BATCH_SIZE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::OPTIONS);
	gArgs.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);
	gArgs.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);
	gArgs.AddArg("-feefilter",
	strprintf("Tell other nodes to filter invs to us by our "
	"mempool min fee (default: %d)",
	DEFAULT_FEEFILTER),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::OPTIONS);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.AddArg("-loadblock=<file>",
	"Imports blocks from external file on startup",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.AddArg("-maxmempool=<n>",
	strprintf("Keep the transaction memory pool below <n> "
	"megabytes (default: %u)",
	DEFAULT_MAX_MEMPOOL_SIZE),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.AddArg("-maxorphantx=<n>",
	strprintf("Keep at most <n> unconnectable transactions in "
	"memory (default: %u)",
	DEFAULT_MAX_ORPHAN_TRANSACTIONS),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.AddArg("-persistmempool",
	strprintf("Whether to save the mempool on shutdown and load "
	"on restart (default: %u)",
	DEFAULT_PERSIST_MEMPOOL),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.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);
	gArgs.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 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);
	gArgs.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);
	gArgs.AddArg(
	"-reindex",
	"Rebuild chain state and block index from the blk*.dat files on disk",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.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);
	#ifndef WIN32
	gArgs.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
	gArgs.AddArg("-txindex",
	strprintf("Maintain a full transaction index, used by the "
	"getrawtransaction rpc call (default: %d)",
	DEFAULT_TXINDEX),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	gArgs.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);
	gArgs.AddArg("-usecashaddr",
	"Use Cash Address for destination encoding instead of base58 "
	"(activate by default on Jan, 14)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

	gArgs.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);
	gArgs.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);
	gArgs.AddArg("-banscore=<n>",
	strprintf("Threshold for disconnecting and discouraging "
	"misbehaving peers (default: %u)",
	DEFAULT_BANSCORE_THRESHOLD),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-bantime=<n>",
	strprintf("Default duration (in seconds) of manually "
	"configured bans (default: %u)",
	DEFAULT_MISBEHAVING_BANTIME),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-bind=<addr>",
	"Bind to given address and always listen on it. Use "
	"[host]:port notation for IPv6",
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CONNECTION);
	gArgs.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);
	gArgs.AddArg("-discover",
	"Discover own IP addresses (default: 1 when listening and no "
	"-externalip or -proxy)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-dns",
	strprintf("Allow DNS lookups for -addnode, -seednode and "
	"-connect (default: %d)",
	DEFAULT_NAME_LOOKUP),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-dnsseed",
	"Query for peer addresses via DNS lookup, if low on addresses "
	"(default: 1 unless -connect used)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

	gArgs.AddArg("-externalip=<ip>", "Specify your own public address",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-forcednsseed",
	strprintf(
	"Always query for peer addresses via DNS lookup (default: %d)",
	DEFAULT_FORCEDNSSEED),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-listen",
	"Accept connections from outside (default: 1 if no -proxy or -connect)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-listenonion",
	strprintf("Automatically create Tor hidden service (default: %d)",
	DEFAULT_LISTEN_ONION),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-maxconnections=<n>",
	strprintf("Maintain at most <n> connections to peers (default: %u)",
	DEFAULT_MAX_PEER_CONNECTIONS),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-maxreceivebuffer=<n>",
	strprintf("Maximum per-connection receive buffer, <n>*1000 "
	"bytes (default: %u)",
	DEFAULT_MAXRECEIVEBUFFER),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-maxsendbuffer=<n>",
	strprintf(
	"Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
	DEFAULT_MAXSENDBUFFER),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.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);
	gArgs.AddArg("-onion=<ip:port>",
	strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
	"hidden services (default: %s)",
	"-proxy"),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-onlynet=<net>",
	"Make outgoing connections only through network <net> (ipv4, ipv6 or "
	"onion). Incoming connections are not affected by this option. This "
	"option can be specified multiple times to allow multiple networks.",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-peerbloomfilters",
	strprintf("Support filtering of blocks and transaction with "
	"bloom filters (default: %d)",
	DEFAULT_PEERBLOOMFILTERS),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-peerblockfilters",
	strprintf(
	"Serve compact block filters to peers per BIP 157 (default: %u)",
	DEFAULT_PEERBLOCKFILTERS),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-permitbaremultisig",
	strprintf("Relay non-P2SH multisig (default: %d)",
	DEFAULT_PERMIT_BAREMULTISIG),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-port=<port>",
	strprintf("Listen for connections on <port> (default: %u, "
	"testnet: %u, regtest: %u)",
	defaultChainParams->GetDefaultPort(),
	testnetChainParams->GetDefaultPort(),
	regtestChainParams->GetDefaultPort()),
	ArgsManager::ALLOW_ANY \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CONNECTION);
	gArgs.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-proxyrandomize",
	strprintf("Randomize credentials for every proxy connection. "
	"This enables Tor stream isolation (default: %d)",
	DEFAULT_PROXYRANDOMIZE),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-seednode=<ip>",
	"Connect to a node to retrieve peer addresses, and disconnect",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-timeout=<n>",
	strprintf("Specify connection timeout in milliseconds "
	"(minimum: 1, default: %d)",
	DEFAULT_CONNECT_TIMEOUT),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.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);
	gArgs.AddArg(
	"-torcontrol=<ip>:<port>",
	strprintf(
	"Tor control port to use if onion listening enabled (default: %s)",
	DEFAULT_TOR_CONTROL),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg("-torpassword=<pass>",
	"Tor control port password (default: empty)",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::CONNECTION);
	#ifdef USE_UPNP
	#if USE_UPNP
	gArgs.AddArg("-upnp",
	"Use UPnP to map the listening port (default: 1 when "
	"listening and no -proxy)",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	#else
	gArgs.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
	gArgs.AddArg("-whitebind=<[permissions@]addr>",
	"Bind to given address and whitelist peers connecting to it."
	" Use [host]:port notation for IPv6. Allowed permissions are "
	"bloomfilter (allow requesting BIP37 filtered blocks and "
	"transactions), noban (do not ban for misbehavior), "
	"forcerelay (relay even non-standard transactions), "
	"relay (relay even in -blocksonly mode), "
	"and mempool (allow requesting BIP35 mempool contents). "
	"Specify multiple permissions separated by commas (default: "
	"noban,mempool,relay). Can be specified multiple times.",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

	gArgs.AddArg("-whitelist=<[permissions@]IP address or network>",
	"Whitelist 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 same permissions as -whitebind. Can be specified "
	"multiple times.",
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
	gArgs.AddArg(
	"-maxuploadtarget=<n>",
	strprintf("Tries to keep outbound traffic under the given target (in "
	"MiB per 24h), 0 = no limit (default: %d)",
	DEFAULT_MAX_UPLOAD_TARGET),
	ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

	g_wallet_init_interface.AddWalletOptions();

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

	gArgs.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);
	gArgs.AddArg(
	"-checklevel=<n>",
	strprintf("How thorough the block verification of "
	"-checkblocks is: "
	"level 0 reads the blocks from disk, "
	"level 1 verifies block validity, "
	"level 2 verifies undo data, "
	"level 3 checks disconnection of tip blocks, "
	"and level 4 tries to reconnect the blocks. "
	"Each level includes the checks of the previous levels "
	"(0-4, default: %u)",
	DEFAULT_CHECKLEVEL),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.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);
	gArgs.AddArg(
	"-checkmempool=<n>",
	strprintf(
	"Run checks every <n> transactions (default: %u, regtest: %u)",
	defaultChainParams->DefaultConsistencyChecks(),
	regtestChainParams->DefaultConsistencyChecks()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.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);
	gArgs.AddArg("-deprecatedrpc=<method>",
	"Allows deprecated RPC method(s) to be used",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.AddArg("-dropmessagestest=<n>",
	"Randomly drop 1 of every <n> network messages",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.AddArg(
	"-stopafterblockimport",
	strprintf("Stop running after importing blocks from disk (default: %d)",
	DEFAULT_STOPAFTERBLOCKIMPORT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.AddArg("-addrmantest", "Allows to test address relay on localhost",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);

	gArgs.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: " +
	ListLogCategories() + ".",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	gArgs.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);
	gArgs.AddArg("-logips",
	strprintf("Include IP addresses in debug output (default: %d)",
	DEFAULT_LOGIPS),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	gArgs.AddArg("-logtimestamps",
	strprintf("Prepend debug output with timestamp (default: %d)",
	DEFAULT_LOGTIMESTAMPS),
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
	gArgs.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);
	gArgs.AddArg(
	"-logtimemicros",
	strprintf("Add microsecond precision to debug timestamps (default: %d)",
	DEFAULT_LOGTIMEMICROS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.AddArg("-mocktime=<n>",
	"Replace actual time with " + UNIX_EPOCH_TIME +
	" (default: 0)",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	gArgs.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);
	gArgs.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);
	gArgs.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);

	gArgs.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);
	gArgs.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);
	gArgs.AddArg(
	"-shrinkdebugfile",
	"Shrink debug.log file on client startup (default: 1 when no -debug)",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

	gArgs.AddArg("-uacomment=<cmt>", "Append comment to the user agent string",
	ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);

	SetupChainParamsBaseOptions();

	gArgs.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);
	gArgs.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);
	gArgs.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)",
	CURRENCY_UNIT, FormatMoney(DUST_RELAY_TX_FEE)),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::NODE_RELAY);

	gArgs.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);
	gArgs.AddArg(
	"-datacarrier",
	strprintf("Relay and mine data carrier transactions (default: %d)",
	DEFAULT_ACCEPT_DATACARRIER),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	gArgs.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);
	gArgs.AddArg(
	"-minrelaytxfee=<amt>",
	strprintf("Fees (in %s/kB) smaller than this are rejected for "
	"relaying, mining and transaction creation (default: %s)",
	CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE_PER_KB)),
	ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
	gArgs.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);
	gArgs.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 or "
	"violate local relay policy (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.
	gArgs.AddArg("-excessutxocharge=<amt>",
	strprintf("Fees (in %s/kB) to charge per utxo created for "
	"relaying, and mining (default: %s)",
	CURRENCY_UNIT, FormatMoney(DEFAULT_UTXO_FEE)),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::NODE_RELAY);

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

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

	gArgs.AddArg("-server", "Accept command line and JSON-RPC commands",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	gArgs.AddArg("-rest",
	strprintf("Accept public REST requests (default: %d)",
	DEFAULT_REST_ENABLE),
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	gArgs.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);
	gArgs.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);
	gArgs.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::RPC);
	gArgs.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
	ArgsManager::ALLOW_ANY \| ArgsManager::SENSITIVE,
	OptionsCategory::RPC);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.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);
	gArgs.AddArg(
	"-rpcthreads=<n>",
	strprintf(
	"Set the number of threads to service RPC calls (default: %d)",
	DEFAULT_HTTP_THREADS),
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
	gArgs.AddArg(
	"-rpccorsdomain=value",
	"Domain from which to accept cross origin requests (browser enforced)",
	ArgsManager::ALLOW_ANY, OptionsCategory::RPC);

	gArgs.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);
	gArgs.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
	gArgs.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.
	gArgs.AddArg(
	"-enableavalanche",
	strprintf("Enable avalanche (default: %u)", AVALANCHE_DEFAULT_ENABLED),
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
	gArgs.AddArg(
	"-avacooldown",
	strprintf("Mandatory cooldown between two avapoll (default: %u)",
	AVALANCHE_DEFAULT_COOLDOWN),
	ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);

	// Add the hidden options
	gArgs.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";
	}

	#if defined(HAVE_SYSTEM)
	static void BlockNotifyCallback(SynchronizationState sync_state,
	const CBlockIndex *pBlockIndex) {
	if (sync_state != SynchronizationState::POST_INIT \|\| !pBlockIndex) {
	return;
	}

	std::string strCmd = gArgs.GetArg("-blocknotify", "");
	if (!strCmd.empty()) {
	boost::replace_all(strCmd, "%s", pBlockIndex->GetBlockHash().GetHex());
	std::thread t(runCommand, strCmd);
	// thread runs free
	t.detach();
	}
	}
	#endif

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

	struct CImportingNow {
	CImportingNow() {
	assert(fImporting == false);
	fImporting = true;
	}

	~CImportingNow() {
	assert(fImporting == true);
	fImporting = false;
	}
	};

	// If we're using -prune with -reindex, then delete block files that will be
	// ignored by the reindex. Since reindexing works by starting at block file 0
	// and looping until a blockfile is missing, do the same here to delete any
	// later block files after a gap. Also delete all rev files since they'll be
	// rewritten by the reindex anyway. This ensures that vinfoBlockFile is in sync
	// with what's actually on disk by the time we start downloading, so that
	// pruning works correctly.
	static void CleanupBlockRevFiles() {
	std::map<std::string, fs::path> mapBlockFiles;

	// Glob all blk?????.dat and rev?????.dat files from the blocks directory.
	// Remove the rev files immediately and insert the blk file paths into an
	// ordered map keyed by block file index.
	LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for "
	"-reindex with -prune\n");
	const auto directoryIterator = fs::directory_iterator{GetBlocksDir()};
	for (const auto &file : directoryIterator) {
	const auto fileName = file.path().filename().string();
	if (fs::is_regular_file(file) && fileName.length() == 12 &&
	fileName.substr(8, 4) == ".dat") {
	if (fileName.substr(0, 3) == "blk") {
	mapBlockFiles[fileName.substr(3, 5)] = file.path();
	} else if (fileName.substr(0, 3) == "rev") {
	remove(file.path());
	}
	}
	}

	// Remove all block files that aren't part of a contiguous set starting at
	// zero by walking the ordered map (keys are block file indices) by keeping
	// a separate counter. Once we hit a gap (or if 0 doesn't exist) start
	// removing block files.
	int contiguousCounter = 0;
	for (const auto &item : mapBlockFiles) {
	if (atoi(item.first) == contiguousCounter) {
	contiguousCounter++;
	continue;
	}
	remove(item.second);
	}
	}

	-static void ThreadImport(const Config &config,
	+static void ThreadImport(const Config &config, ChainstateManager &chainman,
	std::vector<fs::path> vImportFiles) {
	util::ThreadRename("loadblk");
	ScheduleBatchPriority();

	{
	const CChainParams &chainParams = config.GetChainParams();

	CImportingNow imp;

	// -reindex
	if (fReindex) {
	int nFile = 0;
	while (true) {
	FlatFilePos pos(nFile, 0);
	if (!fs::exists(GetBlockPosFilename(pos))) {
	// No block files left to reindex
	break;
	}
	FILE *file = OpenBlockFile(pos, true);
	if (!file) {
	// This error is logged in OpenBlockFile
	break;
	}
	LogPrintf("Reindexing block file blk%05u.dat...\n",
	(unsigned int)nFile);
	LoadExternalBlockFile(config, file, &pos);
	nFile++;
	}
	pblocktree->WriteReindexing(false);
	fReindex = false;
	LogPrintf("Reindexing finished\n");
	// To avoid ending up in a situation without genesis block, re-try
	// initializing (no-op if reindexing worked):
	LoadGenesisBlock(chainParams);
	}

	// -loadblock=
	for (const fs::path &path : vImportFiles) {
	FILE *file = fsbridge::fopen(path, "rb");
	if (file) {
	LogPrintf("Importing blocks file %s...\n", path.string());
	LoadExternalBlockFile(config, file);
	} else {
	LogPrintf("Warning: Could not open blocks file %s\n",
	path.string());
	}
	}

	// Reconsider blocks we know are valid. They may have been marked
	// invalid by, for instance, running an outdated version of the node
	// software.
	const MapCheckpoints &checkpoints =
	chainParams.Checkpoints().mapCheckpoints;
	for (const MapCheckpoints::value_type &i : checkpoints) {
	const BlockHash &hash = i.second;

	LOCK(cs_main);
	CBlockIndex *pblockindex = LookupBlockIndex(hash);
	if (pblockindex && !pblockindex->nStatus.isValid()) {
	LogPrintf("Reconsidering checkpointed block %s ...\n",
	hash.GetHex());
	ResetBlockFailureFlags(pblockindex);
	}
	}

	// scan for better chains in the block chain database, that are not yet
	// connected in the active best chain

	// We can't hold cs_main during ActivateBestChain even though we're
	- // accessing the g_chainman unique_ptrs since ABC requires us not to be
	+ // accessing the chainman unique_ptrs since ABC requires us not to be
	// holding cs_main, so retrieve the relevant pointers before the ABC
	// call.
	for (CChainState *chainstate :
	- WITH_LOCK(::cs_main, return g_chainman.GetAll())) {
	+ WITH_LOCK(::cs_main, return chainman.GetAll())) {
	BlockValidationState state;
	if (!chainstate->ActivateBestChain(config, state, nullptr)) {
	LogPrintf("Failed to connect best block (%s)\n",
	state.ToString());
	StartShutdown();
	return;
	}
	}

	if (gArgs.GetBoolArg("-stopafterblockimport",
	DEFAULT_STOPAFTERBLOCKIMPORT)) {
	LogPrintf("Stopping after block import\n");
	StartShutdown();
	return;
	}
	} // End scope of CImportingNow
	if (gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
	LoadMempool(config, ::g_mempool);
	}
	::g_mempool.SetIsLoaded(!ShutdownRequested());
	}

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

	return true;
	}

	static bool AppInitServers(Config &config,
	HTTPRPCRequestProcessor &httpRPCRequestProcessor) {
	RPCServerSignals::OnStarted(&OnRPCStarted);
	RPCServerSignals::OnStopped(&OnRPCStopped);
	if (!InitHTTPServer(config)) {
	return false;
	}

	StartRPC();

	if (!StartHTTPRPC(httpRPCRequestProcessor)) {
	return false;
	}
	if (gArgs.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
	StartREST(httpRPCRequestProcessor.context);
	}

	StartHTTPServer();
	return true;
	}

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

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

	if (gArgs.IsArgSet("-proxy")) {
	// to protect privacy, do not listen by default if a default proxy
	// server is specified.
	if (gArgs.SoftSetBoolArg("-listen", false)) {
	LogPrintf(
	"%s: parameter interaction: -proxy set -> setting -listen=0\n",
	__func__);
	}
	// to protect privacy, do not use UPNP 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 (gArgs.SoftSetBoolArg("-upnp", false)) {
	LogPrintf(
	"%s: parameter interaction: -proxy set -> setting -upnp=0\n",
	__func__);
	}
	// to protect privacy, do not discover addresses by default
	if (gArgs.SoftSetBoolArg("-discover", false)) {
	LogPrintf("%s: parameter interaction: -proxy set -> setting "
	"-discover=0\n",
	__func__);
	}
	}

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

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

	// disable whitelistrelay in blocksonly mode
	if (gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
	if (gArgs.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 (gArgs.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
	if (gArgs.SoftSetBoolArg("-whitelistrelay", true)) {
	LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
	"setting -whitelistrelay=1\n",
	__func__);
	}
	}
	}

	/**
	* 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() {
	LogInstance().m_print_to_file = !gArgs.IsArgNegated("-debuglogfile");
	LogInstance().m_file_path = AbsPathForConfigVal(
	gArgs.GetArg("-debuglogfile", DEFAULT_DEBUGLOGFILE));

	LogInstance().m_print_to_console = gArgs.GetBoolArg(
	"-printtoconsole", !gArgs.GetBoolArg("-daemon", false));
	LogInstance().m_log_timestamps =
	gArgs.GetBoolArg("-logtimestamps", DEFAULT_LOGTIMESTAMPS);
	LogInstance().m_log_time_micros =
	gArgs.GetBoolArg("-logtimemicros", DEFAULT_LOGTIMEMICROS);
	LogInstance().m_log_threadnames =
	gArgs.GetBoolArg("-logthreadnames", DEFAULT_LOGTHREADNAMES);

	fLogIPs = gArgs.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() {
	// 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 (!gArgs.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 CChainParams &chainparams = config.GetChainParams();
	// Step 2: parameter interactions

	// also see: InitParameterInteraction()

	// Warn 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 = gArgs.GetChainName();
	for (const auto &arg : gArgs.GetUnsuitableSectionOnlyArgs()) {
	return InitError(strprintf(_("Config setting for %s only applied on %s "
	"network when in [%s] section."),
	arg, network, network));
	}

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

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

	// parse and validate enabled filter types
	std::string blockfilterindex_value =
	gArgs.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 =
	gArgs.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);
	}
	}

	// Basic filters are the only supported filters. The basic filters index
	// must be enabled to serve compact filters
	if (gArgs.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS) &&
	g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
	return InitError(
	_("Cannot set -peerblockfilters without -blockfilterindex."));
	}

	// if using block pruning, then disallow txindex
	if (gArgs.GetArg("-prune", 0)) {
	if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	return InitError(_("Prune mode is incompatible with -txindex."));
	}
	if (!g_enabled_filter_types.empty()) {
	return InitError(
	_("Prune mode is incompatible with -blockfilterindex."));
	}
	}

	// -bind and -whitebind can't be set when not listening
	size_t nUserBind =
	gArgs.GetArgs("-bind").size() + gArgs.GetArgs("-whitebind").size();
	if (nUserBind != 0 && !gArgs.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 =
	gArgs.GetArg("-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 + 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) {
	InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, "
	"because of system limitations.")
	.translated,
	nUserMaxConnections, nMaxConnections));
	}

	// Step 3: parameter-to-internal-flags
	if (gArgs.IsArgSet("-debug")) {
	// Special-case: if -debug=0/-nodebug is set, turn off debugging
	// messages
	const std::vector<std::string> &categories = gArgs.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.").translated,
	"-debug", cat));
	}
	}
	}
	}

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

	// Checkmempool and checkblockindex default to true in regtest mode
	int ratio = std::min<int>(
	std::max<int>(
	gArgs.GetArg("-checkmempool",
	chainparams.DefaultConsistencyChecks() ? 1 : 0),
	0),
	1000000);
	if (ratio != 0) {
	g_mempool.setSanityCheck(1.0 / ratio);
	}
	fCheckBlockIndex = gArgs.GetBoolArg("-checkblockindex",
	chainparams.DefaultConsistencyChecks());
	fCheckpointsEnabled =
	gArgs.GetBoolArg("-checkpoints", DEFAULT_CHECKPOINTS_ENABLED);
	if (fCheckpointsEnabled) {
	LogPrintf("Checkpoints will be verified.\n");
	} else {
	LogPrintf("Skipping checkpoint verification.\n");
	}

	hashAssumeValid = BlockHash::fromHex(
	gArgs.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 (gArgs.IsArgSet("-minimumchainwork")) {
	const std::string minChainWorkStr =
	gArgs.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 =
	gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
	int64_t nMempoolSizeMin =
	gArgs.GetArg("-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 uint64_t nProposedExcessiveBlockSize =
	gArgs.GetArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
	if (!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 uint64_t nProposedMaxGeneratedBlockSize =
	gArgs.GetArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
	if (nProposedMaxGeneratedBlockSize > config.GetMaxBlockSize()) {
	auto msg = _("Max generated block size (blockmaxsize) cannot exceed "
	"the excessive block size (excessiveblocksize)");
	return InitError(msg);
	}

	// block pruning; get the amount of disk space (in MiB) to allot for block &
	// undo files
	int64_t nPruneArg = gArgs.GetArg("-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 = gArgs.GetArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
	if (nConnectTimeout <= 0) {
	nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
	}

	peer_connect_timeout =
	gArgs.GetArg("-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 (gArgs.IsArgSet("-excessutxocharge")) {
	Amount n = Amount::zero();
	auto parsed = ParseMoney(gArgs.GetArg("-excessutxocharge", ""), n);
	if (!parsed \|\| Amount::zero() > n) {
	return InitError(AmountErrMsg(
	"excessutxocharge", gArgs.GetArg("-excessutxocharge", "")));
	}
	config.SetExcessUTXOCharge(n);
	} else {
	config.SetExcessUTXOCharge(DEFAULT_UTXO_FEE);
	}

	if (gArgs.IsArgSet("-minrelaytxfee")) {
	Amount n = Amount::zero();
	auto parsed = ParseMoney(gArgs.GetArg("-minrelaytxfee", ""), n);
	if (!parsed \|\| n == Amount::zero()) {
	return InitError(AmountErrMsg("minrelaytxfee",
	gArgs.GetArg("-minrelaytxfee", "")));
	}
	// High fee check is done afterward in CWallet::CreateWalletFromFile()
	::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 (gArgs.IsArgSet("-blockmintxfee")) {
	Amount n = Amount::zero();
	if (!ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n)) {
	return InitError(AmountErrMsg("blockmintxfee",
	gArgs.GetArg("-blockmintxfee", "")));
	}
	}

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

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

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

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

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

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

	nMaxTipAge = gArgs.GetArg("-maxtipage", DEFAULT_MAX_TIP_AGE);

	return true;
	}

	static bool LockDataDirectory(bool probeOnly) {
	// Make sure only a single Bitcoin process is using the data directory.
	fs::path datadir = GetDataDir();
	if (!DirIsWritable(datadir)) {
	return InitError(strprintf(
	_("Cannot write to data directory '%s'; check permissions."),
	datadir.string()));
	}
	if (!LockDirectory(datadir, ".lock", probeOnly)) {
	return InitError(strprintf(_("Cannot obtain a lock on data directory "
	"%s. %s is probably already running."),
	datadir.string(), 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 AppInitMain(Config &config, RPCServer &rpcServer,
	HTTPRPCRequestProcessor &httpRPCRequestProcessor,
	NodeContext &node) {
	// Step 4a: application initialization
	const CChainParams &chainparams = config.GetChainParams();

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

	BCLog::Logger &logger = LogInstance();
	if (logger.m_print_to_file) {
	if (gArgs.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"),
	logger.m_file_path.string()));
	}

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

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

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

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

	// Warn about relative -datadir path.
	if (gArgs.IsArgSet("-datadir") &&
	!fs::path(gArgs.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",
	gArgs.GetArg("-datadir", ""), fs::current_path().string());
	}

	InitSignatureCache();
	InitScriptExecutionCache();

	int script_threads = gArgs.GetArg("-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) {
	for (int i = 0; i < script_threads; ++i) {
	threadGroup.create_thread([i]() { return ThreadScriptCheck(i); });
	}
	}

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

	// Start the lightweight task scheduler thread
	CScheduler::Function serviceLoop = [&node] {
	node.scheduler->serviceQueue();
	};
	threadGroup.create_thread(std::bind(&TraceThread<CScheduler::Function>,
	"scheduler", serviceLoop));

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

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

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

	/**
	* 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 (gArgs.GetBoolArg("-server", false)) {
	uiInterface.InitMessage_connect(SetRPCWarmupStatus);
	if (!AppInitServers(config, httpRPCRequestProcessor)) {
	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(chainparams)) {
	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.

	assert(!node.banman);
	node.banman = std::make_unique<BanMan>(
	GetDataDir() / "banlist.dat", config.GetChainParams(), &uiInterface,
	gArgs.GetArg("-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()));
	+ assert(!node.chainman);
	+ node.chainman = &g_chainman;
	+ ChainstateManager &chainman = EnsureChainman(node);

	node.peer_logic.reset(new PeerLogicValidation(
	node.connman.get(), node.banman.get(), *node.scheduler));
	RegisterValidationInterface(node.peer_logic.get());

	// sanitize comments per BIP-0014, format user agent and check total size
	std::vector<std::string> uacomments;
	for (const std::string &cmt : gArgs.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 strSubVersion =
	FormatSubVersion(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 (gArgs.IsArgSet("-onlynet")) {
	std::set<enum Network> nets;
	for (const std::string &snet : gArgs.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 = gArgs.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);

	bool proxyRandomize =
	gArgs.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 = gArgs.GetArg("-proxy", "");
	SetReachable(NET_ONION, false);
	if (proxyArg != "" && proxyArg != "0") {
	CService proxyAddr;
	if (!Lookup(proxyArg.c_str(), 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 = gArgs.GetArg("-onion", "");
	if (onionArg != "") {
	if (onionArg == "0") {
	// Handle -noonion/-onion=0
	SetReachable(NET_ONION, false);
	} else {
	CService onionProxy;
	if (!Lookup(onionArg.c_str(), 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);
	}
	}

	// see Step 2: parameter interactions for more information about these
	fListen = gArgs.GetBoolArg("-listen", DEFAULT_LISTEN);
	fDiscover = gArgs.GetBoolArg("-discover", true);
	g_relay_txes = !gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY);

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

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

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

	if (g_zmq_notification_interface) {
	RegisterValidationInterface(g_zmq_notification_interface);
	}
	#endif
	// unlimited unless -maxuploadtarget is set
	uint64_t nMaxOutboundLimit = 0;
	uint64_t nMaxOutboundTimeframe = MAX_UPLOAD_TIMEFRAME;

	if (gArgs.IsArgSet("-maxuploadtarget")) {
	nMaxOutboundLimit =
	gArgs.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET) * 1024 *
	1024;
	}

	// Step 6.5 (I guess ?): Initialize Avalanche.
	g_avalanche =
	std::make_unique<avalanche::Processor>(*node.chain, node.connman.get());

	// Step 7: load block chain

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

	// cache size calculations
	int64_t nTotalCache = (gArgs.GetArg("-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, gArgs.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
	nCoinCacheUsage = nTotalCache;
	int64_t nMempoolSizeMax =
	gArgs.GetArg("-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 (gArgs.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);
	- g_chainman.InitializeChainstate();
	+ chainman.InitializeChainstate();
	UnloadBlockIndex();

	// 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 (!LoadBlockIndex(params)) {
	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 (!::BlockIndex().empty() &&
	!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 && !LoadGenesisBlock(chainparams)) {
	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 : g_chainman.GetAll()) {
	+ for (CChainState *chainstate : chainman.GetAll()) {
	LogPrintf("Initializing chainstate %s\n",
	chainstate->ToString());
	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(params)) {
	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();
	assert(chainstate->CanFlushToDisk());

	if (!is_coinsview_empty(chainstate)) {
	// LoadChainTip initializes the chain based on
	// CoinsTip()'s best block
	if (!chainstate->LoadChainTip(chainparams)) {
	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 : g_chainman.GetAll()) {
	+ for (CChainState *chainstate : chainman.GetAll()) {
	if (!is_coinsview_empty(chainstate)) {
	uiInterface.InitMessage(
	_("Verifying blocks...").translated);
	if (fHavePruned &&
	gArgs.GetArg("-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;
	}

	// Only verify the DB of the active chainstate. This is
	// fixed in later work when we allow VerifyDB to be
	// parameterized by chainstate.
	if (&::ChainstateActive() == chainstate &&
	!CVerifyDB().VerifyDB(
	config, &chainstate->CoinsDB(),
	gArgs.GetArg("-checklevel", DEFAULT_CHECKLEVEL),
	gArgs.GetArg("-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(gArgs.GetBoolArg("-usecashaddr", true));

	// Now that the chain state is loaded, make mempool generally available in
	// the node context. For example the connection manager, wallet, or RPC
	// threads, which are all started after this, may use it from the node
	// context.
	assert(!node.mempool);
	node.mempool = &::g_mempool;

	// Step 8: load indexers
	if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);
	g_txindex->Start();
	}

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

	// Step 9: load wallet
	for (const auto &client : node.chain_clients) {
	if (!client->load(chainparams)) {
	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 : g_chainman.GetAll()) {
	+ for (CChainState *chainstate : chainman.GetAll()) {
	uiInterface.InitMessage(_("Pruning blockstore...").translated);
	chainstate->PruneAndFlush();
	}
	}
	}

	// Step 11: import blocks
	if (!CheckDiskSpace(GetDataDir())) {
	InitError(
	strprintf(_("Error: Disk space is low for %s"), GetDataDir()));
	return false;
	}
	if (!CheckDiskSpace(GetBlocksDir())) {
	InitError(
	strprintf(_("Error: Disk space is low for %s"), GetBlocksDir()));
	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 (::ChainActive().Tip() == nullptr) {
	block_notify_genesis_wait_connection =
	uiInterface.NotifyBlockTip_connect(
	std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
	} else {
	fHaveGenesis = true;
	}

	#if defined(HAVE_SYSTEM)
	if (gArgs.IsArgSet("-blocknotify")) {
	uiInterface.NotifyBlockTip_connect(BlockNotifyCallback);
	}
	#endif

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

	- threadGroup.create_thread(
	- std::bind(&ThreadImport, std::ref(config), vImportFiles));
	+ threadGroup.create_thread([=, &config, &chainman] {
	+ ThreadImport(config, chainman, vImportFiles);
	+ });

	// 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", ::BlockIndex().size());
	chain_active_height = ::ChainActive().Height();
	}
	LogPrintf("nBestHeight = %d\n", chain_active_height);

	if (gArgs.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
	StartTorControl();
	}

	Discover();

	// Map ports with UPnP
	if (gArgs.GetBoolArg("-upnp", DEFAULT_UPNP)) {
	StartMapPort();
	}

	CConnman::Options connOptions;
	connOptions.nLocalServices = nLocalServices;
	connOptions.nMaxConnections = nMaxConnections;
	connOptions.m_max_outbound_full_relay = std::min(
	MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, connOptions.nMaxConnections);
	connOptions.m_max_outbound_block_relay = std::min(
	MAX_BLOCKS_ONLY_CONNECTIONS,
	connOptions.nMaxConnections - connOptions.m_max_outbound_full_relay);
	connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
	connOptions.nMaxFeeler = 1;
	connOptions.nBestHeight = chain_active_height;
	connOptions.uiInterface = &uiInterface;
	connOptions.m_banman = node.banman.get();
	connOptions.m_msgproc = node.peer_logic.get();
	connOptions.nSendBufferMaxSize =
	1000 * gArgs.GetArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
	connOptions.nReceiveFloodSize =
	1000 * gArgs.GetArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
	connOptions.m_added_nodes = gArgs.GetArgs("-addnode");

	connOptions.nMaxOutboundTimeframe = nMaxOutboundTimeframe;
	connOptions.nMaxOutboundLimit = nMaxOutboundLimit;
	connOptions.m_peer_connect_timeout = peer_connect_timeout;

	for (const std::string &strBind : gArgs.GetArgs("-bind")) {
	CService addrBind;
	if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false)) {
	return InitError(Untranslated(ResolveErrMsg("bind", strBind)));
	}
	connOptions.vBinds.push_back(addrBind);
	}

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

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

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

	// Initiate outbound connections unless connect=0
	connOptions.m_use_addrman_outgoing = !gArgs.IsArgSet("-connect");
	if (!connOptions.m_use_addrman_outgoing) {
	const auto connect = gArgs.GetArgs("-connect");
	if (connect.size() != 1 \|\| connect[0] != "0") {
	connOptions.m_specified_outgoing = connect;
	}
	}
	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);

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

	return true;
	}
	diff --git a/src/node/context.h b/src/node/context.h
	index 312b5bfd75..8867251dd4 100644
	--- a/src/node/context.h
	+++ b/src/node/context.h
	@@ -1,48 +1,57 @@
	// Copyright (c) 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.

	#ifndef BITCOIN_NODE_CONTEXT_H
	#define BITCOIN_NODE_CONTEXT_H

	+#include <cassert>
	#include <memory>
	#include <vector>

	class BanMan;
	class CConnman;
	class CScheduler;
	class CTxMemPool;
	+class ChainstateManager;
	class PeerLogicValidation;
	namespace interfaces {
	class Chain;
	class ChainClient;
	} // namespace interfaces

	//! NodeContext struct containing references to chain state and connection
	//! state.
	//!
	//! This is used by init, rpc, and test code to pass object references around
	//! without needing to declare the same variables and parameters repeatedly, or
	//! to use globals. More variables could be added to this struct (particularly
	//! references to validation objects) to eliminate use of globals
	//! and make code more modular and testable. The struct isn't intended to have
	//! any member functions. It should just be a collection of references that can
	//! be used without pulling in unwanted dependencies or functionality.
	struct NodeContext {
	std::unique_ptr<CConnman> connman;
	// Currently a raw pointer because the memory is not managed by this struct
	CTxMemPool *mempool{nullptr};
	std::unique_ptr<PeerLogicValidation> peer_logic;
	+ // Currently a raw pointer because the memory is not managed by this struct
	+ ChainstateManager *chainman{nullptr};
	std::unique_ptr<BanMan> banman;
	std::unique_ptr<interfaces::Chain> chain;
	std::vector<std::unique_ptr<interfaces::ChainClient>> chain_clients;
	std::unique_ptr<CScheduler> scheduler;

	//! Declare default constructor and destructor that are not inline, so code
	//! instantiating the NodeContext struct doesn't need to #include class
	//! definitions for all the unique_ptr members.
	NodeContext();
	~NodeContext();
	};

	+inline ChainstateManager &EnsureChainman(const NodeContext &node) {
	+ assert(node.chainman);
	+ return *node.chainman;
	+}
	+
	#endif // BITCOIN_NODE_CONTEXT_H
	diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
	index 9fc6d9530b..5d015859c9 100644
	--- a/src/test/util/setup_common.cpp
	+++ b/src/test/util/setup_common.cpp
	@@ -1,374 +1,376 @@
	// Copyright (c) 2011-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 <test/util/setup_common.h>

	#include <banman.h>
	#include <chainparams.h>
	#include <config.h>
	#include <consensus/consensus.h>
	#include <consensus/validation.h>
	#include <crypto/sha256.h>
	#include <init.h>
	#include <interfaces/chain.h>
	#include <logging.h>
	#include <miner.h>
	#include <net.h>
	#include <net_processing.h>
	#include <noui.h>
	#include <pow/pow.h>
	#include <rpc/blockchain.h>
	#include <rpc/register.h>
	#include <rpc/server.h>
	#include <script/script_error.h>
	#include <script/scriptcache.h>
	#include <script/sigcache.h>
	#include <streams.h>
	#include <txdb.h>
	#include <txmempool.h>
	#include <util/strencodings.h>
	#include <util/time.h>
	#include <util/translation.h>
	#include <validation.h>
	#include <validationinterface.h>
	#include <walletinitinterface.h>

	#include <functional>
	#include <memory>

	const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;

	FastRandomContext g_insecure_rand_ctx;
	/**
	* Random context to get unique temp data dirs. Separate from
	* g_insecure_rand_ctx, which can be seeded from a const env var
	*/
	static FastRandomContext g_insecure_rand_ctx_temp_path;

	/**
	* Return the unsigned from the environment var if available,
	* otherwise 0
	*/
	static uint256 GetUintFromEnv(const std::string &env_name) {
	const char *num = std::getenv(env_name.c_str());
	if (!num) {
	return {};
	}
	return uint256S(num);
	}

	void Seed(FastRandomContext &ctx) {
	// Should be enough to get the seed once for the process
	static uint256 seed{};
	static const std::string RANDOM_CTX_SEED{"RANDOM_CTX_SEED"};
	if (seed.IsNull()) {
	seed = GetUintFromEnv(RANDOM_CTX_SEED);
	}
	if (seed.IsNull()) {
	seed = GetRandHash();
	}
	LogPrintf("%s: Setting random seed for current tests to %s=%s\n", __func__,
	RANDOM_CTX_SEED, seed.GetHex());
	ctx = FastRandomContext(seed);
	}

	std::ostream &operator<<(std::ostream &os, const uint256 &num) {
	os << num.ToString();
	return os;
	}

	std::ostream &operator<<(std::ostream &os, const ScriptError &err) {
	os << ScriptErrorString(err);
	return os;
	}

	BasicTestingSetup::BasicTestingSetup(const std::string &chainName)
	: m_path_root{fs::temp_directory_path() / "test_common_" PACKAGE_NAME /
	g_insecure_rand_ctx_temp_path.rand256().ToString()} {
	SetMockTime(0);
	fs::create_directories(m_path_root);
	gArgs.ForceSetArg("-datadir", m_path_root.string());
	ClearDatadirCache();
	SelectParams(chainName);
	SeedInsecureRand();
	gArgs.ForceSetArg("-printtoconsole", "0");
	InitLogging();
	LogInstance().StartLogging();
	SHA256AutoDetect();
	ECC_Start();
	SetupEnvironment();
	SetupNetworking();
	InitSignatureCache();
	InitScriptExecutionCache();

	m_node.chain = interfaces::MakeChain(m_node, Params());
	g_wallet_init_interface.Construct(m_node);

	fCheckBlockIndex = true;
	static bool noui_connected = false;
	if (!noui_connected) {
	noui_connect();
	noui_connected = true;
	}
	}

	BasicTestingSetup::~BasicTestingSetup() {
	LogInstance().DisconnectTestLogger();
	fs::remove_all(m_path_root);
	ECC_Stop();
	}

	TestingSetup::TestingSetup(const std::string &chainName)
	: BasicTestingSetup(chainName) {
	const Config &config = GetConfig();
	const CChainParams &chainparams = config.GetChainParams();

	// Ideally we'd move all the RPC tests to the functional testing framework
	// instead of unit tests, but for now we need these here.
	RPCServer rpcServer;
	RegisterAllRPCCommands(config, rpcServer, tableRPC);

	/**
	* RPC does not come out of the warmup state on its own. Normally, this is
	* handled in bitcoind's init path, but unit tests do not trigger this
	* codepath, so we call it explicitly as part of setup.
	*/
	std::string rpcWarmupStatus;
	if (RPCIsInWarmup(&rpcWarmupStatus)) {
	SetRPCWarmupFinished();
	}

	m_node.scheduler = std::make_unique<CScheduler>();

	// We have to run a scheduler thread to prevent ActivateBestChain
	// from blocking due to queue overrun.
	threadGroup.create_thread([&] { m_node.scheduler->serviceQueue(); });
	GetMainSignals().RegisterBackgroundSignalScheduler(*m_node.scheduler);

	pblocktree.reset(new CBlockTreeDB(1 << 20, true));

	- g_chainman.InitializeChainstate();
	+ m_node.chainman = &::g_chainman;
	+ m_node.chainman->InitializeChainstate();
	::ChainstateActive().InitCoinsDB(
	/* cache_size_bytes / 1 << 23, / in_memory */ true,
	/* should_wipe */ false);
	assert(!::ChainstateActive().CanFlushToDisk());
	::ChainstateActive().InitCoinsCache();
	assert(::ChainstateActive().CanFlushToDisk());
	if (!LoadGenesisBlock(chainparams)) {
	throw std::runtime_error("LoadGenesisBlock failed.");
	}
	{
	BlockValidationState state;
	if (!ActivateBestChain(config, state)) {
	throw std::runtime_error(
	strprintf("ActivateBestChain failed. (%s)", state.ToString()));
	}
	}
	constexpr int script_check_threads = 2;
	for (int i = 0; i < script_check_threads; ++i) {
	threadGroup.create_thread([i]() { return ThreadScriptCheck(i); });
	}

	m_node.mempool = &::g_mempool;
	m_node.mempool->setSanityCheck(1.0);
	m_node.banman =
	std::make_unique<BanMan>(GetDataDir() / "banlist.dat", chainparams,
	nullptr, DEFAULT_MISBEHAVING_BANTIME);
	// Deterministic randomness for tests.
	m_node.connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
	m_node.peer_logic = std::make_unique<PeerLogicValidation>(
	m_node.connman.get(), m_node.banman.get(), *m_node.scheduler);
	}

	TestingSetup::~TestingSetup() {
	if (m_node.scheduler) {
	m_node.scheduler->stop();
	}
	threadGroup.interrupt_all();
	threadGroup.join_all();
	GetMainSignals().FlushBackgroundCallbacks();
	GetMainSignals().UnregisterBackgroundSignalScheduler();
	m_node.connman.reset();
	m_node.banman.reset();
	m_node.mempool = nullptr;
	m_node.scheduler.reset();
	UnloadBlockIndex();
	- g_chainman.Reset();
	+ m_node.chainman->Reset();
	+ m_node.chainman = nullptr;
	pblocktree.reset();
	}

	TestChain100Setup::TestChain100Setup() {
	// Generate a 100-block chain:
	coinbaseKey.MakeNewKey(true);
	CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
	<< OP_CHECKSIG;
	for (int i = 0; i < COINBASE_MATURITY; i++) {
	std::vector<CMutableTransaction> noTxns;
	CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
	m_coinbase_txns.push_back(b.vtx[0]);
	}
	}

	//
	// Create a new block with just given transactions, coinbase paying to
	// scriptPubKey, and try to add it to the current chain.
	//
	CBlock TestChain100Setup::CreateAndProcessBlock(
	const std::vector<CMutableTransaction> &txns, const CScript &scriptPubKey) {
	const Config &config = GetConfig();
	std::unique_ptr<CBlockTemplate> pblocktemplate =
	BlockAssembler(config, *m_node.mempool).CreateNewBlock(scriptPubKey);
	CBlock &block = pblocktemplate->block;

	// Replace mempool-selected txns with just coinbase plus passed-in txns:
	block.vtx.resize(1);
	for (const CMutableTransaction &tx : txns) {
	block.vtx.push_back(MakeTransactionRef(tx));
	}

	// Order transactions by canonical order
	std::sort(std::begin(block.vtx) + 1, std::end(block.vtx),
	[](const std::shared_ptr<const CTransaction> &txa,
	const std::shared_ptr<const CTransaction> &txb) -> bool {
	return txa->GetId() < txb->GetId();
	});

	// IncrementExtraNonce creates a valid coinbase and merkleRoot
	{
	LOCK(cs_main);
	unsigned int extraNonce = 0;
	IncrementExtraNonce(&block, ::ChainActive().Tip(),
	config.GetMaxBlockSize(), extraNonce);
	}

	const Consensus::Params &params = config.GetChainParams().GetConsensus();
	while (!CheckProofOfWork(block.GetHash(), block.nBits, params)) {
	++block.nNonce;
	}

	std::shared_ptr<const CBlock> shared_pblock =
	std::make_shared<const CBlock>(block);
	ProcessNewBlock(config, shared_pblock, true, nullptr);

	CBlock result = block;
	return result;
	}

	TestChain100Setup::~TestChain100Setup() {}

	CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction &tx) {
	return FromTx(MakeTransactionRef(tx));
	}

	CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransactionRef &tx) {
	return CTxMemPoolEntry(tx, nFee, nTime, nHeight, spendsCoinbase,
	nSigOpCount, LockPoints());
	}

	/**
	* @returns a real block
	* (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af) with 9
	* txs.
	*/
	CBlock getBlock13b8a() {
	CBlock block;
	CDataStream stream(
	ParseHex(
	"0100000090f0a9f110702f808219ebea1173056042a714bad51b916cb680000000"
	"0000005275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558"
	"da2fdb261b4d4c86041b1ab1bf9309010000000100000000000000000000000000"
	"00000000000000000000000000000000000000ffffffff07044c86041b0146ffff"
	"ffff0100f2052a01000000434104e18f7afbe4721580e81e8414fc8c24d7cfacf2"
	"54bb5c7b949450c3e997c2dc1242487a8169507b631eb3771f2b425483fb13102c"
	"4eb5d858eef260fe70fbfae0ac00000000010000000196608ccbafa16abada9027"
	"80da4dc35dafd7af05fa0da08cf833575f8cf9e836000000004a493046022100da"
	"b24889213caf43ae6adc41cf1c9396c08240c199f5225acf45416330fd7dbd0221"
	"00fe37900e0644bf574493a07fc5edba06dbc07c311b947520c2d514bc5725dcb4"
	"01ffffffff0100f2052a010000001976a914f15d1921f52e4007b146dfa60f369e"
	"d2fc393ce288ac000000000100000001fb766c1288458c2bafcfec81e48b24d98e"
	"c706de6b8af7c4e3c29419bfacb56d000000008c493046022100f268ba165ce0ad"
	"2e6d93f089cfcd3785de5c963bb5ea6b8c1b23f1ce3e517b9f022100da7c0f21ad"
	"c6c401887f2bfd1922f11d76159cbc597fbd756a23dcbb00f4d7290141042b4e86"
	"25a96127826915a5b109852636ad0da753c9e1d5606a50480cd0c40f1f8b8d8982"
	"35e571fe9357d9ec842bc4bba1827daaf4de06d71844d0057707966affffffff02"
	"80969800000000001976a9146963907531db72d0ed1a0cfb471ccb63923446f388"
	"ac80d6e34c000000001976a914f0688ba1c0d1ce182c7af6741e02658c7d4dfcd3"
	"88ac000000000100000002c40297f730dd7b5a99567eb8d27b78758f607507c522"
	"92d02d4031895b52f2ff010000008b483045022100f7edfd4b0aac404e5bab4fd3"
	"889e0c6c41aa8d0e6fa122316f68eddd0a65013902205b09cc8b2d56e1cd1f7f2f"
	"afd60a129ed94504c4ac7bdc67b56fe67512658b3e014104732012cb962afa90d3"
	"1b25d8fb0e32c94e513ab7a17805c14ca4c3423e18b4fb5d0e676841733cb83aba"
	"f975845c9f6f2a8097b7d04f4908b18368d6fc2d68ecffffffffca5065ff9617cb"
	"cba45eb23726df6498a9b9cafed4f54cbab9d227b0035ddefb000000008a473044"
	"022068010362a13c7f9919fa832b2dee4e788f61f6f5d344a7c2a0da6ae7406056"
	"58022006d1af525b9a14a35c003b78b72bd59738cd676f845d1ff3fc25049e0100"
	"3614014104732012cb962afa90d31b25d8fb0e32c94e513ab7a17805c14ca4c342"
	"3e18b4fb5d0e676841733cb83abaf975845c9f6f2a8097b7d04f4908b18368d6fc"
	"2d68ecffffffff01001ec4110200000043410469ab4181eceb28985b9b4e895c13"
	"fa5e68d85761b7eee311db5addef76fa8621865134a221bd01f28ec9999ee3e021"
	"e60766e9d1f3458c115fb28650605f11c9ac000000000100000001cdaf2f758e91"
	"c514655e2dc50633d1e4c84989f8aa90a0dbc883f0d23ed5c2fa010000008b4830"
	"4502207ab51be6f12a1962ba0aaaf24a20e0b69b27a94fac5adf45aa7d2d18ffd9"
	"236102210086ae728b370e5329eead9accd880d0cb070aea0c96255fae6c4f1ddc"
	"ce1fd56e014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
	"4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
	"ebbb12dcd4ffffffff02404b4c00000000001976a9142b6ba7c9d796b75eef7942"
	"fc9288edd37c32f5c388ac002d3101000000001976a9141befba0cdc1ad5652937"
	"1864d9f6cb042faa06b588ac000000000100000001b4a47603e71b61bc3326efd9"
	"0111bf02d2f549b067f4c4a8fa183b57a0f800cb010000008a4730440220177c37"
	"f9a505c3f1a1f0ce2da777c339bd8339ffa02c7cb41f0a5804f473c9230220585b"
	"25a2ee80eb59292e52b987dad92acb0c64eced92ed9ee105ad153cdb12d0014104"
	"43bd44f683467e549dae7d20d1d79cbdb6df985c6e9c029c8d0c6cb46cc1a4d3cf"
	"7923c5021b27f7a0b562ada113bc85d5fda5a1b41e87fe6e8802817cf69996ffff"
	"ffff0280651406000000001976a9145505614859643ab7b547cd7f1f5e7e2a1232"
	"2d3788ac00aa0271000000001976a914ea4720a7a52fc166c55ff2298e07baf70a"
	"e67e1b88ac00000000010000000586c62cd602d219bb60edb14a3e204de0705176"
	"f9022fe49a538054fb14abb49e010000008c493046022100f2bc2aba2534becbdf"
	"062eb993853a42bbbc282083d0daf9b4b585bd401aa8c9022100b1d7fd7ee0b956"
	"00db8535bbf331b19eed8d961f7a8e54159c53675d5f69df8c014104462e76fd40"
	"67b3a0aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c6"
	"9b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff03ad0e"
	"58ccdac3df9dc28a218bcf6f1997b0a93306faaa4b3a28ae83447b217901000000"
	"8b483045022100be12b2937179da88599e27bb31c3525097a07cdb52422d165b3c"
	"a2f2020ffcf702200971b51f853a53d644ebae9ec8f3512e442b1bcb6c315a5b49"
	"1d119d10624c83014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33"
	"d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312e"
	"f1c0e8ebbb12dcd4ffffffff2acfcab629bbc8685792603762c921580030ba144a"
	"f553d271716a95089e107b010000008b483045022100fa579a840ac258871365dd"
	"48cd7552f96c8eea69bd00d84f05b283a0dab311e102207e3c0ee9234814cfbb1b"
	"659b83671618f45abc1326b9edcc77d552a4f2a805c0014104462e76fd4067b3a0"
	"aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc3"
	"1895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffffdcdc6023bbc9"
	"944a658ddc588e61eacb737ddf0a3cd24f113b5a8634c517fcd2000000008b4830"
	"450221008d6df731df5d32267954bd7d2dda2302b74c6c2a6aa5c0ca64ecbabc1a"
	"f03c75022010e55c571d65da7701ae2da1956c442df81bbf076cdbac25133f99d9"
	"8a9ed34c014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
	"4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
	"ebbb12dcd4ffffffffe15557cd5ce258f479dfd6dc6514edf6d7ed5b21fcfa4a03"
	"8fd69f06b83ac76e010000008b483045022023b3e0ab071eb11de2eb1cc3a67261"
	"b866f86bf6867d4558165f7c8c8aca2d86022100dc6e1f53a91de3efe8f6351285"
	"0811f26284b62f850c70ca73ed5de8771fb451014104462e76fd4067b3a0aa4207"
	"0082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0"
	"c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff01404b4c0000000000"
	"1976a9142b6ba7c9d796b75eef7942fc9288edd37c32f5c388ac00000000010000"
	"000166d7577163c932b4f9690ca6a80b6e4eb001f0a2fa9023df5595602aae96ed"
	"8d000000008a4730440220262b42546302dfb654a229cefc86432b89628ff259dc"
	"87edd1154535b16a67e102207b4634c020a97c3e7bbd0d4d19da6aa2269ad9dded"
	"4026e896b213d73ca4b63f014104979b82d02226b3a4597523845754d44f13639e"
	"3bf2df5e82c6aab2bdc79687368b01b1ab8b19875ae3c90d661a3d0a33161dab29"
	"934edeb36aa01976be3baf8affffffff02404b4c00000000001976a9144854e695"
	"a02af0aeacb823ccbc272134561e0a1688ac40420f00000000001976a914abee93"
	"376d6b37b5c2940655a6fcaf1c8e74237988ac0000000001000000014e3f8ef2e9"
	"1349a9059cb4f01e54ab2597c1387161d3da89919f7ea6acdbb371010000008c49"
	"304602210081f3183471a5ca22307c0800226f3ef9c353069e0773ac76bb580654"
	"d56aa523022100d4c56465bdc069060846f4fbf2f6b20520b2a80b08b168b31e66"
	"ddb9c694e240014104976c79848e18251612f8940875b2b08d06e6dc73b9840e88"
	"60c066b7e87432c477e9a59a453e71e6d76d5fe34058b800a098fc1740ce3012e8"
	"fc8a00c96af966ffffffff02c0e1e400000000001976a9144134e75a6fcb604203"
	"4aab5e18570cf1f844f54788ac404b4c00000000001976a9142b6ba7c9d796b75e"
	"ef7942fc9288edd37c32f5c388ac00000000"),
	SER_NETWORK, PROTOCOL_VERSION);
	stream >> block;
	return block;
	}
	diff --git a/src/validation.h b/src/validation.h
	index 81eadc9056..2787873e09 100644
	--- a/src/validation.h
	+++ b/src/validation.h
	@@ -1,1277 +1,1275 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2019 The Bitcoin Core developers
	// Copyright (c) 2017-2020 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_VALIDATION_H
	#define BITCOIN_VALIDATION_H

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

	#include <amount.h>
	#include <blockfileinfo.h>
	#include <blockindexworkcomparator.h>
	#include <coins.h>
	#include <consensus/consensus.h>
	#include <disconnectresult.h>
	#include <flatfile.h>
	#include <fs.h>
	#include <protocol.h> // For CMessageHeader::MessageMagic
	#include <script/script_error.h>
	#include <script/script_metrics.h>
	#include <sync.h>
	#include <txdb.h>
	#include <txmempool.h> // For CTxMemPool::cs
	#include <versionbits.h>

	#include <atomic>
	#include <cstdint>
	#include <map>
	#include <memory>
	#include <optional>
	#include <set>
	#include <utility>
	#include <vector>

	class BlockValidationState;
	class CBlockIndex;
	class CBlockTreeDB;
	class CBlockUndo;
	class CChainParams;
	class CChain;
	class CConnman;
	class CInv;
	+class ChainstateManager;
	class Config;
	class CScriptCheck;
	class CTxMemPool;
	class CTxUndo;
	class DisconnectedBlockTransactions;
	class TxValidationState;

	struct ChainTxData;
	struct FlatFilePos;
	struct PrecomputedTransactionData;
	struct LockPoints;

	namespace Consensus {
	struct Params;
	}

	#define MIN_TRANSACTION_SIZE \
	(::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))

	/** Default for -minrelaytxfee, minimum relay fee for transactions */
	static const Amount DEFAULT_MIN_RELAY_TX_FEE_PER_KB(1000 * SATOSHI);
	/** Default for -excessutxocharge for transactions transactions */
	static const Amount DEFAULT_UTXO_FEE = Amount::zero();
	/**
	* Default for -mempoolexpiry, expiration time for mempool transactions in
	* hours.
	*/
	static const unsigned int DEFAULT_MEMPOOL_EXPIRY = 336;
	/** The maximum size of a blk?????.dat file (since 0.8) */
	static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB

	/** Maximum number of dedicated script-checking threads allowed */
	static const int MAX_SCRIPTCHECK_THREADS = 15;
	/** -par default (number of script-checking threads, 0 = auto) */
	static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
	/**
	* Number of blocks that can be requested at any given time from a single peer.
	*/
	static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
	/**
	* Timeout in seconds during which a peer must stall block download progress
	* before being disconnected.
	*/
	static const unsigned int BLOCK_STALLING_TIMEOUT = 2;
	/**
	* Number of headers sent in one getheaders result. We rely on the assumption
	* that if a peer sends less than this number, we reached its tip. Changing this
	* value is a protocol upgrade.
	*/
	static const unsigned int MAX_HEADERS_RESULTS = 2000;
	/**
	* Maximum depth of blocks we're willing to serve as compact blocks to peers
	* when requested. For older blocks, a regular BLOCK response will be sent.
	*/
	static const int MAX_CMPCTBLOCK_DEPTH = 5;
	/**
	* Maximum depth of blocks we're willing to respond to GETBLOCKTXN requests for.
	*/
	static const int MAX_BLOCKTXN_DEPTH = 10;
	/**
	* Size of the "block download window": how far ahead of our current height do
	* we fetch ? Larger windows tolerate larger download speed differences between
	* peer, but increase the potential degree of disordering of blocks on disk
	* (which make reindexing and in the future perhaps 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;
	/** Time to wait (in seconds) between writing blocks/block index to disk. */
	static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;
	/** Time to wait (in seconds) between flushing chainstate to disk. */
	static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
	/** Block download timeout base, expressed in millionths of the block interval
	* (i.e. 10 min) */
	static const int64_t BLOCK_DOWNLOAD_TIMEOUT_BASE = 1000000;
	/**
	* Additional block download timeout per parallel downloading peer (i.e. 5 min)
	*/
	static const int64_t BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 500000;

	static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
	/**
	* Maximum age of our tip in seconds for us to be considered current for fee
	* estimation.
	*/
	static const int64_t MAX_FEE_ESTIMATION_TIP_AGE = 3 * 60 * 60;

	static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
	static const bool DEFAULT_TXINDEX = false;
	static const char *const DEFAULT_BLOCKFILTERINDEX = "0";
	static const unsigned int DEFAULT_BANSCORE_THRESHOLD = 100;

	/** Default for -persistmempool */
	static const bool DEFAULT_PERSIST_MEMPOOL = true;
	/** Default for using fee filter */
	static const bool DEFAULT_FEEFILTER = true;

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

	static const bool DEFAULT_PEERBLOOMFILTERS = true;

	/** Default for -stopatheight */
	static const int DEFAULT_STOPATHEIGHT = 0;
	/** Default for -maxreorgdepth */
	static const int DEFAULT_MAX_REORG_DEPTH = 10;
	/**
	* Default for -finalizationdelay
	* This is the minimum time between a block header reception and the block
	* finalization.
	* This value should be >> block propagation and validation time
	*/
	static const int64_t DEFAULT_MIN_FINALIZATION_DELAY = 2 * 60 * 60;

	/** Current sync state passed to tip changed callbacks. */
	enum class SynchronizationState { INIT_REINDEX, INIT_DOWNLOAD, POST_INIT };

	extern RecursiveMutex cs_main;
	extern CTxMemPool g_mempool;
	typedef std::unordered_map<BlockHash, CBlockIndex *, BlockHasher> BlockMap;
	extern Mutex g_best_block_mutex;
	extern std::condition_variable g_best_block_cv;
	extern uint256 g_best_block;
	extern std::atomic_bool fImporting;
	extern std::atomic_bool fReindex;
	extern bool fRequireStandard;
	extern bool fCheckBlockIndex;
	extern bool fCheckpointsEnabled;
	extern size_t nCoinCacheUsage;

	/**
	* A fee rate smaller than this is considered zero fee (for relaying, mining and
	* transaction creation)
	*/
	extern CFeeRate minRelayTxFee;
	/**
	* If the tip is older than this (in seconds), the node is considered to be in
	* initial block download.
	*/
	extern int64_t nMaxTipAge;

	/**
	* Block hash whose ancestors we will assume to have valid scripts without
	* checking them.
	*/
	extern BlockHash hashAssumeValid;

	/**
	* Minimum work we will assume exists on some valid chain.
	*/
	extern arith_uint256 nMinimumChainWork;

	/**
	* Best header we've seen so far (used for getheaders queries' starting points).
	*/
	extern CBlockIndex *pindexBestHeader;

	/** Pruning-related variables and constants */
	/** True if any block files have ever been pruned. */
	extern bool fHavePruned;
	/** True if we're running in -prune mode. */
	extern bool fPruneMode;
	/** Number of MiB of block files that we're trying to stay below. */
	extern uint64_t nPruneTarget;
	/**
	* Block files containing a block-height within MIN_BLOCKS_TO_KEEP of
	* ::ChainActive().Tip() will not be pruned.
	*/
	static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
	/** Minimum blocks required to signal NODE_NETWORK_LIMITED */
	static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288;

	static const signed int DEFAULT_CHECKBLOCKS = 6;
	static const unsigned int DEFAULT_CHECKLEVEL = 3;

	/**
	* Require that user allocate at least 550 MiB for block & undo files
	* (blk???.dat and rev???.dat)
	* At 1MB per block, 288 blocks = 288MB.
	* Add 15% for Undo data = 331MB
	* Add 20% for Orphan block rate = 397MB
	* We want the low water mark after pruning to be at least 397 MB and since we
	* prune in full block file chunks, we need the high water mark which triggers
	* the prune to be one 128MB block file + added 15% undo data = 147MB greater
	* for a total of 545MB
	* Setting the target to >= 550 MiB will make it likely we can respect the
	* target.
	*/
	static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;

	class BlockValidationOptions {
	private:
	uint64_t excessiveBlockSize;
	bool checkPoW : 1;
	bool checkMerkleRoot : 1;

	public:
	// Do full validation by default
	explicit BlockValidationOptions(const Config &config);
	explicit BlockValidationOptions(uint64_t _excessiveBlockSize,
	bool _checkPow = true,
	bool _checkMerkleRoot = true)
	: excessiveBlockSize(_excessiveBlockSize), checkPoW(_checkPow),
	checkMerkleRoot(_checkMerkleRoot) {}

	BlockValidationOptions withCheckPoW(bool _checkPoW = true) const {
	BlockValidationOptions ret = *this;
	ret.checkPoW = _checkPoW;
	return ret;
	}

	BlockValidationOptions
	withCheckMerkleRoot(bool _checkMerkleRoot = true) const {
	BlockValidationOptions ret = *this;
	ret.checkMerkleRoot = _checkMerkleRoot;
	return ret;
	}

	bool shouldValidatePoW() const { return checkPoW; }
	bool shouldValidateMerkleRoot() const { return checkMerkleRoot; }
	uint64_t getExcessiveBlockSize() const { return excessiveBlockSize; }
	};

	/**
	* Process an incoming block. This only returns after the best known valid
	* block is made active. Note that it does not, however, guarantee that the
	* specific block passed to it has been checked for validity!
	*
	* If you want to possibly get feedback on whether pblock is valid, you must
	* install a CValidationInterface (see validationinterface.h) - this will have
	* its BlockChecked method called whenever any block completes validation.
	*
	* Note that we guarantee that either the proof-of-work is valid on pblock, or
	* (and possibly also) BlockChecked will have been called.
	*
	* May not be called in a validationinterface callback.
	*
	* @param[in] config The global config.
	* @param[in] pblock The block we want to process.
	* @param[in] fForceProcessing Process this block even if unrequested; used
	* for non-network block sources and whitelisted peers.
	* @param[out] fNewBlock A boolean which is set to indicate if the block was
	* first received via this call.
	* @returns If the block was processed, independently of block validity
	*/
	bool ProcessNewBlock(const Config &config,
	const std::shared_ptr<const CBlock> pblock,
	bool fForceProcessing, bool *fNewBlock)
	LOCKS_EXCLUDED(cs_main);

	/**
	* Process incoming block headers.
	*
	* May not be called in a validationinterface callback.
	*
	* @param[in] config The config.
	* @param[in] block The block headers themselves.
	* @param[out] state This may be set to an Error state if any error
	* occurred processing them.
	* @param[out] ppindex If set, the pointer will be set to point to the
	* last new block index object for the given headers.
	* @return True if block headers were accepted as valid.
	*/
	bool ProcessNewBlockHeaders(const Config &config,
	const std::vector<CBlockHeader> &block,
	BlockValidationState &state,
	const CBlockIndex **ppindex = nullptr)
	LOCKS_EXCLUDED(cs_main);

	/**
	* Import blocks from an external file.
	*/
	bool LoadExternalBlockFile(const Config &config, FILE *fileIn,
	FlatFilePos *dbp = nullptr);

	/**
	* Ensures we have a genesis block in the block tree, possibly writing one to
	* disk.
	*/
	bool LoadGenesisBlock(const CChainParams &chainparams);

	/**
	* Load the block tree and coins database from disk, initializing state if we're
	* running with -reindex.
	*/
	bool LoadBlockIndex(const Consensus::Params &params)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Unload database information.
	*/
	void UnloadBlockIndex();

	/**
	* Run an instance of the script checking thread.
	*/
	void ThreadScriptCheck(int worker_num);

	/**
	* Retrieve a transaction (from memory pool, or from disk, if possible).
	*/
	bool GetTransaction(const TxId &txid, CTransactionRef &txOut,
	const Consensus::Params &params, BlockHash &hashBlock,
	const CBlockIndex *const blockIndex = nullptr);

	/**
	* Find the best known block, and make it the tip of the block chain
	*
	* May not be called with cs_main held. May not be called in a
	* validationinterface callback.
	*/
	bool ActivateBestChain(
	const Config &config, BlockValidationState &state,
	std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>());
	Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams);

	/**
	* Guess verification progress (as a fraction between 0.0=genesis and
	* 1.0=current tip).
	*/
	double GuessVerificationProgress(const ChainTxData &data,
	const CBlockIndex *pindex);

	/**
	* Calculate the amount of disk space the block & undo files currently use.
	*/
	uint64_t CalculateCurrentUsage();

	/**
	* Mark one block file as pruned.
	*/
	void PruneOneBlockFile(const int fileNumber) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Actually unlink the specified files
	*/
	void UnlinkPrunedFiles(const std::set<int> &setFilesToPrune);

	/** Prune block files up to a given height */
	void PruneBlockFilesManual(int nManualPruneHeight);

	/**
	* (try to) add transaction to memory pool
	*/
	bool AcceptToMemoryPool(const Config &config, CTxMemPool &pool,
	TxValidationState &state, const CTransactionRef &tx,
	bool bypass_limits, const Amount nAbsurdFee,
	bool test_accept = false)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Simple class for regulating resource usage during CheckInputs (and
	* CScriptCheck), atomic so as to be compatible with parallel validation.
	*/
	class CheckInputsLimiter {
	protected:
	std::atomic<int64_t> remaining;

	public:
	explicit CheckInputsLimiter(int64_t limit) : remaining(limit) {}

	bool consume_and_check(int consumed) {
	auto newvalue = (remaining -= consumed);
	return newvalue >= 0;
	}

	bool check() { return remaining >= 0; }
	};

	class TxSigCheckLimiter : public CheckInputsLimiter {
	public:
	TxSigCheckLimiter() : CheckInputsLimiter(MAX_TX_SIGCHECKS) {}

	// Let's make this bad boy copiable.
	TxSigCheckLimiter(const TxSigCheckLimiter &rhs)
	: CheckInputsLimiter(rhs.remaining.load()) {}

	TxSigCheckLimiter &operator=(const TxSigCheckLimiter &rhs) {
	remaining = rhs.remaining.load();
	return *this;
	}

	static TxSigCheckLimiter getDisabled() {
	TxSigCheckLimiter txLimiter;
	// Historically, there has not been a transaction with more than 20k sig
	// checks on testnet or mainnet, so this effectively disable sigchecks.
	txLimiter.remaining = 20000;
	return txLimiter;
	}
	};

	class ConnectTrace;

	/**
	* Check whether all inputs of this transaction are valid (no double spends,
	* scripts & sigs, amounts). This does not modify the UTXO set.
	*
	* If pvChecks is not nullptr, script checks are pushed onto it instead of being
	* performed inline. Any script checks which are not necessary (eg due to script
	* execution cache hits) are, obviously, not pushed onto pvChecks/run.
	*
	* Upon success nSigChecksOut will be filled in with either:
	* - correct total for all inputs, or,
	* - 0, in the case when checks were pushed onto pvChecks (i.e., a cache miss
	* with pvChecks non-null), in which case the total can be found by executing
	* pvChecks and adding the results.
	*
	* Setting sigCacheStore/scriptCacheStore to false will remove elements from the
	* corresponding cache which are matched. This is useful for checking blocks
	* where we will likely never need the cache entry again.
	*
	* pLimitSigChecks can be passed to limit the sigchecks count either in parallel
	* or serial validation. With pvChecks null (serial validation), breaking the
	* pLimitSigChecks limit will abort evaluation early and return false. With
	* pvChecks not-null (parallel validation): the cached nSigChecks may itself
	* break the limit in which case false is returned, OR, each entry in the
	* returned pvChecks must be executed exactly once in order to probe the limit
	* accurately.
	*/
	bool CheckInputs(const CTransaction &tx, TxValidationState &state,
	const CCoinsViewCache &view, const uint32_t flags,
	bool sigCacheStore, bool scriptCacheStore,
	const PrecomputedTransactionData &txdata, int &nSigChecksOut,
	TxSigCheckLimiter &txLimitSigChecks,
	CheckInputsLimiter *pBlockLimitSigChecks,
	std::vector<CScriptCheck> *pvChecks)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Handy shortcut to full fledged CheckInputs call.
	*/
	static inline bool
	CheckInputs(const CTransaction &tx, TxValidationState &state,
	const CCoinsViewCache &view, const uint32_t flags,
	bool sigCacheStore, bool scriptCacheStore,
	const PrecomputedTransactionData &txdata, int &nSigChecksOut)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	TxSigCheckLimiter nSigChecksTxLimiter;
	return CheckInputs(tx, state, view, flags, sigCacheStore, scriptCacheStore,
	txdata, nSigChecksOut, nSigChecksTxLimiter, nullptr,
	nullptr);
	}

	/** Get the BIP9 state for a given deployment at the current tip. */
	ThresholdState VersionBitsTipState(const Consensus::Params &params,
	Consensus::DeploymentPos pos);

	/** Get the BIP9 state for a given deployment at a given block. */
	ThresholdState VersionBitsBlockState(const Consensus::Params &params,
	Consensus::DeploymentPos pos,
	const CBlockIndex *pindex);

	/**
	* Get the numerical statistics for the BIP9 state for a given deployment at the
	* current tip.
	*/
	BIP9Stats VersionBitsTipStatistics(const Consensus::Params &params,
	Consensus::DeploymentPos pos);

	/**
	* Get the block height at which the BIP9 deployment switched into the state for
	* the block building on the current tip.
	*/
	int VersionBitsTipStateSinceHeight(const Consensus::Params &params,
	Consensus::DeploymentPos pos);

	/** Apply the effects of this transaction on the UTXO set represented by view */
	void UpdateCoins(const CTransaction &tx, CCoinsViewCache &inputs, int nHeight);

	/**
	* Mark all the coins corresponding to a given transaction inputs as spent.
	*/
	void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
	int nHeight);

	/**
	* Apply the effects of this transaction on the UTXO set represented by view.
	*/
	void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, int nHeight);
	void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
	int nHeight);

	/**
	* Test whether the LockPoints height and time are still valid on the current
	* chain.
	*/
	bool TestLockPointValidity(const LockPoints *lp)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Check if transaction will be BIP 68 final in the next block to be created.
	*
	* Simulates calling SequenceLocks() with data from the tip of the current
	* active chain. Optionally stores in LockPoints the resulting height and time
	* calculated and the hash of the block needed for calculation or skips the
	* calculation and uses the LockPoints passed in for evaluation. The LockPoints
	* should not be considered valid if CheckSequenceLocks returns false.
	*
	* See consensus/consensus.h for flag definitions.
	*/
	bool CheckSequenceLocks(const CTxMemPool &pool, const CTransaction &tx,
	int flags, LockPoints *lp = nullptr,
	bool useExistingLockPoints = false)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Closure representing one script verification.
	* Note that this stores references to the spending transaction.
	*
	* Note that if pLimitSigChecks is passed, then failure does not imply that
	* scripts have failed.
	*/
	class CScriptCheck {
	private:
	CTxOut m_tx_out;
	const CTransaction *ptxTo;
	unsigned int nIn;
	uint32_t nFlags;
	bool cacheStore;
	ScriptError error;
	ScriptExecutionMetrics metrics;
	PrecomputedTransactionData txdata;
	TxSigCheckLimiter *pTxLimitSigChecks;
	CheckInputsLimiter *pBlockLimitSigChecks;

	public:
	CScriptCheck()
	: ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false),
	error(ScriptError::UNKNOWN), txdata(), pTxLimitSigChecks(nullptr),
	pBlockLimitSigChecks(nullptr) {}

	CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn,
	unsigned int nInIn, uint32_t nFlagsIn, bool cacheIn,
	const PrecomputedTransactionData &txdataIn,
	TxSigCheckLimiter *pTxLimitSigChecksIn = nullptr,
	CheckInputsLimiter *pBlockLimitSigChecksIn = nullptr)
	: m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn),
	cacheStore(cacheIn), error(ScriptError::UNKNOWN), txdata(txdataIn),
	pTxLimitSigChecks(pTxLimitSigChecksIn),
	pBlockLimitSigChecks(pBlockLimitSigChecksIn) {}

	bool operator()();

	void swap(CScriptCheck &check) {
	std::swap(ptxTo, check.ptxTo);
	std::swap(m_tx_out, check.m_tx_out);
	std::swap(nIn, check.nIn);
	std::swap(nFlags, check.nFlags);
	std::swap(cacheStore, check.cacheStore);
	std::swap(error, check.error);
	std::swap(metrics, check.metrics);
	std::swap(txdata, check.txdata);
	std::swap(pTxLimitSigChecks, check.pTxLimitSigChecks);
	std::swap(pBlockLimitSigChecks, check.pBlockLimitSigChecks);
	}

	ScriptError GetScriptError() const { return error; }

	ScriptExecutionMetrics GetScriptExecutionMetrics() const { return metrics; }
	};

	bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex *pindex);

	/** Functions for validating blocks and updating the block tree */

	/**
	* Context-independent validity checks.
	*
	* Returns true if the provided block is valid (has valid header,
	* transactions are valid, block is a valid size, etc.)
	*/
	bool CheckBlock(const CBlock &block, BlockValidationState &state,
	const Consensus::Params &params,
	BlockValidationOptions validationOptions);

	/**
	* This is a variant of ContextualCheckTransaction which computes the contextual
	* check for a transaction based on the chain tip.
	*
	* See consensus/consensus.h for flag definitions.
	*/
	bool ContextualCheckTransactionForCurrentBlock(const Consensus::Params &params,
	const CTransaction &tx,
	TxValidationState &state,
	int flags = -1);

	/**
	* Check a block is completely valid from start to finish (only works on top of
	* our current best block)
	*/
	bool TestBlockValidity(BlockValidationState &state, const CChainParams &params,
	const CBlock &block, CBlockIndex *pindexPrev,
	BlockValidationOptions validationOptions)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* RAII wrapper for VerifyDB: Verify consistency of the block and coin
	* databases.
	*/
	class CVerifyDB {
	public:
	CVerifyDB();
	~CVerifyDB();
	bool VerifyDB(const Config &config, CCoinsView *coinsview, int nCheckLevel,
	int nCheckDepth);
	};

	CBlockIndex *LookupBlockIndex(const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/** Find the last common block between the parameter chain and a locator. */
	CBlockIndex *FindForkInGlobalIndex(const CChain &chain,
	const CBlockLocator &locator)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/** @see CChainState::FlushStateToDisk */
	enum class FlushStateMode { NONE, IF_NEEDED, PERIODIC, ALWAYS };

	/** Global variable that points to the active CCoinsView (protected by cs_main)
	*/
	extern std::unique_ptr<CCoinsViewCache> pcoinsTip;

	/**
	* Maintains a tree of blocks (stored in `m_block_index`) which is consulted
	* to determine where the most-work tip is.
	*
	* This data is used mostly in `CChainState` - information about, e.g.,
	* candidate tips is not maintained here.
	*/
	class BlockManager {
	public:
	BlockMap m_block_index GUARDED_BY(cs_main);

	/**
	* In order to efficiently track invalidity of headers, we keep the set of
	* blocks which we tried to connect and found to be invalid here (ie which
	* were set to BLOCK_FAILED_VALID since the last restart). We can then
	* walk this set and check if a new header is a descendant of something in
	* this set, preventing us from having to walk m_block_index when we try
	* to connect a bad block and fail.
	*
	* While this is more complicated than marking everything which descends
	* from an invalid block as invalid at the time we discover it to be
	* invalid, doing so would require walking all of m_block_index to find all
	* descendants. Since this case should be very rare, keeping track of all
	* BLOCK_FAILED_VALID blocks in a set should be just fine and work just as
	* well.
	*
	* Because we already walk m_block_index in height-order at startup, we go
	* ahead and mark descendants of invalid blocks as FAILED_CHILD at that
	* time, instead of putting things in this set.
	*/
	std::set<CBlockIndex *> m_failed_blocks;

	/**
	* All pairs A->B, where A (or one of its ancestors) misses transactions,
	* but B has transactions. Pruned nodes may have entries where B is missing
	* data.
	*/
	std::multimap<CBlockIndex , CBlockIndex > m_blocks_unlinked;

	/**
	* Load the blocktree off disk and into memory. Populate certain metadata
	* per index entry (nStatus, nChainWork, nTimeMax, etc.) as well as
	* peripheral collections like setDirtyBlockIndex.
	*
	* @param[out] block_index_candidates Fill this set with any valid blocks
	* for which we've downloaded all transactions.
	*/
	bool LoadBlockIndex(const Consensus::Params &consensus_params,
	CBlockTreeDB &blocktree,
	std::set<CBlockIndex *, CBlockIndexWorkComparator>
	&block_index_candidates)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/** Clear all data members. */
	void Unload() EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	CBlockIndex *AddToBlockIndex(const CBlockHeader &block)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	/** Create a new block index entry for a given block hash */
	CBlockIndex *InsertBlockIndex(const BlockHash &hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* If a block header hasn't already been seen, call CheckBlockHeader on it,
	* ensure that it doesn't descend from an invalid block, and then add it to
	* m_block_index.
	*/
	bool AcceptBlockHeader(const Config &config, const CBlockHeader &block,
	BlockValidationState &state, CBlockIndex **ppindex)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	};

	/**
	* A convenience class for constructing the CCoinsView* hierarchy used
	* to facilitate access to the UTXO set.
	*
	* This class consists of an arrangement of layered CCoinsView objects,
	* preferring to store and retrieve coins in memory via `m_cacheview` but
	* ultimately falling back on cache misses to the canonical store of UTXOs on
	* disk, `m_dbview`.
	*/
	class CoinsViews {
	public:
	//! The lowest level of the CoinsViews cache hierarchy sits in a leveldb
	//! database on disk. All unspent coins reside in this store.
	CCoinsViewDB m_dbview GUARDED_BY(cs_main);

	//! This view wraps access to the leveldb instance and handles read errors
	//! gracefully.
	CCoinsViewErrorCatcher m_catcherview GUARDED_BY(cs_main);

	//! This is the top layer of the cache hierarchy - it keeps as many coins in
	//! memory as can fit per the dbcache setting.
	std::unique_ptr<CCoinsViewCache> m_cacheview GUARDED_BY(cs_main);

	//! This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher
	//! instances, but it does not create a CCoinsViewCache instance by
	//! default. This is done separately because the presence of the cache has
	//! implications on whether or not we're allowed to flush the cache's state
	//! to disk, which should not be done until the health of the database is
	//! verified.
	//!
	//! All arguments forwarded onto CCoinsViewDB.
	CoinsViews(std::string ldb_name, size_t cache_size_bytes, bool in_memory,
	bool should_wipe);

	//! Initialize the CCoinsViewCache member.
	void InitCache() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
	};

	-// Defined below, but needed for `friend` usage in CChainState.
	-class ChainstateManager;
	-
	/**
	* CChainState stores and provides an API to update our local knowledge of the
	* current best chain.
	*
	* Eventually, the API here is targeted at being exposed externally as a
	* consumable libconsensus library, so any functions added must only call
	* other class member functions, pure functions in other parts of the consensus
	* library, callbacks via the validation interface, or read/write-to-disk
	* functions (eventually this will also be via callbacks).
	*
	* Anything that is contingent on the current tip of the chain is stored here,
	* whereas block information and metadata independent of the current tip is
	* kept in `BlockMetadataManager`.
	*/
	class CChainState {
	private:
	/**
	* the ChainState CriticalSection
	* A lock that must be held when modifying this ChainState - held in
	* ActivateBestChain()
	*/
	RecursiveMutex m_cs_chainstate;

	/**
	* Every received block is assigned a unique and increasing identifier, so
	* we know which one to give priority in case of a fork.
	* Blocks loaded from disk are assigned id 0, so start the counter at 1.
	*/
	std::atomic<int32_t> nBlockSequenceId{1};
	/** Decreasing counter (used by subsequent preciousblock calls). */
	int32_t nBlockReverseSequenceId = -1;
	/** chainwork for the last block that preciousblock has been applied to. */
	arith_uint256 nLastPreciousChainwork = 0;

	/**
	* Whether this chainstate is undergoing initial block download.
	*
	* Mutable because we need to be able to mark IsInitialBlockDownload()
	* const, which latches this for caching purposes.
	*/
	mutable std::atomic<bool> m_cached_finished_ibd{false};

	//! Reference to a BlockManager instance which itself is shared across all
	//! CChainState instances. Keeping a local reference allows us to test more
	//! easily as opposed to referencing a global.
	BlockManager &m_blockman;

	//! Manages the UTXO set, which is a reflection of the contents of
	//! `m_chain`.
	std::unique_ptr<CoinsViews> m_coins_views;

	/**
	* The best finalized block.
	* This block cannot be reorged in any way except by explicit user action.
	*/
	const CBlockIndex *m_finalizedBlockIndex GUARDED_BY(cs_main) = nullptr;

	public:
	explicit CChainState(BlockManager &blockman,
	BlockHash from_snapshot_blockhash = BlockHash());

	/**
	* Initialize the CoinsViews UTXO set database management data structures.
	* The in-memory cache is initialized separately.
	*
	* All parameters forwarded to CoinsViews.
	*/
	void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe,
	std::string leveldb_name = "chainstate");

	//! Initialize the in-memory coins cache (to be done after the health of the
	//! on-disk database is verified).
	void InitCoinsCache() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	//! @returns whether or not the CoinsViews object has been fully initialized
	//! and we can
	//! safely flush this object to disk.
	bool CanFlushToDisk() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	return m_coins_views && m_coins_views->m_cacheview;
	}

	//! The current chain of blockheaders we consult and build on.
	//! @see CChain, CBlockIndex.
	CChain m_chain;

	/**
	* The blockhash which is the base of the snapshot this chainstate was
	* created from.
	*
	* IsNull() if this chainstate was not created from a snapshot.
	*/
	const BlockHash m_from_snapshot_blockhash{};

	/**
	* The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for
	* itself and all ancestors) and as good as our current tip or better.
	* Entries may be failed, though, and pruning nodes may be missing the data
	* for the block.
	*/
	std::set<CBlockIndex *, CBlockIndexWorkComparator> setBlockIndexCandidates;

	//! @returns A reference to the in-memory cache of the UTXO set.
	CCoinsViewCache &CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	assert(m_coins_views->m_cacheview);
	return *m_coins_views->m_cacheview.get();
	}

	//! @returns A reference to the on-disk UTXO set database.
	CCoinsViewDB &CoinsDB() { return m_coins_views->m_dbview; }

	//! @returns A reference to a wrapped view of the in-memory UTXO set that
	//! handles disk read errors gracefully.
	CCoinsViewErrorCatcher &CoinsErrorCatcher()
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	return m_coins_views->m_catcherview;
	}

	//! Destructs all objects related to accessing the UTXO set.
	void ResetCoinsViews() { m_coins_views.reset(); }

	/**
	* Update the on-disk chain state.
	* The caches and indexes are flushed depending on the mode we're called
	* with if they're too large, if it's been a while since the last write, or
	* always and in all cases if we're in prune mode and are deleting files.
	*
	* If FlushStateMode::NONE is used, then FlushStateToDisk(...) won't do
	* anything besides checking if we need to prune.
	*
	* @returns true unless a system error occurred
	*/
	bool FlushStateToDisk(const CChainParams &chainparams,
	BlockValidationState &state, FlushStateMode mode,
	int nManualPruneHeight = 0);

	//! Unconditionally flush all changes to disk.
	void ForceFlushStateToDisk();

	//! Prune blockfiles from the disk if necessary and then flush chainstate
	//! changes if we pruned.
	void PruneAndFlush();

	/**
	* Make the best chain active, in multiple steps. The result is either
	* failure or an activated best chain. pblock is either nullptr or a pointer
	* to a block that is already loaded (to avoid loading it again from disk).
	*
	* ActivateBestChain is split into steps (see ActivateBestChainStep) so that
	* we avoid holding cs_main for an extended period of time; the length of
	* this call may be quite long during reindexing or a substantial reorg.
	*
	* May not be called with cs_main held. May not be called in a
	* validationinterface callback.
	*
	* @returns true unless a system error occurred
	*/
	bool ActivateBestChain(
	const Config &config, BlockValidationState &state,
	std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>())
	LOCKS_EXCLUDED(cs_main);

	bool AcceptBlock(const Config &config,
	const std::shared_ptr<const CBlock> &pblock,
	BlockValidationState &state, bool fRequested,
	const FlatFilePos dbp, bool fNewBlock)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	// Block (dis)connection on a given view:
	DisconnectResult DisconnectBlock(const CBlock &block,
	const CBlockIndex *pindex,
	CCoinsViewCache &view);
	bool ConnectBlock(const CBlock &block, BlockValidationState &state,
	CBlockIndex *pindex, CCoinsViewCache &view,
	const CChainParams &params,
	BlockValidationOptions options, bool fJustCheck = false)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	// Block disconnection on our pcoinsTip:
	bool DisconnectTip(const CChainParams &params, BlockValidationState &state,
	DisconnectedBlockTransactions *disconnectpool)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::g_mempool.cs);

	// Manual block validity manipulation:
	bool PreciousBlock(const Config &config, BlockValidationState &state,
	CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main);
	/** Mark a block as invalid. */
	bool InvalidateBlock(const Config &config, BlockValidationState &state,
	CBlockIndex *pindex)
	LOCKS_EXCLUDED(cs_main, m_cs_chainstate);
	/** Park a block. */
	bool ParkBlock(const Config &config, BlockValidationState &state,
	CBlockIndex *pindex)
	LOCKS_EXCLUDED(cs_main, m_cs_chainstate);

	/**
	* Finalize a block.
	* A finalized block can not be reorged in any way.
	*/
	bool FinalizeBlock(const Config &config, BlockValidationState &state,
	CBlockIndex *pindex)
	LOCKS_EXCLUDED(cs_main, m_cs_chainstate);
	/** Return the currently finalized block index. */
	const CBlockIndex *GetFinalizedBlock() const
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	/**
	* Checks if a block is finalized.
	*/
	bool IsBlockFinalized(const CBlockIndex *pindex) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	void ResetBlockFailureFlags(CBlockIndex *pindex)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	template <typename F>
	bool UpdateFlagsForBlock(CBlockIndex pindexBase, CBlockIndex pindex, F f)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	template <typename F, typename C, typename AC>
	void UpdateFlags(CBlockIndex pindex, CBlockIndex &pindexReset, F f,
	C fChild, AC fAncestorWasChanged)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	/** Remove parked status from a block and its descendants. */
	void UnparkBlockImpl(CBlockIndex *pindex, bool fClearChildren)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/** Replay blocks that aren't fully applied to the database. */
	bool ReplayBlocks(const Consensus::Params &params);
	bool LoadGenesisBlock(const CChainParams &chainparams);

	void PruneBlockIndexCandidates();

	void UnloadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Check whether we are doing an initial block download (synchronizing from
	* disk or network)
	*/
	bool IsInitialBlockDownload() const;

	/**
	* Make various assertions about the state of the block index.
	*
	* By default this only executes fully when using the Regtest chain; see:
	* fCheckBlockIndex.
	*/
	void CheckBlockIndex(const Consensus::Params &consensusParams);

	/** Update the chain tip based on database information, i.e. CoinsTip()'s
	* best block. */
	bool LoadChainTip(const CChainParams &chainparams)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	std::string ToString() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	private:
	bool ActivateBestChainStep(const Config &config,
	BlockValidationState &state,
	CBlockIndex *pindexMostWork,
	const std::shared_ptr<const CBlock> &pblock,
	bool &fInvalidFound, ConnectTrace &connectTrace)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::g_mempool.cs);
	bool ConnectTip(const Config &config, BlockValidationState &state,
	CBlockIndex *pindexNew,
	const std::shared_ptr<const CBlock> &pblock,
	ConnectTrace &connectTrace,
	DisconnectedBlockTransactions &disconnectpool)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::g_mempool.cs);
	void InvalidBlockFound(CBlockIndex *pindex,
	const BlockValidationState &state)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	void InvalidChainFound(CBlockIndex *pindexNew)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	CBlockIndex *FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	bool MarkBlockAsFinal(const Config &config, BlockValidationState &state,
	const CBlockIndex *pindex)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew,
	const FlatFilePos &pos)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs,
	const Consensus::Params &params)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	bool UnwindBlock(const Config &config, BlockValidationState &state,
	CBlockIndex *pindex, bool invalidate)
	EXCLUSIVE_LOCKS_REQUIRED(m_cs_chainstate);

	friend ChainstateManager;
	};

	/**
	* Mark a block as precious and reorganize.
	*
	* May not be called in a validationinterface callback.
	*/
	bool PreciousBlock(const Config &config, BlockValidationState &state,
	CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main);

	/** Remove invalidity status from a block and its descendants. */
	void ResetBlockFailureFlags(CBlockIndex *pindex)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/** Remove parked status from a block and its descendants. */
	void UnparkBlockAndChildren(CBlockIndex *pindex)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/** Remove parked status from a block. */
	void UnparkBlock(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	/**
	* Provides an interface for creating and interacting with one or two
	* chainstates: an IBD chainstate generated by downloading blocks, and
	* an optional snapshot chainstate loaded from a UTXO snapshot. Managed
	* chainstates can be maintained at different heights simultaneously.
	*
	* This class provides abstractions that allow the retrieval of the current
	* most-work chainstate ("Active") as well as chainstates which may be in
	* background use to validate UTXO snapshots.
	*
	* Definitions:
	*
	* IBD chainstate: a chainstate whose current state has been "fully"
	* validated by the initial block download process.
	*
	* Snapshot chainstate: a chainstate populated by loading in an
	* assumeutxo UTXO snapshot.
	*
	* Active chainstate: the chainstate containing the current most-work
	* chain. Consulted by most parts of the system (net_processing,
	* wallet) as a reflection of the current chain and UTXO set.
	* This may either be an IBD chainstate or a snapshot chainstate.
	*
	* Background IBD chainstate: an IBD chainstate for which the
	* IBD process is happening in the background while use of the
	* active (snapshot) chainstate allows the rest of the system to function.
	*
	* Validated chainstate: the most-work chainstate which has been validated
	* locally via initial block download. This will be the snapshot chainstate
	* if a snapshot was loaded and all blocks up to the snapshot starting point
	* have been downloaded and validated (via background validation), otherwise
	* it will be the IBD chainstate.
	*/
	class ChainstateManager {
	private:
	//! The chainstate used under normal operation (i.e. "regular" IBD) or, if
	//! a snapshot is in use, for background validation.
	//!
	//! Its contents (including on-disk data) will be deleted upon shutdown
	//! after background validation of the snapshot has completed. We do not
	//! free the chainstate contents immediately after it finishes validation
	//! to cautiously avoid a case where some other part of the system is still
	//! using this pointer (e.g. net_processing).
	//!
	//! Once this pointer is set to a corresponding chainstate, it will not
	//! be reset until init.cpp:Shutdown(). This means it is safe to acquire
	//! the contents of this pointer with ::cs_main held, release the lock,
	//! and then use the reference without concern of it being deconstructed.
	//!
	//! This is especially important when, e.g., calling ActivateBestChain()
	//! on all chainstates because we are not able to hold ::cs_main going into
	//! that call.
	std::unique_ptr<CChainState> m_ibd_chainstate;

	//! A chainstate initialized on the basis of a UTXO snapshot. If this is
	//! non-null, it is always our active chainstate.
	//!
	//! Once this pointer is set to a corresponding chainstate, it will not
	//! be reset until init.cpp:Shutdown(). This means it is safe to acquire
	//! the contents of this pointer with ::cs_main held, release the lock,
	//! and then use the reference without concern of it being deconstructed.
	//!
	//! This is especially important when, e.g., calling ActivateBestChain()
	//! on all chainstates because we are not able to hold ::cs_main going into
	//! that call.
	std::unique_ptr<CChainState> m_snapshot_chainstate;

	//! Points to either the ibd or snapshot chainstate; indicates our
	//! most-work chain.
	//!
	//! Once this pointer is set to a corresponding chainstate, it will not
	//! be reset until init.cpp:Shutdown(). This means it is safe to acquire
	//! the contents of this pointer with ::cs_main held, release the lock,
	//! and then use the reference without concern of it being deconstructed.
	//!
	//! This is especially important when, e.g., calling ActivateBestChain()
	//! on all chainstates because we are not able to hold ::cs_main going into
	//! that call.
	CChainState *m_active_chainstate{nullptr};

	//! If true, the assumed-valid chainstate has been fully validated
	//! by the background validation chainstate.
	bool m_snapshot_validated{false};

	// For access to m_active_chainstate.
	friend CChainState &ChainstateActive();
	friend CChain &ChainActive();

	public:
	//! A single BlockManager instance is shared across each constructed
	//! chainstate to avoid duplicating block metadata.
	BlockManager m_blockman GUARDED_BY(::cs_main);

	//! Instantiate a new chainstate and assign it based upon whether it is
	//! from a snapshot.
	//!
	//! @param[in] snapshot_blockhash If given, signify that this chainstate
	//! is based on a snapshot.
	CChainState &
	InitializeChainstate(const BlockHash &snapshot_blockhash = BlockHash())
	EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	//! Get all chainstates currently being used.
	std::vector<CChainState *> GetAll();

	//! The most-work chain.
	CChain &ActiveChain() const;
	int ActiveHeight() const { return ActiveChain().Height(); }
	CBlockIndex *ActiveTip() const { return ActiveChain().Tip(); }

	BlockMap &BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
	return m_blockman.m_block_index;
	}

	bool IsSnapshotActive() const;

	std::optional<BlockHash> SnapshotBlockhash() const;

	//! Is there a snapshot in use and has it been fully validated?
	bool IsSnapshotValidated() const { return m_snapshot_validated; }

	//! @returns true if this chainstate is being used to validate an active
	//! snapshot in the background.
	bool IsBackgroundIBD(CChainState *chainstate) const;

	//! Return the most-work chainstate that has been fully validated.
	//!
	//! During background validation of a snapshot, this is the IBD chain. After
	//! background validation has completed, this is the snapshot chain.
	CChainState &ValidatedChainstate() const;

	CChain &ValidatedChain() const { return ValidatedChainstate().m_chain; }
	CBlockIndex *ValidatedTip() const { return ValidatedChain().Tip(); }

	//! Unload block index and chain data before shutdown.
	void Unload() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	//! Clear (deconstruct) chainstate data.
	void Reset();
	};

	extern ChainstateManager g_chainman GUARDED_BY(::cs_main);

	/** @returns the most-work valid chainstate. */
	CChainState &ChainstateActive();

	/** @returns the most-work chain. */
	CChain &ChainActive();

	/** @returns the global block index map. */
	BlockMap &BlockIndex();

	/**
	* Global variable that points to the active block tree (protected by cs_main)
	*/
	extern std::unique_ptr<CBlockTreeDB> pblocktree;

	/**
	* Return the spend height, which is one more than the inputs.GetBestBlock().
	* While checking, GetBestBlock() refers to the parent block. (protected by
	* cs_main)
	* This is also true for mempool checks.
	*/
	int GetSpendHeight(const CCoinsViewCache &inputs);

	/**
	* Determine what nVersion a new block should use.
	*/
	int32_t ComputeBlockVersion(const CBlockIndex *pindexPrev,
	const Consensus::Params &params);

	/** Get block file info entry for one block file */
	CBlockFileInfo *GetBlockFileInfo(size_t n);

	/** Dump the mempool to disk. */
	bool DumpMempool(const CTxMemPool &pool);

	/** Load the mempool from disk. */
	bool LoadMempool(const Config &config, CTxMemPool &pool);

	//! Check whether the block associated with this index entry is pruned or not.
	bool IsBlockPruned(const CBlockIndex *pblockindex);

	#endif // BITCOIN_VALIDATION_H

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 21:28 (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5865960
Default Alt Text: (190 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions