No OneTemporary
Actions

Size

238 KB

Subscribers

None

View Options

	diff --git a/src/index/base.cpp b/src/index/base.cpp
	index 08a3656e6..aae693e5a 100644
	--- a/src/index/base.cpp
	+++ b/src/index/base.cpp
	@@ -1,440 +1,463 @@
	// Copyright (c) 2017-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.

	#include <chain.h>
	#include <chainparams.h>
	#include <common/args.h>
	#include <config.h>
	#include <index/base.h>
	#include <interfaces/chain.h>
	#include <logging.h>
	#include <node/blockstorage.h>
	#include <node/context.h>
	#include <node/database_args.h>
	#include <node/ui_interface.h>
	#include <shutdown.h>
	#include <tinyformat.h>
	#include <util/thread.h>
	#include <util/translation.h>
	#include <validation.h> // For Chainstate
	#include <warnings.h>

	#include <functional>
	#include <string>
	#include <utility>

	+using node::g_indexes_ready_to_sync;
	+
	constexpr uint8_t DB_BEST_BLOCK{'B'};

	constexpr int64_t SYNC_LOG_INTERVAL = 30; // secon
	constexpr int64_t SYNC_LOCATOR_WRITE_INTERVAL = 30; // seconds

	template <typename... Args>
	static void FatalError(const char *fmt, const Args &...args) {
	std::string strMessage = tfm::format(fmt, args...);
	SetMiscWarning(Untranslated(strMessage));
	LogPrintf("*** %s\n", strMessage);
	AbortError(_("A fatal internal error occurred, see debug.log for details"));
	StartShutdown();
	}

	BaseIndex::DB::DB(const fs::path &path, size_t n_cache_size, bool f_memory,
	bool f_wipe, bool f_obfuscate)
	: CDBWrapper{DBParams{.path = path,
	.cache_bytes = n_cache_size,
	.memory_only = f_memory,
	.wipe_data = f_wipe,
	.obfuscate = f_obfuscate,
	.options = [] {
	DBOptions options;
	node::ReadDatabaseArgs(gArgs, options);
	return options;
	}()}} {}

	bool BaseIndex::DB::ReadBestBlock(CBlockLocator &locator) const {
	bool success = Read(DB_BEST_BLOCK, locator);
	if (!success) {
	locator.SetNull();
	}
	return success;
	}

	void BaseIndex::DB::WriteBestBlock(CDBBatch &batch,
	const CBlockLocator &locator) {
	batch.Write(DB_BEST_BLOCK, locator);
	}

	BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name)
	: m_chain{std::move(chain)}, m_name{std::move(name)} {}

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

	bool BaseIndex::Init() {
	CBlockLocator locator;
	if (!GetDB().ReadBestBlock(locator)) {
	locator.SetNull();
	}

	LOCK(cs_main);
	CChain &active_chain = m_chainstate->m_chain;
	if (locator.IsNull()) {
	SetBestBlockIndex(nullptr);
	} else {
	- SetBestBlockIndex(m_chainstate->FindForkInGlobalIndex(locator));
	+ // Setting the best block to the locator's top block. If it is not part
	+ // of the best chain, we will rewind to the fork point during index sync
	+ const CBlockIndex *locator_index{
	+ m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.at(0))};
	+ if (!locator_index) {
	+ return InitError(
	+ strprintf(Untranslated("%s: best block of the index not found. "
	+ "Please rebuild the index."),
	+ GetName()));
	+ }
	+ SetBestBlockIndex(locator_index);
	}

	// Note: this will latch to true immediately if the user starts up with an
	// empty datadir and an index enabled. If this is the case, indexation will
	// happen solely via `BlockConnected` signals until, possibly, the next
	// restart.
	m_synced = m_best_block_index.load() == active_chain.Tip();
	- if (!m_synced) {
	+
	+ // Skip pruning check if indexes are not ready to sync (because
	+ // reindex-chainstate has wiped the chain).
	+ if (!m_synced && g_indexes_ready_to_sync) {
	bool prune_violation = false;
	if (!m_best_block_index) {
	// index is not built yet
	// make sure we have all block data back to the genesis
	prune_violation =
	m_chainstate->m_blockman.GetFirstStoredBlock(
	*active_chain.Tip()) != active_chain.Genesis();
	}
	// in case the index has a best block set and is not fully synced
	// check if we have the required blocks to continue building the index
	else {
	const CBlockIndex *block_to_test = m_best_block_index.load();
	if (!active_chain.Contains(block_to_test)) {
	// if the bestblock is not part of the mainchain, find the fork
	// and make sure we have all data down to the fork
	block_to_test = active_chain.FindFork(block_to_test);
	}
	const CBlockIndex *block = active_chain.Tip();
	prune_violation = true;
	// check backwards from the tip if we have all block data until we
	// reach the indexes bestblock
	while (block_to_test && block && block->nStatus.hasData()) {
	if (block_to_test == block) {
	prune_violation = false;
	break;
	}
	// block->pprev must exist at this point, since block_to_test is
	// part of the chain and thus must be encountered when going
	// backwards from the tip
	assert(block->pprev);
	block = block->pprev;
	}
	}
	if (prune_violation) {
	return InitError(strprintf(
	Untranslated("%s best block of the index goes beyond pruned "
	"data. Please disable the index or reindex (which "
	"will download the whole blockchain again)"),
	GetName()));
	}
	}
	return true;
	}

	static const CBlockIndex NextSyncBlock(const CBlockIndex pindex_prev,
	CChain &chain)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	AssertLockHeld(cs_main);

	if (!pindex_prev) {
	return chain.Genesis();
	}

	const CBlockIndex *pindex = chain.Next(pindex_prev);
	if (pindex) {
	return pindex;
	}

	return chain.Next(chain.FindFork(pindex_prev));
	}

	void BaseIndex::ThreadSync() {
	+ // Wait for a possible reindex-chainstate to finish until continuing
	+ // with the index sync
	+ while (!g_indexes_ready_to_sync) {
	+ if (!m_interrupt.sleep_for(std::chrono::milliseconds(500))) {
	+ return;
	+ }
	+ }
	+
	const CBlockIndex *pindex = m_best_block_index.load();
	if (!m_synced) {
	int64_t last_log_time = 0;
	int64_t last_locator_write_time = 0;
	while (true) {
	if (m_interrupt) {
	SetBestBlockIndex(pindex);
	// No need to handle errors in Commit. If it fails, the error
	// will be already be logged. The best way to recover is to
	// continue, as index cannot be corrupted by a missed commit to
	// disk for an advanced index state.
	Commit();
	return;
	}

	{
	LOCK(cs_main);
	const CBlockIndex *pindex_next =
	NextSyncBlock(pindex, m_chainstate->m_chain);
	if (!pindex_next) {
	SetBestBlockIndex(pindex);
	m_synced = true;
	// No need to handle errors in Commit. See rationale above.
	Commit();
	break;
	}
	if (pindex_next->pprev != pindex &&
	!Rewind(pindex, pindex_next->pprev)) {
	FatalError(
	"%s: Failed to rewind index %s to a previous chain tip",
	__func__, GetName());
	return;
	}
	pindex = pindex_next;
	}

	CBlock block;
	if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *pindex)) {
	FatalError("%s: Failed to read block %s from disk", __func__,
	pindex->GetBlockHash().ToString());
	return;
	}
	if (!WriteBlock(block, pindex)) {
	FatalError("%s: Failed to write block %s to index database",
	__func__, pindex->GetBlockHash().ToString());
	return;
	}

	int64_t current_time = GetTime();
	if (last_log_time + SYNC_LOG_INTERVAL < current_time) {
	LogPrintf("Syncing %s with block chain from height %d\n",
	GetName(), pindex->nHeight);
	last_log_time = current_time;
	}

	if (last_locator_write_time + SYNC_LOCATOR_WRITE_INTERVAL <
	current_time) {
	SetBestBlockIndex(pindex->pprev);
	last_locator_write_time = current_time;
	// No need to handle errors in Commit. See rationale above.
	Commit();
	}
	}
	}

	if (pindex) {
	LogPrintf("%s is enabled at height %d\n", GetName(), pindex->nHeight);
	} else {
	LogPrintf("%s is enabled\n", GetName());
	}
	}

	bool BaseIndex::Commit() {
	CDBBatch batch(GetDB());
	if (!CommitInternal(batch) \|\| !GetDB().WriteBatch(batch)) {
	return error("%s: Failed to commit latest %s state", __func__,
	GetName());
	}
	return true;
	}

	bool BaseIndex::CommitInternal(CDBBatch &batch) {
	LOCK(cs_main);
	// Don't commit anything if we haven't indexed any block yet
	// (this could happen if init is interrupted).
	if (m_best_block_index == nullptr) {
	return false;
	}
	GetDB().WriteBestBlock(batch, GetLocator(m_best_block_index));
	return true;
	}

	bool BaseIndex::Rewind(const CBlockIndex *current_tip,
	const CBlockIndex *new_tip) {
	assert(current_tip == m_best_block_index);
	assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);

	// In the case of a reorg, ensure persisted block locator is not stale.
	// Pruning has a minimum of 288 blocks-to-keep and getting the index
	// out of sync may be possible but a users fault.
	// In case we reorg beyond the pruned depth, ReadBlockFromDisk would
	// throw and lead to a graceful shutdown
	SetBestBlockIndex(new_tip);
	if (!Commit()) {
	// If commit fails, revert the best block index to avoid corruption.
	SetBestBlockIndex(current_tip);
	return false;
	}

	return true;
	}

	void BaseIndex::BlockConnected(const std::shared_ptr<const CBlock> &block,
	const CBlockIndex *pindex) {
	if (!m_synced) {
	return;
	}

	const CBlockIndex *best_block_index = m_best_block_index.load();
	if (!best_block_index) {
	if (pindex->nHeight != 0) {
	FatalError("%s: First block connected is not the genesis block "
	"(height=%d)",
	__func__, pindex->nHeight);
	return;
	}
	} else {
	// Ensure block connects to an ancestor of the current best block. This
	// should be the case most of the time, but may not be immediately after
	// the the sync thread catches up and sets m_synced. Consider the case
	// where there is a reorg and the blocks on the stale branch are in the
	// ValidationInterface queue backlog even after the sync thread has
	// caught up to the new chain tip. In this unlikely event, log a warning
	// and let the queue clear.
	if (best_block_index->GetAncestor(pindex->nHeight - 1) !=
	pindex->pprev) {
	LogPrintf("%s: WARNING: Block %s does not connect to an ancestor "
	"of known best chain (tip=%s); not updating index\n",
	__func__, pindex->GetBlockHash().ToString(),
	best_block_index->GetBlockHash().ToString());
	return;
	}
	if (best_block_index != pindex->pprev &&
	!Rewind(best_block_index, pindex->pprev)) {
	FatalError("%s: Failed to rewind index %s to a previous chain tip",
	__func__, GetName());
	return;
	}
	}

	if (WriteBlock(*block, pindex)) {
	// Setting the best block index is intentionally the last step of this
	// function, so BlockUntilSyncedToCurrentChain callers waiting for the
	// best block index to be updated can rely on the block being fully
	// processed, and the index object being safe to delete.
	SetBestBlockIndex(pindex);
	} else {
	FatalError("%s: Failed to write block %s to index", __func__,
	pindex->GetBlockHash().ToString());
	return;
	}
	}

	void BaseIndex::ChainStateFlushed(const CBlockLocator &locator) {
	if (!m_synced) {
	return;
	}

	const BlockHash &locator_tip_hash = locator.vHave.front();
	const CBlockIndex *locator_tip_index;
	{
	LOCK(cs_main);
	locator_tip_index =
	m_chainstate->m_blockman.LookupBlockIndex(locator_tip_hash);
	}

	if (!locator_tip_index) {
	FatalError("%s: First block (hash=%s) in locator was not found",
	__func__, locator_tip_hash.ToString());
	return;
	}

	// This checks that ChainStateFlushed callbacks are received after
	// BlockConnected. The check may fail immediately after the the sync thread
	// catches up and sets m_synced. Consider the case where there is a reorg
	// and the blocks on the stale branch are in the ValidationInterface queue
	// backlog even after the sync thread has caught up to the new chain tip. In
	// this unlikely event, log a warning and let the queue clear.
	const CBlockIndex *best_block_index = m_best_block_index.load();
	if (best_block_index->GetAncestor(locator_tip_index->nHeight) !=
	locator_tip_index) {
	LogPrintf("%s: WARNING: Locator contains block (hash=%s) not on known "
	"best chain (tip=%s); not writing index locator\n",
	__func__, locator_tip_hash.ToString(),
	best_block_index->GetBlockHash().ToString());
	return;
	}

	// No need to handle errors in Commit. If it fails, the error will be
	// already be logged. The best way to recover is to continue, as index
	// cannot be corrupted by a missed commit to disk for an advanced index
	// state.
	Commit();
	}

	bool BaseIndex::BlockUntilSyncedToCurrentChain() const {
	AssertLockNotHeld(cs_main);

	if (!m_synced) {
	return false;
	}

	{
	// Skip the queue-draining stuff if we know we're caught up with
	// m_chain.Tip().
	LOCK(cs_main);
	const CBlockIndex *chain_tip = m_chainstate->m_chain.Tip();
	const CBlockIndex *best_block_index = m_best_block_index.load();
	if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
	return true;
	}
	}

	LogPrintf("%s: %s is catching up on block notifications\n", __func__,
	GetName());
	SyncWithValidationInterfaceQueue();
	return true;
	}

	void BaseIndex::Interrupt() {
	m_interrupt();
	}

	bool BaseIndex::Start() {
	// m_chainstate member gives indexing code access to node internals. It is
	// removed in a followup
	m_chainstate = &m_chain->context()->chainman->ActiveChainstate();
	// Need to register this ValidationInterface before running Init(), so that
	// callbacks are not missed if Init sets m_synced to true.
	RegisterValidationInterface(this);
	if (!Init()) {
	return false;
	}

	m_thread_sync =
	std::thread(&util::TraceThread, GetName(), [this] { ThreadSync(); });
	return true;
	}

	void BaseIndex::Stop() {
	UnregisterValidationInterface(this);

	if (m_thread_sync.joinable()) {
	m_thread_sync.join();
	}
	}

	IndexSummary BaseIndex::GetSummary() const {
	IndexSummary summary{};
	summary.name = GetName();
	summary.synced = m_synced;
	summary.best_block_height =
	m_best_block_index ? m_best_block_index.load()->nHeight : 0;
	return summary;
	}

	void BaseIndex::SetBestBlockIndex(const CBlockIndex *block) {
	assert(!m_chainstate->m_blockman.IsPruneMode() \|\| AllowPrune());

	if (AllowPrune() && block) {
	node::PruneLockInfo prune_lock;
	prune_lock.height_first = block->nHeight;
	WITH_LOCK(::cs_main, m_chainstate->m_blockman.UpdatePruneLock(
	GetName(), prune_lock));
	}

	// Intentionally set m_best_block_index as the last step in this function,
	// after updating prune locks above, and after making any other references
	// to *this, so the BlockUntilSyncedToCurrentChain function (which checks
	// m_best_block_index as an optimization) can be used to wait for the last
	// BlockConnected notification and safely assume that prune locks are
	// updated and that the index object is safe to delete.
	m_best_block_index = block;
	}
	diff --git a/src/init.cpp b/src/init.cpp
	index eb85ff13c..9427841f1 100644
	--- a/src/init.cpp
	+++ b/src/init.cpp
	@@ -1,3025 +1,3033 @@
	// 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 <kernel/mempool_persist.h>
	#include <kernel/validation_cache_sizes.h>

	#include <addrman.h>
	#include <avalanche/avalanche.h>
	#include <avalanche/processor.h>
	#include <avalanche/proof.h> // For AVALANCHE_LEGACY_PROOF_DEFAULT
	#include <avalanche/validation.h>
	#include <avalanche/voterecord.h> // For AVALANCHE_VOTE_STALE_*
	#include <banman.h>
	#include <blockfilter.h>
	#include <chain.h>
	#include <chainparams.h>
	#include <common/args.h>
	#include <compat/sanity.h>
	#include <config.h>
	#include <consensus/amount.h>
	#include <currencyunit.h>
	#include <flatfile.h>
	#include <hash.h>
	#include <httprpc.h>
	#include <httpserver.h>
	#include <index/blockfilterindex.h>
	#include <index/coinstatsindex.h>
	#include <index/txindex.h>
	#include <init/common.h>
	#include <interfaces/chain.h>
	#include <interfaces/node.h>
	#include <mapport.h>
	#include <mempool_args.h>
	#include <net.h>
	#include <net_permissions.h>
	#include <net_processing.h>
	#include <netbase.h>
	#include <node/blockmanager_args.h>
	#include <node/blockstorage.h>
	#include <node/caches.h>
	#include <node/chainstate.h>
	#include <node/chainstatemanager_args.h>
	#include <node/context.h>
	#include <node/kernel_notifications.h>
	#include <node/mempool_persist_args.h>
	#include <node/miner.h>
	#include <node/peerman_args.h>
	#include <node/ui_interface.h>
	#include <node/validation_cache_args.h>
	#include <policy/block/rtt.h>
	#include <policy/policy.h>
	#include <policy/settings.h>
	#include <rpc/blockchain.h>
	#include <rpc/register.h>
	#include <rpc/server.h>
	#include <rpc/util.h>
	#include <scheduler.h>
	#include <script/scriptcache.h>
	#include <script/sigcache.h>
	#include <script/standard.h>
	#include <shutdown.h>
	#include <sync.h>
	#include <timedata.h>
	#include <torcontrol.h>
	#include <txdb.h>
	#include <txmempool.h>
	#include <util/asmap.h>
	#include <util/check.h>
	#include <util/fs.h>
	#include <util/fs_helpers.h>
	#include <util/moneystr.h>
	#include <util/string.h>
	#include <util/syserror.h>
	#include <util/thread.h>
	#include <util/threadnames.h>
	#include <util/translation.h>
	#include <validation.h>
	#include <validationinterface.h>
	#include <walletinitinterface.h>

	#include <boost/signals2/signal.hpp>

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

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

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

	using kernel::DEFAULT_STOPAFTERBLOCKIMPORT;
	using kernel::DumpMempool;
	using kernel::ValidationCacheSizes;

	using node::ApplyArgsManOptions;
	using node::BlockManager;
	using node::CacheSizes;
	using node::CalculateCacheSizes;
	using node::DEFAULT_PERSIST_MEMPOOL;
	using node::fReindex;
	+using node::g_indexes_ready_to_sync;
	using node::KernelNotifications;
	using node::LoadChainstate;
	using node::MempoolPath;
	using node::NodeContext;
	using node::ShouldPersistMempool;
	using node::ThreadImport;
	using node::VerifyLoadedChainstate;

	static const bool DEFAULT_PROXYRANDOMIZE = true;
	static const bool DEFAULT_REST_ENABLE = false;
	static constexpr bool DEFAULT_CHRONIK = 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";

	static const std::string HEADERS_TIME_FILE_NAME{"headerstime.dat"};

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

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

	[[nodiscard]] static bool CreatePidFile(const ArgsManager &args) {
	std::ofstream file{GetPidFile(args)};
	if (file) {
	#ifdef WIN32
	tfm::format(file, "%d\n", GetCurrentProcessId());
	#else
	tfm::format(file, "%d\n", getpid());
	#endif
	return true;
	} else {
	return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
	fs::PathToString(GetPidFile(args)),
	SysErrorString(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.
	//

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

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

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

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

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

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

	StopTorControl();

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

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

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

	if (node.mempool && node.mempool->GetLoadTried() &&
	ShouldPersistMempool(*node.args)) {
	DumpMempool(node.mempool, MempoolPath(node.args));
	}

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

	#if ENABLE_CHRONIK
	if (node.args->GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
	chronik::Stop();
	}
	#endif

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

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

	if (node.chainman) {
	LOCK(cs_main);
	for (Chainstate *chainstate : node.chainman->GetAll()) {
	if (chainstate->CanFlushToDisk()) {
	chainstate->ForceFlushStateToDisk();
	chainstate->ResetCoinsViews();
	}
	}

	node.chainman->DumpRecentHeadersTime(node.chainman->m_options.datadir /
	HEADERS_TIME_FILE_NAME);
	}
	for (const auto &client : node.chain_clients) {
	client->stop();
	}

	#if ENABLE_ZMQ
	if (g_zmq_notification_interface) {
	UnregisterValidationInterface(g_zmq_notification_interface.get());
	g_zmq_notification_interface.reset();
	}
	#endif

	node.chain_clients.clear();
	UnregisterAllValidationInterfaces();
	GetMainSignals().UnregisterBackgroundSignalScheduler();
	init::UnsetGlobals();
	node.mempool.reset();
	node.chainman.reset();
	node.scheduler.reset();

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

	LogPrintf("%s: done\n", __func__);
	}

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

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

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

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

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

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

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

	init::AddLoggingArgs(argsman);

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

	// Hidden Options
	std::vector<std::string> hidden_args = {
	"-dbcrashratio",
	"-forcecompactdb",
	"-maxaddrtosend",
	"-parkdeepreorg",
	"-automaticunparking",
	"-replayprotectionactivationtime",
	"-enableminerfund",
	"-chronikallowpause",
	"-chronikcors",
	// GUI args. These will be overwritten by SetupUIArgs for the GUI
	"-allowselfsignedrootcertificates",
	"-choosedatadir",
	"-lang=<lang>",
	"-min",
	"-resetguisettings",
	"-rootcertificates=<file>",
	"-splash",
	"-uiplatform",
	// TODO remove after the May. 2025 upgrade
	"-schumpeteractivationtime",
	};

	// Set all of the args and their help
	// When adding new options to the categories, please keep and ensure
	// alphabetical ordering. Do not translate _(...) -help-debug options, Many
	// technical terms, and only a very small audience, so is unnecessary stress
	// to translators.
	argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
	OptionsCategory::OPTIONS);
	#if defined(HAVE_SYSTEM)
	argsman.AddArg(
	"-alertnotify=<cmd>",
	"Execute command when a relevant alert is received or we see "
	"a really long fork (%s in cmd is replaced by message)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	argsman.AddArg(
	"-assumevalid=<hex>",
	strprintf(
	"If this block is in the chain assume that it and its ancestors "
	"are valid and potentially skip their script verification (0 to "
	"verify all, default: %s, testnet: %s)",
	defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
	testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-blocksdir=<dir>",
	"Specify directory to hold blocks subdirectory for *.dat "
	"files (default: <datadir>)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-fastprune",
	"Use smaller block files and lower minimum prune height for "
	"testing purposes",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	#if defined(HAVE_SYSTEM)
	argsman.AddArg("-blocknotify=<cmd>",
	"Execute command when the best block changes (%s in cmd is "
	"replaced by block hash)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	argsman.AddArg("-blockreconstructionextratxn=<n>",
	strprintf("Extra transactions to keep in memory for compact "
	"block reconstructions (default: %u)",
	DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-blocksonly",
	strprintf("Whether to reject transactions from network peers. "
	"Disables automatic broadcast and rebroadcast of "
	"transactions, unless the source peer has the "
	"'forcerelay' permission. RPC transactions are"
	" not affected. (default: %u)",
	DEFAULT_BLOCKSONLY),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-coinstatsindex",
	strprintf("Maintain coinstats index used by the "
	"gettxoutsetinfo RPC (default: %u)",
	DEFAULT_COINSTATSINDEX),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-conf=<file>",
	strprintf("Specify path to read-only configuration file. Relative "
	"paths will be prefixed by datadir location. (default: %s)",
	BITCOIN_CONF_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-datadir=<dir>", "Specify data directory",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-dbbatchsize",
	strprintf("Maximum database write batch size in bytes (default: %u)",
	DEFAULT_DB_BATCH_SIZE),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-dbcache=<n>",
	strprintf("Set database cache size in MiB (%d to %d, default: %d)",
	MIN_DB_CACHE_MB, MAX_DB_CACHE_MB, DEFAULT_DB_CACHE_MB),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-includeconf=<file>",
	"Specify additional configuration file, relative to the -datadir path "
	"(only useable from configuration file, not command line)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-loadblock=<file>",
	"Imports blocks from external file on startup",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-maxmempool=<n>",
	strprintf("Keep the transaction memory pool below <n> "
	"megabytes (default: %u)",
	DEFAULT_MAX_MEMPOOL_SIZE_MB),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-maxorphantx=<n>",
	strprintf("Keep at most <n> unconnectable transactions in "
	"memory (default: %u)",
	DEFAULT_MAX_ORPHAN_TRANSACTIONS),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-mempoolexpiry=<n>",
	strprintf("Do not keep transactions in the mempool longer "
	"than <n> hours (default: %u)",
	DEFAULT_MEMPOOL_EXPIRY_HOURS),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-minimumchainwork=<hex>",
	strprintf(
	"Minimum work assumed to exist on a valid chain in hex "
	"(default: %s, testnet: %s)",
	defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
	testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-par=<n>",
	strprintf("Set the number of script verification threads (%u to %d, 0 "
	"= auto, <0 = leave that many cores free, default: %d)",
	-GetNumCores(), MAX_SCRIPTCHECK_THREADS,
	DEFAULT_SCRIPTCHECK_THREADS),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg("-persistmempool",
	strprintf("Whether to save the mempool on shutdown and load "
	"on restart (default: %u)",
	DEFAULT_PERSIST_MEMPOOL),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-persistrecentheaderstime",
	strprintf(
	"Whether the node stores the recent headers reception time to a "
	"file and load it upon startup. This is intended for mining nodes "
	"to overestimate the real time target upon restart (default: %u)",
	DEFAULT_STORE_RECENT_HEADERS_TIME),
	ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-pid=<file>",
	strprintf("Specify pid file. Relative paths will be prefixed "
	"by a net-specific datadir location. (default: %s)",
	BITCOIN_PID_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-prune=<n>",
	strprintf("Reduce storage requirements by enabling pruning (deleting) "
	"of old blocks. This allows the pruneblockchain RPC to be "
	"called to delete specific blocks and enables automatic "
	"pruning of old blocks if a target size in MiB is provided. "
	"This mode is incompatible with -txindex and -rescan. "
	"Warning: Reverting this setting requires re-downloading the "
	"entire blockchain. (default: 0 = disable pruning blocks, "
	"1 = allow manual pruning via RPC, >=%u = automatically "
	"prune block files to stay under the specified target size "
	"in MiB)",
	MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-reindex-chainstate",
	"Rebuild chain state from the currently indexed blocks. When "
	"in pruning mode or if blocks on disk might be corrupted, use "
	"full -reindex instead.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-reindex",
	- "Rebuild chain state and block index from the blk*.dat files on disk",
	+ "Rebuild chain state and block index from the blk*.dat files on disk."
	+ " This will also rebuild active optional indexes.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-settings=<file>",
	strprintf(
	"Specify path to dynamic settings data file. Can be disabled with "
	"-nosettings. File is written at runtime and not meant to be "
	"edited by users (use %s instead for custom settings). Relative "
	"paths will be prefixed by datadir location. (default: %s)",
	BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#if HAVE_SYSTEM
	argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#endif
	#ifndef WIN32
	argsman.AddArg(
	"-sysperms",
	"Create new files with system default permissions, instead of umask "
	"077 (only effective with disabled wallet functionality)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#else
	hidden_args.emplace_back("-sysperms");
	#endif
	argsman.AddArg("-txindex",
	strprintf("Maintain a full transaction index, used by the "
	"getrawtransaction rpc call (default: %d)",
	DEFAULT_TXINDEX),
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	#if ENABLE_CHRONIK
	argsman.AddArg(
	"-chronik",
	strprintf("Enable the Chronik indexer, which can be read via a "
	"dedicated HTTP/Protobuf interface (default: %d)",
	DEFAULT_CHRONIK),
	ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
	argsman.AddArg(
	"-chronikbind=<addr>[:port]",
	strprintf(
	"Bind the Chronik indexer to the given address to listen for "
	"HTTP/Protobuf connections to access the index. Unlike the "
	"JSON-RPC, it's ok to have this publicly exposed on the internet. "
	"This option can be specified multiple times (default: %s; default "
	"port: %u, testnet: %u, regtest: %u)",
	Join(chronik::DEFAULT_BINDS, ", "),
	defaultBaseParams->ChronikPort(), testnetBaseParams->ChronikPort(),
	regtestBaseParams->ChronikPort()),
	ArgsManager::ALLOW_STRING \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::CHRONIK);
	argsman.AddArg("-chroniktokenindex",
	"Enable token indexing in Chronik (default: 1)",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
	argsman.AddArg("-chroniklokadidindex",
	"Enable LOKAD ID indexing in Chronik (default: 1)",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
	argsman.AddArg("-chronikreindex",
	"Reindex the Chronik indexer from genesis, but leave the "
	"other indexes untouched",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
	argsman.AddArg(
	"-chroniktxnumcachebuckets",
	strprintf(
	"Tuning param of the TxNumCache, specifies how many buckets "
	"to use on the belt. Caution against setting this too high, "
	"it may slow down indexing. Set to 0 to disable. (default: %d)",
	chronik::DEFAULT_TX_NUM_CACHE_BUCKETS),
	ArgsManager::ALLOW_INT, OptionsCategory::CHRONIK);
	argsman.AddArg(
	"-chroniktxnumcachebucketsize",
	strprintf(
	"Tuning param of the TxNumCache, specifies the size of each bucket "
	"on the belt. Unlike the number of buckets, this may be increased "
	"without much danger of slowing the indexer down. The total cache "
	"size will be `num_buckets * bucket_size * 40B`, so by default the "
	"cache will require %dkB of memory. (default: %d)",
	chronik::DEFAULT_TX_NUM_CACHE_BUCKETS *
	chronik::DEFAULT_TX_NUM_CACHE_BUCKET_SIZE * 40 / 1000,
	chronik::DEFAULT_TX_NUM_CACHE_BUCKET_SIZE),
	ArgsManager::ALLOW_INT, OptionsCategory::CHRONIK);
	argsman.AddArg("-chronikperfstats",
	"Output some performance statistics (e.g. num cache hits, "
	"seconds spent) into a <datadir>/perf folder. (default: 0)",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
	argsman.AddArg(
	"-chronikscripthashindex",
	"Enable the scripthash index for the Chronik indexer (default: 0) ",
	ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
	argsman.AddArg(
	"-chronikelectrumbind=<addr>[:port][:t\|s]",
	strprintf(
	"Bind the Chronik Electrum interface to the given "
	"address:port:protocol. If not set, the Electrum interface will "
	"not start. This option can be specified multiple times. The "
	"protocol is selected by a single letter, where 't' means TCP and "
	"'s' means TLS. If TLS is selected, the certificate chain and "
	"private key must both be passed (see -chronikelectrumcert and "
	"-chronikelectrumprivkey (default: disabled; default port: %u, "
	"testnet: %u, regtest: %u; default protocol: TCP)",
	defaultBaseParams->ChronikElectrumPort(),
	testnetBaseParams->ChronikElectrumPort(),
	regtestBaseParams->ChronikElectrumPort()),
	ArgsManager::ALLOW_STRING \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::HIDDEN);
	argsman.AddArg(
	"-chronikelectrumcert",
	"Path to the certificate file to be used by the Chronik Electrum "
	"server when the TLS protocol is selected. The file should contain "
	"the whole certificate chain (typically a .pem file). If used the "
	"-chronikelectrumprivkey must be set as well.",
	ArgsManager::ALLOW_STRING \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::HIDDEN);
	argsman.AddArg(
	"-chronikelectrumprivkey",
	"Path to the private key file to be used by the Chronik Electrum "
	"server when the TLS protocol is selected. If used the "
	"-chronikelectrumcert must be set as well.",
	ArgsManager::ALLOW_STRING \| ArgsManager::NETWORK_ONLY,
	OptionsCategory::HIDDEN);
	argsman.AddArg(
	"-chronikelectrummaxhistory",
	strprintf("Largest tx history we are willing to serve. (default: %u)",
	chronik::DEFAULT_ELECTRUM_MAX_HISTORY),
	ArgsManager::ALLOW_INT, OptionsCategory::HIDDEN);
	argsman.AddArg(
	"-chronikelectrumdonationaddress",
	strprintf(
	"The server donation address. No checks are done on the server "
	"side to ensure this is a valid eCash address, it is just relayed "
	"to clients verbatim as a text string (%u characters maximum).",
	chronik::MAX_LENGTH_DONATION_ADDRESS),
	ArgsManager::ALLOW_STRING, OptionsCategory::HIDDEN);
	#endif
	argsman.AddArg(
	"-blockfilterindex=<type>",
	strprintf("Maintain an index of compact filters by block "
	"(default: %s, values: %s).",
	DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
	" If <type> is not supplied or if <type> = 1, indexes for "
	"all known types are enabled.",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
	argsman.AddArg(
	"-usecashaddr",
	"Use Cash Address for destination encoding instead of base58 "
	"(activate by default on Jan, 14)",
	ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

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

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

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

	g_wallet_init_interface.AddWalletOptions(argsman);

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

	argsman.AddArg(
	"-checkblocks=<n>",
	strprintf("How many blocks to check at startup (default: %u, 0 = all)",
	DEFAULT_CHECKBLOCKS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checklevel=<n>",
	strprintf("How thorough the block verification of "
	"-checkblocks is: %s (0-4, default: %u)",
	Join(CHECKLEVEL_DOC, ", "), DEFAULT_CHECKLEVEL),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checkblockindex",
	strprintf("Do a consistency check for the block tree, "
	"chainstate, and other validation data structures "
	"occasionally. (default: %u, regtest: %u)",
	defaultChainParams->DefaultConsistencyChecks(),
	regtestChainParams->DefaultConsistencyChecks()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checkaddrman=<n>",
	strprintf("Run addrman consistency checks every <n> "
	"operations. Use 0 to disable. (default: %u)",
	DEFAULT_ADDRMAN_CONSISTENCY_CHECKS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-checkmempool=<n>",
	strprintf("Run mempool consistency checks every <n> transactions. Use "
	"0 to disable. (default: %u, regtest: %u)",
	defaultChainParams->DefaultConsistencyChecks(),
	regtestChainParams->DefaultConsistencyChecks()),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-checkpoints",
	strprintf("Only accept block chain matching built-in "
	"checkpoints (default: %d)",
	DEFAULT_CHECKPOINTS_ENABLED),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-deprecatedrpc=<method>",
	"Allows deprecated RPC method(s) to be used",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-stopafterblockimport",
	strprintf("Stop running after importing blocks from disk (default: %d)",
	DEFAULT_STOPAFTERBLOCKIMPORT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-stopatheight",
	strprintf("Stop running after reaching the given height in "
	"the main chain (default: %u)",
	DEFAULT_STOPATHEIGHT),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-addrmantest", "Allows to test address relay on localhost",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-capturemessages", "Capture all P2P messages to disk",
	ArgsManager::ALLOW_BOOL \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-mocktime=<n>",
	"Replace actual time with " + UNIX_EPOCH_TIME +
	" (default: 0)",
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-maxsigcachesize=<n>",
	strprintf("Limit size of signature cache to <n> MiB (default: %u)",
	DEFAULT_MAX_SIG_CACHE_BYTES >> 20),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg(
	"-maxscriptcachesize=<n>",
	strprintf("Limit size of script cache to <n> MiB (default: %u)",
	DEFAULT_MAX_SCRIPT_CACHE_BYTES >> 20),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);
	argsman.AddArg("-maxtipage=<n>",
	strprintf("Maximum tip age in seconds to consider node in "
	"initial block download (default: %u)",
	Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::DEBUG_TEST);

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

	SetupChainParamsBaseOptions(argsman);

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

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

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

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

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

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

	#if HAVE_DECL_FORK
	argsman.AddArg("-daemon",
	strprintf("Run in the background as a daemon and accept "
	"commands (default: %d)",
	DEFAULT_DAEMON),
	ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
	argsman.AddArg("-daemonwait",
	strprintf("Wait for initialization to be finished before "
	"exiting. This implies -daemon (default: %d)",
	DEFAULT_DAEMONWAIT),
	ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
	#else
	hidden_args.emplace_back("-daemon");
	hidden_args.emplace_back("-daemonwait");
	#endif

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

	hidden_args.emplace_back("-avalanchepreconsensus");
	hidden_args.emplace_back("-avalanchestakingpreconsensus");

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

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

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

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

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

	StartRPC();
	node.rpc_interruption_point = RpcInterruptionPoint;

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

	StartHTTPServer();
	return true;
	}

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

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

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

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

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

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

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

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

	/**
	* Initialize global loggers.
	*
	* Note that this is called very early in the process lifetime, so you should be
	* careful about what global state you rely on here.
	*/
	void InitLogging(const ArgsManager &args) {
	init::SetLoggingOptions(args);
	init::LogPackageVersion();
	}

	namespace { // Variables internal to initialization process only

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

	} // namespace

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

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

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

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

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

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

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

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

	std::set_new_handler(new_handler_terminate);

	return true;
	}

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

	// also see: InitParameterInteraction()

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

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

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

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

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

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

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

	nLocalServices = ServiceFlags(nLocalServices \| NODE_COMPACT_FILTERS);
	}

	if (args.GetIntArg("-prune", 0)) {
	if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	return InitError(_("Prune mode is incompatible with -txindex."));
	}
	if (args.GetBoolArg("-reindex-chainstate", false)) {
	return InitError(
	_("Prune mode is incompatible with -reindex-chainstate. Use "
	"full -reindex instead."));
	}
	if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
	return InitError(_("Prune mode is incompatible with -chronik."));
	}
	}

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

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

	// -maxavalancheoutbound takes precedence over -maxconnections
	const int maxAvalancheOutbound = args.GetIntArg(
	"-maxavalancheoutbound", DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS);
	const bool fAvalanche =
	args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
	if (fAvalanche && maxAvalancheOutbound > nMaxConnections) {
	nMaxConnections = std::max(maxAvalancheOutbound, nMaxConnections);
	// Indicate the value set by the user
	LogPrintf("Increasing -maxconnections from %d to %d to comply with "
	"-maxavalancheoutbound\n",
	nUserMaxConnections, nMaxConnections);
	}

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

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

	// Step 3: parameter-to-internal-flags
	init::SetLoggingCategories(args);

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

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

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

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

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

	nBytesPerSigCheck =
	args.IsArgSet("-bytespersigcheck")
	? args.GetIntArg("-bytespersigcheck", nBytesPerSigCheck)
	: args.GetIntArg("-bytespersigop", nBytesPerSigCheck);

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

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

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

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

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

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

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

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

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

	// This is a staking node
	if (fAvalanche && args.IsArgSet("-avaproof")) {
	if (!args.GetBoolArg("-listen", true)) {
	return InitError(_("Running a staking node requires accepting "
	"inbound connections. Please enable -listen."));
	}
	if (args.IsArgSet("-proxy")) {
	return InitError(_("Running a staking node behind a proxy is not "
	"supported. Please disable -proxy."));
	}
	if (args.IsArgSet("-i2psam")) {
	return InitError(_("Running a staking node behind I2P is not "
	"supported. Please disable -i2psam."));
	}
	if (args.IsArgSet("-onlynet")) {
	return InitError(
	_("Restricting the outbound network is not supported when "
	"running a staking node. Please disable -onlynet."));
	}
	}

	// Also report errors from parsing before daemonization
	{
	KernelNotifications notifications{};
	ChainstateManager::Options chainman_opts_dummy{
	.config = config,
	.datadir = args.GetDataDirNet(),
	.notifications = notifications,
	};
	if (const auto error{ApplyArgsManOptions(args, chainman_opts_dummy)}) {
	return InitError(*error);
	}
	BlockManager::Options blockman_opts_dummy{
	.chainparams = chainman_opts_dummy.config.GetChainParams(),
	.blocks_dir = args.GetBlocksDirPath(),
	};
	if (const auto error{ApplyArgsManOptions(args, blockman_opts_dummy)}) {
	return InitError(*error);
	}
	}

	return true;
	}

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

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

	init::SetGlobals();

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

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

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

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

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

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

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

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

	ValidationCacheSizes validation_cache_sizes{};
	ApplyArgsManOptions(args, validation_cache_sizes);

	if (!InitSignatureCache(validation_cache_sizes.signature_cache_bytes)) {
	return InitError(strprintf(
	_("Unable to allocate memory for -maxsigcachesize: '%s' MiB"),
	args.GetIntArg("-maxsigcachesize",
	DEFAULT_MAX_SIG_CACHE_BYTES >> 20)));
	}
	if (!InitScriptExecutionCache(
	validation_cache_sizes.script_execution_cache_bytes)) {
	return InitError(strprintf(
	_("Unable to allocate memory for -maxscriptcachesize: '%s' MiB"),
	args.GetIntArg("-maxscriptcachesize",
	DEFAULT_MAX_SCRIPT_CACHE_BYTES >> 20)));
	}

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

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

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

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

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

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

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

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

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

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

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

	// Step 6: network initialization

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

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

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

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

	uiInterface.InitMessage(_("Loading P2P addresses...").translated);
	auto addrman{LoadAddrman(chainparams, asmap, args)};
	if (!addrman) {
	return InitError(util::ErrorString(addrman));
	}
	node.addrman = std::move(*addrman);
	}

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

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

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

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

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

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

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

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

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

	#if ENABLE_ZMQ
	g_zmq_notification_interface = CZMQNotificationInterface::Create(
	[&chainman = node.chainman](CBlock &block, const CBlockIndex &index) {
	assert(chainman);
	return chainman->m_blockman.ReadBlockFromDisk(block, index);
	});

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

	// Step 7: load block chain

	node.notifications = std::make_unique<KernelNotifications>();
	fReindex = args.GetBoolArg("-reindex", false);
	bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);

	ChainstateManager::Options chainman_opts{
	.config = config,
	.datadir = args.GetDataDirNet(),
	.adjusted_time_callback = GetAdjustedTime,
	.notifications = *node.notifications,
	};
	// no error can happen, already checked in AppInitParameterInteraction
	Assert(!ApplyArgsManOptions(args, chainman_opts));

	if (chainman_opts.checkpoints_enabled) {
	LogPrintf("Checkpoints will be verified.\n");
	} else {
	LogPrintf("Skipping checkpoint verification.\n");
	}

	BlockManager::Options blockman_opts{
	.chainparams = chainman_opts.config.GetChainParams(),
	.blocks_dir = args.GetBlocksDirPath(),
	};
	// no error can happen, already checked in AppInitParameterInteraction
	Assert(!ApplyArgsManOptions(args, blockman_opts));

	// cache size calculations
	CacheSizes cache_sizes =
	CalculateCacheSizes(args, g_enabled_filter_types.size());

	LogPrintf("Cache configuration:\n");
	LogPrintf("* Using %.1f MiB for block index database\n",
	cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
	if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	LogPrintf("* Using %.1f MiB for transaction index database\n",
	cache_sizes.tx_index * (1.0 / 1024 / 1024));
	}
	for (BlockFilterType filter_type : g_enabled_filter_types) {
	LogPrintf("* Using %.1f MiB for %s block filter index database\n",
	cache_sizes.filter_index * (1.0 / 1024 / 1024),
	BlockFilterTypeName(filter_type));
	}
	LogPrintf("* Using %.1f MiB for chain state database\n",
	cache_sizes.coins_db * (1.0 / 1024 / 1024));

	assert(!node.mempool);
	assert(!node.chainman);

	CTxMemPool::Options mempool_opts{
	.check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
	};
	if (const auto err{ApplyArgsManOptions(args, chainparams, mempool_opts)}) {
	return InitError(*err);
	}
	mempool_opts.check_ratio =
	std::clamp<int>(mempool_opts.check_ratio, 0, 1'000'000);

	// FIXME: this legacy limit comes from the DEFAULT_DESCENDANT_SIZE_LIMIT
	// (101) that was enforced before the wellington activation. While it's
	// still a good idea to have some minimum mempool size, using this value as
	// a threshold is no longer relevant.
	int64_t nMempoolSizeMin = 101 * 1000 * 40;
	if (mempool_opts.max_size_bytes < 0 \|\|
	(!chainparams.IsTestChain() &&
	mempool_opts.max_size_bytes < nMempoolSizeMin)) {
	return InitError(strprintf(_("-maxmempool must be at least %d MB"),
	std::ceil(nMempoolSizeMin / 1000000.0)));
	}
	LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
	"unused mempool space)\n",
	cache_sizes.coins * (1.0 / 1024 / 1024),
	mempool_opts.max_size_bytes * (1.0 / 1024 / 1024));

	for (bool fLoaded = false; !fLoaded && !ShutdownRequested();) {
	node.mempool = std::make_unique<CTxMemPool>(mempool_opts);

	node.chainman =
	std::make_unique<ChainstateManager>(chainman_opts, blockman_opts);
	ChainstateManager &chainman = *node.chainman;

	node::ChainstateLoadOptions options;
	options.mempool = Assert(node.mempool.get());
	options.reindex = node::fReindex;
	options.reindex_chainstate = fReindexChainState;
	options.prune = chainman.m_blockman.IsPruneMode();
	options.check_blocks =
	args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
	options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
	options.require_full_verification =
	args.IsArgSet("-checkblocks") \|\| args.IsArgSet("-checklevel");
	options.check_interrupt = ShutdownRequested;
	options.coins_error_cb = [] {
	uiInterface.ThreadSafeMessageBox(
	_("Error reading from database, shutting down."), "",
	CClientUIInterface::MSG_ERROR);
	};

	uiInterface.InitMessage(_("Loading block index...").translated);

	const int64_t load_block_index_start_time = GetTimeMillis();
	auto catch_exceptions = [](auto &&f) {
	try {
	return f();
	} catch (const std::exception &e) {
	LogPrintf("%s\n", e.what());
	return std::make_tuple(node::ChainstateLoadStatus::FAILURE,
	_("Error opening block database"));
	}
	};
	auto [status, error] = catch_exceptions(
	[&] { return LoadChainstate(chainman, cache_sizes, options); });
	if (status == node::ChainstateLoadStatus::SUCCESS) {
	uiInterface.InitMessage(_("Verifying blocks...").translated);
	if (chainman.m_blockman.m_have_pruned &&
	options.check_blocks > MIN_BLOCKS_TO_KEEP) {
	LogPrintfCategory(BCLog::PRUNE,
	"pruned datadir may not have more than %d "
	"blocks; only checking available blocks\n",
	MIN_BLOCKS_TO_KEEP);
	}
	std::tie(status, error) = catch_exceptions(
	[&] { return VerifyLoadedChainstate(chainman, options); });
	if (status == node::ChainstateLoadStatus::SUCCESS) {
	WITH_LOCK(cs_main, return node.chainman->LoadRecentHeadersTime(
	node.chainman->m_options.datadir /
	HEADERS_TIME_FILE_NAME));
	fLoaded = true;
	LogPrintf(" block index %15dms\n",
	GetTimeMillis() - load_block_index_start_time);
	}
	}

	if (status == node::ChainstateLoadStatus::FAILURE_FATAL \|\|
	status == node::ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB \|\|
	status ==
	node::ChainstateLoadStatus::FAILURE_INSUFFICIENT_DBCACHE) {
	return InitError(error);
	}

	if (!fLoaded && !ShutdownRequested()) {
	// first suggest a reindex
	if (!options.reindex) {
	bool fRet = uiInterface.ThreadSafeQuestion(
	error + Untranslated(".\n\n") +
	_("Do you want to rebuild the block database now?"),
	error.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(error);
	}
	}
	}

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

	ChainstateManager &chainman = *Assert(node.chainman);

	if (args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED)) {
	// Initialize Avalanche.
	bilingual_str avalancheError;
	node.avalanche = avalanche::Processor::MakeProcessor(
	args, *node.chain, node.connman.get(), chainman, node.mempool.get(),
	*node.scheduler, avalancheError);
	if (!node.avalanche) {
	InitError(avalancheError);
	return false;
	}

	if (node.avalanche->isAvalancheServiceAvailable()) {
	nLocalServices = ServiceFlags(nLocalServices \| NODE_AVALANCHE);
	}
	}

	PeerManager::Options peerman_opts{};
	ApplyArgsManOptions(args, peerman_opts);

	assert(!node.peerman);
	node.peerman = PeerManager::make(node.connman, node.addrman,
	node.banman.get(), chainman, *node.mempool,
	node.avalanche.get(), peerman_opts);
	RegisterValidationInterface(node.peerman.get());

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

	// Step 8: load indexers
	+
	+ // If reindex-chainstate was specified, delay syncing indexes until
	+ // ThreadImport has reindexed the chain
	+ if (!fReindexChainState) {
	+ g_indexes_ready_to_sync = true;
	+ }
	if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
	auto result{
	WITH_LOCK(cs_main, return CheckLegacyTxindex(*Assert(
	chainman.m_blockman.m_block_tree_db)))};
	if (!result) {
	return InitError(util::ErrorString(result));
	}

	g_txindex =
	std::make_unique<TxIndex>(interfaces::MakeChain(node, Params()),
	cache_sizes.tx_index, false, fReindex);
	if (!g_txindex->Start()) {
	return false;
	}
	}

	for (const auto &filter_type : g_enabled_filter_types) {
	InitBlockFilterIndex(
	[&] { return interfaces::MakeChain(node, Params()); }, filter_type,
	cache_sizes.filter_index, false, fReindex);
	if (!GetBlockFilterIndex(filter_type)->Start()) {
	return false;
	}
	}

	if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
	g_coin_stats_index = std::make_unique<CoinStatsIndex>(
	interfaces::MakeChain(node, Params()), /* cache size */ 0, false,
	fReindex);
	if (!g_coin_stats_index->Start()) {
	return false;
	}
	}

	#if ENABLE_CHRONIK
	if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
	const bool fReindexChronik =
	fReindex \|\| args.GetBoolArg("-chronikreindex", false);
	if (!chronik::Start(args, config, node, fReindexChronik)) {
	return false;
	}
	}
	#endif

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

	// Step 10: data directory maintenance

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

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

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

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

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

	avalanche::Processor *const avalanche = node.avalanche.get();
	chainman.m_load_block =
	std::thread(&util::TraceThread, "loadblk", [=, &chainman, &args] {
	ThreadImport(chainman, avalanche, vImportFiles,
	ShouldPersistMempool(args) ? MempoolPath(args)
	: fs::path{});
	});

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

	if (ShutdownRequested()) {
	return false;
	}

	// Step 12: start node

	int chain_active_height;

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

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

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

	connOptions.nMaxOutboundLimit =
	1024 * 1024 *
	args.GetIntArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
	connOptions.m_peer_connect_timeout = peer_connect_timeout;
	connOptions.whitelist_forcerelay =
	args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
	connOptions.whitelist_relay =
	args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);

	// Port to bind to if `-bind=addr` is provided without a `:port` suffix.
	const uint16_t default_bind_port = static_cast<uint16_t>(
	args.GetIntArg("-port", config.GetChainParams().GetDefaultPort()));

	const auto BadPortWarning = [](const char *prefix, uint16_t port) {
	return strprintf(_("%s request to listen on port %u. This port is "
	"considered \"bad\" and "
	"thus it is unlikely that any Bitcoin ABC peers "
	"connect to it. See "
	"doc/p2p-bad-ports.md for details and a full list."),
	prefix, port);
	};

	for (const std::string &bind_arg : args.GetArgs("-bind")) {
	CService bind_addr;
	const size_t index = bind_arg.rfind('=');
	if (index == std::string::npos) {
	if (Lookup(bind_arg, bind_addr, default_bind_port,
	/fAllowLookup=/false)) {
	connOptions.vBinds.push_back(bind_addr);
	if (IsBadPort(bind_addr.GetPort())) {
	InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
	}
	continue;
	}
	} else {
	const std::string network_type = bind_arg.substr(index + 1);
	if (network_type == "onion") {
	const std::string truncated_bind_arg =
	bind_arg.substr(0, index);
	if (Lookup(truncated_bind_arg, bind_addr,
	BaseParams().OnionServiceTargetPort(), false)) {
	connOptions.onion_binds.push_back(bind_addr);
	continue;
	}
	}
	}
	return InitError(ResolveErrMsg("bind", bind_arg));
	}

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

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

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

	CService onion_service_target;
	if (!connOptions.onion_binds.empty()) {
	onion_service_target = connOptions.onion_binds.front();
	} else if (!connOptions.vBinds.empty()) {
	onion_service_target = connOptions.vBinds.front();
	} else {
	onion_service_target = DefaultOnionServiceTarget();
	connOptions.onion_binds.push_back(onion_service_target);
	}

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

	if (connOptions.bind_on_any) {
	// Only add all IP addresses of the machine if we would be listening on
	// any address - 0.0.0.0 (IPv4) and :: (IPv6).
	Discover();
	}

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

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

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

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

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

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

	// Step 13: finished

	// At this point, the RPC is "started", but still in warmup, which means it
	// cannot yet be called. Before we make it callable, we need to make sure
	// that the RPC's view of the best block is valid and consistent with
	// ChainstateManager's active tip.
	//
	// If we do not do this, RPC's view of the best block will be height=0 and
	// hash=0x0. This will lead to erroroneous responses for things like
	// waitforblockheight.
	RPCNotifyBlockChange(
	WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()));
	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.
	if (node.avalanche) {
	node.avalanche->startEventLoop(*node.scheduler);
	}

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

	#if HAVE_SYSTEM
	StartupNotify(args);
	#endif

	return true;
	}
	diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
	index b694a945b..803d590e9 100644
	--- a/src/node/blockstorage.cpp
	+++ b/src/node/blockstorage.cpp
	@@ -1,1034 +1,1036 @@
	// Copyright (c) 2011-2022 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <node/blockstorage.h>

	#include <avalanche/processor.h>
	#include <blockindexcomparators.h>
	#include <chain.h>
	#include <clientversion.h>
	#include <common/system.h>
	#include <config.h>
	#include <consensus/validation.h>
	#include <flatfile.h>
	#include <hash.h>
	#include <kernel/chainparams.h>
	#include <logging.h>
	#include <pow/pow.h>
	#include <reverse_iterator.h>
	#include <shutdown.h>
	#include <streams.h>
	#include <undo.h>
	#include <util/batchpriority.h>
	#include <util/fs.h>
	#include <validation.h>

	#include <map>
	#include <unordered_map>

	namespace node {
	std::atomic_bool fReindex(false);
	+std::atomic_bool g_indexes_ready_to_sync{false};

	std::vector<CBlockIndex *> BlockManager::GetAllBlockIndices() {
	AssertLockHeld(cs_main);
	std::vector<CBlockIndex *> rv;
	rv.reserve(m_block_index.size());
	for (auto &[_, block_index] : m_block_index) {
	rv.push_back(&block_index);
	}
	return rv;
	}

	CBlockIndex *BlockManager::LookupBlockIndex(const BlockHash &hash) {
	AssertLockHeld(cs_main);
	BlockMap::iterator it = m_block_index.find(hash);
	return it == m_block_index.end() ? nullptr : &it->second;
	}

	const CBlockIndex *BlockManager::LookupBlockIndex(const BlockHash &hash) const {
	AssertLockHeld(cs_main);
	BlockMap::const_iterator it = m_block_index.find(hash);
	return it == m_block_index.end() ? nullptr : &it->second;
	}

	CBlockIndex *BlockManager::AddToBlockIndex(const CBlockHeader &block,
	CBlockIndex *&best_header) {
	AssertLockHeld(cs_main);

	const auto [mi, inserted] =
	m_block_index.try_emplace(block.GetHash(), block);
	if (!inserted) {
	return &mi->second;
	}
	CBlockIndex pindexNew = &(mi).second;

	// We assign the sequence id to blocks only when the full data is available,
	// to avoid miners withholding blocks but broadcasting headers, to get a
	// competitive advantage.
	pindexNew->nSequenceId = 0;

	pindexNew->phashBlock = &((*mi).first);
	BlockMap::iterator miPrev = m_block_index.find(block.hashPrevBlock);
	if (miPrev != m_block_index.end()) {
	pindexNew->pprev = &(*miPrev).second;
	pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
	pindexNew->BuildSkip();
	}
	pindexNew->nTimeReceived = GetTime();
	pindexNew->nTimeMax =
	(pindexNew->pprev
	? std::max(pindexNew->pprev->nTimeMax, pindexNew->nTime)
	: pindexNew->nTime);
	pindexNew->nChainWork =
	(pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) +
	GetBlockProof(*pindexNew);
	pindexNew->RaiseValidity(BlockValidity::TREE);
	if (best_header == nullptr \|\|
	best_header->nChainWork < pindexNew->nChainWork) {
	best_header = pindexNew;
	}

	m_dirty_blockindex.insert(pindexNew);
	return pindexNew;
	}

	void BlockManager::PruneOneBlockFile(const int fileNumber) {
	AssertLockHeld(cs_main);
	LOCK(cs_LastBlockFile);

	for (auto &entry : m_block_index) {
	CBlockIndex *pindex = &entry.second;
	if (pindex->nFile == fileNumber) {
	pindex->nStatus = pindex->nStatus.withData(false).withUndo(false);
	pindex->nFile = 0;
	pindex->nDataPos = 0;
	pindex->nUndoPos = 0;
	m_dirty_blockindex.insert(pindex);

	// Prune from m_blocks_unlinked -- any block we prune would have
	// to be downloaded again in order to consider its chain, at which
	// point it would be considered as a candidate for
	// m_blocks_unlinked or setBlockIndexCandidates.
	auto range = m_blocks_unlinked.equal_range(pindex->pprev);
	while (range.first != range.second) {
	std::multimap<CBlockIndex , CBlockIndex >::iterator _it =
	range.first;
	range.first++;
	if (_it->second == pindex) {
	m_blocks_unlinked.erase(_it);
	}
	}
	}
	}

	m_blockfile_info[fileNumber].SetNull();
	m_dirty_fileinfo.insert(fileNumber);
	}

	void BlockManager::FindFilesToPruneManual(std::set<int> &setFilesToPrune,
	int nManualPruneHeight,
	int chain_tip_height) {
	assert(IsPruneMode() && nManualPruneHeight > 0);

	LOCK2(cs_main, cs_LastBlockFile);
	if (chain_tip_height < 0) {
	return;
	}

	// last block to prune is the lesser of (user-specified height,
	// MIN_BLOCKS_TO_KEEP from the tip)
	unsigned int nLastBlockWeCanPrune{std::min(
	(unsigned)nManualPruneHeight, chain_tip_height - MIN_BLOCKS_TO_KEEP)};
	int count = 0;
	for (int fileNumber = 0; fileNumber < m_last_blockfile; fileNumber++) {
	if (m_blockfile_info[fileNumber].nSize == 0 \|\|
	m_blockfile_info[fileNumber].nHeightLast > nLastBlockWeCanPrune) {
	continue;
	}
	PruneOneBlockFile(fileNumber);
	setFilesToPrune.insert(fileNumber);
	count++;
	}
	LogPrintf("Prune (Manual): prune_height=%d removed %d blk/rev pairs\n",
	nLastBlockWeCanPrune, count);
	}

	void BlockManager::FindFilesToPrune(std::set<int> &setFilesToPrune,
	uint64_t nPruneAfterHeight,
	int chain_tip_height, int prune_height,
	bool is_ibd) {
	LOCK2(cs_main, cs_LastBlockFile);
	if (chain_tip_height < 0 \|\| GetPruneTarget() == 0) {
	return;
	}
	if (uint64_t(chain_tip_height) <= nPruneAfterHeight) {
	return;
	}

	unsigned int nLastBlockWeCanPrune = std::min(
	prune_height, chain_tip_height - static_cast<int>(MIN_BLOCKS_TO_KEEP));
	uint64_t nCurrentUsage = CalculateCurrentUsage();
	// We don't check to prune until after we've allocated new space for files,
	// so we should leave a buffer under our target to account for another
	// allocation before the next pruning.
	uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
	uint64_t nBytesToPrune;
	int count = 0;

	if (nCurrentUsage + nBuffer >= GetPruneTarget()) {
	// On a prune event, the chainstate DB is flushed.
	// To avoid excessive prune events negating the benefit of high dbcache
	// values, we should not prune too rapidly.
	// So when pruning in IBD, increase the buffer a bit to avoid a re-prune
	// too soon.
	if (is_ibd) {
	// Since this is only relevant during IBD, we use a fixed 10%
	nBuffer += GetPruneTarget() / 10;
	}

	for (int fileNumber = 0; fileNumber < m_last_blockfile; fileNumber++) {
	nBytesToPrune = m_blockfile_info[fileNumber].nSize +
	m_blockfile_info[fileNumber].nUndoSize;

	if (m_blockfile_info[fileNumber].nSize == 0) {
	continue;
	}

	// are we below our target?
	if (nCurrentUsage + nBuffer < GetPruneTarget()) {
	break;
	}

	// don't prune files that could have a block within
	// MIN_BLOCKS_TO_KEEP of the main chain's tip but keep scanning
	if (m_blockfile_info[fileNumber].nHeightLast >
	nLastBlockWeCanPrune) {
	continue;
	}

	PruneOneBlockFile(fileNumber);
	// Queue up the files for removal
	setFilesToPrune.insert(fileNumber);
	nCurrentUsage -= nBytesToPrune;
	count++;
	}
	}

	LogPrint(BCLog::PRUNE,
	"Prune: target=%dMiB actual=%dMiB diff=%dMiB "
	"max_prune_height=%d removed %d blk/rev pairs\n",
	GetPruneTarget() / 1024 / 1024, nCurrentUsage / 1024 / 1024,
	(int64_t(GetPruneTarget()) - int64_t(nCurrentUsage)) / 1024 / 1024,
	nLastBlockWeCanPrune, count);
	}

	void BlockManager::UpdatePruneLock(const std::string &name,
	const PruneLockInfo &lock_info) {
	AssertLockHeld(::cs_main);
	m_prune_locks[name] = lock_info;
	}

	CBlockIndex *BlockManager::InsertBlockIndex(const BlockHash &hash) {
	AssertLockHeld(cs_main);

	if (hash.IsNull()) {
	return nullptr;
	}

	const auto [mi, inserted] = m_block_index.try_emplace(hash);
	CBlockIndex pindex = &(mi).second;
	if (inserted) {
	pindex->phashBlock = &((*mi).first);
	}
	return pindex;
	}

	bool BlockManager::LoadBlockIndex() {
	AssertLockHeld(cs_main);
	if (!m_block_tree_db->LoadBlockIndexGuts(
	GetConsensus(),
	[this](const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
	return this->InsertBlockIndex(hash);
	})) {
	return false;
	}

	// Calculate nChainWork
	std::vector<CBlockIndex *> vSortedByHeight{GetAllBlockIndices()};
	std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
	CBlockIndexHeightOnlyComparator());

	for (CBlockIndex *pindex : vSortedByHeight) {
	if (ShutdownRequested()) {
	return false;
	}
	pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) +
	GetBlockProof(*pindex);
	pindex->nTimeMax =
	(pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime)
	: pindex->nTime);

	// We can link the chain of blocks for which we've received
	// transactions at some point, or blocks that are assumed-valid on the
	// basis of snapshot load (see PopulateAndValidateSnapshot()).
	// Pruned nodes may have deleted the block.
	if (pindex->nTx > 0) {
	if (!pindex->UpdateChainStats() && pindex->pprev) {
	m_blocks_unlinked.insert(std::make_pair(pindex->pprev, pindex));
	}
	}

	if (!pindex->nStatus.hasFailed() && pindex->pprev &&
	pindex->pprev->nStatus.hasFailed()) {
	pindex->nStatus = pindex->nStatus.withFailedParent();
	m_dirty_blockindex.insert(pindex);
	}

	if (pindex->pprev) {
	pindex->BuildSkip();
	}
	}

	return true;
	}

	bool BlockManager::WriteBlockIndexDB() {
	std::vector<std::pair<int, const CBlockFileInfo *>> vFiles;
	vFiles.reserve(m_dirty_fileinfo.size());
	for (int i : m_dirty_fileinfo) {
	vFiles.push_back(std::make_pair(i, &m_blockfile_info[i]));
	}

	m_dirty_fileinfo.clear();

	std::vector<const CBlockIndex *> vBlocks;
	vBlocks.reserve(m_dirty_blockindex.size());
	for (const CBlockIndex *cbi : m_dirty_blockindex) {
	vBlocks.push_back(cbi);
	}

	m_dirty_blockindex.clear();

	if (!m_block_tree_db->WriteBatchSync(vFiles, m_last_blockfile, vBlocks)) {
	return false;
	}
	return true;
	}

	bool BlockManager::LoadBlockIndexDB() {
	if (!LoadBlockIndex()) {
	return false;
	}

	// Load block file info
	m_block_tree_db->ReadLastBlockFile(m_last_blockfile);
	m_blockfile_info.resize(m_last_blockfile + 1);
	LogPrintf("%s: last block file = %i\n", __func__, m_last_blockfile);
	for (int nFile = 0; nFile <= m_last_blockfile; nFile++) {
	m_block_tree_db->ReadBlockFileInfo(nFile, m_blockfile_info[nFile]);
	}
	LogPrintf("%s: last block file info: %s\n", __func__,
	m_blockfile_info[m_last_blockfile].ToString());
	for (int nFile = m_last_blockfile + 1; true; nFile++) {
	CBlockFileInfo info;
	if (m_block_tree_db->ReadBlockFileInfo(nFile, info)) {
	m_blockfile_info.push_back(info);
	} else {
	break;
	}
	}

	// Check presence of blk files
	LogPrintf("Checking all blk files are present...\n");
	std::set<int> setBlkDataFiles;
	for (const auto &[_, block_index] : m_block_index) {
	if (block_index.nStatus.hasData()) {
	setBlkDataFiles.insert(block_index.nFile);
	}
	}

	for (const int i : setBlkDataFiles) {
	FlatFilePos pos(i, 0);
	if (CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION)
	.IsNull()) {
	return false;
	}
	}

	// Check whether we have ever pruned block & undo files
	m_block_tree_db->ReadFlag("prunedblockfiles", m_have_pruned);
	if (m_have_pruned) {
	LogPrintf(
	"LoadBlockIndexDB(): Block files have previously been pruned\n");
	}

	// Check whether we need to continue reindexing
	if (m_block_tree_db->IsReindexing()) {
	fReindex = true;
	}

	return true;
	}

	void BlockManager::ScanAndUnlinkAlreadyPrunedFiles() {
	AssertLockHeld(::cs_main);
	if (!m_have_pruned) {
	return;
	}

	std::set<int> block_files_to_prune;
	for (int file_number = 0; file_number < m_last_blockfile; file_number++) {
	if (m_blockfile_info[file_number].nSize == 0) {
	block_files_to_prune.insert(file_number);
	}
	}

	UnlinkPrunedFiles(block_files_to_prune);
	}

	const CBlockIndex *
	BlockManager::GetLastCheckpoint(const CCheckpointData &data) {
	const MapCheckpoints &checkpoints = data.mapCheckpoints;

	for (const MapCheckpoints::value_type &i : reverse_iterate(checkpoints)) {
	const BlockHash &hash = i.second;
	const CBlockIndex *pindex = LookupBlockIndex(hash);
	if (pindex) {
	return pindex;
	}
	}

	return nullptr;
	}

	bool BlockManager::IsBlockPruned(const CBlockIndex *pblockindex) {
	AssertLockHeld(::cs_main);
	return (m_have_pruned && !pblockindex->nStatus.hasData() &&
	pblockindex->nTx > 0);
	}

	const CBlockIndex *
	BlockManager::GetFirstStoredBlock(const CBlockIndex &start_block) {
	AssertLockHeld(::cs_main);
	const CBlockIndex *last_block = &start_block;
	while (last_block->pprev && (last_block->pprev->nStatus.hasData())) {
	last_block = last_block->pprev;
	}
	return last_block;
	}

	// 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 m_blockfile_info is in
	// sync with what's actually on disk by the time we start downloading, so that
	// pruning works correctly.
	void BlockManager::CleanupBlockRevFiles() const {
	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");
	for (const auto &file : fs::directory_iterator{m_opts.blocks_dir}) {
	const std::string path = fs::PathToString(file.path().filename());
	if (fs::is_regular_file(file) && path.length() == 12 &&
	path.substr(8, 4) == ".dat") {
	if (path.substr(0, 3) == "blk") {
	mapBlockFiles[path.substr(3, 5)] = file.path();
	} else if (path.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);
	}
	}

	CBlockFileInfo *BlockManager::GetBlockFileInfo(size_t n) {
	LOCK(cs_LastBlockFile);

	return &m_blockfile_info.at(n);
	}

	bool BlockManager::UndoWriteToDisk(
	const CBlockUndo &blockundo, FlatFilePos &pos, const BlockHash &hashBlock,
	const CMessageHeader::MessageMagic &messageStart) const {
	// Open history file to append
	CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
	if (fileout.IsNull()) {
	return error("%s: OpenUndoFile failed", __func__);
	}

	// Write index header
	unsigned int nSize = GetSerializeSize(blockundo, fileout.GetVersion());
	fileout << messageStart << nSize;

	// Write undo data
	long fileOutPos = ftell(fileout.Get());
	if (fileOutPos < 0) {
	return error("%s: ftell failed", __func__);
	}
	pos.nPos = (unsigned int)fileOutPos;
	fileout << blockundo;

	// calculate & write checksum
	HashWriter hasher{};
	hasher << hashBlock;
	hasher << blockundo;
	fileout << hasher.GetHash();

	return true;
	}

	bool BlockManager::UndoReadFromDisk(CBlockUndo &blockundo,
	const CBlockIndex &index) const {
	const FlatFilePos pos{WITH_LOCK(::cs_main, return index.GetUndoPos())};

	if (pos.IsNull()) {
	return error("%s: no undo data available", __func__);
	}

	// Open history file to read
	CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
	if (filein.IsNull()) {
	return error("%s: OpenUndoFile failed", __func__);
	}

	// Read block
	uint256 hashChecksum;
	// We need a CHashVerifier as reserializing may lose data
	CHashVerifier<CAutoFile> verifier(&filein);
	try {
	verifier << index.pprev->GetBlockHash();
	verifier >> blockundo;
	filein >> hashChecksum;
	} catch (const std::exception &e) {
	return error("%s: Deserialize or I/O error - %s", __func__, e.what());
	}

	// Verify checksum
	if (hashChecksum != verifier.GetHash()) {
	return error("%s: Checksum mismatch", __func__);
	}

	return true;
	}

	void BlockManager::FlushUndoFile(int block_file, bool finalize) {
	FlatFilePos undo_pos_old(block_file,
	m_blockfile_info[block_file].nUndoSize);
	if (!UndoFileSeq().Flush(undo_pos_old, finalize)) {
	AbortNode("Flushing undo file to disk failed. This is likely the "
	"result of an I/O error.");
	}
	}

	void BlockManager::FlushBlockFile(bool fFinalize, bool finalize_undo) {
	LOCK(cs_LastBlockFile);

	if (m_blockfile_info.empty()) {
	// Return if we haven't loaded any blockfiles yet. This happens during
	// chainstate init, when we call
	// ChainstateManager::MaybeRebalanceCaches() (which then calls
	// FlushStateToDisk()), resulting in a call to this function before we
	// have populated `m_blockfile_info` via LoadBlockIndexDB().
	return;
	}
	assert(static_cast<int>(m_blockfile_info.size()) > m_last_blockfile);

	FlatFilePos block_pos_old(m_last_blockfile,
	m_blockfile_info[m_last_blockfile].nSize);
	if (!BlockFileSeq().Flush(block_pos_old, fFinalize)) {
	AbortNode("Flushing block file to disk failed. This is likely the "
	"result of an I/O error.");
	}
	// we do not always flush the undo file, as the chain tip may be lagging
	// behind the incoming blocks,
	// e.g. during IBD or a sync after a node going offline
	if (!fFinalize \|\| finalize_undo) {
	FlushUndoFile(m_last_blockfile, finalize_undo);
	}
	}

	uint64_t BlockManager::CalculateCurrentUsage() {
	LOCK(cs_LastBlockFile);

	uint64_t retval = 0;
	for (const CBlockFileInfo &file : m_blockfile_info) {
	retval += file.nSize + file.nUndoSize;
	}

	return retval;
	}

	void BlockManager::UnlinkPrunedFiles(
	const std::set<int> &setFilesToPrune) const {
	std::error_code error_code;
	for (const int i : setFilesToPrune) {
	FlatFilePos pos(i, 0);
	const bool removed_blockfile{
	fs::remove(BlockFileSeq().FileName(pos), error_code)};
	const bool removed_undofile{
	fs::remove(UndoFileSeq().FileName(pos), error_code)};
	if (removed_blockfile \|\| removed_undofile) {
	LogPrint(BCLog::BLOCKSTORE, "Prune: %s deleted blk/rev (%05u)\n",
	__func__, i);
	}
	}
	}

	FlatFileSeq BlockManager::BlockFileSeq() const {
	return FlatFileSeq(m_opts.blocks_dir, "blk",
	m_opts.fast_prune ? 0x4000 /* 16kb */
	: BLOCKFILE_CHUNK_SIZE);
	}

	FlatFileSeq BlockManager::UndoFileSeq() const {
	return FlatFileSeq(m_opts.blocks_dir, "rev", UNDOFILE_CHUNK_SIZE);
	}

	FILE *BlockManager::OpenBlockFile(const FlatFilePos &pos,
	bool fReadOnly) const {
	return BlockFileSeq().Open(pos, fReadOnly);
	}

	/** Open an undo file (rev?????.dat) */
	FILE *BlockManager::OpenUndoFile(const FlatFilePos &pos, bool fReadOnly) const {
	return UndoFileSeq().Open(pos, fReadOnly);
	}

	fs::path BlockManager::GetBlockPosFilename(const FlatFilePos &pos) const {
	return BlockFileSeq().FileName(pos);
	}

	bool BlockManager::FindBlockPos(FlatFilePos &pos, unsigned int nAddSize,
	unsigned int nHeight, uint64_t nTime,
	bool fKnown) {
	LOCK(cs_LastBlockFile);

	unsigned int nFile = fKnown ? pos.nFile : m_last_blockfile;
	if (m_blockfile_info.size() <= nFile) {
	m_blockfile_info.resize(nFile + 1);
	}

	bool finalize_undo = false;
	if (!fKnown) {
	unsigned int max_blockfile_size{MAX_BLOCKFILE_SIZE};
	// Use smaller blockfiles in test-only -fastprune mode - but avoid
	// the possibility of having a block not fit into the block file.
	if (m_opts.fast_prune) {
	max_blockfile_size = 0x10000; // 64kiB
	if (nAddSize >= max_blockfile_size) {
	// dynamically adjust the blockfile size to be larger than the
	// added size
	max_blockfile_size = nAddSize + 1;
	}
	}
	// TODO: we will also need to dynamically adjust the blockfile size
	// or raise MAX_BLOCKFILE_SIZE when we reach block sizes larger than
	// 128 MiB
	assert(nAddSize < max_blockfile_size);
	while (m_blockfile_info[nFile].nSize + nAddSize >= max_blockfile_size) {
	// when the undo file is keeping up with the block file, we want to
	// flush it explicitly when it is lagging behind (more blocks arrive
	// than are being connected), we let the undo block write case
	// handle it
	finalize_undo = (m_blockfile_info[nFile].nHeightLast ==
	m_undo_height_in_last_blockfile);
	nFile++;
	if (m_blockfile_info.size() <= nFile) {
	m_blockfile_info.resize(nFile + 1);
	}
	}
	pos.nFile = nFile;
	pos.nPos = m_blockfile_info[nFile].nSize;
	}

	if ((int)nFile != m_last_blockfile) {
	if (!fKnown) {
	LogPrint(BCLog::BLOCKSTORE, "Leaving block file %i: %s\n",
	m_last_blockfile,
	m_blockfile_info[m_last_blockfile].ToString());
	}
	FlushBlockFile(!fKnown, finalize_undo);
	m_last_blockfile = nFile;
	// No undo data yet in the new file, so reset our undo-height tracking.
	m_undo_height_in_last_blockfile = 0;
	}

	m_blockfile_info[nFile].AddBlock(nHeight, nTime);
	if (fKnown) {
	m_blockfile_info[nFile].nSize =
	std::max(pos.nPos + nAddSize, m_blockfile_info[nFile].nSize);
	} else {
	m_blockfile_info[nFile].nSize += nAddSize;
	}

	if (!fKnown) {
	bool out_of_space;
	size_t bytes_allocated =
	BlockFileSeq().Allocate(pos, nAddSize, out_of_space);
	if (out_of_space) {
	return AbortNode("Disk space is too low!",
	_("Disk space is too low!"));
	}
	if (bytes_allocated != 0 && IsPruneMode()) {
	m_check_for_pruning = true;
	}
	}

	m_dirty_fileinfo.insert(nFile);
	return true;
	}

	bool BlockManager::FindUndoPos(BlockValidationState &state, int nFile,
	FlatFilePos &pos, unsigned int nAddSize) {
	pos.nFile = nFile;

	LOCK(cs_LastBlockFile);

	pos.nPos = m_blockfile_info[nFile].nUndoSize;
	m_blockfile_info[nFile].nUndoSize += nAddSize;
	m_dirty_fileinfo.insert(nFile);

	bool out_of_space;
	size_t bytes_allocated =
	UndoFileSeq().Allocate(pos, nAddSize, out_of_space);
	if (out_of_space) {
	return AbortNode(state, "Disk space is too low!",
	_("Disk space is too low!"));
	}
	if (bytes_allocated != 0 && IsPruneMode()) {
	m_check_for_pruning = true;
	}

	return true;
	}

	bool BlockManager::WriteBlockToDisk(
	const CBlock &block, FlatFilePos &pos,
	const CMessageHeader::MessageMagic &messageStart) const {
	// Open history file to append
	CAutoFile fileout(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
	if (fileout.IsNull()) {
	return error("WriteBlockToDisk: OpenBlockFile failed");
	}

	// Write index header
	unsigned int nSize = GetSerializeSize(block, fileout.GetVersion());
	fileout << messageStart << nSize;

	// Write block
	long fileOutPos = ftell(fileout.Get());
	if (fileOutPos < 0) {
	return error("WriteBlockToDisk: ftell failed");
	}

	pos.nPos = (unsigned int)fileOutPos;
	fileout << block;

	return true;
	}

	bool BlockManager::WriteUndoDataForBlock(const CBlockUndo &blockundo,
	BlockValidationState &state,
	CBlockIndex &block) {
	AssertLockHeld(::cs_main);
	// Write undo information to disk
	if (block.GetUndoPos().IsNull()) {
	FlatFilePos _pos;
	if (!FindUndoPos(state, block.nFile, _pos,
	::GetSerializeSize(blockundo, CLIENT_VERSION) + 40)) {
	return error("ConnectBlock(): FindUndoPos failed");
	}
	if (!UndoWriteToDisk(blockundo, _pos, block.pprev->GetBlockHash(),
	GetParams().DiskMagic())) {
	return AbortNode(state, "Failed to write undo data");
	}
	// rev files are written in block height order, whereas blk files are
	// written as blocks come in (often out of order) we want to flush the
	// rev (undo) file once we've written the last block, which is indicated
	// by the last height in the block file info as below; note that this
	// does not catch the case where the undo writes are keeping up with the
	// block writes (usually when a synced up node is getting newly mined
	// blocks) -- this case is caught in the FindBlockPos function
	if (_pos.nFile < m_last_blockfile &&
	static_cast<uint32_t>(block.nHeight) ==
	m_blockfile_info[_pos.nFile].nHeightLast) {
	FlushUndoFile(_pos.nFile, true);
	} else if (_pos.nFile == m_last_blockfile &&
	static_cast<uint32_t>(block.nHeight) >
	m_undo_height_in_last_blockfile) {
	m_undo_height_in_last_blockfile = block.nHeight;
	}
	// update nUndoPos in block index
	block.nUndoPos = _pos.nPos;
	block.nStatus = block.nStatus.withUndo();
	m_dirty_blockindex.insert(&block);
	}

	return true;
	}

	bool BlockManager::ReadBlockFromDisk(CBlock &block,
	const FlatFilePos &pos) const {
	block.SetNull();

	// Open history file to read
	CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
	if (filein.IsNull()) {
	return error("ReadBlockFromDisk: OpenBlockFile failed for %s",
	pos.ToString());
	}

	// Read block
	try {
	filein >> block;
	} catch (const std::exception &e) {
	return error("%s: Deserialize or I/O error - %s at %s", __func__,
	e.what(), pos.ToString());
	}

	// Check the header
	if (!CheckProofOfWork(block.GetHash(), block.nBits, GetConsensus())) {
	return error("ReadBlockFromDisk: Errors in block header at %s",
	pos.ToString());
	}

	return true;
	}

	bool BlockManager::ReadBlockFromDisk(CBlock &block,
	const CBlockIndex &index) const {
	const FlatFilePos block_pos{WITH_LOCK(cs_main, return index.GetBlockPos())};

	if (!ReadBlockFromDisk(block, block_pos)) {
	return false;
	}

	if (block.GetHash() != index.GetBlockHash()) {
	return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() "
	"doesn't match index for %s at %s",
	index.ToString(), block_pos.ToString());
	}

	return true;
	}

	bool BlockManager::ReadTxFromDisk(CMutableTransaction &tx,
	const FlatFilePos &pos) const {
	// Open history file to read
	CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
	if (filein.IsNull()) {
	return error("ReadTxFromDisk: OpenBlockFile failed for %s",
	pos.ToString());
	}

	// Read tx
	try {
	filein >> tx;
	} catch (const std::exception &e) {
	return error("%s: Deserialize or I/O error - %s at %s", __func__,
	e.what(), pos.ToString());
	}

	return true;
	}

	bool BlockManager::ReadTxUndoFromDisk(CTxUndo &tx_undo,
	const FlatFilePos &pos) const {
	// Open undo file to read
	CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
	if (filein.IsNull()) {
	return error("ReadTxUndoFromDisk: OpenUndoFile failed for %s",
	pos.ToString());
	}

	// Read undo data
	try {
	filein >> tx_undo;
	} catch (const std::exception &e) {
	return error("%s: Deserialize or I/O error - %s at %s", __func__,
	e.what(), pos.ToString());
	}

	return true;
	}

	FlatFilePos BlockManager::SaveBlockToDisk(const CBlock &block, int nHeight,
	const FlatFilePos *dbp) {
	unsigned int nBlockSize = ::GetSerializeSize(block, CLIENT_VERSION);
	FlatFilePos blockPos;
	const auto position_known{dbp != nullptr};
	if (position_known) {
	blockPos = *dbp;
	} else {
	// When known, blockPos.nPos points at the offset of the block data in
	// the blk file. That already accounts for the serialization header
	// present in the file (the 4 magic message start bytes + the 4 length
	// bytes = 8 bytes = BLOCK_SERIALIZATION_HEADER_SIZE). We add
	// BLOCK_SERIALIZATION_HEADER_SIZE only for new blocks since they will
	// have the serialization header added when written to disk.
	nBlockSize +=
	static_cast<unsigned int>(BLOCK_SERIALIZATION_HEADER_SIZE);
	}
	if (!FindBlockPos(blockPos, nBlockSize, nHeight, block.GetBlockTime(),
	position_known)) {
	error("%s: FindBlockPos failed", __func__);
	return FlatFilePos();
	}
	if (!position_known) {
	if (!WriteBlockToDisk(block, blockPos, GetParams().DiskMagic())) {
	AbortNode("Failed to write block");
	return FlatFilePos();
	}
	}
	return blockPos;
	}

	class ImportingNow {
	std::atomic<bool> &m_importing;

	public:
	ImportingNow(std::atomic<bool> &importing) : m_importing{importing} {
	assert(m_importing == false);
	m_importing = true;
	}
	~ImportingNow() {
	assert(m_importing == true);
	m_importing = false;
	}
	};

	void ThreadImport(ChainstateManager &chainman,
	avalanche::Processor *const avalanche,
	std::vector<fs::path> vImportFiles,
	const fs::path &mempool_path) {
	ScheduleBatchPriority();

	{
	ImportingNow imp{chainman.m_blockman.m_importing};

	// -reindex
	if (fReindex) {
	int nFile = 0;
	// Map of disk positions for blocks with unknown parent (only used
	// for reindex); parent hash -> child disk position, multiple
	// children can have the same parent.
	std::multimap<BlockHash, FlatFilePos> blocks_with_unknown_parent;
	while (true) {
	FlatFilePos pos(nFile, 0);
	if (!fs::exists(chainman.m_blockman.GetBlockPosFilename(pos))) {
	// No block files left to reindex
	break;
	}
	FILE *file = chainman.m_blockman.OpenBlockFile(pos, true);
	if (!file) {
	// This error is logged in OpenBlockFile
	break;
	}
	LogPrintf("Reindexing block file blk%05u.dat...\n",
	(unsigned int)nFile);
	chainman.LoadExternalBlockFile(
	file, &pos, &blocks_with_unknown_parent, avalanche);
	if (ShutdownRequested()) {
	LogPrintf("Shutdown requested. Exit %s\n", __func__);
	return;
	}
	nFile++;
	}
	WITH_LOCK(
	::cs_main,
	chainman.m_blockman.m_block_tree_db->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):
	chainman.ActiveChainstate().LoadGenesisBlock();
	}

	// -loadblock=
	for (const fs::path &path : vImportFiles) {
	FILE *file = fsbridge::fopen(path, "rb");
	if (file) {
	LogPrintf("Importing blocks file %s...\n",
	fs::PathToString(path));
	chainman.LoadExternalBlockFile(
	file, /dbp=/nullptr,
	/blocks_with_unknown_parent=/nullptr, avalanche);
	if (ShutdownRequested()) {
	LogPrintf("Shutdown requested. Exit %s\n", __func__);
	return;
	}
	} else {
	LogPrintf("Warning: Could not open blocks file %s\n",
	fs::PathToString(path));
	}
	}

	// 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 =
	chainman.GetParams().Checkpoints().mapCheckpoints;
	for (const MapCheckpoints::value_type &i : checkpoints) {
	const BlockHash &hash = i.second;

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

	if (pblockindex && pblockindex->nStatus.isOnParkedChain()) {
	LogPrintf("Unparking checkpointed block %s ...\n",
	hash.GetHex());
	chainman.ActiveChainstate().UnparkBlockAndChildren(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 chainman unique_ptrs since ABC requires us not to be
	// holding cs_main, so retrieve the relevant pointers before the ABC
	// call.
	for (Chainstate *chainstate :
	WITH_LOCK(::cs_main, return chainman.GetAll())) {
	BlockValidationState state;
	if (!chainstate->ActivateBestChain(state, nullptr, avalanche)) {
	LogPrintf("Failed to connect best block (%s)\n",
	state.ToString());
	StartShutdown();
	return;
	}
	}

	if (chainman.m_blockman.StopAfterBlockImport()) {
	LogPrintf("Stopping after block import\n");
	StartShutdown();
	return;
	}
	} // End scope of ImportingNow
	chainman.ActiveChainstate().LoadMempool(mempool_path);
	+ g_indexes_ready_to_sync = true;
	}
	} // namespace node
	diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
	index e0d75b5e5..883473bcd 100644
	--- a/src/node/blockstorage.h
	+++ b/src/node/blockstorage.h
	@@ -1,317 +1,318 @@
	// Copyright (c) 2011-2021 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_NODE_BLOCKSTORAGE_H
	#define BITCOIN_NODE_BLOCKSTORAGE_H

	#include <cstdint>
	#include <unordered_map>
	#include <vector>

	#include <chain.h>
	#include <chainparams.h>
	#include <kernel/blockmanager_opts.h>
	#include <kernel/cs_main.h>
	#include <protocol.h> // For CMessageHeader::MessageStartChars
	#include <sync.h>
	#include <txdb.h>
	#include <util/fs.h>

	class BlockValidationState;
	class CBlock;
	class CBlockFileInfo;
	class CBlockHeader;
	class CBlockUndo;
	class CChainParams;
	class CTxUndo;
	class Chainstate;
	class ChainstateManager;
	struct CCheckpointData;
	class Config;
	struct FlatFilePos;
	namespace Consensus {
	struct Params;
	}
	namespace avalanche {
	class Processor;
	}

	namespace node {

	/** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
	static constexpr unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
	/** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
	static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
	/** The maximum size of a blk?????.dat file (since 0.8) */
	static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB

	/** Size of header written by WriteBlockToDisk before a serialized CBlock */
	static constexpr size_t BLOCK_SERIALIZATION_HEADER_SIZE =
	CMessageHeader::MESSAGE_START_SIZE + sizeof(unsigned int);

	extern std::atomic_bool fReindex;
	+extern std::atomic_bool g_indexes_ready_to_sync;

	// Because validation code takes pointers to the map's CBlockIndex objects, if
	// we ever switch to another associative container, we need to either use a
	// container that has stable addressing (true of all std associative
	// containers), or make the key a `std::unique_ptr<CBlockIndex>`
	using BlockMap = std::unordered_map<BlockHash, CBlockIndex, BlockHasher>;

	struct PruneLockInfo {
	//! Height of earliest block that should be kept and not pruned
	int height_first{std::numeric_limits<int>::max()};
	};

	/**
	* 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 `Chainstate` - information about, e.g.,
	* candidate tips is not maintained here.
	*/
	class BlockManager {
	friend Chainstate;
	friend ChainstateManager;

	private:
	const CChainParams &GetParams() const { return m_opts.chainparams; }
	const Consensus::Params &GetConsensus() const {
	return m_opts.chainparams.GetConsensus();
	}
	/**
	* Load the blocktree off disk and into memory. Populate certain metadata
	* per index entry (nStatus, nChainWork, nTimeMax, etc.) as well as
	* peripheral collections like m_dirty_blockindex.
	*/
	bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
	void FlushBlockFile(bool fFinalize = false, bool finalize_undo = false);
	void FlushUndoFile(int block_file, bool finalize = false);
	bool FindBlockPos(FlatFilePos &pos, unsigned int nAddSize,
	unsigned int nHeight, uint64_t nTime, bool fKnown);
	bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos,
	unsigned int nAddSize);

	FlatFileSeq BlockFileSeq() const;
	FlatFileSeq UndoFileSeq() const;

	FILE *OpenUndoFile(const FlatFilePos &pos, bool fReadOnly = false) const;

	bool
	WriteBlockToDisk(const CBlock &block, FlatFilePos &pos,
	const CMessageHeader::MessageMagic &messageStart) const;
	bool
	UndoWriteToDisk(const CBlockUndo &blockundo, FlatFilePos &pos,
	const BlockHash &hashBlock,
	const CMessageHeader::MessageMagic &messageStart) const;

	/**
	* Calculate the block/rev files to delete based on height specified
	* by user with RPC command pruneblockchain
	*/
	void FindFilesToPruneManual(std::set<int> &setFilesToPrune,
	int nManualPruneHeight, int chain_tip_height);

	/**
	* Prune block and undo files (blk???.dat and undo???.dat) so that the disk
	* space used is less than a user-defined target. The user sets the target
	* (in MB) on the command line or in config file. This will be run on
	* startup and whenever new space is allocated in a block or undo file,
	* staying below the target. Changing back to unpruned requires a reindex
	* (which in this case means the blockchain must be re-downloaded.)
	*
	* Pruning functions are called from FlushStateToDisk when the
	* m_check_for_pruning flag has been set. Block and undo files are deleted
	* in lock-step (when blk00003.dat is deleted, so is rev00003.dat.) Pruning
	* cannot take place until the longest chain is at least a certain length
	* (CChainParams::nPruneAfterHeight). Pruning will never delete a block
	* within a defined distance (currently 288) from the active chain's tip.
	* The block index is updated by unsetting HAVE_DATA and HAVE_UNDO for any
	* blocks that were stored in the deleted files. A db flag records the fact
	* that at least some block files have been pruned.
	*
	* @param[out] setFilesToPrune The set of file indices that can be
	* unlinked will be returned
	*/
	void FindFilesToPrune(std::set<int> &setFilesToPrune,
	uint64_t nPruneAfterHeight, int chain_tip_height,
	int prune_height, bool is_ibd);

	RecursiveMutex cs_LastBlockFile;
	std::vector<CBlockFileInfo> m_blockfile_info;
	int m_last_blockfile = 0;

	// Track the height of the highest block in m_last_blockfile whose undo
	// data has been written. Block data is written to block files in download
	// order, but is written to undo files in validation order, which is
	// usually in order by height. To avoid wasting disk space, undo files will
	// be trimmed whenever the corresponding block file is finalized and
	// the height of the highest block written to the block file equals the
	// height of the highest block written to the undo file. This is a
	// heuristic and can sometimes preemptively trim undo files that will write
	// more data later, and sometimes fail to trim undo files that can't have
	// more data written later.
	unsigned int m_undo_height_in_last_blockfile = 0;

	/**
	* Global flag to indicate we should check to see if there are
	* block/undo files that should be deleted. Set on startup
	* or if we allocate more file space when we're in prune mode
	*/
	bool m_check_for_pruning = false;

	const bool m_prune_mode;

	/** Dirty block index entries. */
	std::set<CBlockIndex *> m_dirty_blockindex;

	/** Dirty block file entries. */
	std::set<int> m_dirty_fileinfo;

	/**
	* Map from external index name to oldest block that must not be pruned.
	*
	* @note Internally, only blocks at height
	* (height_first - PRUNE_LOCK_BUFFER - 1) and below will be pruned,
	* but callers should avoid assuming any particular buffer size.
	*/
	std::unordered_map<std::string, PruneLockInfo>
	m_prune_locks GUARDED_BY(::cs_main);

	const kernel::BlockManagerOpts m_opts;

	public:
	using Options = kernel::BlockManagerOpts;

	explicit BlockManager(Options opts)
	: m_prune_mode{opts.prune_target > 0}, m_opts{std::move(opts)} {};

	std::atomic<bool> m_importing{false};

	BlockMap m_block_index GUARDED_BY(cs_main);

	std::vector<CBlockIndex *> GetAllBlockIndices()
	EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

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

	std::unique_ptr<CBlockTreeDB> m_block_tree_db GUARDED_BY(::cs_main);

	bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
	bool LoadBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	/**
	* Remove any pruned block & undo files that are still on disk.
	* This could happen on some systems if the file was still being read while
	* unlinked, or if we crash before unlinking.
	*/
	void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	CBlockIndex *AddToBlockIndex(const CBlockHeader &block,
	CBlockIndex *&best_header)
	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);

	//! Mark one block file as pruned (modify associated database entries)
	void PruneOneBlockFile(const int fileNumber)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

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

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

	bool WriteUndoDataForBlock(const CBlockUndo &blockundo,
	BlockValidationState &state, CBlockIndex &block)
	EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	/**
	* Store block on disk. If dbp is not nullptr, then it provides the known
	* position of the block within a block file on disk.
	*/
	FlatFilePos SaveBlockToDisk(const CBlock &block, int nHeight,
	const FlatFilePos *dbp);

	/** Whether running in -prune mode. */
	[[nodiscard]] bool IsPruneMode() const { return m_prune_mode; }

	/** Attempt to stay below this number of bytes of block files. */
	[[nodiscard]] uint64_t GetPruneTarget() const {
	return m_opts.prune_target;
	}
	static constexpr auto PRUNE_TARGET_MANUAL{
	std::numeric_limits<uint64_t>::max()};

	[[nodiscard]] bool LoadingBlocks() const { return m_importing \|\| fReindex; }

	[[nodiscard]] bool StopAfterBlockImport() const {
	return m_opts.stop_after_block_import;
	}

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

	//! Returns last CBlockIndex* that is a checkpoint
	const CBlockIndex *GetLastCheckpoint(const CCheckpointData &data)
	EXCLUSIVE_LOCKS_REQUIRED(cs_main);

	//! Find the first block that is not pruned
	const CBlockIndex *GetFirstStoredBlock(const CBlockIndex &start_block)
	EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	/** True if any block files have ever been pruned. */
	bool m_have_pruned = false;

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

	//! Create or update a prune lock identified by its name
	void UpdatePruneLock(const std::string &name,
	const PruneLockInfo &lock_info)
	EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

	/** Open a block file (blk?????.dat) */
	FILE *OpenBlockFile(const FlatFilePos &pos, bool fReadOnly = false) const;

	/** Translation to a filesystem path. */
	fs::path GetBlockPosFilename(const FlatFilePos &pos) const;

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

	/** Functions for disk access for blocks */
	bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos) const;
	bool ReadBlockFromDisk(CBlock &block, const CBlockIndex &index) const;
	bool UndoReadFromDisk(CBlockUndo &blockundo,
	const CBlockIndex &index) const;

	/** Functions for disk access for txs */
	bool ReadTxFromDisk(CMutableTransaction &tx, const FlatFilePos &pos) const;
	bool ReadTxUndoFromDisk(CTxUndo &tx, const FlatFilePos &pos) const;

	void CleanupBlockRevFiles() const;
	};

	void ThreadImport(ChainstateManager &chainman,
	avalanche::Processor *const avalanche,
	std::vector<fs::path> vImportFiles,
	const fs::path &mempool_path);
	} // namespace node

	#endif // BITCOIN_NODE_BLOCKSTORAGE_H
	diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
	index 1edc351f3..1ba3dcfb5 100644
	--- a/src/test/util/setup_common.cpp
	+++ b/src/test/util/setup_common.cpp
	@@ -1,660 +1,661 @@
	// 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 <kernel/mempool_entry.h>
	#include <kernel/validation_cache_sizes.h>

	#include <addrman.h>
	#include <banman.h>
	#include <chainparams.h>
	#include <common/system.h>
	#include <config.h>
	#include <consensus/consensus.h>
	#include <consensus/merkle.h>
	#include <consensus/validation.h>
	#include <crypto/sha256.h>
	#include <init.h>
	#include <interfaces/chain.h>
	#include <logging.h>
	#include <mempool_args.h>
	#include <net.h>
	#include <net_processing.h>
	#include <node/blockstorage.h>
	#include <node/chainstate.h>
	#include <node/chainstatemanager_args.h>
	#include <node/context.h>
	#include <node/kernel_notifications.h>
	#include <node/miner.h>
	#include <node/peerman_args.h>
	#include <node/validation_cache_args.h>
	#include <noui.h>
	#include <pow/pow.h>
	#include <random.h>
	#include <rpc/blockchain.h>
	#include <rpc/register.h>
	#include <rpc/server.h>
	#include <scheduler.h>
	#include <script/script_error.h>
	#include <script/scriptcache.h>
	#include <script/sigcache.h>
	#include <shutdown.h>
	#include <streams.h>
	#include <timedata.h>
	#include <txdb.h>
	#include <txmempool.h>
	#include <util/strencodings.h>
	#include <util/thread.h>
	#include <util/threadnames.h>
	#include <util/time.h>
	#include <util/translation.h>
	#include <util/vector.h>
	#include <validation.h>
	#include <validationinterface.h>
	#include <walletinitinterface.h>

	#include <test/util/mining.h>
	#include <test/util/random.h>

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

	using kernel::ValidationCacheSizes;
	using node::ApplyArgsManOptions;
	using node::BlockAssembler;
	using node::BlockManager;
	using node::CalculateCacheSizes;
	using node::fReindex;
	using node::KernelNotifications;
	using node::LoadChainstate;
	using node::NodeContext;
	using node::VerifyLoadedChainstate;

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

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

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

	std::vector<const char *> fixture_extra_args{};

	BasicTestingSetup::BasicTestingSetup(
	const std::string &chainName, const std::vector<const char *> &extra_args)
	: m_path_root{fsbridge::GetTempDirectoryPath() /
	"test_common_" PACKAGE_NAME /
	g_insecure_rand_ctx_temp_path.rand256().ToString()},
	m_args{} {
	// clang-format off
	std::vector<const char *> arguments = Cat(
	{
	"dummy",
	"-printtoconsole=0",
	"-logsourcelocations",
	"-logtimemicros",
	"-debug",
	"-debugexclude=libevent",
	"-debugexclude=leveldb",
	},
	extra_args);
	// clang-format on
	arguments = Cat(arguments, fixture_extra_args);
	auto &config = const_cast<Config &>(GetConfig());
	SetMockTime(0);
	fs::create_directories(m_path_root);
	m_args.ForceSetArg("-datadir", fs::PathToString(m_path_root));
	gArgs.ForceSetArg("-datadir", fs::PathToString(m_path_root));
	gArgs.ClearPathCache();
	{
	SetupServerArgs(m_node);
	std::string error;
	const bool success{m_node.args->ParseParameters(
	arguments.size(), arguments.data(), error)};
	assert(success);
	assert(error.empty());
	}
	SelectParams(chainName);
	SeedInsecureRand();
	InitLogging(*m_node.args);
	AppInitParameterInteraction(config, *m_node.args);
	LogInstance().StartLogging();
	SHA256AutoDetect();
	ECC_Start();
	SetupEnvironment();
	SetupNetworking();

	ValidationCacheSizes validation_cache_sizes{};
	ApplyArgsManOptions(*m_node.args, validation_cache_sizes);
	Assert(InitSignatureCache(validation_cache_sizes.signature_cache_bytes));
	Assert(InitScriptExecutionCache(
	validation_cache_sizes.script_execution_cache_bytes));

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

	static bool noui_connected = false;
	if (!noui_connected) {
	noui_connect();
	noui_connected = true;
	}
	+ node::g_indexes_ready_to_sync = true;
	}

	BasicTestingSetup::~BasicTestingSetup() {
	LogInstance().DisconnectTestLogger();
	fs::remove_all(m_path_root);
	gArgs.ClearArgs();
	ECC_Stop();
	}
	CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node) {
	CTxMemPool::Options mempool_opts{
	// Default to always checking mempool regardless of
	// chainparams.DefaultConsistencyChecks for tests
	.check_ratio = 1,
	};
	const auto err{ApplyArgsManOptions(
	*node.args, ::GetConfig().GetChainParams(), mempool_opts)};
	Assert(!err);
	return mempool_opts;
	}

	ChainTestingSetup::ChainTestingSetup(
	const std::string &chainName, const std::vector<const char *> &extra_args)
	: BasicTestingSetup(chainName, extra_args) {
	const Config &config = GetConfig();

	// We have to run a scheduler thread to prevent ActivateBestChain
	// from blocking due to queue overrun.
	m_node.scheduler = std::make_unique<CScheduler>();
	m_node.scheduler->m_service_thread =
	std::thread(util::TraceThread, "scheduler",
	[&] { m_node.scheduler->serviceQueue(); });
	GetMainSignals().RegisterBackgroundSignalScheduler(*m_node.scheduler);

	m_node.mempool =
	std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node));

	m_cache_sizes = CalculateCacheSizes(m_args);

	m_node.notifications = std::make_unique<KernelNotifications>();

	ChainstateManager::Options chainman_opts{
	.config = config,
	.datadir = m_args.GetDataDirNet(),
	.adjusted_time_callback = GetAdjustedTime,
	.check_block_index = true,
	.notifications = *m_node.notifications,
	};
	ApplyArgsManOptions(*m_node.args, chainman_opts);
	const BlockManager::Options blockman_opts{
	.chainparams = chainman_opts.config.GetChainParams(),
	.blocks_dir = m_args.GetBlocksDirPath(),
	};
	m_node.chainman =
	std::make_unique<ChainstateManager>(chainman_opts, blockman_opts);
	m_node.chainman->m_blockman.m_block_tree_db =
	std::make_unique<CBlockTreeDB>(DBParams{
	.path = m_args.GetDataDirNet() / "blocks" / "index",
	.cache_bytes = static_cast<size_t>(m_cache_sizes.block_tree_db),
	.memory_only = true});
	// Call Upgrade on the block database so that the version field is set,
	// else LoadBlockIndexGuts will fail (see D8319).
	m_node.chainman->m_blockman.m_block_tree_db->Upgrade();

	constexpr int script_check_threads = 2;
	StartScriptCheckWorkerThreads(script_check_threads);
	}

	ChainTestingSetup::~ChainTestingSetup() {
	if (m_node.scheduler) {
	m_node.scheduler->stop();
	}
	StopScriptCheckWorkerThreads();
	GetMainSignals().FlushBackgroundCallbacks();
	GetMainSignals().UnregisterBackgroundSignalScheduler();
	m_node.connman.reset();
	m_node.banman.reset();
	m_node.addrman.reset();
	m_node.args = nullptr;
	m_node.mempool.reset();
	m_node.scheduler.reset();
	m_node.chainman.reset();
	}

	void TestingSetup::LoadVerifyActivateChainstate() {
	auto &chainman{*Assert(m_node.chainman)};
	node::ChainstateLoadOptions options;
	options.mempool = Assert(m_node.mempool.get());
	options.block_tree_db_in_memory = m_block_tree_db_in_memory;
	options.coins_db_in_memory = m_coins_db_in_memory;
	options.reindex = node::fReindex;
	options.reindex_chainstate =
	m_args.GetBoolArg("-reindex-chainstate", false);
	options.prune = chainman.m_blockman.IsPruneMode();
	options.check_blocks =
	m_args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
	options.check_level = m_args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
	options.require_full_verification =
	m_args.IsArgSet("-checkblocks") \|\| m_args.IsArgSet("-checklevel");
	auto [status, error] = LoadChainstate(chainman, m_cache_sizes, options);
	assert(status == node::ChainstateLoadStatus::SUCCESS);

	std::tie(status, error) = VerifyLoadedChainstate(chainman, options);
	assert(status == node::ChainstateLoadStatus::SUCCESS);

	BlockValidationState state;
	if (!chainman.ActiveChainstate().ActivateBestChain(state)) {
	throw std::runtime_error(
	strprintf("ActivateBestChain failed. (%s)", state.ToString()));
	}
	}

	TestingSetup::TestingSetup(const std::string &chainName,
	const std::vector<const char *> &extra_args,
	const bool coins_db_in_memory,
	const bool block_tree_db_in_memory)
	: ChainTestingSetup(chainName, extra_args),
	m_coins_db_in_memory(coins_db_in_memory),
	m_block_tree_db_in_memory(block_tree_db_in_memory) {
	const Config &config = GetConfig();

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

	LoadVerifyActivateChainstate();

	m_node.addrman = std::make_unique<AddrMan>(
	/* asmap= / std::vector<bool>(), / consistency_check_ratio= */ 0);
	m_node.banman = std::make_unique<BanMan>(
	m_args.GetDataDirBase() / "banlist.dat", config.GetChainParams(),
	nullptr, DEFAULT_MISBEHAVING_BANTIME);
	// Deterministic randomness for tests.
	m_node.connman =
	std::make_unique<CConnman>(config, 0x1337, 0x1337, *m_node.addrman);
	PeerManager::Options peerman_opts;
	ApplyArgsManOptions(*m_node.args, peerman_opts);
	peerman_opts.deterministic_rng = true;
	m_node.peerman = PeerManager::make(
	m_node.connman, m_node.addrman, m_node.banman.get(), *m_node.chainman,
	m_node.mempool, /avalanche=*/nullptr, peerman_opts);
	{
	CConnman::Options options;
	options.m_msgproc.push_back(m_node.peerman.get());
	m_node.connman->Init(options);
	}
	}

	TestChain100Setup::TestChain100Setup(
	const std::string &chain_name, const std::vector<const char *> &extra_args,
	const bool coins_db_in_memory, const bool block_tree_db_in_memory)
	: TestingSetup{CBaseChainParams::REGTEST, extra_args, coins_db_in_memory,
	block_tree_db_in_memory} {
	SetMockTime(1598887952);
	constexpr std::array<uint8_t, 32> vchKey = {
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
	coinbaseKey.Set(vchKey.begin(), vchKey.end(), true);

	// Generate a 100-block chain:
	this->mineBlocks(COINBASE_MATURITY);

	{
	LOCK(::cs_main);
	assert(
	m_node.chainman->ActiveTip()->GetBlockHash().ToString() ==
	"5afde277a26b6f36aee8f61a1dbf755587e1c6be63e654a88abe2a1ff0fbfb05");
	}
	}

	void TestChain100Setup::mineBlocks(int num_blocks) {
	CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
	<< OP_CHECKSIG;
	for (int i = 0; i < num_blocks; i++) {
	std::vector<CMutableTransaction> noTxns;
	CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
	SetMockTime(GetTime() + 1);
	m_coinbase_txns.push_back(b.vtx[0]);
	}
	}

	CBlock
	TestChain100Setup::CreateBlock(const std::vector<CMutableTransaction> &txns,
	const CScript &scriptPubKey,
	Chainstate &chainstate) {
	const Config &config = GetConfig();
	CBlock block = BlockAssembler{config, chainstate, nullptr}
	.CreateNewBlock(scriptPubKey)
	->block;

	Assert(block.vtx.size() == 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();
	});

	createCoinbaseAndMerkleRoot(&block,
	WITH_LOCK(m_node.chainman->GetMutex(),
	return m_node.chainman->ActiveTip()),
	config.GetMaxBlockSize());

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

	return block;
	}

	CBlock TestChain100Setup::CreateAndProcessBlock(
	const std::vector<CMutableTransaction> &txns, const CScript &scriptPubKey,
	Chainstate *chainstate) {
	if (!chainstate) {
	chainstate = &Assert(m_node.chainman)->ActiveChainstate();
	}

	const CBlock block = this->CreateBlock(txns, scriptPubKey, *chainstate);
	std::shared_ptr<const CBlock> shared_pblock =
	std::make_shared<const CBlock>(block);
	Assert(m_node.chainman)
	->ProcessNewBlock(shared_pblock, true, true, nullptr);

	return block;
	}

	CMutableTransaction TestChain100Setup::CreateValidMempoolTransaction(
	CTransactionRef input_transaction, int input_vout, int input_height,
	CKey input_signing_key, CScript output_destination, Amount output_amount,
	bool submit) {
	// Transaction we will submit to the mempool
	CMutableTransaction mempool_txn;

	// Create an input
	COutPoint outpoint_to_spend(input_transaction->GetId(), input_vout);
	CTxIn input(outpoint_to_spend);
	mempool_txn.vin.push_back(input);

	// Create an output
	CTxOut output(output_amount, output_destination);
	mempool_txn.vout.push_back(output);

	// Sign the transaction
	// - Add the signing key to a keystore
	FillableSigningProvider keystore;
	keystore.AddKey(input_signing_key);
	// - Populate a CoinsViewCache with the unspent output
	CCoinsView coins_view;
	CCoinsViewCache coins_cache(&coins_view);
	AddCoins(coins_cache, *input_transaction.get(), input_height);
	// - Use GetCoin to properly populate utxo_to_spend,
	Coin utxo_to_spend;
	assert(coins_cache.GetCoin(outpoint_to_spend, utxo_to_spend));
	// - Then add it to a map to pass in to SignTransaction
	std::map<COutPoint, Coin> input_coins;
	input_coins.insert({outpoint_to_spend, utxo_to_spend});
	// - Default signature hashing type
	SigHashType nHashType = SigHashType().withForkId();
	std::map<int, std::string> input_errors;
	assert(SignTransaction(mempool_txn, &keystore, input_coins, nHashType,
	input_errors));

	// If submit=true, add transaction to the mempool.
	if (submit) {
	LOCK(cs_main);
	const MempoolAcceptResult result = m_node.chainman->ProcessTransaction(
	MakeTransactionRef(mempool_txn));
	assert(result.m_result_type == MempoolAcceptResult::ResultType::VALID);
	}

	return mempool_txn;
	}

	TestChain100Setup::~TestChain100Setup() {
	SetMockTime(0);
	}

	std::vector<CTransactionRef>
	TestChain100Setup::PopulateMempool(FastRandomContext &det_rand,
	size_t num_transactions, bool submit) {
	std::vector<CTransactionRef> mempool_transactions;
	std::deque<std::pair<COutPoint, Amount>> unspent_prevouts;
	std::transform(m_coinbase_txns.begin(), m_coinbase_txns.end(),
	std::back_inserter(unspent_prevouts), [](const auto &tx) {
	return std::make_pair(COutPoint(tx->GetId(), 0),
	tx->vout[0].nValue);
	});
	while (num_transactions > 0 && !unspent_prevouts.empty()) {
	// The number of inputs and outputs are random, between 1 and 24.
	CMutableTransaction mtx = CMutableTransaction();
	const size_t num_inputs = det_rand.randrange(24) + 1;
	Amount total_in{Amount::zero()};
	for (size_t n{0}; n < num_inputs; ++n) {
	if (unspent_prevouts.empty()) {
	break;
	}
	const auto &[prevout, amount] = unspent_prevouts.front();
	mtx.vin.push_back(CTxIn(prevout, CScript()));
	total_in += amount;
	unspent_prevouts.pop_front();
	}
	const size_t num_outputs = det_rand.randrange(24) + 1;
	// Approximately 1000sat "fee," equal output amounts.
	const Amount amount_per_output =
	(total_in - 1000 * SATOSHI) / int(num_outputs);
	for (size_t n{0}; n < num_outputs; ++n) {
	CScript spk = CScript() << CScriptNum(num_transactions + n);
	mtx.vout.push_back(CTxOut(amount_per_output, spk));
	}
	CTransactionRef ptx = MakeTransactionRef(mtx);
	mempool_transactions.push_back(ptx);
	if (amount_per_output > 2000 * SATOSHI) {
	// If the value is high enough to fund another transaction + fees,
	// keep track of it so it can be used to build a more complex
	// transaction graph. Insert randomly into unspent_prevouts for
	// extra randomness in the resulting structures.
	for (size_t n{0}; n < num_outputs; ++n) {
	unspent_prevouts.push_back(std::make_pair(
	COutPoint(ptx->GetId(), n), amount_per_output));
	std::swap(unspent_prevouts.back(),
	unspent_prevouts[det_rand.randrange(
	unspent_prevouts.size())]);
	}
	}
	if (submit) {
	LOCK2(m_node.mempool->cs, cs_main);
	LockPoints lp;
	m_node.mempool->addUnchecked(
	CTxMemPoolEntryRef::make(ptx, 1000 * SATOSHI, 0, 1, 4, lp));
	}
	--num_transactions;
	}
	return mempool_transactions;
	}

	void TestChain100Setup::MockMempoolMinFee(const CFeeRate &target_feerate) {
	LOCK2(cs_main, m_node.mempool->cs);
	// Transactions in the mempool will affect the new minimum feerate.
	assert(m_node.mempool->size() == 0);
	// The target feerate cannot be too low...
	// ...otherwise the transaction's feerate will need to be negative.
	assert(target_feerate > MEMPOOL_FULL_FEE_INCREMENT);
	// ...otherwise this is not meaningful. The feerate policy uses the maximum
	// of both feerates.
	assert(target_feerate > m_node.mempool->m_min_relay_feerate);

	// Manually create an invalid transaction. Manually set the fee in the
	// CTxMemPoolEntry to achieve the exact target feerate.
	CMutableTransaction mtx = CMutableTransaction();
	mtx.vin.push_back(CTxIn{COutPoint{TxId{g_insecure_rand_ctx.rand256()}, 0}});
	mtx.vout.push_back(CTxOut(
	1 * COIN, GetScriptForDestination(ScriptHash(CScript() << OP_TRUE))));
	const auto tx{MakeTransactionRef(mtx)};
	// The new mempool min feerate is equal to the removed package's feerate +
	// incremental feerate.
	const auto tx_fee =
	target_feerate.GetFee(GetVirtualTransactionSize(*tx)) -
	MEMPOOL_FULL_FEE_INCREMENT.GetFee(GetVirtualTransactionSize(*tx));
	TestMemPoolEntryHelper entryHelper;
	auto entry =
	entryHelper.Fee(tx_fee).Time(0).Height(1).SigChecks(1).FromTx(tx);
	m_node.mempool->addUnchecked(std::move(entry));

	m_node.mempool->TrimToSize(0);
	assert(m_node.mempool->GetMinFee() == target_feerate);
	}

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

	CTxMemPoolEntryRef
	TestMemPoolEntryHelper::FromTx(const CTransactionRef &tx) const {
	CTxMemPoolEntry ret(tx, nFee, nTime, nHeight, nSigChecks, LockPoints());
	ret.SetEntryId(entryId);
	return CTxMemPoolEntryRef::make(std::move(ret));
	}

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

	DummyConfig::DummyConfig()
	: chainParams(CreateChainParams(ArgsManager{}, CBaseChainParams::REGTEST)) {
	}

	DummyConfig::DummyConfig(std::string net)
	: chainParams(CreateChainParams(ArgsManager{}, net)) {}
	diff --git a/test/functional/feature_coinstatsindex.py b/test/functional/feature_coinstatsindex.py
	index 0ceb51ee9..bdb9d2cf6 100644
	--- a/test/functional/feature_coinstatsindex.py
	+++ b/test/functional/feature_coinstatsindex.py
	@@ -1,324 +1,369 @@
	# Copyright (c) 2020 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.
	"""Test coinstatsindex across nodes.

	Test that the values returned by gettxoutsetinfo are consistent
	between a node running the coinstatsindex and a node without
	the index.
	"""

	from decimal import Decimal

	from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase
	from test_framework.messages import XEC, CTxOut, ToHex
	from test_framework.script import OP_FALSE, OP_RETURN, CScript
	from test_framework.test_framework import BitcoinTestFramework
	from test_framework.util import assert_equal, assert_raises_rpc_error
	from test_framework.wallet import MiniWallet, getnewdestination


	class CoinStatsIndexTest(BitcoinTestFramework):
	def set_test_params(self):
	self.setup_clean_chain = True
	self.num_nodes = 2
	self.supports_cli = False
	self.extra_args = [
	[
	- "-automaticunparking=1",
	+ "-noparkdeepreorg",
	],
	[
	"-coinstatsindex",
	],
	]

	def run_test(self):
	self.wallet = MiniWallet(self.nodes[0])
	self._test_coin_stats_index()
	self._test_use_index_option()
	self._test_reorg_index()
	self._test_index_rejects_hash_serialized()
	+ self._test_init_index_after_reorg()

	def block_sanity_check(self, block_info):
	block_subsidy = 50_000_000
	assert_equal(
	block_info["prevout_spent"] + block_subsidy,
	block_info["new_outputs_ex_coinbase"]
	+ block_info["coinbase"]
	+ block_info["unspendable"],
	)

	+ def sync_index_node(self):
	+ self.wait_until(
	+ lambda: self.nodes[1].getindexinfo()["coinstatsindex"]["synced"] is True
	+ )
	+
	def _test_coin_stats_index(self):
	node = self.nodes[0]
	index_node = self.nodes[1]
	# Both none and muhash options allow the usage of the index
	index_hash_options = ["none", "muhash"]

	# Generate a normal transaction and mine it
	self.generate(self.wallet, COINBASE_MATURITY + 1)
	self.wallet.send_self_transfer(from_node=node)
	self.generate(node, 1)

	self.log.info(
	"Test that gettxoutsetinfo() output is consistent with or without"
	" coinstatsindex option"
	)
	res0 = node.gettxoutsetinfo("none")

	# The fields 'disk_size' and 'transactions' do not exist on the index
	del res0["disk_size"], res0["transactions"]

	for hash_option in index_hash_options:
	res1 = index_node.gettxoutsetinfo(hash_option)
	# The fields 'block_info' and 'total_unspendable_amount' only exist
	# on the index
	del res1["block_info"], res1["total_unspendable_amount"]
	res1.pop("muhash", None)

	# Everything left should be the same
	assert_equal(res1, res0)

	self.log.info(
	"Test that gettxoutsetinfo() can get fetch data on specific "
	"heights with index"
	)

	# Generate a new tip
	self.generate(node, 5)

	for hash_option in index_hash_options:
	# Fetch old stats by height
	res2 = index_node.gettxoutsetinfo(hash_option, 102)
	del res2["block_info"], res2["total_unspendable_amount"]
	res2.pop("muhash", None)
	assert_equal(res0, res2)

	# Fetch old stats by hash
	res3 = index_node.gettxoutsetinfo(hash_option, res0["bestblock"])
	del res3["block_info"], res3["total_unspendable_amount"]
	res3.pop("muhash", None)
	assert_equal(res0, res3)

	# It does not work without coinstatsindex
	assert_raises_rpc_error(
	-8,
	"Querying specific block heights requires coinstatsindex",
	node.gettxoutsetinfo,
	hash_option,
	102,
	)

	self.log.info("Test gettxoutsetinfo() with index and verbose flag")

	for hash_option in index_hash_options:
	# Genesis block is unspendable
	res4 = index_node.gettxoutsetinfo(hash_option, 0)
	assert_equal(res4["total_unspendable_amount"], 50_000_000)
	assert_equal(
	res4["block_info"],
	{
	"unspendable": 50_000_000,
	"prevout_spent": 0,
	"new_outputs_ex_coinbase": 0,
	"coinbase": 0,
	"unspendables": {
	"genesis_block": 50_000_000,
	"bip30": 0,
	"scripts": 0,
	"unclaimed_rewards": 0,
	},
	},
	)
	self.block_sanity_check(res4["block_info"])

	# Test an older block height that included a normal tx
	res5 = index_node.gettxoutsetinfo(hash_option, 102)
	assert_equal(res5["total_unspendable_amount"], 50_000_000)
	assert_equal(
	res5["block_info"],
	{
	"unspendable": 0,
	"prevout_spent": 50_000_000,
	"new_outputs_ex_coinbase": Decimal("49999700.00"),
	"coinbase": Decimal("50000300.00"),
	"unspendables": {
	"genesis_block": 0,
	"bip30": 0,
	"scripts": 0,
	"unclaimed_rewards": 0,
	},
	},
	)
	self.block_sanity_check(res5["block_info"])

	# Generate and send a normal tx with two outputs
	tx1_txid, tx1_vout = self.wallet.send_to(
	from_node=node,
	scriptPubKey=self.wallet.get_scriptPubKey(),
	amount=21_000_000 * XEC,
	)

	# Find the right position of the 21 MegXEC output
	tx1_out_21 = self.wallet.get_utxo(txid=tx1_txid, vout=tx1_vout)

	# Generate and send another tx with an OP_RETURN output (which is
	# unspendable)
	tx2 = self.wallet.create_self_transfer(utxo_to_spend=tx1_out_21)["tx"]
	tx2.vout = [
	CTxOut(int(20_990_000 * XEC), CScript([OP_RETURN] + [OP_FALSE] * 50))
	]
	tx2_hex = tx2.serialize().hex()
	self.nodes[0].sendrawtransaction(tx2_hex)

	# Include both txs in a block
	self.generate(self.nodes[0], 1)

	for hash_option in index_hash_options:
	# Check all amounts were registered correctly
	res6 = index_node.gettxoutsetinfo(hash_option, 108)
	assert_equal(res6["total_unspendable_amount"], Decimal("70990000.00"))
	assert_equal(
	res6["block_info"],
	{
	"unspendable": Decimal("20990000.00"),
	"prevout_spent": 71_000_000,
	"new_outputs_ex_coinbase": Decimal("49999990.00"),
	"coinbase": Decimal("50010010.00"),
	"unspendables": {
	"genesis_block": 0,
	"bip30": 0,
	"scripts": Decimal("20990000.00"),
	"unclaimed_rewards": 0,
	},
	},
	)
	self.block_sanity_check(res6["block_info"])

	# Create a coinbase that does not claim full subsidy and also
	# has two outputs
	cb = create_coinbase(109, nValue=35_000_000)
	cb.vout.append(CTxOut(5_000_000 * XEC, CScript([OP_FALSE])))
	cb.rehash()

	# Generate a block that includes previous coinbase
	tip = self.nodes[0].getbestblockhash()
	block_time = self.nodes[0].getblock(tip)["time"] + 1
	block = create_block(int(tip, 16), cb, block_time)
	block.solve()
	self.nodes[0].submitblock(ToHex(block))
	self.sync_all()

	for hash_option in index_hash_options:
	res7 = index_node.gettxoutsetinfo(hash_option, 109)
	assert_equal(res7["total_unspendable_amount"], Decimal("80990000.00"))
	assert_equal(
	res7["block_info"],
	{
	"unspendable": 10_000_000,
	"prevout_spent": 0,
	"new_outputs_ex_coinbase": 0,
	"coinbase": 40_000_000,
	"unspendables": {
	"genesis_block": 0,
	"bip30": 0,
	"scripts": 0,
	"unclaimed_rewards": 10_000_000,
	},
	},
	)
	self.block_sanity_check(res7["block_info"])

	self.log.info("Test that the index is robust across restarts")

	res8 = index_node.gettxoutsetinfo("muhash")
	self.restart_node(1, extra_args=self.extra_args[1])
	res9 = index_node.gettxoutsetinfo("muhash")
	assert_equal(res8, res9)

	self.generate(index_node, 1, sync_fun=self.no_op)
	res10 = index_node.gettxoutsetinfo("muhash")
	assert res8["txouts"] < res10["txouts"]

	+ self.log.info("Test that the index works with -reindex")
	+
	+ self.restart_node(1, extra_args=["-coinstatsindex", "-reindex"])
	+ self.sync_index_node()
	+ res11 = index_node.gettxoutsetinfo("muhash")
	+ assert_equal(res11, res10)
	+
	+ self.log.info("Test that the index works with -reindex-chainstate")
	+
	+ self.restart_node(1, extra_args=["-coinstatsindex", "-reindex-chainstate"])
	+ self.sync_index_node()
	+ res12 = index_node.gettxoutsetinfo("muhash")
	+ assert_equal(res12, res10)
	+
	def _test_use_index_option(self):
	self.log.info("Test use_index option for nodes running the index")

	self.connect_nodes(0, 1)
	self.nodes[0].waitforblockheight(110)
	res = self.nodes[0].gettxoutsetinfo("muhash")
	option_res = self.nodes[1].gettxoutsetinfo(
	hash_type="muhash", hash_or_height=None, use_index=False
	)
	del res["disk_size"], option_res["disk_size"]
	assert_equal(res, option_res)

	def _test_reorg_index(self):
	self.log.info("Test that index can handle reorgs")

	# Generate two block, let the index catch up, then invalidate the
	# blocks
	index_node = self.nodes[1]
	reorg_blocks = self.generatetoaddress(index_node, 2, getnewdestination()[2])
	reorg_block = reorg_blocks[1]
	+ self.sync_index_node()
	res_invalid = index_node.gettxoutsetinfo("muhash")
	index_node.invalidateblock(reorg_blocks[0])
	assert_equal(index_node.gettxoutsetinfo("muhash")["height"], 110)

	# Add two new blocks
	block = self.generate(index_node, 2, sync_fun=self.no_op)[1]
	res = index_node.gettxoutsetinfo(
	hash_type="muhash", hash_or_height=None, use_index=False
	)

	# Test that the result of the reorged block is not returned for its old
	# block height
	res2 = index_node.gettxoutsetinfo(hash_type="muhash", hash_or_height=112)
	assert_equal(res["bestblock"], block)
	assert_equal(res["muhash"], res2["muhash"])
	assert res["muhash"] != res_invalid["muhash"]

	# Test that requesting reorged out block by hash is still returning
	# correct results
	res_invalid2 = index_node.gettxoutsetinfo(
	hash_type="muhash", hash_or_height=reorg_block
	)
	assert_equal(res_invalid2["muhash"], res_invalid["muhash"])
	assert res["muhash"] != res_invalid2["muhash"]

	# Add another block, so we don't depend on reconsiderblock remembering
	# which blocks were touched by invalidateblock
	self.generate(index_node, 1)

	# Ensure that removing and re-adding blocks yields consistent results
	block = index_node.getblockhash(99)
	index_node.invalidateblock(block)
	index_node.reconsiderblock(block)
	res3 = index_node.gettxoutsetinfo(hash_type="muhash", hash_or_height=112)
	assert_equal(res2, res3)

	def _test_index_rejects_hash_serialized(self):
	self.log.info(
	"Test that the rpc raises if the legacy hash is passed with the index"
	)

	msg = "hash_serialized hash type cannot be queried for a specific block"
	assert_raises_rpc_error(
	-8,
	msg,
	self.nodes[1].gettxoutsetinfo,
	hash_type="hash_serialized",
	hash_or_height=111,
	)

	for use_index in {True, False, None}:
	assert_raises_rpc_error(
	-8,
	msg,
	self.nodes[1].gettxoutsetinfo,
	hash_type="hash_serialized",
	hash_or_height=111,
	use_index=use_index,
	)

	+ def _test_init_index_after_reorg(self):
	+ self.log.info("Test a reorg while the index is deactivated")
	+ index_node = self.nodes[1]
	+ block = self.nodes[0].getbestblockhash()
	+ self.generate(index_node, 2, sync_fun=self.no_op)
	+ self.sync_index_node()
	+
	+ # Restart without index
	+ self.restart_node(1, extra_args=[])
	+ self.connect_nodes(0, 1)
	+ index_node.invalidateblock(block)
	+ self.generatetoaddress(index_node, 5, getnewdestination()[2])
	+ res = index_node.gettxoutsetinfo(
	+ hash_type="muhash", hash_or_height=None, use_index=False
	+ )
	+
	+ # Restart with index that still has its best block on the old chain
	+ self.restart_node(1, extra_args=self.extra_args[1])
	+ self.sync_index_node()
	+ res1 = index_node.gettxoutsetinfo(
	+ hash_type="muhash", hash_or_height=None, use_index=True
	+ )
	+ assert_equal(res["muhash"], res1["muhash"])
	+

	if __name__ == "__main__":
	CoinStatsIndexTest().main()

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 12:10 (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187794
Default Alt Text: (238 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions