init.cpp

Go to the documentation of this file.

// 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/checks.h>
#include <kernel/mempool_persist.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 <chainparamsbase.h>
#include <clientversion.h>
#include <common/args.h>
#include <common/messages.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 <kernel/caches.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 <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/chaintype.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 common::AmountErrMsg;
using common::InvalidPortErrMsg;
using common::ResolveErrMsg;
 
using kernel::DEFAULT_STOPAFTERBLOCKIMPORT;
using kernel::DumpMempool;
 
using node::ApplyArgsManOptions;
using node::BlockManager;
using node::CalculateCacheSizes;
using node::DEFAULT_PERSIST_MEMPOOL;
using node::fReindex;
using node::ImportBlocks;
using node::KernelNotifications;
using node::LoadChainstate;
using node::MempoolPath;
using node::NodeContext;
using node::ShouldPersistMempool;
using node::VerifyLoadedChainstate;
using util::Join;
using util::ReplaceAll;
 
static const bool DEFAULT_PROXYRANDOMIZE = true;
static const bool DEFAULT_REST_ENABLE = false;
static constexpr bool DEFAULT_CHRONIK = false;
static constexpr bool DEFAULT_USEASHADDR = true;
 
#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"};
 
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);
 
    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_thread_load.joinable()) {
        node.chainman->m_thread_load.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();
    node.kernel.reset();
    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__);
}
 
#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(ChainType::MAIN);
    const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
    const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
    const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
    const auto testnetChainParams =
        CreateChainParams(argsman, ChainType::TESTNET);
    const auto regtestChainParams =
        CreateChainParams(argsman, ChainType::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 2026 upgrade
        "-obolenskyactivationtime",
    };
 
    // 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_CACHE_BATCH),
        ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
        OptionsCategory::OPTIONS);
    argsman.AddArg("-dbcache=<n>",
                   strprintf("Maximum database cache size <n> MiB (minimum %d, "
                             "default: %d). Make sure you have enough RAM. In "
                             "addition, unused memory allocated to the mempool "
                             "is shared with this cache (see -maxmempool).",
                             MIN_DB_CACHE >> 20, DEFAULT_DB_CACHE >> 20),
                   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("-allowignoredconf",
                   strprintf("For backwards compatibility, treat an unused %s "
                             "file in the datadir as a warning, not an error.",
                             BITCOIN_CONF_FILENAME),
                   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_ANY, OptionsCategory::OPTIONS);
    argsman.AddArg(
        "-pid=<file>",
        strprintf("Specify pid file. Relative paths will be prefixed "
                  "by a net-specific datadir location. (default: %s)",
                  BITCOIN_PID_FILENAME),
        ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
    argsman.AddArg(
        "-prune=<n>",
        strprintf("Reduce storage requirements by enabling pruning (deleting) "
                  "of old blocks. This allows the pruneblockchain RPC to be "
                  "called to delete specific blocks and enables automatic "
                  "pruning of old blocks if a target size in MiB is provided. "
                  "This mode is incompatible with -txindex 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."
        " 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_ANY, 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_ANY | ArgsManager::DISALLOW_NEGATION |
            ArgsManager::NETWORK_ONLY,
        OptionsCategory::CHRONIK);
    argsman.AddArg("-chroniktokenindex",
                   "Enable token indexing in Chronik (default: 1)",
                   ArgsManager::ALLOW_ANY, OptionsCategory::CHRONIK);
    argsman.AddArg("-chroniklokadidindex",
                   "Enable LOKAD ID indexing in Chronik (default: 1)",
                   ArgsManager::ALLOW_ANY, OptionsCategory::CHRONIK);
    argsman.AddArg("-chronikreindex",
                   "Reindex the Chronik indexer from genesis, but leave the "
                   "other indexes untouched",
                   ArgsManager::ALLOW_ANY, 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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY, OptionsCategory::CHRONIK);
    argsman.AddArg("-chronikscripthashindex",
                   "Enable the scripthash index for the Chronik indexer "
                   "(default: 1 if chronikelectrumbind is set, 0 otherwise) ",
                   ArgsManager::ALLOW_ANY, OptionsCategory::CHRONIK);
    argsman.AddArg(
        "-chronikelectrumbind=<addr>[:port][:t|s|w|y]",
        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, 's' "
            "means TLS, 'w' means WS and 'y' means WSS. If TLS and/or WSS 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: TLS)",
            defaultBaseParams->ChronikElectrumPort(),
            testnetBaseParams->ChronikElectrumPort(),
            regtestBaseParams->ChronikElectrumPort()),
        ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION |
            ArgsManager::NETWORK_ONLY,
        OptionsCategory::CHRONIK);
    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_ANY | ArgsManager::DISALLOW_NEGATION |
            ArgsManager::NETWORK_ONLY,
        OptionsCategory::CHRONIK);
    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_ANY | ArgsManager::DISALLOW_NEGATION |
            ArgsManager::NETWORK_ONLY,
        OptionsCategory::CHRONIK);
    argsman.AddArg(
        "-chronikelectrumurl",
        "The URL to advertise to the Electrum peers. This needs to be set to "
        "the server public URL to instruct the other Electrum peers that they "
        "don't have to drop the connection. See the 'hosts' key in "
        "https://electrum-cash-protocol.readthedocs.io/en/latest/"
        "protocol-methods.html#server.features (default: 127.0.0.1).",
        ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION |
            ArgsManager::NETWORK_ONLY,
        OptionsCategory::CHRONIK);
    argsman.AddArg(
        "-chronikelectrummaxhistory",
        strprintf("Largest tx history we are willing to serve. (default: %u)",
                  chronik::DEFAULT_ELECTRUM_MAX_HISTORY),
        ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION,
        OptionsCategory::CHRONIK);
    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_ANY | ArgsManager::DISALLOW_NEGATION,
        OptionsCategory::CHRONIK);
    argsman.AddArg(
        "-chronikelectrumpeersvalidationinterval",
        strprintf(
            "The peers submitted via the Chronik Electrum server.add_peer "
            "endpoint are periodically checked for validity and are only "
            "returned after they passed the validation. This option controls "
            "the interval duration between successive peers validation "
            "processes in seconds (default: %u). Setting this value to 0 "
            "disables the peer validation completely.",
            std::chrono::duration_cast<std::chrono::seconds>(
                chronik::DEFAULT_ELECTRUM_PEER_VALIDATION_INTERVAL)
                .count()),
        ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION,
        OptionsCategory::CHRONIK);
#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",
        strprintf("Use Cash Address for destination encoding instead of legacy "
                  "base58 addresses (default: %d)",
                  DEFAULT_USEASHADDR),
        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); -noconnect 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_ANY, 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_ANY, 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);
#if HAVE_SOCKADDR_UN
    argsman.AddArg("-onion=<ip:port|path>",
                   "Use separate SOCKS5 proxy to reach peers via Tor onion "
                   "services, set -noonion to disable (default: -proxy). May "
                   "be a local file path prefixed with 'unix:'.",
                   ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
#else
    argsman.AddArg(
        "-onion=<ip:port>",
        strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
                  "onion services, set -noonion to disable (default: %s)",
                  "-proxy"),
        ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
#endif
    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_ANY, 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.",
        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);
#if HAVE_SOCKADDR_UN
    argsman.AddArg("-proxy=<ip:port|path>",
                   "Connect through SOCKS5 proxy, set -noproxy to disable "
                   "(default: disabled). May be a local file path prefixed "
                   "with 'unix:' if the proxy supports it.",
                   ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION,
                   OptionsCategory::CONNECTION);
#else
    argsman.AddArg("-proxy=<ip:port>",
                   "Connect through SOCKS5 proxy, set -noproxy to disable "
                   "(default: disabled)",
                   ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION,
                   OptionsCategory::CONNECTION);
#endif
    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_ANY, 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
    argsman.AddArg("-upnp",
                   strprintf("Use UPnP to map the listening port (default: %u)",
                             DEFAULT_UPNP),
                   ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
#else
    hidden_args.emplace_back("-upnp");
#endif
#ifdef USE_NATPMP
    argsman.AddArg(
        "-natpmp",
        strprintf("Use NAT-PMP to map the listening port (default: %u)",
                  DEFAULT_NATPMP),
        ArgsManager::ALLOW_ANY, 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_ANY | ArgsManager::DEBUG_ONLY,
                   OptionsCategory::DEBUG_TEST);
    argsman.AddArg("-mocktime=<n>",
                   "Replace actual time with " + UNIX_EPOCH_TIME +
                       " (default: 0)",
                   ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                   OptionsCategory::DEBUG_TEST);
    argsman.AddArg(
        "-maxsigcachesize=<n>",
        strprintf("Limit size of signature cache to <n> MiB (default: %u)",
                  DEFAULT_SIGNATURE_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_SCRIPT_EXECUTION_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_ANY, OptionsCategory::BLOCK_CREATION);
 
    argsman.AddArg("-blockversion=<n>",
                   "Override block version to test forking scenarios",
                   ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                   OptionsCategory::BLOCK_CREATION);
 
    argsman.AddArg("-server", "Accept command line and JSON-RPC commands",
                   ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
    argsman.AddArg("-rest",
                   strprintf("Accept public REST requests (default: %d)",
                             DEFAULT_REST_ENABLE),
                   ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
    argsman.AddArg(
        "-rpcbind=<addr>[:port]",
        "Bind to given address to listen for JSON-RPC connections. Do not "
        "expose the RPC server to untrusted networks such as the public "
        "internet! This option is ignored unless -rpcallowip is also passed. "
        "Port is optional and overrides -rpcport.  Use [host]:port notation "
        "for IPv6. This option can be specified multiple times (default: "
        "127.0.0.1 and ::1 i.e., localhost)",
        ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY |
            ArgsManager::SENSITIVE,
        OptionsCategory::RPC);
    argsman.AddArg(
        "-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_ANY, 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_ANY, OptionsCategory::OPTIONS);
    argsman.AddArg("-daemonwait",
                   strprintf("Wait for initialization to be finished before "
                             "exiting. This implies -daemon (default: %d)",
                             DEFAULT_DAEMONWAIT),
                   ArgsManager::ALLOW_ANY, 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_ANY, OptionsCategory::AVALANCHE);
    argsman.AddArg("-avalanchestakingpreconsensus",
                   strprintf("Enable the avalanche staking rewards "
                             "preconsensus feature (default: %u)",
                             DEFAULT_AVALANCHE_STAKING_PRECONSENSUS),
                   ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
    argsman.AddArg(
        "-avalanchepreconsensus",
        strprintf("Enable the avalanche preconsensus feature (default: %u)",
                  DEFAULT_AVALANCHE_PRECONSENSUS),
        ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
    argsman.AddArg("-avalanchepreconsensusmining",
                   strprintf("Enable mining only the avalanche finalized "
                             "transactions (default: %u)",
                             DEFAULT_AVALANCHE_MINING_PRECONSENSUS),
                   ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
    argsman.AddArg("-avalancheconflictingproofcooldown",
                   strprintf("Mandatory cooldown before a proof conflicting "
                             "with an already registered one can be considered "
                             "in seconds (default: %u)",
                             AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN),
                   ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION,
                   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_ANY | ArgsManager::DISALLOW_NEGATION,
                   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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY, 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_ANY | ArgsManager::DISALLOW_NEGATION,
        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_ANY, OptionsCategory::AVALANCHE);
 
    // 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);
    }
}
 
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_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, std::atomic<int> &exit_status) {
// Step 1: setup
#ifdef _MSC_VER
    // Turn off Microsoft heap dump noise
    _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
    _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
                                             OPEN_EXISTING, 0, 0));
    // Disable confusing "helpful" text message on abort, Ctrl-C
    _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
#endif
#ifdef WIN32
    // Enable Data Execution Prevention (DEP)
    SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
#endif
    if (!SetupNetworking()) {
        return InitError(Untranslated("Initializing networking failed"));
    }
 
#ifndef WIN32
    if (!args.GetBoolArg("-sysperms", false)) {
        umask(077);
    }
 
    // Clean shutdown on SIGTERM
    registerSignalHandler(SIGTERM, HandleSIGTERM);
    registerSignalHandler(SIGINT, HandleSIGTERM);
 
    // Reopen debug.log on SIGHUP
    registerSignalHandler(SIGHUP, HandleSIGHUP);
 
    // Ignore SIGPIPE, otherwise it will bring the daemon down if the client
    // closes unexpectedly
    signal(SIGPIPE, SIG_IGN);
#else
    SetConsoleCtrlHandler(consoleCtrlHandler, true);
#endif
 
    std::set_new_handler(new_handler_terminate);
 
    return true;
}
 
bool AppInitParameterInteraction(Config &config, const ArgsManager &args) {
    const CChainParams &chainparams = config.GetChainParams();
    // Step 2: parameter interactions
 
    // also see: InitParameterInteraction()
 
    // Error if network-specific options (-addnode, -connect, etc) are
    // specified in default section of config file, but not overridden
    // on the command line or in this chain's section of the config file.
    ChainType chain = args.GetChainType();
    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, ChainTypeToString(chain), ChainTypeToString(chain));
    }
 
    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);
    init::SetLoggingLevel(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);
    }
 
    // 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
    {
        kernel::Notifications 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(),
            .notifications = chainman_opts_dummy.notifications,
        };
        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.
    const fs::path &datadir = gArgs.GetDataDirNet();
    switch (util::LockDirectory(datadir, ".lock", probeOnly)) {
        case util::LockResult::ErrorLock:
            return InitError(
                strprintf(_("Cannot obtain a lock on data directory %s. %s is "
                            "probably already running."),
                          fs::PathToString(datadir), PACKAGE_NAME));
        case util::LockResult::Success:
            return true;
        case util::LockResult::ErrorWrite:
            return InitError(strprintf(
                _("Cannot write to data directory '%s'; check permissions."),
                fs::PathToString(datadir)));
    } // no default case, so the compiler can warn about missing cases
    assert(false);
}
 
bool AppInitSanityChecks(const kernel::Context &kernel) {
    // Step 4: sanity checks
    auto result{kernel::SanityChecks(kernel)};
    if (!result) {
        InitError(util::ErrorString(result));
        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()));
    }
 
    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>();
    auto &scheduler = *node.scheduler;
 
    // 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});
 
    if (args.GetBoolArg("-logratelimit", BCLog::DEFAULT_LOGRATELIMIT)) {
        LogInstance().SetRateLimiting(BCLog::LogRateLimiter::Create(
            [&scheduler](auto func, auto window) {
                scheduler.scheduleEvery(std::move(func), window);
            },
            BCLog::RATELIMIT_MAX_BYTES, BCLog::RATELIMIT_WINDOW));
    } else {
        LogInfo("Log rate limiting disabled\n");
    }
 
    GetMainSignals().RegisterBackgroundSignalScheduler(*node.scheduler);
 
    RegisterAllRPCCommands(config, rpcServer, tableRPC);
    for (const auto &client : node.chain_clients) {
        client->registerRpcs();
    }
#if ENABLE_ZMQ
    RegisterZMQRPCCommands(tableRPC);
#endif
 
    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);
    }
 
    FastRandomContext rng;
    assert(!node.banman);
    node.banman = std::make_unique<BanMan>(
        args.GetDataDirNet() / "banlist", config.GetChainParams(), &uiInterface,
        args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
    assert(!node.connman);
    node.connman = std::make_unique<CConnman>(
        config, rng.rand64(), rng.rand64(), *node.addrman,
        args.GetBoolArg("-networkactive", true));
 
    // Check port numbers
    for (const std::string port_option : {
             "-port",
             "-rpcport",
         }) {
        if (args.IsArgSet(port_option)) {
            const std::string port = args.GetArg(port_option, "");
            uint16_t n;
            if (!ParseUInt16(port, &n) || n == 0) {
                return InitError(InvalidPortErrMsg(port_option, port));
            }
        }
    }
 
    for (const std::string port_option : {
             "-i2psam",
             "-onion",
             "-proxy",
             "-rpcbind",
             "-torcontrol",
             "-whitebind",
             "-zmqpubhashblock",
             "-zmqpubhashtx",
             "-zmqpubrawblock",
             "-zmqpubrawtx",
             "-zmqpubsequence",
         }) {
        for (const std::string &socket_addr : args.GetArgs(port_option)) {
            std::string host_out;
            uint16_t port_out{0};
            if (!SplitHostPort(socket_addr, port_out, host_out)) {
#if HAVE_SOCKADDR_UN
                // Allow unix domain sockets for -proxy and -onion e.g.
                // unix:/some/file/path
                if ((port_option != "-proxy" && port_option != "-onion") ||
                    socket_addr.find(ADDR_PREFIX_UNIX) != 0) {
                    return InitError(
                        InvalidPortErrMsg(port_option, socket_addr));
                }
#else
                return InitError(InvalidPortErrMsg(port_option, socket_addr));
#endif
            }
        }
    }
 
    for (const std::string &socket_addr : args.GetArgs("-bind")) {
        std::string host_out;
        uint16_t port_out{0};
        std::string bind_socket_addr =
            socket_addr.substr(0, socket_addr.rfind('='));
        if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
            return InitError(InvalidPortErrMsg("-bind", socket_addr));
        }
    }
 
    // 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;
            assert(IsReachable(net));
            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);
 
    Proxy onion_proxy;
 
    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", "");
    if (proxyArg != "" && proxyArg != "0") {
        Proxy addrProxy;
        if (IsUnixSocketPath(proxyArg)) {
            addrProxy = Proxy(proxyArg, proxyRandomize);
        } else {
            const std::optional<CService> proxyAddr{
                Lookup(proxyArg, 9050, fNameLookup)};
            if (!proxyAddr.has_value()) {
                return InitError(strprintf(
                    _("Invalid -proxy address or hostname: '%s'"), proxyArg));
            }
 
            addrProxy = Proxy(proxyAddr.value(), proxyRandomize);
        }
 
        if (!addrProxy.IsValid()) {
            return InitError(strprintf(
                _("Invalid -proxy address or hostname: '%s'"), proxyArg));
        }
 
        SetProxy(NET_IPV4, addrProxy);
        SetProxy(NET_IPV6, addrProxy);
        SetNameProxy(addrProxy);
        onion_proxy = addrProxy;
    }
 
    const bool onlynet_used_with_onion{args.IsArgSet("-onlynet") &&
                                       IsReachable(NET_ONION)};
 
    // -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
            onion_proxy = Proxy{};
            if (onlynet_used_with_onion) {
                return InitError(_("Outbound connections restricted to Tor "
                                   "(-onlynet=onion) but the proxy for "
                                   "reaching the Tor network is explicitly "
                                   "forbidden: -onion=0"));
            }
        } else {
            if (IsUnixSocketPath(onionArg)) {
                onion_proxy = Proxy(onionArg, proxyRandomize);
            } else {
                const std::optional<CService> addr{
                    Lookup(onionArg, 9050, fNameLookup)};
                if (!addr.has_value() || !addr->IsValid()) {
                    return InitError(
                        strprintf(_("Invalid -onion address or hostname: '%s'"),
                                  onionArg));
                }
 
                onion_proxy = Proxy(addr.value(), proxyRandomize);
            }
        }
    }
 
    if (onion_proxy.IsValid()) {
        SetProxy(NET_ONION, onion_proxy);
    } else {
        // If -listenonion is set, then we will (try to) connect to the Tor
        // control port later from the torcontrol thread and may retrieve the
        // onion proxy from there.
        const bool listenonion_disabled{
            !args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
        if (onlynet_used_with_onion && listenonion_disabled) {
            return InitError(_("Outbound connections restricted to Tor "
                               "(-onlynet=onion) but the proxy for "
                               "reaching the Tor network is not provided: none "
                               "of -proxy, -onion or "
                               "-listenonion is given"));
        }
        SetReachable(NET_ONION, false);
    }
 
    for (const std::string &strAddr : args.GetArgs("-externalip")) {
        const std::optional<CService> addrLocal{
            Lookup(strAddr, GetListenPort(), fNameLookup)};
        if (addrLocal.has_value() && addrLocal->IsValid()) {
            AddLocal(addrLocal.value(), 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.ReadBlock(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>(node.exit_status);
    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(),
        .notifications = chainman_opts.notifications,
    };
    // no error can happen, already checked in AppInitParameterInteraction
    Assert(!ApplyArgsManOptions(args, blockman_opts));
 
    // cache size calculations
    const auto [index_cache_sizes, kernel_cache_sizes] =
        CalculateCacheSizes(args, g_enabled_filter_types.size());
 
    LogInfo("Cache configuration:\n");
    LogInfo("* Using %.1f MiB for block index database\n",
            kernel_cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
    if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
        LogInfo("* Using %.1f MiB for transaction index database\n",
                index_cache_sizes.tx_index * (1.0 / 1024 / 1024));
    }
    for (BlockFilterType filter_type : g_enabled_filter_types) {
        LogInfo("* Using %.1f MiB for %s block filter index database\n",
                index_cache_sizes.filter_index * (1.0 / 1024 / 1024),
                BlockFilterTypeName(filter_type));
    }
    LogInfo("* Using %.1f MiB for chain state database\n",
            kernel_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)));
    }
    LogInfo("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
            "unused mempool space)\n",
            kernel_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>(config, mempool_opts);
 
        node.chainman = std::make_unique<ChainstateManager>(
            node.kernel->interrupt, chainman_opts, blockman_opts);
        ChainstateManager &chainman = *node.chainman;
 
        // This is defined and set here instead of inline in validation.h to
        // avoid a hard dependency between validation and index/base, since the
        // latter is not in libbitcoinkernel.
        chainman.snapshot_download_completed = [&node]() {
            if (!node.chainman->m_blockman.IsPruneMode()) {
                LogPrintf("[snapshot] re-enabling NODE_NETWORK services\n");
                node.connman->AddLocalServices(NODE_NETWORK);
            }
 
            LogPrintf("[snapshot] restarting indexes\n");
 
            // Drain the validation interface queue to ensure that the old
            // indexes don't have any pending work.
            SyncWithValidationInterfaceQueue();
 
            for (auto *index : node.indexes) {
                index->Interrupt();
                index->Stop();
                if (!(index->Init() && index->StartBackgroundSync())) {
                    LogPrintf("[snapshot] WARNING failed to restart index %s "
                              "on snapshot chain\n",
                              index->GetName());
                }
            }
        };
 
        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([&, &kernel_cache_sizes_ = kernel_cache_sizes] {
                return LoadChainstate(chainman, kernel_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) {
                LogWarning("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", DEFAULT_USEASHADDR));
 
    // Step 8: load indexers
 
    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()), index_cache_sizes.tx_index,
            false, fReindex);
        node.indexes.emplace_back(g_txindex.get());
    }
 
    for (const auto &filter_type : g_enabled_filter_types) {
        InitBlockFilterIndex(
            [&] { return interfaces::MakeChain(node, Params()); }, filter_type,
            index_cache_sizes.filter_index, false, fReindex);
        node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
    }
 
    if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
        g_coin_stats_index = std::make_unique<CoinStatsIndex>(
            interfaces::MakeChain(node, Params()), /* cache size */ 0, false,
            fReindex);
        node.indexes.emplace_back(g_coin_stats_index.get());
    }
 
    // Init indexes
    for (auto index : node.indexes) {
        if (!index->Init()) {
            return false;
        }
    }
 
    const bool background_sync_in_progress{WITH_LOCK(
        chainman.GetMutex(), return chainman.BackgroundSyncInProgress())};
#if ENABLE_CHRONIK
    if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
        if (background_sync_in_progress) {
            return InitError(
                _("Assumeutxo is incompatible with -chronik. Wait for "
                  "background sync to complete before enabling 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, perform the initial blockstore prune
    // after any wallet rescanning has taken place.
    if (chainman.m_blockman.IsPruneMode()) {
        if (!fReindex) {
            LOCK(cs_main);
            for (Chainstate *chainstate : chainman.GetAll()) {
                uiInterface.InitMessage(_("Pruning blockstore...").translated);
                chainstate->PruneAndFlush();
            }
        }
    } else {
        // Prior to setting NODE_NETWORK, check if we can provide historical
        // blocks.
        if (!background_sync_in_progress) {
            LogPrintf("Setting NODE_NETWORK on non-prune mode\n");
            nLocalServices = ServiceFlags(nLocalServices | NODE_NETWORK);
        } else {
            LogPrintf("Running node in NODE_NETWORK_LIMITED mode until "
                      "snapshot background sync completes\n");
        }
    }
 
    // 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_thread_load = std::thread(
        &util::TraceThread, "initload", [=, &chainman, &args, &node] {
            // Import blocks
            ImportBlocks(chainman, avalanche, vImportFiles);
            // Start indexes initial sync
            if (!StartIndexBackgroundSync(node)) {
                bilingual_str err_str =
                    _("Failed to start indexes, shutting down..");
                chainman.GetNotifications().fatalError(err_str.original,
                                                       err_str);
                return;
            }
            // Load mempool from disk
            chainman.ActiveChainstate().LoadMempool(
                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
        // ImportBlocks 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;
 
    {
        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")) {
        std::optional<CService> bind_addr;
        const size_t index = bind_arg.rfind('=');
        if (index == std::string::npos) {
            bind_addr =
                Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false);
            if (bind_addr.has_value()) {
                connOptions.vBinds.push_back(bind_addr.value());
                if (IsBadPort(bind_addr.value().GetPort())) {
                    InitWarning(
                        BadPortWarning("-bind", bind_addr.value().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);
                bind_addr =
                    Lookup(truncated_bind_arg,
                           BaseParams().OnionServiceTargetPort(), false);
                if (bind_addr.has_value()) {
                    connOptions.onion_binds.push_back(bind_addr.value());
                    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.ToStringAddrPort()));
        }
        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()) {
        const std::optional<CService> addr{
            Lookup(i2psam_arg, 7656, fNameLookup)};
        if (!addr.has_value() || !addr->IsValid()) {
            return InitError(strprintf(
                _("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
        }
        SetProxy(NET_I2P, Proxy{addr.value()});
    } 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;
}
 
bool StartIndexBackgroundSync(NodeContext &node) {
    // Find the oldest block among all indexes.
    // This block is used to verify that we have the required blocks' data
    // stored on disk, starting from that point up to the current tip.
    // indexes_start_block='nullptr' means "start from height 0".
    std::optional<const CBlockIndex *> indexes_start_block;
    std::string older_index_name;
    ChainstateManager &chainman = *Assert(node.chainman);
    const Chainstate &chainstate =
        WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing());
    const CChain &index_chain = chainstate.m_chain;
 
    for (auto index : node.indexes) {
        const IndexSummary &summary = index->GetSummary();
        if (summary.synced) {
            continue;
        }
 
        // Get the last common block between the index best block and the active
        // chain
        LOCK(::cs_main);
        const CBlockIndex *pindex = chainman.m_blockman.LookupBlockIndex(
            BlockHash{summary.best_block_hash});
        if (!index_chain.Contains(pindex)) {
            pindex = index_chain.FindFork(pindex);
        }
 
        if (!indexes_start_block || !pindex ||
            pindex->nHeight < indexes_start_block.value()->nHeight) {
            indexes_start_block = pindex;
            older_index_name = summary.name;
            if (!pindex) {
                // Starting from genesis so no need to look for earlier block.
                break;
            }
        }
    };
 
    // Verify all blocks needed to sync to current tip are present.
    if (indexes_start_block) {
        LOCK(::cs_main);
        const CBlockIndex *start_block = *indexes_start_block;
        if (!start_block) {
            start_block = chainman.ActiveChain().Genesis();
        }
        if (!chainman.m_blockman.CheckBlockDataAvailability(
                *index_chain.Tip(), *Assert(start_block))) {
            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)"),
                older_index_name));
        }
    }
 
    // Start threads
    for (auto index : node.indexes) {
        if (!index->StartBackgroundSync()) {
            return false;
        }
    }
    return true;
}