Bitcoin ABC 0.31.8
P2P Digital Currency
init.cpp
Go to the documentation of this file.
1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-2018 The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#if defined(HAVE_CONFIG_H)
7#include <config/bitcoin-config.h>
8#endif
9
10#include <init.h>
11
12#include <kernel/checks.h>
15
16#include <addrman.h>
17#include <avalanche/avalanche.h>
18#include <avalanche/processor.h>
19#include <avalanche/proof.h> // For AVALANCHE_LEGACY_PROOF_DEFAULT
21#include <avalanche/voterecord.h> // For AVALANCHE_VOTE_STALE_*
22#include <banman.h>
23#include <blockfilter.h>
24#include <chain.h>
25#include <chainparams.h>
26#include <chainparamsbase.h>
27#include <common/args.h>
28#include <config.h>
29#include <consensus/amount.h>
30#include <currencyunit.h>
31#include <flatfile.h>
32#include <hash.h>
33#include <httprpc.h>
34#include <httpserver.h>
37#include <index/txindex.h>
38#include <init/common.h>
39#include <interfaces/chain.h>
40#include <interfaces/node.h>
41#include <mapport.h>
42#include <mempool_args.h>
43#include <net.h>
44#include <net_permissions.h>
45#include <net_processing.h>
46#include <netbase.h>
48#include <node/blockstorage.h>
49#include <node/caches.h>
50#include <node/chainstate.h>
52#include <node/context.h>
55#include <node/miner.h>
56#include <node/peerman_args.h>
57#include <node/ui_interface.h>
59#include <policy/block/rtt.h>
60#include <policy/policy.h>
61#include <policy/settings.h>
62#include <rpc/blockchain.h>
63#include <rpc/register.h>
64#include <rpc/server.h>
65#include <rpc/util.h>
66#include <scheduler.h>
67#include <script/scriptcache.h>
68#include <script/sigcache.h>
69#include <script/standard.h>
70#include <shutdown.h>
71#include <sync.h>
72#include <timedata.h>
73#include <torcontrol.h>
74#include <txdb.h>
75#include <txmempool.h>
76#include <util/asmap.h>
77#include <util/chaintype.h>
78#include <util/check.h>
79#include <util/fs.h>
80#include <util/fs_helpers.h>
81#include <util/moneystr.h>
82#include <util/string.h>
83#include <util/syserror.h>
84#include <util/thread.h>
85#include <util/threadnames.h>
86#include <util/translation.h>
87#include <validation.h>
88#include <validationinterface.h>
89#include <walletinitinterface.h>
90
91#include <boost/signals2/signal.hpp>
92
93#if ENABLE_CHRONIK
94#include <chronik-cpp/chronik.h>
95#endif
96
97#if ENABLE_ZMQ
100#include <zmq/zmqrpc.h>
101#endif
102
103#ifndef WIN32
104#include <cerrno>
105#include <csignal>
106#include <sys/stat.h>
107#endif
108#include <algorithm>
109#include <condition_variable>
110#include <cstdint>
111#include <cstdio>
112#include <fstream>
113#include <functional>
114#include <set>
115#include <string>
116#include <thread>
117#include <vector>
118
122
125using node::CacheSizes;
128using node::fReindex;
136
137static const bool DEFAULT_PROXYRANDOMIZE = true;
138static const bool DEFAULT_REST_ENABLE = false;
139static constexpr bool DEFAULT_CHRONIK = false;
140
141#ifdef WIN32
142// Win32 LevelDB doesn't use filedescriptors, and the ones used for accessing
143// block files don't count towards the fd_set size limit anyway.
144#define MIN_CORE_FILEDESCRIPTORS 0
145#else
146#define MIN_CORE_FILEDESCRIPTORS 150
147#endif
148
149static const char *DEFAULT_ASMAP_FILENAME = "ip_asn.map";
150
151static const std::string HEADERS_TIME_FILE_NAME{"headerstime.dat"};
152
156static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";
157
158static fs::path GetPidFile(const ArgsManager &args) {
159 return AbsPathForConfigVal(args,
160 args.GetPathArg("-pid", BITCOIN_PID_FILENAME));
161}
162
163[[nodiscard]] static bool CreatePidFile(const ArgsManager &args) {
164 std::ofstream file{GetPidFile(args)};
165 if (file) {
166#ifdef WIN32
167 tfm::format(file, "%d\n", GetCurrentProcessId());
168#else
169 tfm::format(file, "%d\n", getpid());
170#endif
171 return true;
172 } else {
173 return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
175 SysErrorString(errno)));
176 }
177}
178
180//
181// Shutdown
182//
183
184//
185// Thread management and startup/shutdown:
186//
187// The network-processing threads are all part of a thread group created by
188// AppInit() or the Qt main() function.
189//
190// A clean exit happens when StartShutdown() or the SIGTERM signal handler sets
191// fRequestShutdown, which makes main thread's WaitForShutdown() interrupts the
192// thread group.
193// And then, WaitForShutdown() makes all other on-going threads in the thread
194// group join the main thread.
195// Shutdown() is then called to clean up database connections, and stop other
196// threads that should only be stopped after the main network-processing threads
197// have exited.
198//
199// Shutdown for Qt is very similar, only it uses a QTimer to detect
200// ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
201//
202
206 InterruptRPC();
210 if (node.avalanche) {
211 // Avalanche needs to be stopped before we interrupt the thread group as
212 // the scheduler will stop working then.
213 node.avalanche->stopEventLoop();
214 }
215 if (node.connman) {
216 node.connman->Interrupt();
217 }
218 if (g_txindex) {
219 g_txindex->Interrupt();
220 }
221 ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Interrupt(); });
222 if (g_coin_stats_index) {
223 g_coin_stats_index->Interrupt();
224 }
225}
226
228 static Mutex g_shutdown_mutex;
229 TRY_LOCK(g_shutdown_mutex, lock_shutdown);
230 if (!lock_shutdown) {
231 return;
232 }
233 LogPrintf("%s: In progress...\n", __func__);
234 Assert(node.args);
235
240 util::ThreadRename("shutoff");
241 if (node.mempool) {
242 node.mempool->AddTransactionsUpdated(1);
243 }
244
245 StopHTTPRPC();
246 StopREST();
247 StopRPC();
249 for (const auto &client : node.chain_clients) {
250 client->flush();
251 }
252 StopMapPort();
253
254 // Because avalanche and the network depend on each other, it is important
255 // to shut them down in this order:
256 // 1. Stop avalanche event loop.
257 // 2. Shutdown network processing.
258 // 3. Destroy avalanche::Processor.
259 // 4. Destroy CConnman
260 if (node.avalanche) {
261 node.avalanche->stopEventLoop();
262 }
263
264 // Because these depend on each-other, we make sure that neither can be
265 // using the other before destroying them.
266 if (node.peerman) {
267 UnregisterValidationInterface(node.peerman.get());
268 }
269 if (node.connman) {
270 node.connman->Stop();
271 }
272
274
275 // After everything has been shut down, but before things get flushed, stop
276 // the CScheduler/checkqueue, scheduler and load block thread.
277 if (node.scheduler) {
278 node.scheduler->stop();
279 }
280 if (node.chainman && node.chainman->m_thread_load.joinable()) {
281 node.chainman->m_thread_load.join();
282 }
284
285 // After the threads that potentially access these pointers have been
286 // stopped, destruct and reset all to nullptr.
287 node.peerman.reset();
288
289 // Destroy various global instances
290 node.avalanche.reset();
291 node.connman.reset();
292 node.banman.reset();
293 node.addrman.reset();
294
295 if (node.mempool && node.mempool->GetLoadTried() &&
296 ShouldPersistMempool(*node.args)) {
297 DumpMempool(*node.mempool, MempoolPath(*node.args));
298 }
299
300 // FlushStateToDisk generates a ChainStateFlushed callback, which we should
301 // avoid missing
302 if (node.chainman) {
303 LOCK(cs_main);
304 for (Chainstate *chainstate : node.chainman->GetAll()) {
305 if (chainstate->CanFlushToDisk()) {
306 chainstate->ForceFlushStateToDisk();
307 }
308 }
309 }
310
311 // After there are no more peers/RPC left to give us new data which may
312 // generate CValidationInterface callbacks, flush them...
314
315#if ENABLE_CHRONIK
316 if (node.args->GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
317 chronik::Stop();
318 }
319#endif
320
321 // Stop and delete all indexes only after flushing background callbacks.
322 if (g_txindex) {
323 g_txindex->Stop();
324 g_txindex.reset();
325 }
326 if (g_coin_stats_index) {
327 g_coin_stats_index->Stop();
328 g_coin_stats_index.reset();
329 }
330 ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Stop(); });
332
333 // Any future callbacks will be dropped. This should absolutely be safe - if
334 // missing a callback results in an unrecoverable situation, unclean
335 // shutdown would too. The only reason to do the above flushes is to let the
336 // wallet catch up with our current chain to avoid any strange pruning edge
337 // cases and make next startup faster by avoiding rescan.
338
339 if (node.chainman) {
340 LOCK(cs_main);
341 for (Chainstate *chainstate : node.chainman->GetAll()) {
342 if (chainstate->CanFlushToDisk()) {
343 chainstate->ForceFlushStateToDisk();
344 chainstate->ResetCoinsViews();
345 }
346 }
347
348 node.chainman->DumpRecentHeadersTime(node.chainman->m_options.datadir /
350 }
351 for (const auto &client : node.chain_clients) {
352 client->stop();
353 }
354
355#if ENABLE_ZMQ
359 }
360#endif
361
362 node.chain_clients.clear();
365 node.kernel.reset();
366 node.mempool.reset();
367 node.chainman.reset();
368 node.scheduler.reset();
369
370 try {
371 if (!fs::remove(GetPidFile(*node.args))) {
372 LogPrintf("%s: Unable to remove PID file: File does not exist\n",
373 __func__);
374 }
375 } catch (const fs::filesystem_error &e) {
376 LogPrintf("%s: Unable to remove PID file: %s\n", __func__,
378 }
379
380 LogPrintf("%s: done\n", __func__);
381}
382
388#ifndef WIN32
389static void HandleSIGTERM(int) {
391}
392
393static void HandleSIGHUP(int) {
394 LogInstance().m_reopen_file = true;
395}
396#else
397static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) {
399 Sleep(INFINITE);
400 return true;
401}
402#endif
403
404#ifndef WIN32
405static void registerSignalHandler(int signal, void (*handler)(int)) {
406 struct sigaction sa;
407 sa.sa_handler = handler;
408 sigemptyset(&sa.sa_mask);
409 sa.sa_flags = 0;
410 sigaction(signal, &sa, NULL);
411}
412#endif
413
414static boost::signals2::connection rpc_notify_block_change_connection;
415static void OnRPCStarted() {
416 rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(
417 std::bind(RPCNotifyBlockChange, std::placeholders::_2));
418}
419
420static void OnRPCStopped() {
422 RPCNotifyBlockChange(nullptr);
423 g_best_block_cv.notify_all();
424 LogPrint(BCLog::RPC, "RPC stopped.\n");
425}
426
428 assert(!node.args);
429 node.args = &gArgs;
430 ArgsManager &argsman = *node.args;
431
432 SetupHelpOptions(argsman);
434 // server-only for now
435 argsman.AddArg("-help-debug",
436 "Print help message with debugging options and exit", false,
438
439 init::AddLoggingArgs(argsman);
440
441 const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
442 const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
443 const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
444 const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
445 const auto testnetChainParams =
447 const auto regtestChainParams =
449
450 // Hidden Options
451 std::vector<std::string> hidden_args = {
452 "-dbcrashratio",
453 "-forcecompactdb",
454 "-maxaddrtosend",
455 "-parkdeepreorg",
456 "-automaticunparking",
457 "-replayprotectionactivationtime",
458 "-enableminerfund",
459 "-chronikallowpause",
460 "-chronikcors",
461 // GUI args. These will be overwritten by SetupUIArgs for the GUI
462 "-allowselfsignedrootcertificates",
463 "-choosedatadir",
464 "-lang=<lang>",
465 "-min",
466 "-resetguisettings",
467 "-rootcertificates=<file>",
468 "-splash",
469 "-uiplatform",
470 // TODO remove after the May 2025 upgrade
471 "-schumpeteractivationtime",
472 // TODO remove after the Nov 2025 upgrade
473 "-shibusawaactivationtime",
474 };
475
476 // Set all of the args and their help
477 // When adding new options to the categories, please keep and ensure
478 // alphabetical ordering. Do not translate _(...) -help-debug options, Many
479 // technical terms, and only a very small audience, so is unnecessary stress
480 // to translators.
481 argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
483#if defined(HAVE_SYSTEM)
484 argsman.AddArg(
485 "-alertnotify=<cmd>",
486 "Execute command when a relevant alert is received or we see "
487 "a really long fork (%s in cmd is replaced by message)",
489#endif
490 argsman.AddArg(
491 "-assumevalid=<hex>",
492 strprintf(
493 "If this block is in the chain assume that it and its ancestors "
494 "are valid and potentially skip their script verification (0 to "
495 "verify all, default: %s, testnet: %s)",
496 defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
497 testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
499 argsman.AddArg("-blocksdir=<dir>",
500 "Specify directory to hold blocks subdirectory for *.dat "
501 "files (default: <datadir>)",
503 argsman.AddArg("-fastprune",
504 "Use smaller block files and lower minimum prune height for "
505 "testing purposes",
508#if defined(HAVE_SYSTEM)
509 argsman.AddArg("-blocknotify=<cmd>",
510 "Execute command when the best block changes (%s in cmd is "
511 "replaced by block hash)",
513#endif
514 argsman.AddArg("-blockreconstructionextratxn=<n>",
515 strprintf("Extra transactions to keep in memory for compact "
516 "block reconstructions (default: %u)",
519 argsman.AddArg(
520 "-blocksonly",
521 strprintf("Whether to reject transactions from network peers. "
522 "Disables automatic broadcast and rebroadcast of "
523 "transactions, unless the source peer has the "
524 "'forcerelay' permission. RPC transactions are"
525 " not affected. (default: %u)",
528 argsman.AddArg("-coinstatsindex",
529 strprintf("Maintain coinstats index used by the "
530 "gettxoutsetinfo RPC (default: %u)",
533 argsman.AddArg(
534 "-conf=<file>",
535 strprintf("Specify path to read-only configuration file. Relative "
536 "paths will be prefixed by datadir location. (default: %s)",
539 argsman.AddArg("-datadir=<dir>", "Specify data directory",
541 argsman.AddArg(
542 "-dbbatchsize",
543 strprintf("Maximum database write batch size in bytes (default: %u)",
547 argsman.AddArg(
548 "-dbcache=<n>",
549 strprintf("Set database cache size in MiB (%d to %d, default: %d)",
552 argsman.AddArg(
553 "-includeconf=<file>",
554 "Specify additional configuration file, relative to the -datadir path "
555 "(only useable from configuration file, not command line)",
557 argsman.AddArg("-allowignoredconf",
558 strprintf("For backwards compatibility, treat an unused %s "
559 "file in the datadir as a warning, not an error.",
562 argsman.AddArg("-loadblock=<file>",
563 "Imports blocks from external file on startup",
565 argsman.AddArg("-maxmempool=<n>",
566 strprintf("Keep the transaction memory pool below <n> "
567 "megabytes (default: %u)",
570 argsman.AddArg("-maxorphantx=<n>",
571 strprintf("Keep at most <n> unconnectable transactions in "
572 "memory (default: %u)",
575 argsman.AddArg("-mempoolexpiry=<n>",
576 strprintf("Do not keep transactions in the mempool longer "
577 "than <n> hours (default: %u)",
580 argsman.AddArg(
581 "-minimumchainwork=<hex>",
582 strprintf(
583 "Minimum work assumed to exist on a valid chain in hex "
584 "(default: %s, testnet: %s)",
585 defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
586 testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
589 argsman.AddArg(
590 "-par=<n>",
591 strprintf("Set the number of script verification threads (%u to %d, 0 "
592 "= auto, <0 = leave that many cores free, default: %d)",
596 argsman.AddArg("-persistmempool",
597 strprintf("Whether to save the mempool on shutdown and load "
598 "on restart (default: %u)",
601 argsman.AddArg(
602 "-persistrecentheaderstime",
603 strprintf(
604 "Whether the node stores the recent headers reception time to a "
605 "file and load it upon startup. This is intended for mining nodes "
606 "to overestimate the real time target upon restart (default: %u)",
609 argsman.AddArg(
610 "-pid=<file>",
611 strprintf("Specify pid file. Relative paths will be prefixed "
612 "by a net-specific datadir location. (default: %s)",
615 argsman.AddArg(
616 "-prune=<n>",
617 strprintf("Reduce storage requirements by enabling pruning (deleting) "
618 "of old blocks. This allows the pruneblockchain RPC to be "
619 "called to delete specific blocks and enables automatic "
620 "pruning of old blocks if a target size in MiB is provided. "
621 "This mode is incompatible with -txindex and -rescan. "
622 "Warning: Reverting this setting requires re-downloading the "
623 "entire blockchain. (default: 0 = disable pruning blocks, "
624 "1 = allow manual pruning via RPC, >=%u = automatically "
625 "prune block files to stay under the specified target size "
626 "in MiB)",
627 MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
629 argsman.AddArg(
630 "-reindex-chainstate",
631 "Rebuild chain state from the currently indexed blocks. When "
632 "in pruning mode or if blocks on disk might be corrupted, use "
633 "full -reindex instead.",
635 argsman.AddArg(
636 "-reindex",
637 "Rebuild chain state and block index from the blk*.dat files on disk."
638 " This will also rebuild active optional indexes.",
640 argsman.AddArg(
641 "-settings=<file>",
642 strprintf(
643 "Specify path to dynamic settings data file. Can be disabled with "
644 "-nosettings. File is written at runtime and not meant to be "
645 "edited by users (use %s instead for custom settings). Relative "
646 "paths will be prefixed by datadir location. (default: %s)",
649#if HAVE_SYSTEM
650 argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.",
652#endif
653#ifndef WIN32
654 argsman.AddArg(
655 "-sysperms",
656 "Create new files with system default permissions, instead of umask "
657 "077 (only effective with disabled wallet functionality)",
659#else
660 hidden_args.emplace_back("-sysperms");
661#endif
662 argsman.AddArg("-txindex",
663 strprintf("Maintain a full transaction index, used by the "
664 "getrawtransaction rpc call (default: %d)",
667#if ENABLE_CHRONIK
668 argsman.AddArg(
669 "-chronik",
670 strprintf("Enable the Chronik indexer, which can be read via a "
671 "dedicated HTTP/Protobuf interface (default: %d)",
674 argsman.AddArg(
675 "-chronikbind=<addr>[:port]",
676 strprintf(
677 "Bind the Chronik indexer to the given address to listen for "
678 "HTTP/Protobuf connections to access the index. Unlike the "
679 "JSON-RPC, it's ok to have this publicly exposed on the internet. "
680 "This option can be specified multiple times (default: %s; default "
681 "port: %u, testnet: %u, regtest: %u)",
682 Join(chronik::DEFAULT_BINDS, ", "),
683 defaultBaseParams->ChronikPort(), testnetBaseParams->ChronikPort(),
684 regtestBaseParams->ChronikPort()),
688 argsman.AddArg("-chroniktokenindex",
689 "Enable token indexing in Chronik (default: 1)",
691 argsman.AddArg("-chroniklokadidindex",
692 "Enable LOKAD ID indexing in Chronik (default: 1)",
694 argsman.AddArg("-chronikreindex",
695 "Reindex the Chronik indexer from genesis, but leave the "
696 "other indexes untouched",
698 argsman.AddArg(
699 "-chroniktxnumcachebuckets",
700 strprintf(
701 "Tuning param of the TxNumCache, specifies how many buckets "
702 "to use on the belt. Caution against setting this too high, "
703 "it may slow down indexing. Set to 0 to disable. (default: %d)",
704 chronik::DEFAULT_TX_NUM_CACHE_BUCKETS),
707 argsman.AddArg(
708 "-chroniktxnumcachebucketsize",
709 strprintf(
710 "Tuning param of the TxNumCache, specifies the size of each bucket "
711 "on the belt. Unlike the number of buckets, this may be increased "
712 "without much danger of slowing the indexer down. The total cache "
713 "size will be `num_buckets * bucket_size * 40B`, so by default the "
714 "cache will require %dkB of memory. (default: %d)",
715 chronik::DEFAULT_TX_NUM_CACHE_BUCKETS *
716 chronik::DEFAULT_TX_NUM_CACHE_BUCKET_SIZE * 40 / 1000,
717 chronik::DEFAULT_TX_NUM_CACHE_BUCKET_SIZE),
720 argsman.AddArg("-chronikperfstats",
721 "Output some performance statistics (e.g. num cache hits, "
722 "seconds spent) into a <datadir>/perf folder. (default: 0)",
724 argsman.AddArg("-chronikscripthashindex",
725 "Enable the scripthash index for the Chronik indexer "
726 "(default: 1 if chronikelectrumbind is set, 0 otherwise) ",
728 argsman.AddArg(
729 "-chronikelectrumbind=<addr>[:port][:t|s|w|y]",
730 strprintf(
731 "Bind the Chronik Electrum interface to the given "
732 "address:port:protocol. If not set, the Electrum interface will "
733 "not start. This option can be specified multiple times. The "
734 "protocol is selected by a single letter, where 't' means TCP, 's' "
735 "means TLS, 'w' means WS and 'y' means WSS. If TLS and/or WSS is "
736 "selected, the certificate chain and private key must both be "
737 "passed (see -chronikelectrumcert and -chronikelectrumprivkey "
738 "(default: disabled; default port: %u, testnet: %u, regtest: %u; "
739 "default protocol: TLS)",
740 defaultBaseParams->ChronikElectrumPort(),
741 testnetBaseParams->ChronikElectrumPort(),
742 regtestBaseParams->ChronikElectrumPort()),
746 argsman.AddArg(
747 "-chronikelectrumcert",
748 "Path to the certificate file to be used by the Chronik Electrum "
749 "server when the TLS protocol is selected. The file should contain "
750 "the whole certificate chain (typically a .pem file). If used the "
751 "-chronikelectrumprivkey must be set as well.",
755 argsman.AddArg(
756 "-chronikelectrumprivkey",
757 "Path to the private key file to be used by the Chronik Electrum "
758 "server when the TLS protocol is selected. If used the "
759 "-chronikelectrumcert must be set as well.",
763 argsman.AddArg(
764 "-chronikelectrumurl",
765 "The URL to advertise to the Electrum peers. This needs to be set to "
766 "the server public URL to instruct the other Electrum peers that they "
767 "don't have to drop the connection. See the 'hosts' key in "
768 "https://electrum-cash-protocol.readthedocs.io/en/latest/"
769 "protocol-methods.html#server.features (default: 127.0.0.1).",
773 argsman.AddArg(
774 "-chronikelectrummaxhistory",
775 strprintf("Largest tx history we are willing to serve. (default: %u)",
776 chronik::DEFAULT_ELECTRUM_MAX_HISTORY),
779 argsman.AddArg(
780 "-chronikelectrumdonationaddress",
781 strprintf(
782 "The server donation address. No checks are done on the server "
783 "side to ensure this is a valid eCash address, it is just relayed "
784 "to clients verbatim as a text string (%u characters maximum).",
785 chronik::MAX_LENGTH_DONATION_ADDRESS),
788 argsman.AddArg(
789 "-chronikelectrumpeersvalidationinterval",
790 strprintf(
791 "The peers submitted via the Chronik Electrum server.add_peer "
792 "endpoint are periodically checked for validity and are only "
793 "returned after they passed the validation. This option controls "
794 "the interval duration between successive peers validation "
795 "processes in seconds (default: %u). Setting this value to 0 "
796 "disables the peer validation completely.",
797 std::chrono::duration_cast<std::chrono::seconds>(
798 chronik::DEFAULT_ELECTRUM_PEER_VALIDATION_INTERVAL)
799 .count()),
802#endif
803 argsman.AddArg(
804 "-blockfilterindex=<type>",
805 strprintf("Maintain an index of compact filters by block "
806 "(default: %s, values: %s).",
808 " If <type> is not supplied or if <type> = 1, indexes for "
809 "all known types are enabled.",
811 argsman.AddArg(
812 "-usecashaddr",
813 "Use Cash Address for destination encoding instead of base58 "
814 "(activate by default on Jan, 14)",
816
817 argsman.AddArg(
818 "-addnode=<ip>",
819 "Add a node to connect to and attempt to keep the connection "
820 "open (see the `addnode` RPC command help for more info)",
823 argsman.AddArg("-asmap=<file>",
824 strprintf("Specify asn mapping used for bucketing of the "
825 "peers (default: %s). Relative paths will be "
826 "prefixed by the net-specific datadir location.",
829 argsman.AddArg("-bantime=<n>",
830 strprintf("Default duration (in seconds) of manually "
831 "configured bans (default: %u)",
834 argsman.AddArg(
835 "-bind=<addr>[:<port>][=onion]",
836 strprintf("Bind to given address and always listen on it (default: "
837 "0.0.0.0). Use [host]:port notation for IPv6. Append =onion "
838 "to tag any incoming connections to that address and port as "
839 "incoming Tor connections (default: 127.0.0.1:%u=onion, "
840 "testnet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)",
841 defaultBaseParams->OnionServiceTargetPort(),
842 testnetBaseParams->OnionServiceTargetPort(),
843 regtestBaseParams->OnionServiceTargetPort()),
846 argsman.AddArg(
847 "-connect=<ip>",
848 "Connect only to the specified node(s); -connect=0 disables automatic "
849 "connections (the rules for this peer are the same as for -addnode)",
852 argsman.AddArg(
853 "-discover",
854 "Discover own IP addresses (default: 1 when listening and no "
855 "-externalip or -proxy)",
857 argsman.AddArg("-dns",
858 strprintf("Allow DNS lookups for -addnode, -seednode and "
859 "-connect (default: %d)",
862 argsman.AddArg(
863 "-dnsseed",
864 strprintf(
865 "Query for peer addresses via DNS lookup, if low on addresses "
866 "(default: %u unless -connect used)",
869 argsman.AddArg("-externalip=<ip>", "Specify your own public address",
871 argsman.AddArg(
872 "-fixedseeds",
873 strprintf(
874 "Allow fixed seeds if DNS seeds don't provide peers (default: %u)",
877 argsman.AddArg(
878 "-forcednsseed",
879 strprintf(
880 "Always query for peer addresses via DNS lookup (default: %d)",
883 argsman.AddArg("-overridednsseed",
884 "If set, only use the specified DNS seed when "
885 "querying for peer addresses via DNS lookup.",
887 argsman.AddArg(
888 "-listen",
889 "Accept connections from outside (default: 1 if no -proxy or -connect)",
891 argsman.AddArg(
892 "-listenonion",
893 strprintf("Automatically create Tor onion service (default: %d)",
896 argsman.AddArg(
897 "-maxconnections=<n>",
898 strprintf("Maintain at most <n> connections to peers. The effective "
899 "limit depends on system limitations and might be lower than "
900 "the specified value (default: %u)",
903 argsman.AddArg("-maxreceivebuffer=<n>",
904 strprintf("Maximum per-connection receive buffer, <n>*1000 "
905 "bytes (default: %u)",
908 argsman.AddArg(
909 "-maxsendbuffer=<n>",
910 strprintf(
911 "Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
914 argsman.AddArg(
915 "-maxtimeadjustment",
916 strprintf("Maximum allowed median peer time offset adjustment. Local "
917 "perspective of time may be influenced by peers forward or "
918 "backward by this amount. (default: %u seconds)",
921 argsman.AddArg("-onion=<ip:port>",
922 strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
923 "onion services (default: %s)",
924 "-proxy"),
926 argsman.AddArg("-i2psam=<ip:port>",
927 "I2P SAM proxy to reach I2P peers and accept I2P "
928 "connections (default: none)",
930 argsman.AddArg(
931 "-i2pacceptincoming",
932 "If set and -i2psam is also set then incoming I2P connections are "
933 "accepted via the SAM proxy. If this is not set but -i2psam is set "
934 "then only outgoing connections will be made to the I2P network. "
935 "Ignored if -i2psam is not set. Listening for incoming I2P connections "
936 "is done through the SAM proxy, not by binding to a local address and "
937 "port (default: 1)",
939
940 argsman.AddArg(
941 "-onlynet=<net>",
942 "Make outgoing connections only through network <net> (" +
943 Join(GetNetworkNames(), ", ") +
944 "). Incoming connections are not affected by this option. This "
945 "option can be specified multiple times to allow multiple "
946 "networks. Warning: if it is used with non-onion networks "
947 "and the -onion or -proxy option is set, then outbound onion "
948 "connections will still be made; use -noonion or -onion=0 to "
949 "disable outbound onion connections in this case",
951 argsman.AddArg("-peerbloomfilters",
952 strprintf("Support filtering of blocks and transaction with "
953 "bloom filters (default: %d)",
956 argsman.AddArg(
957 "-peerblockfilters",
958 strprintf(
959 "Serve compact block filters to peers per BIP 157 (default: %u)",
962 argsman.AddArg("-permitbaremultisig",
963 strprintf("Relay non-P2SH multisig (default: %d)",
966 // TODO: remove the sentence "Nodes not using ... incoming connections."
967 // once the changes from https://github.com/bitcoin/bitcoin/pull/23542 have
968 // become widespread.
969 argsman.AddArg("-port=<port>",
970 strprintf("Listen for connections on <port>. Nodes not "
971 "using the default ports (default: %u, "
972 "testnet: %u, regtest: %u) are unlikely to get "
973 "incoming connections. Not relevant for I2P (see "
974 "doc/i2p.md).",
975 defaultChainParams->GetDefaultPort(),
976 testnetChainParams->GetDefaultPort(),
977 regtestChainParams->GetDefaultPort()),
980 argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
983 argsman.AddArg(
984 "-proxyrandomize",
985 strprintf("Randomize credentials for every proxy connection. "
986 "This enables Tor stream isolation (default: %d)",
989 argsman.AddArg(
990 "-seednode=<ip>",
991 "Connect to a node to retrieve peer addresses, and disconnect",
993 argsman.AddArg(
994 "-networkactive",
995 "Enable all P2P network activity (default: 1). Can be changed "
996 "by the setnetworkactive RPC command",
998 argsman.AddArg("-timeout=<n>",
999 strprintf("Specify connection timeout in milliseconds "
1000 "(minimum: 1, default: %d)",
1003 argsman.AddArg(
1004 "-peertimeout=<n>",
1005 strprintf("Specify p2p connection timeout in seconds. This option "
1006 "determines the amount of time a peer may be inactive before "
1007 "the connection to it is dropped. (minimum: 1, default: %d)",
1010 argsman.AddArg(
1011 "-torcontrol=<ip>:<port>",
1012 strprintf(
1013 "Tor control port to use if onion listening enabled (default: %s)",
1016 argsman.AddArg("-torpassword=<pass>",
1017 "Tor control port password (default: empty)",
1020#ifdef USE_UPNP
1021#if USE_UPNP
1022 argsman.AddArg("-upnp",
1023 "Use UPnP to map the listening port (default: 1 when "
1024 "listening and no -proxy)",
1026#else
1027 argsman.AddArg(
1028 "-upnp",
1029 strprintf("Use UPnP to map the listening port (default: %u)", 0),
1031#endif
1032#else
1033 hidden_args.emplace_back("-upnp");
1034#endif
1035#ifdef USE_NATPMP
1036 argsman.AddArg(
1037 "-natpmp",
1038 strprintf("Use NAT-PMP to map the listening port (default: %s)",
1039 DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"),
1041#else
1042 hidden_args.emplace_back("-natpmp");
1043#endif // USE_NATPMP
1044 argsman.AddArg(
1045 "-whitebind=<[permissions@]addr>",
1046 "Bind to the given address and add permission flags to the peers "
1047 "connecting to it."
1048 "Use [host]:port notation for IPv6. Allowed permissions: " +
1049 Join(NET_PERMISSIONS_DOC, ", ") +
1050 ". "
1051 "Specify multiple permissions separated by commas (default: "
1052 "download,noban,mempool,relay). Can be specified multiple times.",
1054
1055 argsman.AddArg("-whitelist=<[permissions@]IP address or network>",
1056 "Add permission flags to the peers using the given "
1057 "IP address (e.g. 1.2.3.4) or CIDR-notated network "
1058 "(e.g. 1.2.3.0/24). "
1059 "Uses the same permissions as -whitebind. "
1060 "Additional flags \"in\" and \"out\" control whether "
1061 "permissions apply to incoming connections and/or manual "
1062 "(default: incoming only). "
1063 "Can be specified multiple times.",
1065 argsman.AddArg(
1066 "-maxuploadtarget=<n>",
1067 strprintf("Tries to keep outbound traffic under the given target (in "
1068 "MiB per 24h). Limit does not apply to peers with 'download' "
1069 "permission. 0 = no limit (default: %d)",
1072
1074
1075#if ENABLE_ZMQ
1076 argsman.AddArg("-zmqpubhashblock=<address>",
1077 "Enable publish hash block in <address>",
1079 argsman.AddArg("-zmqpubhashtx=<address>",
1080 "Enable publish hash transaction in <address>",
1082 argsman.AddArg("-zmqpubrawblock=<address>",
1083 "Enable publish raw block in <address>",
1085 argsman.AddArg("-zmqpubrawtx=<address>",
1086 "Enable publish raw transaction in <address>",
1088 argsman.AddArg("-zmqpubsequence=<address>",
1089 "Enable publish hash block and tx sequence in <address>",
1091 argsman.AddArg(
1092 "-zmqpubhashblockhwm=<n>",
1093 strprintf("Set publish hash block outbound message high water "
1094 "mark (default: %d)",
1097 argsman.AddArg(
1098 "-zmqpubhashtxhwm=<n>",
1099 strprintf("Set publish hash transaction outbound message high "
1100 "water mark (default: %d)",
1102 false, OptionsCategory::ZMQ);
1103 argsman.AddArg(
1104 "-zmqpubrawblockhwm=<n>",
1105 strprintf("Set publish raw block outbound message high water "
1106 "mark (default: %d)",
1109 argsman.AddArg(
1110 "-zmqpubrawtxhwm=<n>",
1111 strprintf("Set publish raw transaction outbound message high "
1112 "water mark (default: %d)",
1115 argsman.AddArg("-zmqpubsequencehwm=<n>",
1116 strprintf("Set publish hash sequence message high water mark"
1117 " (default: %d)",
1120#else
1121 hidden_args.emplace_back("-zmqpubhashblock=<address>");
1122 hidden_args.emplace_back("-zmqpubhashtx=<address>");
1123 hidden_args.emplace_back("-zmqpubrawblock=<address>");
1124 hidden_args.emplace_back("-zmqpubrawtx=<address>");
1125 hidden_args.emplace_back("-zmqpubsequence=<n>");
1126 hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
1127 hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
1128 hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
1129 hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
1130 hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
1131#endif
1132
1133 argsman.AddArg(
1134 "-checkblocks=<n>",
1135 strprintf("How many blocks to check at startup (default: %u, 0 = all)",
1139 argsman.AddArg("-checklevel=<n>",
1140 strprintf("How thorough the block verification of "
1141 "-checkblocks is: %s (0-4, default: %u)",
1145 argsman.AddArg("-checkblockindex",
1146 strprintf("Do a consistency check for the block tree, "
1147 "chainstate, and other validation data structures "
1148 "occasionally. (default: %u, regtest: %u)",
1149 defaultChainParams->DefaultConsistencyChecks(),
1150 regtestChainParams->DefaultConsistencyChecks()),
1153 argsman.AddArg("-checkaddrman=<n>",
1154 strprintf("Run addrman consistency checks every <n> "
1155 "operations. Use 0 to disable. (default: %u)",
1159 argsman.AddArg(
1160 "-checkmempool=<n>",
1161 strprintf("Run mempool consistency checks every <n> transactions. Use "
1162 "0 to disable. (default: %u, regtest: %u)",
1163 defaultChainParams->DefaultConsistencyChecks(),
1164 regtestChainParams->DefaultConsistencyChecks()),
1167 argsman.AddArg("-checkpoints",
1168 strprintf("Only accept block chain matching built-in "
1169 "checkpoints (default: %d)",
1173 argsman.AddArg("-deprecatedrpc=<method>",
1174 "Allows deprecated RPC method(s) to be used",
1177 argsman.AddArg(
1178 "-stopafterblockimport",
1179 strprintf("Stop running after importing blocks from disk (default: %d)",
1183 argsman.AddArg("-stopatheight",
1184 strprintf("Stop running after reaching the given height in "
1185 "the main chain (default: %u)",
1189 argsman.AddArg("-addrmantest", "Allows to test address relay on localhost",
1192 argsman.AddArg("-capturemessages", "Capture all P2P messages to disk",
1195 argsman.AddArg("-mocktime=<n>",
1196 "Replace actual time with " + UNIX_EPOCH_TIME +
1197 " (default: 0)",
1200 argsman.AddArg(
1201 "-maxsigcachesize=<n>",
1202 strprintf("Limit size of signature cache to <n> MiB (default: %u)",
1206 argsman.AddArg(
1207 "-maxscriptcachesize=<n>",
1208 strprintf("Limit size of script cache to <n> MiB (default: %u)",
1212 argsman.AddArg("-maxtipage=<n>",
1213 strprintf("Maximum tip age in seconds to consider node in "
1214 "initial block download (default: %u)",
1215 Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
1218
1219 argsman.AddArg("-uacomment=<cmt>",
1220 "Append comment to the user agent string",
1222 argsman.AddArg("-uaclientname=<clientname>", "Set user agent client name",
1224 argsman.AddArg("-uaclientversion=<clientversion>",
1225 "Set user agent client version", ArgsManager::ALLOW_ANY,
1227
1229
1230 argsman.AddArg(
1231 "-acceptnonstdtxn",
1232 strprintf(
1233 "Relay and mine \"non-standard\" transactions (%sdefault: %u)",
1234 "testnet/regtest only; ", defaultChainParams->RequireStandard()),
1237 argsman.AddArg("-excessiveblocksize=<n>",
1238 strprintf("Do not accept blocks larger than this limit, in "
1239 "bytes (default: %d)",
1243 const auto &ticker = Currency::get().ticker;
1244 argsman.AddArg(
1245 "-dustrelayfee=<amt>",
1246 strprintf("Fee rate (in %s/kB) used to define dust, the value of an "
1247 "output such that it will cost about 1/3 of its value in "
1248 "fees at this fee rate to spend it. (default: %s)",
1252
1253 argsman.AddArg(
1254 "-bytespersigcheck",
1255 strprintf("Equivalent bytes per sigCheck in transactions for relay and "
1256 "mining (default: %u).",
1259 argsman.AddArg(
1260 "-bytespersigop",
1261 strprintf("DEPRECATED: Equivalent bytes per sigCheck in transactions "
1262 "for relay and mining (default: %u). This has been "
1263 "deprecated since v0.26.8 and will be removed in the future, "
1264 "please use -bytespersigcheck instead.",
1267 argsman.AddArg(
1268 "-datacarrier",
1269 strprintf("Relay and mine data carrier transactions (default: %d)",
1272 argsman.AddArg(
1273 "-datacarriersize",
1274 strprintf("Maximum size of data in data carrier transactions "
1275 "we relay and mine (default: %u)",
1278 argsman.AddArg(
1279 "-minrelaytxfee=<amt>",
1280 strprintf("Fees (in %s/kB) smaller than this are rejected for "
1281 "relaying, mining and transaction creation (default: %s)",
1284 argsman.AddArg(
1285 "-whitelistrelay",
1286 strprintf("Add 'relay' permission to whitelisted peers "
1287 "with default permissions. This will accept relayed "
1288 "transactions even when not relaying transactions "
1289 "(default: %d)",
1292 argsman.AddArg(
1293 "-whitelistforcerelay",
1294 strprintf("Add 'forcerelay' permission to whitelisted peers "
1295 "with default permissions. This will relay transactions "
1296 "even if the transactions were already in the mempool "
1297 "(default: %d)",
1300
1301 argsman.AddArg("-blockmaxsize=<n>",
1302 strprintf("Set maximum block size in bytes (default: %d)",
1305 argsman.AddArg(
1306 "-blockmintxfee=<amt>",
1307 strprintf("Set lowest fee rate (in %s/kB) for transactions to "
1308 "be included in block creation. (default: %s)",
1311 argsman.AddArg("-simplegbt",
1312 "Use a simplified getblocktemplate output (default: 0)",
1314
1315 argsman.AddArg("-blockversion=<n>",
1316 "Override block version to test forking scenarios",
1319
1320 argsman.AddArg("-server", "Accept command line and JSON-RPC commands",
1322 argsman.AddArg("-rest",
1323 strprintf("Accept public REST requests (default: %d)",
1326 argsman.AddArg(
1327 "-rpcbind=<addr>[:port]",
1328 "Bind to given address to listen for JSON-RPC connections. Do not "
1329 "expose the RPC server to untrusted networks such as the public "
1330 "internet! This option is ignored unless -rpcallowip is also passed. "
1331 "Port is optional and overrides -rpcport. Use [host]:port notation "
1332 "for IPv6. This option can be specified multiple times (default: "
1333 "127.0.0.1 and ::1 i.e., localhost)",
1337 argsman.AddArg(
1338 "-rpcdoccheck",
1339 strprintf("Throw a non-fatal error at runtime if the documentation for "
1340 "an RPC is incorrect (default: %u)",
1343 argsman.AddArg(
1344 "-rpccookiefile=<loc>",
1345 "Location of the auth cookie. Relative paths will be prefixed "
1346 "by a net-specific datadir location. (default: data dir)",
1348 argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
1351 argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
1354 argsman.AddArg(
1355 "-rpcwhitelist=<whitelist>",
1356 "Set a whitelist to filter incoming RPC calls for a specific user. The "
1357 "field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc "
1358 "2>,...,<rpc n>. If multiple whitelists are set for a given user, they "
1359 "are set-intersected. See -rpcwhitelistdefault documentation for "
1360 "information on default whitelist behavior.",
1362 argsman.AddArg(
1363 "-rpcwhitelistdefault",
1364 "Sets default behavior for rpc whitelisting. Unless "
1365 "rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc "
1366 "server acts as if all rpc users are subject to "
1367 "empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault "
1368 "is set to 1 and no -rpcwhitelist is set, rpc server acts as if all "
1369 "rpc users are subject to empty whitelists.",
1371 argsman.AddArg(
1372 "-rpcauth=<userpw>",
1373 "Username and HMAC-SHA-256 hashed password for JSON-RPC connections. "
1374 "The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A "
1375 "canonical python script is included in share/rpcauth. The client then "
1376 "connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> "
1377 "pair of arguments. This option can be specified multiple times",
1379 argsman.AddArg("-rpcport=<port>",
1380 strprintf("Listen for JSON-RPC connections on <port> "
1381 "(default: %u, testnet: %u, regtest: %u)",
1382 defaultBaseParams->RPCPort(),
1383 testnetBaseParams->RPCPort(),
1384 regtestBaseParams->RPCPort()),
1387 argsman.AddArg(
1388 "-rpcallowip=<ip>",
1389 "Allow JSON-RPC connections from specified source. Valid for "
1390 "<ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. "
1391 "1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). "
1392 "This option can be specified multiple times",
1394 argsman.AddArg(
1395 "-rpcthreads=<n>",
1396 strprintf(
1397 "Set the number of threads to service RPC calls (default: %d)",
1400 argsman.AddArg(
1401 "-rpccorsdomain=value",
1402 "Domain from which to accept cross origin requests (browser enforced)",
1404
1405 argsman.AddArg("-rpcworkqueue=<n>",
1406 strprintf("Set the depth of the work queue to service RPC "
1407 "calls (default: %d)",
1411 argsman.AddArg("-rpcservertimeout=<n>",
1412 strprintf("Timeout during HTTP requests (default: %d)",
1416
1417#if HAVE_DECL_FORK
1418 argsman.AddArg("-daemon",
1419 strprintf("Run in the background as a daemon and accept "
1420 "commands (default: %d)",
1423 argsman.AddArg("-daemonwait",
1424 strprintf("Wait for initialization to be finished before "
1425 "exiting. This implies -daemon (default: %d)",
1428#else
1429 hidden_args.emplace_back("-daemon");
1430 hidden_args.emplace_back("-daemonwait");
1431#endif
1432
1433 // Avalanche options.
1434 argsman.AddArg("-avalanche",
1435 strprintf("Enable the avalanche feature (default: %u)",
1438 argsman.AddArg(
1439 "-avalanchestakingrewards",
1440 strprintf("Enable the avalanche staking rewards feature (default: %u, "
1441 "testnet: %u, regtest: %u)",
1442 defaultChainParams->GetConsensus().enableStakingRewards,
1443 testnetChainParams->GetConsensus().enableStakingRewards,
1444 regtestChainParams->GetConsensus().enableStakingRewards),
1446 argsman.AddArg("-avalancheconflictingproofcooldown",
1447 strprintf("Mandatory cooldown before a proof conflicting "
1448 "with an already registered one can be considered "
1449 "in seconds (default: %u)",
1453 argsman.AddArg("-avalanchepeerreplacementcooldown",
1454 strprintf("Mandatory cooldown before a peer can be replaced "
1455 "in seconds (default: %u)",
1459 argsman.AddArg(
1460 "-avaminquorumstake",
1461 strprintf(
1462 "Minimum amount of known stake for a usable quorum (default: %s)",
1465 argsman.AddArg(
1466 "-avaminquorumconnectedstakeratio",
1467 strprintf("Minimum proportion of known stake we"
1468 " need nodes for to have a usable quorum (default: %s). "
1469 "This parameter is parsed with a maximum precision of "
1470 "0.000001.",
1474 argsman.AddArg(
1475 "-avaminavaproofsnodecount",
1476 strprintf("Minimum number of node that needs to send us an avaproofs"
1477 " message before we consider we have a usable quorum"
1478 " (default: %s)",
1482 argsman.AddArg(
1483 "-avastalevotethreshold",
1484 strprintf("Number of avalanche votes before a voted item goes stale "
1485 "when voting confidence is low (default: %u)",
1489 argsman.AddArg(
1490 "-avastalevotefactor",
1491 strprintf(
1492 "Factor affecting the number of avalanche votes before a voted "
1493 "item goes stale when voting confidence is high (default: %u)",
1497 argsman.AddArg("-avacooldown",
1498 strprintf("Mandatory cooldown between two avapoll in "
1499 "milliseconds (default: %u)",
1502 argsman.AddArg(
1503 "-avatimeout",
1504 strprintf("Avalanche query timeout in milliseconds (default: %u)",
1507 argsman.AddArg(
1508 "-avadelegation",
1509 "Avalanche proof delegation to the master key used by this node "
1510 "(default: none). Should be used in conjunction with -avaproof and "
1511 "-avamasterkey",
1513 argsman.AddArg("-avaproof",
1514 "Avalanche proof to be used by this node (default: none)",
1516 argsman.AddArg(
1517 "-avaproofstakeutxoconfirmations",
1518 strprintf(
1519 "Minimum number of confirmations before a stake utxo is mature"
1520 " enough to be included into a proof. Utxos in the mempool are not "
1521 "accepted (i.e this value must be greater than 0) (default: %s)",
1525 argsman.AddArg("-avaproofstakeutxodustthreshold",
1526 strprintf("Minimum value each stake utxo must have to be "
1527 "considered valid (default: %s)",
1530 argsman.AddArg("-avamasterkey",
1531 "Master key associated with the proof. If a proof is "
1532 "required, this is mandatory.",
1535 argsman.AddArg("-avasessionkey", "Avalanche session key (default: random)",
1538 argsman.AddArg("-enablertt",
1539 strprintf("Whether to enforce Real Time Targeting via "
1540 "Avalanche, default (%u)",
1543 argsman.AddArg(
1544 "-maxavalancheoutbound",
1545 strprintf(
1546 "Set the maximum number of avalanche outbound peers to connect to. "
1547 "Note that this option takes precedence over the -maxconnections "
1548 "option (default: %u).",
1552 argsman.AddArg(
1553 "-persistavapeers",
1554 strprintf("Whether to save the avalanche peers upon shutdown and load "
1555 "them upon startup (default: %u).",
1558
1559 hidden_args.emplace_back("-avalanchepreconsensus");
1560 hidden_args.emplace_back("-avalanchestakingpreconsensus");
1561
1562 // Add the hidden options
1563 argsman.AddHiddenArgs(hidden_args);
1564}
1565
1566static bool fHaveGenesis = false;
1568static std::condition_variable g_genesis_wait_cv;
1569
1570static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex) {
1571 if (pBlockIndex != nullptr) {
1572 {
1574 fHaveGenesis = true;
1575 }
1576 g_genesis_wait_cv.notify_all();
1577 }
1578}
1579
1580#if HAVE_SYSTEM
1581static void StartupNotify(const ArgsManager &args) {
1582 std::string cmd = args.GetArg("-startupnotify", "");
1583 if (!cmd.empty()) {
1584 std::thread t(runCommand, cmd);
1585 // thread runs free
1586 t.detach();
1587 }
1588}
1589#endif
1590
1591static bool AppInitServers(Config &config,
1592 HTTPRPCRequestProcessor &httpRPCRequestProcessor,
1593 NodeContext &node) {
1594 const ArgsManager &args = *Assert(node.args);
1597 if (!InitHTTPServer(config)) {
1598 return false;
1599 }
1600
1601 StartRPC();
1602 node.rpc_interruption_point = RpcInterruptionPoint;
1603
1604 if (!StartHTTPRPC(httpRPCRequestProcessor)) {
1605 return false;
1606 }
1607 if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
1608 StartREST(&node);
1609 }
1610
1612 return true;
1613}
1614
1615// Parameter interaction based on rules
1617 // when specifying an explicit binding address, you want to listen on it
1618 // even when -connect or -proxy is specified.
1619 if (args.IsArgSet("-bind")) {
1620 if (args.SoftSetBoolArg("-listen", true)) {
1621 LogPrintf(
1622 "%s: parameter interaction: -bind set -> setting -listen=1\n",
1623 __func__);
1624 }
1625 }
1626 if (args.IsArgSet("-whitebind")) {
1627 if (args.SoftSetBoolArg("-listen", true)) {
1628 LogPrintf("%s: parameter interaction: -whitebind set -> setting "
1629 "-listen=1\n",
1630 __func__);
1631 }
1632 }
1633
1634 if (args.IsArgSet("-connect")) {
1635 // when only connecting to trusted nodes, do not seed via DNS, or listen
1636 // by default.
1637 if (args.SoftSetBoolArg("-dnsseed", false)) {
1638 LogPrintf("%s: parameter interaction: -connect set -> setting "
1639 "-dnsseed=0\n",
1640 __func__);
1641 }
1642 if (args.SoftSetBoolArg("-listen", false)) {
1643 LogPrintf("%s: parameter interaction: -connect set -> setting "
1644 "-listen=0\n",
1645 __func__);
1646 }
1647 }
1648
1649 if (args.IsArgSet("-proxy")) {
1650 // to protect privacy, do not listen by default if a default proxy
1651 // server is specified.
1652 if (args.SoftSetBoolArg("-listen", false)) {
1653 LogPrintf(
1654 "%s: parameter interaction: -proxy set -> setting -listen=0\n",
1655 __func__);
1656 }
1657 // to protect privacy, do not map ports when a proxy is set. The user
1658 // may still specify -listen=1 to listen locally, so don't rely on this
1659 // happening through -listen below.
1660 if (args.SoftSetBoolArg("-upnp", false)) {
1661 LogPrintf(
1662 "%s: parameter interaction: -proxy set -> setting -upnp=0\n",
1663 __func__);
1664 }
1665 if (args.SoftSetBoolArg("-natpmp", false)) {
1666 LogPrintf(
1667 "%s: parameter interaction: -proxy set -> setting -natpmp=0\n",
1668 __func__);
1669 }
1670 // to protect privacy, do not discover addresses by default
1671 if (args.SoftSetBoolArg("-discover", false)) {
1672 LogPrintf("%s: parameter interaction: -proxy set -> setting "
1673 "-discover=0\n",
1674 __func__);
1675 }
1676 }
1677
1678 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
1679 // do not map ports or try to retrieve public IP when not listening
1680 // (pointless)
1681 if (args.SoftSetBoolArg("-upnp", false)) {
1682 LogPrintf(
1683 "%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
1684 __func__);
1685 }
1686 if (args.SoftSetBoolArg("-natpmp", false)) {
1687 LogPrintf(
1688 "%s: parameter interaction: -listen=0 -> setting -natpmp=0\n",
1689 __func__);
1690 }
1691 if (args.SoftSetBoolArg("-discover", false)) {
1692 LogPrintf(
1693 "%s: parameter interaction: -listen=0 -> setting -discover=0\n",
1694 __func__);
1695 }
1696 if (args.SoftSetBoolArg("-listenonion", false)) {
1697 LogPrintf("%s: parameter interaction: -listen=0 -> setting "
1698 "-listenonion=0\n",
1699 __func__);
1700 }
1701 if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
1702 LogPrintf("%s: parameter interaction: -listen=0 -> setting "
1703 "-i2pacceptincoming=0\n",
1704 __func__);
1705 }
1706 }
1707
1708 if (args.IsArgSet("-externalip")) {
1709 // if an explicit public IP is specified, do not try to find others
1710 if (args.SoftSetBoolArg("-discover", false)) {
1711 LogPrintf("%s: parameter interaction: -externalip set -> setting "
1712 "-discover=0\n",
1713 __func__);
1714 }
1715 }
1716
1717 // disable whitelistrelay in blocksonly mode
1718 if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
1719 if (args.SoftSetBoolArg("-whitelistrelay", false)) {
1720 LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
1721 "-whitelistrelay=0\n",
1722 __func__);
1723 }
1724 }
1725
1726 // Forcing relay from whitelisted hosts implies we will accept relays from
1727 // them in the first place.
1728 if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
1729 if (args.SoftSetBoolArg("-whitelistrelay", true)) {
1730 LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
1731 "setting -whitelistrelay=1\n",
1732 __func__);
1733 }
1734 }
1735
1736 // If avalanche is set, soft set all the feature flags accordingly.
1737 if (args.IsArgSet("-avalanche")) {
1738 const bool fAvalanche =
1739 args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
1740 args.SoftSetBoolArg("-automaticunparking", !fAvalanche);
1741 }
1742}
1743
1750void InitLogging(const ArgsManager &args) {
1753}
1754
1755namespace { // Variables internal to initialization process only
1756
1757int nMaxConnections;
1758int nUserMaxConnections;
1759int nFD;
1761int64_t peer_connect_timeout;
1762std::set<BlockFilterType> g_enabled_filter_types;
1763
1764} // namespace
1765
1766[[noreturn]] static void new_handler_terminate() {
1767 // Rather than throwing std::bad-alloc if allocation fails, terminate
1768 // immediately to (try to) avoid chain corruption. Since LogPrintf may
1769 // itself allocate memory, set the handler directly to terminate first.
1770 std::set_new_handler(std::terminate);
1771 LogPrintf("Error: Out of memory. Terminating.\n");
1772
1773 // The log was successful, terminate now.
1774 std::terminate();
1775};
1776
1778// Step 1: setup
1779#ifdef _MSC_VER
1780 // Turn off Microsoft heap dump noise
1781 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
1782 _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
1783 OPEN_EXISTING, 0, 0));
1784 // Disable confusing "helpful" text message on abort, Ctrl-C
1785 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
1786#endif
1787#ifdef WIN32
1788 // Enable Data Execution Prevention (DEP)
1789 SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
1790#endif
1791 if (!InitShutdownState()) {
1792 return InitError(
1793 Untranslated("Initializing wait-for-shutdown state failed."));
1794 }
1795
1796 if (!SetupNetworking()) {
1797 return InitError(Untranslated("Initializing networking failed"));
1798 }
1799
1800#ifndef WIN32
1801 if (!args.GetBoolArg("-sysperms", false)) {
1802 umask(077);
1803 }
1804
1805 // Clean shutdown on SIGTERM
1808
1809 // Reopen debug.log on SIGHUP
1811
1812 // Ignore SIGPIPE, otherwise it will bring the daemon down if the client
1813 // closes unexpectedly
1814 signal(SIGPIPE, SIG_IGN);
1815#else
1816 SetConsoleCtrlHandler(consoleCtrlHandler, true);
1817#endif
1818
1819 std::set_new_handler(new_handler_terminate);
1820
1821 return true;
1822}
1823
1825 const CChainParams &chainparams = config.GetChainParams();
1826 // Step 2: parameter interactions
1827
1828 // also see: InitParameterInteraction()
1829
1830 // Error if network-specific options (-addnode, -connect, etc) are
1831 // specified in default section of config file, but not overridden
1832 // on the command line or in this chain's section of the config file.
1833 ChainType chain = args.GetChainType();
1834 bilingual_str errors;
1835 for (const auto &arg : args.GetUnsuitableSectionOnlyArgs()) {
1836 errors +=
1837 strprintf(_("Config setting for %s only applied on %s "
1838 "network when in [%s] section.") +
1839 Untranslated("\n"),
1840 arg, ChainTypeToString(chain), ChainTypeToString(chain));
1841 }
1842
1843 if (!errors.empty()) {
1844 return InitError(errors);
1845 }
1846
1847 // Warn if unrecognized section name are present in the config file.
1848 bilingual_str warnings;
1849 for (const auto &section : args.GetUnrecognizedSections()) {
1850 warnings += strprintf(Untranslated("%s:%i ") +
1851 _("Section [%s] is not recognized.") +
1852 Untranslated("\n"),
1853 section.m_file, section.m_line, section.m_name);
1854 }
1855
1856 if (!warnings.empty()) {
1857 InitWarning(warnings);
1858 }
1859
1860 if (!fs::is_directory(args.GetBlocksDirPath())) {
1861 return InitError(
1862 strprintf(_("Specified blocks directory \"%s\" does not exist."),
1863 args.GetArg("-blocksdir", "")));
1864 }
1865
1866 // parse and validate enabled filter types
1867 std::string blockfilterindex_value =
1868 args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
1869 if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
1870 g_enabled_filter_types = AllBlockFilterTypes();
1871 } else if (blockfilterindex_value != "0") {
1872 const std::vector<std::string> names =
1873 args.GetArgs("-blockfilterindex");
1874 for (const auto &name : names) {
1875 BlockFilterType filter_type;
1876 if (!BlockFilterTypeByName(name, filter_type)) {
1877 return InitError(
1878 strprintf(_("Unknown -blockfilterindex value %s."), name));
1879 }
1880 g_enabled_filter_types.insert(filter_type);
1881 }
1882 }
1883
1884 // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index
1885 // are both enabled.
1886 if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
1887 if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
1888 return InitError(
1889 _("Cannot set -peerblockfilters without -blockfilterindex."));
1890 }
1891
1892 nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
1893 }
1894
1895 if (args.GetIntArg("-prune", 0)) {
1896 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1897 return InitError(_("Prune mode is incompatible with -txindex."));
1898 }
1899 if (args.GetBoolArg("-reindex-chainstate", false)) {
1900 return InitError(
1901 _("Prune mode is incompatible with -reindex-chainstate. Use "
1902 "full -reindex instead."));
1903 }
1904 if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
1905 return InitError(_("Prune mode is incompatible with -chronik."));
1906 }
1907 }
1908
1909 // -bind and -whitebind can't be set when not listening
1910 size_t nUserBind =
1911 args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
1912 if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
1913 return InitError(Untranslated(
1914 "Cannot set -bind or -whitebind together with -listen=0"));
1915 }
1916
1917 // Make sure enough file descriptors are available
1918 int nBind = std::max(nUserBind, size_t(1));
1919 nUserMaxConnections =
1920 args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
1921 nMaxConnections = std::max(nUserMaxConnections, 0);
1922
1923 // -maxavalancheoutbound takes precedence over -maxconnections
1924 const int maxAvalancheOutbound = args.GetIntArg(
1925 "-maxavalancheoutbound", DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS);
1926 const bool fAvalanche =
1927 args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
1928 if (fAvalanche && maxAvalancheOutbound > nMaxConnections) {
1929 nMaxConnections = std::max(maxAvalancheOutbound, nMaxConnections);
1930 // Indicate the value set by the user
1931 LogPrintf("Increasing -maxconnections from %d to %d to comply with "
1932 "-maxavalancheoutbound\n",
1933 nUserMaxConnections, nMaxConnections);
1934 }
1935
1936 // Trim requested connection counts, to fit into system limitations
1937 // <int> in std::min<int>(...) to work around FreeBSD compilation issue
1938 // described in #2695
1940 nMaxConnections + nBind + MIN_CORE_FILEDESCRIPTORS +
1942#ifdef USE_POLL
1943 int fd_max = nFD;
1944#else
1945 int fd_max = FD_SETSIZE;
1946#endif
1947 nMaxConnections = std::max(
1948 std::min<int>(nMaxConnections,
1949 fd_max - nBind - MIN_CORE_FILEDESCRIPTORS -
1951 0);
1952 if (nFD < MIN_CORE_FILEDESCRIPTORS) {
1953 return InitError(_("Not enough file descriptors available."));
1954 }
1955 nMaxConnections =
1957 nMaxConnections);
1958
1959 if (nMaxConnections < nUserMaxConnections) {
1960 // Not categorizing as "Warning" because this is the normal behavior for
1961 // platforms using the select() interface for which FD_SETSIZE is
1962 // usually 1024.
1963 LogPrintf("Reducing -maxconnections from %d to %d, because of system "
1964 "limitations.\n",
1965 nUserMaxConnections, nMaxConnections);
1966 }
1967
1968 // Step 3: parameter-to-internal-flags
1971
1972 // Configure excessive block size.
1973 const int64_t nProposedExcessiveBlockSize =
1974 args.GetIntArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
1975 if (nProposedExcessiveBlockSize <= 0 ||
1976 !config.SetMaxBlockSize(nProposedExcessiveBlockSize)) {
1977 return InitError(
1978 _("Excessive block size must be > 1,000,000 bytes (1MB)"));
1979 }
1980
1981 // Check blockmaxsize does not exceed maximum accepted block size.
1982 const int64_t nProposedMaxGeneratedBlockSize =
1983 args.GetIntArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
1984 if (nProposedMaxGeneratedBlockSize <= 0) {
1985 return InitError(_("Max generated block size must be greater than 0"));
1986 }
1987 if (uint64_t(nProposedMaxGeneratedBlockSize) > config.GetMaxBlockSize()) {
1988 return InitError(_("Max generated block size (blockmaxsize) cannot "
1989 "exceed the excessive block size "
1990 "(excessiveblocksize)"));
1991 }
1992
1994 if (nConnectTimeout <= 0) {
1996 }
1997
1998 peer_connect_timeout =
1999 args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
2000 if (peer_connect_timeout <= 0) {
2001 return InitError(Untranslated(
2002 "peertimeout cannot be configured with a negative value."));
2003 }
2004
2005 // Sanity check argument for min fee for including tx in block
2006 // TODO: Harmonize which arguments need sanity checking and where that
2007 // happens.
2008 if (args.IsArgSet("-blockmintxfee")) {
2009 Amount n = Amount::zero();
2010 if (!ParseMoney(args.GetArg("-blockmintxfee", ""), n)) {
2011 return InitError(AmountErrMsg("blockmintxfee",
2012 args.GetArg("-blockmintxfee", "")));
2013 }
2014 }
2015
2017 args.IsArgSet("-bytespersigcheck")
2018 ? args.GetIntArg("-bytespersigcheck", nBytesPerSigCheck)
2019 : args.GetIntArg("-bytespersigop", nBytesPerSigCheck);
2020
2022 return false;
2023 }
2024
2025 // Option to startup with mocktime set (used for regression testing):
2026 SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
2027
2028 if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
2029 nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
2030 }
2031
2032 // Avalanche parameters
2033 const int64_t stakeUtxoMinConfirmations =
2034 args.GetIntArg("-avaproofstakeutxoconfirmations",
2036
2037 if (!chainparams.IsTestChain() &&
2038 stakeUtxoMinConfirmations !=
2040 return InitError(_("Avalanche stake UTXO minimum confirmations can "
2041 "only be set on test chains."));
2042 }
2043
2044 if (stakeUtxoMinConfirmations <= 0) {
2045 return InitError(_("Avalanche stake UTXO minimum confirmations must be "
2046 "a positive integer."));
2047 }
2048
2049 if (args.IsArgSet("-avaproofstakeutxodustthreshold")) {
2050 Amount amount = Amount::zero();
2051 auto parsed = ParseMoney(
2052 args.GetArg("-avaproofstakeutxodustthreshold", ""), amount);
2053 if (!parsed || Amount::zero() == amount) {
2054 return InitError(AmountErrMsg(
2055 "avaproofstakeutxodustthreshold",
2056 args.GetArg("-avaproofstakeutxodustthreshold", "")));
2057 }
2058
2059 if (!chainparams.IsTestChain() &&
2061 return InitError(_("Avalanche stake UTXO dust threshold can "
2062 "only be set on test chains."));
2063 }
2064 }
2065
2066 // This is a staking node
2067 if (fAvalanche && args.IsArgSet("-avaproof")) {
2068 if (!args.GetBoolArg("-listen", true)) {
2069 return InitError(_("Running a staking node requires accepting "
2070 "inbound connections. Please enable -listen."));
2071 }
2072 if (args.IsArgSet("-proxy")) {
2073 return InitError(_("Running a staking node behind a proxy is not "
2074 "supported. Please disable -proxy."));
2075 }
2076 if (args.IsArgSet("-i2psam")) {
2077 return InitError(_("Running a staking node behind I2P is not "
2078 "supported. Please disable -i2psam."));
2079 }
2080 if (args.IsArgSet("-onlynet")) {
2081 return InitError(
2082 _("Restricting the outbound network is not supported when "
2083 "running a staking node. Please disable -onlynet."));
2084 }
2085 }
2086
2087 // Also report errors from parsing before daemonization
2088 {
2089 KernelNotifications notifications{};
2090 ChainstateManager::Options chainman_opts_dummy{
2091 .config = config,
2092 .datadir = args.GetDataDirNet(),
2093 .notifications = notifications,
2094 };
2095 if (const auto error{ApplyArgsManOptions(args, chainman_opts_dummy)}) {
2096 return InitError(*error);
2097 }
2098 BlockManager::Options blockman_opts_dummy{
2099 .chainparams = chainman_opts_dummy.config.GetChainParams(),
2100 .blocks_dir = args.GetBlocksDirPath(),
2101 };
2102 if (const auto error{ApplyArgsManOptions(args, blockman_opts_dummy)}) {
2103 return InitError(*error);
2104 }
2105 }
2106
2107 return true;
2108}
2109
2110static bool LockDataDirectory(bool probeOnly) {
2111 // Make sure only a single Bitcoin process is using the data directory.
2112 const fs::path &datadir = gArgs.GetDataDirNet();
2113 if (!DirIsWritable(datadir)) {
2114 return InitError(strprintf(
2115 _("Cannot write to data directory '%s'; check permissions."),
2116 fs::PathToString(datadir)));
2117 }
2118 if (!LockDirectory(datadir, ".lock", probeOnly)) {
2119 return InitError(strprintf(_("Cannot obtain a lock on data directory "
2120 "%s. %s is probably already running."),
2121 fs::PathToString(datadir), PACKAGE_NAME));
2122 }
2123 return true;
2124}
2125
2127 // Step 4: sanity checks
2128 auto result{kernel::SanityChecks(kernel)};
2129 if (!result) {
2131 return InitError(strprintf(
2132 _("Initialization sanity check failed. %s is shutting down."),
2133 PACKAGE_NAME));
2134 }
2135
2136 // Probe the data directory lock to give an early error message, if possible
2137 // We cannot hold the data directory lock here, as the forking for daemon()
2138 // hasn't yet happened, and a fork will cause weird behavior to it.
2139 return LockDataDirectory(true);
2140}
2141
2143 // After daemonization get the data directory lock again and hold on to it
2144 // until exit. This creates a slight window for a race condition to happen,
2145 // however this condition is harmless: it will at most make us exit without
2146 // printing a message to console.
2147 if (!LockDataDirectory(false)) {
2148 // Detailed error printed inside LockDataDirectory
2149 return false;
2150 }
2151 return true;
2152}
2153
2156 // Create client interfaces for wallets that are supposed to be loaded
2157 // according to -wallet and -disablewallet options. This only constructs
2158 // the interfaces, it doesn't load wallet data. Wallets actually get loaded
2159 // when load() and start() interface methods are called below.
2161 return true;
2162}
2163
2164bool AppInitMain(Config &config, RPCServer &rpcServer,
2165 HTTPRPCRequestProcessor &httpRPCRequestProcessor,
2168 // Step 4a: application initialization
2169 const ArgsManager &args = *Assert(node.args);
2170 const CChainParams &chainparams = config.GetChainParams();
2171
2172 if (!CreatePidFile(args)) {
2173 // Detailed error printed inside CreatePidFile().
2174 return false;
2175 }
2176 if (!init::StartLogging(args)) {
2177 // Detailed error printed inside StartLogging().
2178 return false;
2179 }
2180
2181 LogPrintf("Using at most %i automatic connections (%i file descriptors "
2182 "available)\n",
2183 nMaxConnections, nFD);
2184
2185 // Warn about relative -datadir path.
2186 if (args.IsArgSet("-datadir") &&
2187 !args.GetPathArg("-datadir").is_absolute()) {
2188 LogPrintf("Warning: relative datadir option '%s' specified, which will "
2189 "be interpreted relative to the current working directory "
2190 "'%s'. This is fragile, because if bitcoin is started in the "
2191 "future from a different location, it will be unable to "
2192 "locate the current data files. There could also be data "
2193 "loss if bitcoin is started while in a temporary "
2194 "directory.\n",
2195 args.GetArg("-datadir", ""),
2196 fs::PathToString(fs::current_path()));
2197 }
2198
2199 ValidationCacheSizes validation_cache_sizes{};
2200 ApplyArgsManOptions(args, validation_cache_sizes);
2201
2202 if (!InitSignatureCache(validation_cache_sizes.signature_cache_bytes)) {
2203 return InitError(strprintf(
2204 _("Unable to allocate memory for -maxsigcachesize: '%s' MiB"),
2205 args.GetIntArg("-maxsigcachesize",
2207 }
2209 validation_cache_sizes.script_execution_cache_bytes)) {
2210 return InitError(strprintf(
2211 _("Unable to allocate memory for -maxscriptcachesize: '%s' MiB"),
2212 args.GetIntArg("-maxscriptcachesize",
2214 }
2215
2216 int script_threads = args.GetIntArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
2217 if (script_threads <= 0) {
2218 // -par=0 means autodetect (number of cores - 1 script threads)
2219 // -par=-n means "leave n cores free" (number of cores - n - 1 script
2220 // threads)
2221 script_threads += GetNumCores();
2222 }
2223
2224 // Subtract 1 because the main thread counts towards the par threads
2225 script_threads = std::max(script_threads - 1, 0);
2226
2227 // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
2228 script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
2229
2230 LogPrintf("Script verification uses %d additional threads\n",
2231 script_threads);
2232 if (script_threads >= 1) {
2233 StartScriptCheckWorkerThreads(script_threads);
2234 }
2235
2236 assert(!node.scheduler);
2237 node.scheduler = std::make_unique<CScheduler>();
2238
2239 // Start the lightweight task scheduler thread
2240 node.scheduler->m_service_thread =
2241 std::thread(&util::TraceThread, "scheduler",
2242 [&] { node.scheduler->serviceQueue(); });
2243
2244 // Gather some entropy once per minute.
2245 node.scheduler->scheduleEvery(
2246 [] {
2248 return true;
2249 },
2250 std::chrono::minutes{1});
2251
2253
2258 RegisterAllRPCCommands(config, rpcServer, tableRPC);
2259 for (const auto &client : node.chain_clients) {
2260 client->registerRpcs();
2261 }
2262#if ENABLE_ZMQ
2264#endif
2265
2272 if (args.GetBoolArg("-server", false)) {
2273 uiInterface.InitMessage_connect(SetRPCWarmupStatus);
2274 if (!AppInitServers(config, httpRPCRequestProcessor, node)) {
2275 return InitError(
2276 _("Unable to start HTTP server. See debug log for details."));
2277 }
2278 }
2279
2280 // Step 5: verify wallet database integrity
2281 for (const auto &client : node.chain_clients) {
2282 if (!client->verify()) {
2283 return false;
2284 }
2285 }
2286
2287 // Step 6: network initialization
2288
2289 // Note that we absolutely cannot open any actual connections
2290 // until the very end ("start node") as the UTXO/block state
2291 // is not yet setup and may end up being set up twice if we
2292 // need to reindex later.
2293
2294 fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
2295 fDiscover = args.GetBoolArg("-discover", true);
2296
2297 {
2298 // Initialize addrman
2299 assert(!node.addrman);
2300
2301 // Read asmap file if configured
2302 std::vector<bool> asmap;
2303 if (args.IsArgSet("-asmap")) {
2304 fs::path asmap_path =
2305 args.GetPathArg("-asmap", DEFAULT_ASMAP_FILENAME);
2306 if (!asmap_path.is_absolute()) {
2307 asmap_path = args.GetDataDirNet() / asmap_path;
2308 }
2309 if (!fs::exists(asmap_path)) {
2310 InitError(strprintf(_("Could not find asmap file %s"),
2311 fs::quoted(fs::PathToString(asmap_path))));
2312 return false;
2313 }
2314 asmap = DecodeAsmap(asmap_path);
2315 if (asmap.size() == 0) {
2316 InitError(strprintf(_("Could not parse asmap file %s"),
2317 fs::quoted(fs::PathToString(asmap_path))));
2318 return false;
2319 }
2320 const uint256 asmap_version = (HashWriter{} << asmap).GetHash();
2321 LogPrintf("Using asmap version %s for IP bucketing\n",
2322 asmap_version.ToString());
2323 } else {
2324 LogPrintf("Using /16 prefix for IP bucketing\n");
2325 }
2326
2327 uiInterface.InitMessage(_("Loading P2P addresses...").translated);
2328 auto addrman{LoadAddrman(chainparams, asmap, args)};
2329 if (!addrman) {
2330 return InitError(util::ErrorString(addrman));
2331 }
2332 node.addrman = std::move(*addrman);
2333 }
2334
2335 assert(!node.banman);
2336 node.banman = std::make_unique<BanMan>(
2337 args.GetDataDirNet() / "banlist.dat", config.GetChainParams(),
2339 assert(!node.connman);
2340 node.connman = std::make_unique<CConnman>(
2341 config, GetRand<uint64_t>(), GetRand<uint64_t>(), *node.addrman,
2342 args.GetBoolArg("-networkactive", true));
2343
2344 // sanitize comments per BIP-0014, format user agent and check total size
2345 std::vector<std::string> uacomments;
2346 for (const std::string &cmt : args.GetArgs("-uacomment")) {
2347 if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) {
2348 return InitError(strprintf(
2349 _("User Agent comment (%s) contains unsafe characters."), cmt));
2350 }
2351 uacomments.push_back(cmt);
2352 }
2353 const std::string client_name = args.GetArg("-uaclientname", CLIENT_NAME);
2354 const std::string client_version =
2355 args.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));
2356 if (client_name != SanitizeString(client_name, SAFE_CHARS_UA_COMMENT)) {
2357 return InitError(strprintf(
2358 _("-uaclientname (%s) contains invalid characters."), client_name));
2359 }
2360 if (client_version !=
2361 SanitizeString(client_version, SAFE_CHARS_UA_COMMENT)) {
2362 return InitError(
2363 strprintf(_("-uaclientversion (%s) contains invalid characters."),
2364 client_version));
2365 }
2366 const std::string strSubVersion =
2367 FormatUserAgent(client_name, client_version, uacomments);
2368 if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
2369 return InitError(strprintf(
2370 _("Total length of network version string (%i) exceeds maximum "
2371 "length (%i). Reduce the number or size of uacomments."),
2372 strSubVersion.size(), MAX_SUBVERSION_LENGTH));
2373 }
2374
2375 if (args.IsArgSet("-onlynet")) {
2376 std::set<enum Network> nets;
2377 for (const std::string &snet : args.GetArgs("-onlynet")) {
2378 enum Network net = ParseNetwork(snet);
2379 if (net == NET_UNROUTABLE) {
2380 return InitError(strprintf(
2381 _("Unknown network specified in -onlynet: '%s'"), snet));
2382 }
2383 nets.insert(net);
2384 }
2385 for (int n = 0; n < NET_MAX; n++) {
2386 enum Network net = (enum Network)n;
2387 if (!nets.count(net)) {
2388 SetReachable(net, false);
2389 }
2390 }
2391 }
2392
2393 // Check for host lookup allowed before parsing any network related
2394 // parameters
2396
2397 bool proxyRandomize =
2398 args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
2399 // -proxy sets a proxy for all outgoing network traffic
2400 // -noproxy (or -proxy=0) as well as the empty string can be used to not set
2401 // a proxy, this is the default
2402 std::string proxyArg = args.GetArg("-proxy", "");
2403 SetReachable(NET_ONION, false);
2404 if (proxyArg != "" && proxyArg != "0") {
2405 CService proxyAddr;
2406 if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
2407 return InitError(strprintf(
2408 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
2409 }
2410
2411 proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
2412 if (!addrProxy.IsValid()) {
2413 return InitError(strprintf(
2414 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
2415 }
2416
2417 SetProxy(NET_IPV4, addrProxy);
2418 SetProxy(NET_IPV6, addrProxy);
2419 SetProxy(NET_ONION, addrProxy);
2420 SetNameProxy(addrProxy);
2421 // by default, -proxy sets onion as reachable, unless -noonion later
2422 SetReachable(NET_ONION, true);
2423 }
2424
2425 // -onion can be used to set only a proxy for .onion, or override normal
2426 // proxy for .onion addresses.
2427 // -noonion (or -onion=0) disables connecting to .onion entirely. An empty
2428 // string is used to not override the onion proxy (in which case it defaults
2429 // to -proxy set above, or none)
2430 std::string onionArg = args.GetArg("-onion", "");
2431 if (onionArg != "") {
2432 if (onionArg == "0") {
2433 // Handle -noonion/-onion=0
2434 SetReachable(NET_ONION, false);
2435 } else {
2436 CService onionProxy;
2437 if (!Lookup(onionArg, onionProxy, 9050, fNameLookup)) {
2438 return InitError(strprintf(
2439 _("Invalid -onion address or hostname: '%s'"), onionArg));
2440 }
2441 proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
2442 if (!addrOnion.IsValid()) {
2443 return InitError(strprintf(
2444 _("Invalid -onion address or hostname: '%s'"), onionArg));
2445 }
2446 SetProxy(NET_ONION, addrOnion);
2447 SetReachable(NET_ONION, true);
2448 }
2449 }
2450
2451 for (const std::string &strAddr : args.GetArgs("-externalip")) {
2452 CService addrLocal;
2453 if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) &&
2454 addrLocal.IsValid()) {
2455 AddLocal(addrLocal, LOCAL_MANUAL);
2456 } else {
2457 return InitError(ResolveErrMsg("externalip", strAddr));
2458 }
2459 }
2460
2461#if ENABLE_ZMQ
2463 [&chainman = node.chainman](CBlock &block, const CBlockIndex &index) {
2464 assert(chainman);
2465 return chainman->m_blockman.ReadBlockFromDisk(block, index);
2466 });
2467
2470 }
2471#endif
2472
2473 // Step 7: load block chain
2474
2475 node.notifications = std::make_unique<KernelNotifications>();
2476 fReindex = args.GetBoolArg("-reindex", false);
2477 bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
2478
2479 ChainstateManager::Options chainman_opts{
2480 .config = config,
2481 .datadir = args.GetDataDirNet(),
2482 .adjusted_time_callback = GetAdjustedTime,
2483 .notifications = *node.notifications,
2484 };
2485 // no error can happen, already checked in AppInitParameterInteraction
2486 Assert(!ApplyArgsManOptions(args, chainman_opts));
2487
2488 if (chainman_opts.checkpoints_enabled) {
2489 LogPrintf("Checkpoints will be verified.\n");
2490 } else {
2491 LogPrintf("Skipping checkpoint verification.\n");
2492 }
2493
2494 BlockManager::Options blockman_opts{
2495 .chainparams = chainman_opts.config.GetChainParams(),
2496 .blocks_dir = args.GetBlocksDirPath(),
2497 };
2498 // no error can happen, already checked in AppInitParameterInteraction
2499 Assert(!ApplyArgsManOptions(args, blockman_opts));
2500
2501 // cache size calculations
2502 CacheSizes cache_sizes =
2503 CalculateCacheSizes(args, g_enabled_filter_types.size());
2504
2505 LogPrintf("Cache configuration:\n");
2506 LogPrintf("* Using %.1f MiB for block index database\n",
2507 cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
2508 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
2509 LogPrintf("* Using %.1f MiB for transaction index database\n",
2510 cache_sizes.tx_index * (1.0 / 1024 / 1024));
2511 }
2512 for (BlockFilterType filter_type : g_enabled_filter_types) {
2513 LogPrintf("* Using %.1f MiB for %s block filter index database\n",
2514 cache_sizes.filter_index * (1.0 / 1024 / 1024),
2515 BlockFilterTypeName(filter_type));
2516 }
2517 LogPrintf("* Using %.1f MiB for chain state database\n",
2518 cache_sizes.coins_db * (1.0 / 1024 / 1024));
2519
2520 assert(!node.mempool);
2521 assert(!node.chainman);
2522
2523 CTxMemPool::Options mempool_opts{
2524 .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
2525 };
2526 if (const auto err{ApplyArgsManOptions(args, chainparams, mempool_opts)}) {
2527 return InitError(*err);
2528 }
2529 mempool_opts.check_ratio =
2530 std::clamp<int>(mempool_opts.check_ratio, 0, 1'000'000);
2531
2532 // FIXME: this legacy limit comes from the DEFAULT_DESCENDANT_SIZE_LIMIT
2533 // (101) that was enforced before the wellington activation. While it's
2534 // still a good idea to have some minimum mempool size, using this value as
2535 // a threshold is no longer relevant.
2536 int64_t nMempoolSizeMin = 101 * 1000 * 40;
2537 if (mempool_opts.max_size_bytes < 0 ||
2538 (!chainparams.IsTestChain() &&
2539 mempool_opts.max_size_bytes < nMempoolSizeMin)) {
2540 return InitError(strprintf(_("-maxmempool must be at least %d MB"),
2541 std::ceil(nMempoolSizeMin / 1000000.0)));
2542 }
2543 LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
2544 "unused mempool space)\n",
2545 cache_sizes.coins * (1.0 / 1024 / 1024),
2546 mempool_opts.max_size_bytes * (1.0 / 1024 / 1024));
2547
2548 for (bool fLoaded = false; !fLoaded && !ShutdownRequested();) {
2549 node.mempool = std::make_unique<CTxMemPool>(config, mempool_opts);
2550
2551 node.chainman =
2552 std::make_unique<ChainstateManager>(chainman_opts, blockman_opts);
2553 ChainstateManager &chainman = *node.chainman;
2554
2555 // This is defined and set here instead of inline in validation.h to
2556 // avoid a hard dependency between validation and index/base, since the
2557 // latter is not in libbitcoinkernel.
2558 chainman.snapshot_download_completed = [&node]() {
2559 if (!node.chainman->m_blockman.IsPruneMode()) {
2560 LogPrintf("[snapshot] re-enabling NODE_NETWORK services\n");
2561 node.connman->AddLocalServices(NODE_NETWORK);
2562 }
2563
2564 LogPrintf("[snapshot] restarting indexes\n");
2565
2566 // Drain the validation interface queue to ensure that the old
2567 // indexes don't have any pending work.
2569
2570 for (auto *index : node.indexes) {
2571 index->Interrupt();
2572 index->Stop();
2573 if (!(index->Init() && index->StartBackgroundSync())) {
2574 LogPrintf("[snapshot] WARNING failed to restart index %s "
2575 "on snapshot chain\n",
2576 index->GetName());
2577 }
2578 }
2579 };
2580
2582 options.mempool = Assert(node.mempool.get());
2583 options.reindex = node::fReindex;
2584 options.reindex_chainstate = fReindexChainState;
2585 options.prune = chainman.m_blockman.IsPruneMode();
2586 options.check_blocks =
2587 args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
2588 options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
2590 args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
2592 options.coins_error_cb = [] {
2593 uiInterface.ThreadSafeMessageBox(
2594 _("Error reading from database, shutting down."), "",
2596 };
2597
2598 uiInterface.InitMessage(_("Loading block index...").translated);
2599
2600 const int64_t load_block_index_start_time = GetTimeMillis();
2601 auto catch_exceptions = [](auto &&f) {
2602 try {
2603 return f();
2604 } catch (const std::exception &e) {
2605 LogPrintf("%s\n", e.what());
2606 return std::make_tuple(node::ChainstateLoadStatus::FAILURE,
2607 _("Error opening block database"));
2608 }
2609 };
2610 auto [status, error] = catch_exceptions(
2611 [&] { return LoadChainstate(chainman, cache_sizes, options); });
2613 uiInterface.InitMessage(_("Verifying blocks...").translated);
2614 if (chainman.m_blockman.m_have_pruned &&
2615 options.check_blocks > MIN_BLOCKS_TO_KEEP) {
2616 LogWarning("pruned datadir may not have more than %d "
2617 "blocks; only checking available blocks\n",
2619 }
2620 std::tie(status, error) = catch_exceptions(
2621 [&] { return VerifyLoadedChainstate(chainman, options); });
2623 WITH_LOCK(cs_main, return node.chainman->LoadRecentHeadersTime(
2624 node.chainman->m_options.datadir /
2626 fLoaded = true;
2627 LogPrintf(" block index %15dms\n",
2628 GetTimeMillis() - load_block_index_start_time);
2629 }
2630 }
2631
2634 status ==
2636 return InitError(error);
2637 }
2638
2639 if (!fLoaded && !ShutdownRequested()) {
2640 // first suggest a reindex
2641 if (!options.reindex) {
2642 bool fRet = uiInterface.ThreadSafeQuestion(
2643 error + Untranslated(".\n\n") +
2644 _("Do you want to rebuild the block database now?"),
2645 error.original + ".\nPlease restart with -reindex or "
2646 "-reindex-chainstate to recover.",
2647 "",
2650 if (fRet) {
2651 fReindex = true;
2652 AbortShutdown();
2653 } else {
2654 LogPrintf("Aborted block database rebuild. Exiting.\n");
2655 return false;
2656 }
2657 } else {
2658 return InitError(error);
2659 }
2660 }
2661 }
2662
2663 // As LoadBlockIndex can take several minutes, it's possible the user
2664 // requested to kill the GUI during the last operation. If so, exit.
2665 // As the program has not fully started yet, Shutdown() is possibly
2666 // overkill.
2667 if (ShutdownRequested()) {
2668 LogPrintf("Shutdown requested. Exiting.\n");
2669 return false;
2670 }
2671
2672 ChainstateManager &chainman = *Assert(node.chainman);
2673
2674 if (args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED)) {
2675 // Initialize Avalanche.
2676 bilingual_str avalancheError;
2678 args, *node.chain, node.connman.get(), chainman, node.mempool.get(),
2679 *node.scheduler, avalancheError);
2680 if (!node.avalanche) {
2681 InitError(avalancheError);
2682 return false;
2683 }
2684
2685 if (node.avalanche->isAvalancheServiceAvailable()) {
2686 nLocalServices = ServiceFlags(nLocalServices | NODE_AVALANCHE);
2687 }
2688 }
2689
2690 PeerManager::Options peerman_opts{};
2691 ApplyArgsManOptions(args, peerman_opts);
2692
2693 assert(!node.peerman);
2694 node.peerman = PeerManager::make(*node.connman, *node.addrman,
2695 node.banman.get(), chainman, *node.mempool,
2696 node.avalanche.get(), peerman_opts);
2697 RegisterValidationInterface(node.peerman.get());
2698
2699 // Encoded addresses using cashaddr instead of base58.
2700 // We do this by default to avoid confusion with BTC addresses.
2701 config.SetCashAddrEncoding(args.GetBoolArg("-usecashaddr", true));
2702
2703 // Step 8: load indexers
2704
2705 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
2706 auto result{
2708 chainman.m_blockman.m_block_tree_db)))};
2709 if (!result) {
2710 return InitError(util::ErrorString(result));
2711 }
2712
2713 g_txindex =
2714 std::make_unique<TxIndex>(interfaces::MakeChain(node, Params()),
2715 cache_sizes.tx_index, false, fReindex);
2716 node.indexes.emplace_back(g_txindex.get());
2717 }
2718
2719 for (const auto &filter_type : g_enabled_filter_types) {
2721 [&] { return interfaces::MakeChain(node, Params()); }, filter_type,
2722 cache_sizes.filter_index, false, fReindex);
2723 node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
2724 }
2725
2726 if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
2727 g_coin_stats_index = std::make_unique<CoinStatsIndex>(
2728 interfaces::MakeChain(node, Params()), /* cache size */ 0, false,
2729 fReindex);
2730 node.indexes.emplace_back(g_coin_stats_index.get());
2731 }
2732
2733 // Init indexes
2734 for (auto index : node.indexes) {
2735 if (!index->Init()) {
2736 return false;
2737 }
2738 }
2739
2740 const bool background_sync_in_progress{WITH_LOCK(
2741 chainman.GetMutex(), return chainman.BackgroundSyncInProgress())};
2742#if ENABLE_CHRONIK
2743 if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
2744 if (background_sync_in_progress) {
2745 return InitError(
2746 _("Assumeutxo is incompatible with -chronik. Wait for "
2747 "background sync to complete before enabling Chronik."));
2748 }
2749
2750 const bool fReindexChronik =
2751 fReindex || args.GetBoolArg("-chronikreindex", false);
2752 if (!chronik::Start(args, config, node, fReindexChronik)) {
2753 return false;
2754 }
2755 }
2756#endif
2757
2758 // Step 9: load wallet
2759 for (const auto &client : node.chain_clients) {
2760 if (!client->load()) {
2761 return false;
2762 }
2763 }
2764
2765 // Step 10: data directory maintenance
2766
2767 // if pruning, perform the initial blockstore prune
2768 // after any wallet rescanning has taken place.
2769 if (chainman.m_blockman.IsPruneMode()) {
2770 if (!fReindex) {
2771 LOCK(cs_main);
2772 for (Chainstate *chainstate : chainman.GetAll()) {
2773 uiInterface.InitMessage(_("Pruning blockstore...").translated);
2774 chainstate->PruneAndFlush();
2775 }
2776 }
2777 } else {
2778 // Prior to setting NODE_NETWORK, check if we can provide historical
2779 // blocks.
2780 if (!background_sync_in_progress) {
2781 LogPrintf("Setting NODE_NETWORK on non-prune mode\n");
2782 nLocalServices = ServiceFlags(nLocalServices | NODE_NETWORK);
2783 } else {
2784 LogPrintf("Running node in NODE_NETWORK_LIMITED mode until "
2785 "snapshot background sync completes\n");
2786 }
2787 }
2788
2789 // Step 11: import blocks
2790 if (!CheckDiskSpace(args.GetDataDirNet())) {
2791 InitError(
2792 strprintf(_("Error: Disk space is low for %s"),
2794 return false;
2795 }
2796 if (!CheckDiskSpace(args.GetBlocksDirPath())) {
2797 InitError(
2798 strprintf(_("Error: Disk space is low for %s"),
2800 return false;
2801 }
2802
2803 // Either install a handler to notify us when genesis activates, or set
2804 // fHaveGenesis directly.
2805 // No locking, as this happens before any background thread is started.
2806 boost::signals2::connection block_notify_genesis_wait_connection;
2807 if (WITH_LOCK(chainman.GetMutex(),
2808 return chainman.ActiveChain().Tip() == nullptr)) {
2809 block_notify_genesis_wait_connection =
2810 uiInterface.NotifyBlockTip_connect(
2811 std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
2812 } else {
2813 fHaveGenesis = true;
2814 }
2815
2816#if defined(HAVE_SYSTEM)
2817 const std::string block_notify = args.GetArg("-blocknotify", "");
2818 if (!block_notify.empty()) {
2819 uiInterface.NotifyBlockTip_connect([block_notify](
2820 SynchronizationState sync_state,
2821 const CBlockIndex *pBlockIndex) {
2822 if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) {
2823 return;
2824 }
2825 std::string command = block_notify;
2826 ReplaceAll(command, "%s", pBlockIndex->GetBlockHash().GetHex());
2827 std::thread t(runCommand, command);
2828 // thread runs free
2829 t.detach();
2830 });
2831 }
2832#endif
2833
2834 std::vector<fs::path> vImportFiles;
2835 for (const std::string &strFile : args.GetArgs("-loadblock")) {
2836 vImportFiles.push_back(fs::PathFromString(strFile));
2837 }
2838
2839 avalanche::Processor *const avalanche = node.avalanche.get();
2840 chainman.m_thread_load = std::thread(
2841 &util::TraceThread, "initload", [=, &chainman, &args, &node] {
2842 // Import blocks
2843 ImportBlocks(chainman, avalanche, vImportFiles);
2844 // Start indexes initial sync
2846 bilingual_str err_str =
2847 _("Failed to start indexes, shutting down..");
2848 AbortNode(err_str.original, err_str);
2849 // TODO: replace AbortNode call with following line after
2850 // backporting core#27861
2851 // chainman.GetNotifications().fatalError(err_str.original,
2852 // err_str);
2853 return;
2854 }
2855 // Load mempool from disk
2856 chainman.ActiveChainstate().LoadMempool(
2857 ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{});
2858 });
2859
2860 // Wait for genesis block to be processed
2861 {
2863 // We previously could hang here if StartShutdown() is called prior to
2864 // ImportBlocks getting started, so instead we just wait on a timer to
2865 // check ShutdownRequested() regularly.
2866 while (!fHaveGenesis && !ShutdownRequested()) {
2867 g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
2868 }
2869 block_notify_genesis_wait_connection.disconnect();
2870 }
2871
2872 if (ShutdownRequested()) {
2873 return false;
2874 }
2875
2876 // Step 12: start node
2877
2878 int chain_active_height;
2879
2881 {
2882 LOCK(cs_main);
2883 LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
2884 chain_active_height = chainman.ActiveChain().Height();
2885 if (tip_info) {
2886 tip_info->block_height = chain_active_height;
2887 tip_info->block_time =
2888 chainman.ActiveChain().Tip()
2889 ? chainman.ActiveChain().Tip()->GetBlockTime()
2890 : chainman.GetParams().GenesisBlock().GetBlockTime();
2892 chainman.GetParams().TxData(), chainman.ActiveChain().Tip());
2893 }
2894 if (tip_info && chainman.m_best_header) {
2895 tip_info->header_height = chainman.m_best_header->nHeight;
2896 tip_info->header_time = chainman.m_best_header->GetBlockTime();
2897 }
2898 }
2899 LogPrintf("nBestHeight = %d\n", chain_active_height);
2900 if (node.peerman) {
2901 node.peerman->SetBestHeight(chain_active_height);
2902 }
2903
2904 // Map ports with UPnP or NAT-PMP.
2905 StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP),
2906 args.GetBoolArg("-natpmp", DEFAULT_NATPMP));
2907
2908 CConnman::Options connOptions;
2909 connOptions.nLocalServices = nLocalServices;
2910 connOptions.nMaxConnections = nMaxConnections;
2911 connOptions.m_max_avalanche_outbound =
2912 node.avalanche
2913 ? args.GetIntArg("-maxavalancheoutbound",
2915 : 0;
2916 connOptions.m_max_outbound_full_relay = std::min(
2918 connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound);
2919 connOptions.m_max_outbound_block_relay = std::min(
2921 connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound -
2922 connOptions.m_max_outbound_full_relay);
2924 connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
2925 connOptions.uiInterface = &uiInterface;
2926 connOptions.m_banman = node.banman.get();
2927 connOptions.m_msgproc.push_back(node.peerman.get());
2928 if (node.avalanche) {
2929 connOptions.m_msgproc.push_back(node.avalanche.get());
2930 }
2931 connOptions.nSendBufferMaxSize =
2932 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
2933 connOptions.nReceiveFloodSize =
2934 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
2935 connOptions.m_added_nodes = args.GetArgs("-addnode");
2936
2937 connOptions.nMaxOutboundLimit =
2938 1024 * 1024 *
2939 args.GetIntArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
2940 connOptions.m_peer_connect_timeout = peer_connect_timeout;
2941 connOptions.whitelist_forcerelay =
2942 args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
2943 connOptions.whitelist_relay =
2944 args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
2945
2946 // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
2947 const uint16_t default_bind_port = static_cast<uint16_t>(
2948 args.GetIntArg("-port", config.GetChainParams().GetDefaultPort()));
2949
2950 const auto BadPortWarning = [](const char *prefix, uint16_t port) {
2951 return strprintf(_("%s request to listen on port %u. This port is "
2952 "considered \"bad\" and "
2953 "thus it is unlikely that any Bitcoin ABC peers "
2954 "connect to it. See "
2955 "doc/p2p-bad-ports.md for details and a full list."),
2956 prefix, port);
2957 };
2958
2959 for (const std::string &bind_arg : args.GetArgs("-bind")) {
2960 CService bind_addr;
2961 const size_t index = bind_arg.rfind('=');
2962 if (index == std::string::npos) {
2963 if (Lookup(bind_arg, bind_addr, default_bind_port,
2964 /*fAllowLookup=*/false)) {
2965 connOptions.vBinds.push_back(bind_addr);
2966 if (IsBadPort(bind_addr.GetPort())) {
2967 InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
2968 }
2969 continue;
2970 }
2971 } else {
2972 const std::string network_type = bind_arg.substr(index + 1);
2973 if (network_type == "onion") {
2974 const std::string truncated_bind_arg =
2975 bind_arg.substr(0, index);
2976 if (Lookup(truncated_bind_arg, bind_addr,
2977 BaseParams().OnionServiceTargetPort(), false)) {
2978 connOptions.onion_binds.push_back(bind_addr);
2979 continue;
2980 }
2981 }
2982 }
2983 return InitError(ResolveErrMsg("bind", bind_arg));
2984 }
2985
2986 for (const std::string &strBind : args.GetArgs("-whitebind")) {
2987 NetWhitebindPermissions whitebind;
2989 if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) {
2990 return InitError(error);
2991 }
2992 connOptions.vWhiteBinds.push_back(whitebind);
2993 }
2994
2995 // If the user did not specify -bind= or -whitebind= then we bind
2996 // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
2997 connOptions.bind_on_any =
2998 args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
2999
3000 // Emit a warning if a bad port is given to -port= but only if -bind and
3001 // -whitebind are not given, because if they are, then -port= is ignored.
3002 if (connOptions.bind_on_any && args.IsArgSet("-port")) {
3003 const uint16_t port_arg = args.GetIntArg("-port", 0);
3004 if (IsBadPort(port_arg)) {
3005 InitWarning(BadPortWarning("-port", port_arg));
3006 }
3007 }
3008
3009 CService onion_service_target;
3010 if (!connOptions.onion_binds.empty()) {
3011 onion_service_target = connOptions.onion_binds.front();
3012 } else if (!connOptions.vBinds.empty()) {
3013 onion_service_target = connOptions.vBinds.front();
3014 } else {
3015 onion_service_target = DefaultOnionServiceTarget();
3016 connOptions.onion_binds.push_back(onion_service_target);
3017 }
3018
3019 if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
3020 if (connOptions.onion_binds.size() > 1) {
3022 _("More than one onion bind address is provided. Using %s "
3023 "for the automatically created Tor onion service."),
3024 onion_service_target.ToStringIPPort()));
3025 }
3026 StartTorControl(onion_service_target);
3027 }
3028
3029 if (connOptions.bind_on_any) {
3030 // Only add all IP addresses of the machine if we would be listening on
3031 // any address - 0.0.0.0 (IPv4) and :: (IPv6).
3032 Discover();
3033 }
3034
3035 for (const auto &net : args.GetArgs("-whitelist")) {
3037 ConnectionDirection connection_direction;
3039 if (!NetWhitelistPermissions::TryParse(net, subnet,
3040 connection_direction, error)) {
3041 return InitError(error);
3042 }
3043 if (connection_direction & ConnectionDirection::In) {
3044 connOptions.vWhitelistedRangeIncoming.push_back(subnet);
3045 }
3046 if (connection_direction & ConnectionDirection::Out) {
3047 connOptions.vWhitelistedRangeOutgoing.push_back(subnet);
3048 }
3049 }
3050
3051 connOptions.vSeedNodes = args.GetArgs("-seednode");
3052
3053 // Initiate outbound connections unless connect=0
3054 connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
3055 if (!connOptions.m_use_addrman_outgoing) {
3056 const auto connect = args.GetArgs("-connect");
3057 if (connect.size() != 1 || connect[0] != "0") {
3058 connOptions.m_specified_outgoing = connect;
3059 }
3060 }
3061
3062 const std::string &i2psam_arg = args.GetArg("-i2psam", "");
3063 if (!i2psam_arg.empty()) {
3064 CService addr;
3065 if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) || !addr.IsValid()) {
3066 return InitError(strprintf(
3067 _("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
3068 }
3069 SetReachable(NET_I2P, true);
3070 SetProxy(NET_I2P, proxyType{addr});
3071 } else {
3072 SetReachable(NET_I2P, false);
3073 }
3074
3075 connOptions.m_i2p_accept_incoming =
3076 args.GetBoolArg("-i2pacceptincoming", true);
3077
3078 if (!node.connman->Start(*node.scheduler, connOptions)) {
3079 return false;
3080 }
3081
3082 // Step 13: finished
3083
3084 // At this point, the RPC is "started", but still in warmup, which means it
3085 // cannot yet be called. Before we make it callable, we need to make sure
3086 // that the RPC's view of the best block is valid and consistent with
3087 // ChainstateManager's active tip.
3088 //
3089 // If we do not do this, RPC's view of the best block will be height=0 and
3090 // hash=0x0. This will lead to erroroneous responses for things like
3091 // waitforblockheight.
3093 WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()));
3095
3096 uiInterface.InitMessage(_("Done loading").translated);
3097
3098 for (const auto &client : node.chain_clients) {
3099 client->start(*node.scheduler);
3100 }
3101
3102 BanMan *banman = node.banman.get();
3103 node.scheduler->scheduleEvery(
3104 [banman] {
3105 banman->DumpBanlist();
3106 return true;
3107 },
3109
3110 // Start Avalanche's event loop.
3111 if (node.avalanche) {
3112 node.avalanche->startEventLoop(*node.scheduler);
3113 }
3114
3115 if (node.peerman) {
3116 node.peerman->StartScheduledTasks(*node.scheduler);
3117 }
3118
3119#if HAVE_SYSTEM
3120 StartupNotify(args);
3121#endif
3122
3123 return true;
3124}
3125
3127 // Find the oldest block among all indexes.
3128 // This block is used to verify that we have the required blocks' data
3129 // stored on disk, starting from that point up to the current tip.
3130 // indexes_start_block='nullptr' means "start from height 0".
3131 std::optional<const CBlockIndex *> indexes_start_block;
3132 std::string older_index_name;
3133 ChainstateManager &chainman = *Assert(node.chainman);
3134 const Chainstate &chainstate =
3135 WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing());
3136 const CChain &index_chain = chainstate.m_chain;
3137
3138 for (auto index : node.indexes) {
3139 const IndexSummary &summary = index->GetSummary();
3140 if (summary.synced) {
3141 continue;
3142 }
3143
3144 // Get the last common block between the index best block and the active
3145 // chain
3146 LOCK(::cs_main);
3147 const CBlockIndex *pindex = chainman.m_blockman.LookupBlockIndex(
3148 BlockHash{summary.best_block_hash});
3149 if (!index_chain.Contains(pindex)) {
3150 pindex = index_chain.FindFork(pindex);
3151 }
3152
3153 if (!indexes_start_block || !pindex ||
3154 pindex->nHeight < indexes_start_block.value()->nHeight) {
3155 indexes_start_block = pindex;
3156 older_index_name = summary.name;
3157 if (!pindex) {
3158 // Starting from genesis so no need to look for earlier block.
3159 break;
3160 }
3161 }
3162 };
3163
3164 // Verify all blocks needed to sync to current tip are present.
3165 if (indexes_start_block) {
3166 LOCK(::cs_main);
3167 const CBlockIndex *start_block = *indexes_start_block;
3168 if (!start_block) {
3169 start_block = chainman.ActiveChain().Genesis();
3170 }
3171 if (!chainman.m_blockman.CheckBlockDataAvailability(
3172 *index_chain.Tip(), *Assert(start_block))) {
3173 return InitError(strprintf(
3174 Untranslated("%s best block of the index goes beyond pruned "
3175 "data. Please disable the index or reindex (which "
3176 "will download the whole blockchain again)"),
3177 older_index_name));
3178 }
3179 }
3180
3181 // Start threads
3182 for (auto index : node.indexes) {
3183 if (!index->StartBackgroundSync()) {
3184 return false;
3185 }
3186 }
3187 return true;
3188}
util::Result< std::unique_ptr< AddrMan > > LoadAddrman(const CChainParams &chainparams, const std::vector< bool > &asmap, const ArgsManager &args)
Returns an error string on failure.
Definition: addrdb.cpp:164
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
Definition: addrman.h:28
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
Definition: args.cpp:706
const char *const BITCOIN_SETTINGS_FILENAME
Definition: args.cpp:38
ArgsManager gArgs
Definition: args.cpp:40
const char *const BITCOIN_CONF_FILENAME
Definition: args.cpp:37
fs::path AbsPathForConfigVal(const ArgsManager &args, const fs::path &path, bool net_specific=true)
Most paths passed as configuration arguments are treated as relative to the datadir if they are not a...
Definition: configfile.cpp:236
std::vector< bool > DecodeAsmap(fs::path path)
Read asmap from provided binary file.
Definition: asmap.cpp:294
static constexpr bool DEFAULT_PERSIST_AVAPEERS
Default for -persistavapeers.
Definition: avalanche.h:63
static constexpr double AVALANCHE_DEFAULT_MIN_QUORUM_CONNECTED_STAKE_RATIO
Default minimum percentage of stake-weighted peers we must have a node for to constitute a usable quo...
Definition: avalanche.h:53
static constexpr size_t AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN
Peer replacement cooldown time default value in seconds.
Definition: avalanche.h:34
static constexpr double AVALANCHE_DEFAULT_MIN_AVAPROOFS_NODE_COUNT
Default minimum number of nodes that sent us an avaproofs message before we can consider our quorum s...
Definition: avalanche.h:60
static constexpr Amount AVALANCHE_DEFAULT_MIN_QUORUM_STAKE
Default minimum cumulative stake of all known peers that constitutes a usable quorum.
Definition: avalanche.h:46
static constexpr size_t AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN
Conflicting proofs cooldown time default value in seconds.
Definition: avalanche.h:28
static constexpr bool AVALANCHE_DEFAULT_ENABLED
Is avalanche enabled by default.
Definition: avalanche.h:22
static constexpr size_t AVALANCHE_DEFAULT_COOLDOWN
Avalanche default cooldown in milliseconds.
Definition: avalanche.h:40
static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME
Definition: banman.h:20
static constexpr std::chrono::minutes DUMP_BANS_INTERVAL
Definition: banman.h:22
void RPCNotifyBlockChange(const CBlockIndex *pindex)
Callback for when block tip changed.
Definition: blockchain.cpp:249
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
const std::set< BlockFilterType > & AllBlockFilterTypes()
Get a list of known filter types.
const std::string & ListBlockFilterTypes()
Get a comma-separated list of known filter type names.
bool BlockFilterTypeByName(const std::string &name, BlockFilterType &filter_type)
Find a filter type by its human-readable name.
BlockFilterType
Definition: blockfilter.h:88
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
void ForEachBlockFilterIndex(std::function< void(BlockFilterIndex &)> fn)
Iterate over all running block filter indexes, invoking fn on each.
bool InitBlockFilterIndex(std::function< std::unique_ptr< interfaces::Chain >()> make_chain, BlockFilterType filter_type, size_t n_cache_size, bool f_memory, bool f_wipe)
Initialize a block filter index for the given type if one does not already exist.
static const char *const DEFAULT_BLOCKFILTERINDEX
std::unique_ptr< const CChainParams > CreateChainParams(const ArgsManager &args, const ChainType chain)
Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
Definition: chainparams.cpp:33
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:21
const CBaseChainParams & BaseParams()
Return the currently selected parameters.
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const ChainType chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 18445) have been chosen arbitrarily to...
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
static constexpr bool DEFAULT_CHECKPOINTS_ENABLED
static constexpr auto DEFAULT_MAX_TIP_AGE
static constexpr bool DEFAULT_STORE_RECENT_HEADERS_TIME
std::string ChainTypeToString(ChainType chain)
Definition: chaintype.cpp:11
ChainType
Definition: chaintype.h:11
#define Assert(val)
Identity function.
Definition: check.h:84
std::set< std::string > GetUnsuitableSectionOnlyArgs() const
Log warnings for options in m_section_only_args when they are specified in the default section but no...
Definition: args.cpp:141
std::list< SectionInfo > GetUnrecognizedSections() const
Log warnings for unrecognized section names in the config file.
Definition: args.cpp:165
@ NETWORK_ONLY
Definition: args.h:134
@ ALLOW_ANY
disable validation
Definition: args.h:114
@ DISALLOW_NEGATION
unimplemented, draft implementation in #16545
Definition: args.h:124
@ DISALLOW_ELISION
disallow -foo syntax that doesn't assign any value
Definition: args.h:126
@ DEBUG_ONLY
Definition: args.h:128
@ SENSITIVE
Definition: args.h:136
ChainType GetChainType() const
Looks for -regtest, -testnet and returns the appropriate BIP70 chain name.
Definition: args.cpp:762
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: args.cpp:362
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
Definition: args.h:239
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: args.cpp:372
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
Definition: args.cpp:495
fs::path GetBlocksDirPath() const
Get blocks directory path.
Definition: args.cpp:300
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: args.cpp:463
bool SoftSetBoolArg(const std::string &strArg, bool fValue)
Set a boolean argument if it doesn't already have a value.
Definition: args.cpp:558
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: args.cpp:525
void AddHiddenArgs(const std::vector< std::string > &args)
Add many hidden arguments.
Definition: args.cpp:611
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
Definition: args.cpp:589
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const
Return path argument or default value.
Definition: args.cpp:286
std::atomic< bool > m_reopen_file
Definition: logging.h:135
Definition: banman.h:58
void DumpBanlist()
Definition: banman.cpp:49
void Stop()
Stops the instance from staying in sync with blockchain updates.
Definition: base.cpp:424
bool BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(void Interrupt()
Blocks the current thread until the index is caught up to the current state of the block chain.
Definition: base.cpp:410
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
int64_t GetBlockTime() const
Definition: block.h:57
Definition: block.h:60
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: blockindex.h:25
int64_t GetBlockTime() const
Definition: blockindex.h:160
BlockHash GetBlockHash() const
Definition: blockindex.h:130
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: blockindex.h:38
An in-memory indexed chain of blocks.
Definition: chain.h:134
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:150
CBlockIndex * Genesis() const
Returns the index entry for the genesis block of this chain, or nullptr if none.
Definition: chain.h:143
int Height() const
Return the maximal height in the chain.
Definition: chain.h:186
const CBlockIndex * FindFork(const CBlockIndex *pindex) const
Find the last common block between this chain and a block index entry.
Definition: chain.cpp:49
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
Definition: chain.h:166
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:86
const CBlock & GenesisBlock() const
Definition: chainparams.h:112
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
Definition: chainparams.h:114
const ChainTxData & TxData() const
Definition: chainparams.h:158
bool IsTestChain() const
If this chain is exclusively used for testing.
Definition: chainparams.h:118
uint16_t GetDefaultPort() const
Definition: chainparams.h:101
void UnregisterBackgroundSignalScheduler()
Unregister a CScheduler to give callbacks which should run in the background - these callbacks will n...
void RegisterBackgroundSignalScheduler(CScheduler &scheduler)
Register a CScheduler to give callbacks which should run in the background (may only be called once)
void FlushBackgroundCallbacks()
Call any remaining callbacks on the calling thread.
bool IsValid() const
Definition: netaddress.cpp:474
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:545
std::string ToStringIPPort() const
uint16_t GetPort() const
static const int DEFAULT_ZMQ_SNDHWM
static std::unique_ptr< CZMQNotificationInterface > Create(std::function< bool(CBlock &, const CBlockIndex &)> get_block_by_index)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:694
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:793
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:1147
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1419
SnapshotCompletionResult MaybeCompleteSnapshotValidation(std::function< void(bilingual_str)> shutdown_fnc=[](bilingual_str msg) { AbortNode(msg.original, msg);}) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
Definition: validation.h:1395
std::thread m_thread_load
Definition: validation.h:1282
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1277
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1402
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
Definition: validation.h:1407
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
Definition: validation.h:1235
const CChainParams & GetParams() const
Definition: validation.h:1239
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1396
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:1359
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1285
Definition: config.h:19
virtual uint64_t GetMaxBlockSize() const =0
virtual const CChainParams & GetChainParams() const =0
virtual bool SetMaxBlockSize(uint64_t maxBlockSize)=0
virtual void SetCashAddrEncoding(bool)=0
Different type to mark Mutex at global scope.
Definition: sync.h:144
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:100
static bool TryParse(const std::string &str, NetWhitebindPermissions &output, bilingual_str &error)
static bool TryParse(const std::string &str, NetWhitelistPermissions &output, ConnectionDirection &output_connection_direction, bilingual_str &error)
static std::unique_ptr< PeerManager > make(CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, avalanche::Processor *const avalanche, Options opts)
Class for registering and managing all RPC calls.
Definition: server.h:40
virtual void AddWalletOptions(ArgsManager &argsman) const =0
Get wallet help string.
virtual void Construct(node::NodeContext &node) const =0
Add wallets that should be opened to list of chain clients.
virtual bool ParameterInteraction() const =0
Check wallet parameter interaction.
static std::unique_ptr< Processor > MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain, CConnman *connman, ChainstateManager &chainman, CTxMemPool *mempoolIn, CScheduler &scheduler, bilingual_str &error)
Definition: processor.cpp:222
std::string ToString() const
Definition: uint256.h:80
std::string GetHex() const
Definition: uint256.cpp:16
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:30
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
Definition: blockstorage.h:104
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, std::function< bool(BlockStatus)> status_test, const CBlockIndex *lower_block=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
Definition: blockstorage.h:379
CBlockIndex * LookupBlockIndex(const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool IsPruneMode() const
Whether running in -prune mode.
Definition: blockstorage.h:317
bool IsValid() const
Definition: netbase.h:58
256-bit opaque blob.
Definition: uint256.h:129
std::string FormatVersion(int nVersion)
std::string FormatUserAgent(const std::string &name, const std::string &version, const std::vector< std::string > &comments)
Format the subversion field according to BIP 14 spec.
static constexpr int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
Definition: clientversion.h:38
const std::string CLIENT_NAME
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
static constexpr bool DEFAULT_COINSTATSINDEX
static const uint64_t DEFAULT_MAX_BLOCK_SIZE
Default setting for maximum allowed size for a block, in bytes.
Definition: consensus.h:20
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:7
void SetupCurrencyUnitOptions(ArgsManager &argsman)
Definition: currencyunit.cpp:9
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
Definition: error.cpp:53
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
Definition: error.cpp:44
bool LockDirectory(const fs::path &directory, const std::string lockfile_name, bool probe_only)
Definition: fs_helpers.cpp:58
bool DirIsWritable(const fs::path &directory)
Definition: fs_helpers.cpp:97
int RaiseFileDescriptorLimit(int nMinFD)
This function tries to raise the file descriptor limit to the requested number.
Definition: fs_helpers.cpp:182
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
Definition: fs_helpers.cpp:111
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
Definition: httprpc.cpp:477
void StopHTTPRPC()
Stop HTTP RPC subsystem.
Definition: httprpc.cpp:481
bool StartHTTPRPC(HTTPRPCRequestProcessor &httpRPCRequestProcessor)
Start HTTP RPC subsystem.
Definition: httprpc.cpp:456
void StartREST(const std::any &context)
Start HTTP REST subsystem.
Definition: rest.cpp:831
void StopREST()
Stop HTTP REST subsystem.
Definition: rest.cpp:843
void InterruptREST()
Interrupt RPC REST subsystem.
Definition: rest.cpp:841
void InterruptHTTPServer()
Interrupt HTTP server threads.
Definition: httpserver.cpp:555
void StartHTTPServer()
Start HTTP server.
Definition: httpserver.cpp:544
void StopHTTPServer()
Stop HTTP server.
Definition: httpserver.cpp:566
bool InitHTTPServer(Config &config)
Initialize HTTP server.
Definition: httpserver.cpp:477
static const int DEFAULT_HTTP_SERVER_TIMEOUT
Definition: httpserver.h:14
static const int DEFAULT_HTTP_WORKQUEUE
Definition: httpserver.h:13
static const int DEFAULT_HTTP_THREADS
Definition: httpserver.h:12
Common init functions shared by bitcoin-node, bitcoin-wallet, etc.
static const char * BITCOIN_PID_FILENAME
The PID file facilities.
Definition: init.cpp:156
static bool CreatePidFile(const ArgsManager &args)
Definition: init.cpp:163
static const bool DEFAULT_PROXYRANDOMIZE
Definition: init.cpp:137
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:203
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:1750
bool AppInitLockDataDirectory()
Lock bitcoin data directory.
Definition: init.cpp:2142
void SetupServerArgs(NodeContext &node)
Register all arguments with the ArgsManager.
Definition: init.cpp:427
static bool AppInitServers(Config &config, HTTPRPCRequestProcessor &httpRPCRequestProcessor, NodeContext &node)
Definition: init.cpp:1591
#define MIN_CORE_FILEDESCRIPTORS
Definition: init.cpp:146
static bool fHaveGenesis
Definition: init.cpp:1566
void Shutdown(NodeContext &node)
Definition: init.cpp:227
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
Definition: init.cpp:389
static GlobalMutex g_genesis_wait_mutex
Definition: init.cpp:1567
static void OnRPCStarted()
Definition: init.cpp:415
static void HandleSIGHUP(int)
Definition: init.cpp:393
static fs::path GetPidFile(const ArgsManager &args)
Definition: init.cpp:158
static std::condition_variable g_genesis_wait_cv
Definition: init.cpp:1568
bool AppInitMain(Config &config, RPCServer &rpcServer, HTTPRPCRequestProcessor &httpRPCRequestProcessor, NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin main initialization.
Definition: init.cpp:2164
static constexpr bool DEFAULT_CHRONIK
Definition: init.cpp:139
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin: Basic context setup.
Definition: init.cpp:1777
bool StartIndexBackgroundSync(NodeContext &node)
Validates requirements to run the indexes and spawns each index initial sync thread.
Definition: init.cpp:3126
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:2154
static const char * DEFAULT_ASMAP_FILENAME
Definition: init.cpp:149
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:1616
static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex)
Definition: init.cpp:1570
static void OnRPCStopped()
Definition: init.cpp:420
static bool LockDataDirectory(bool probeOnly)
Definition: init.cpp:2110
static void registerSignalHandler(int signal, void(*handler)(int))
Definition: init.cpp:405
bool AppInitParameterInteraction(Config &config, const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:1824
static const bool DEFAULT_REST_ENABLE
Definition: init.cpp:138
static boost::signals2::connection rpc_notify_block_change_connection
Definition: init.cpp:414
static void new_handler_terminate()
Definition: init.cpp:1766
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
Definition: init.cpp:2126
static const std::string HEADERS_TIME_FILE_NAME
Definition: init.cpp:151
static constexpr bool DEFAULT_DAEMON
Default value for -daemon option.
Definition: init.h:16
static constexpr bool DEFAULT_DAEMONWAIT
Default value for -daemonwait option.
Definition: init.h:18
BCLog::Logger & LogInstance()
Definition: logging.cpp:23
bool error(const char *fmt, const Args &...args)
Definition: logging.h:302
#define LogWarning(...)
Definition: logging.h:264
#define LogPrint(category,...)
Definition: logging.h:291
#define LogPrintf(...)
Definition: logging.h:270
void StartMapPort(bool use_upnp, bool use_natpmp)
Definition: mapport.cpp:362
void StopMapPort()
Definition: mapport.cpp:368
void InterruptMapPort()
Definition: mapport.cpp:365
static constexpr bool DEFAULT_NATPMP
Definition: mapport.h:17
static constexpr bool DEFAULT_UPNP
Definition: mapport.h:11
std::optional< bilingual_str > ApplyArgsManOptions(const ArgsManager &argsman, const CChainParams &chainparams, MemPoolOptions &mempool_opts)
Overlay the options set in argsman on top of corresponding members in mempool_opts.
static constexpr unsigned int DEFAULT_MAX_MEMPOOL_SIZE_MB
Default for -maxmempool, maximum megabytes of mempool memory usage.
static constexpr unsigned int DEFAULT_MEMPOOL_EXPIRY_HOURS
Default for -mempoolexpiry, expiration time for mempool transactions in hours.
std::string FormatMoney(const Amount amt)
Do not use these functions to represent or parse monetary amounts to or from JSON but use AmountFromV...
Definition: moneystr.cpp:13
bool ParseMoney(const std::string &money_string, Amount &nRet)
Parse an amount denoted in full coins.
Definition: moneystr.cpp:37
@ RPC
Definition: logging.h:50
void OnStarted(std::function< void()> slot)
Definition: server.cpp:113
void OnStopped(std::function< void()> slot)
Definition: server.cpp:117
static constexpr Amount PROOF_DUST_THRESHOLD
Minimum amount per utxo.
Definition: proof.h:41
static auto quoted(const std::string &s)
Definition: fs.h:107
static bool exists(const path &p)
Definition: fs.h:102
static std::string PathToString(const path &path)
Convert path object to byte string.
Definition: fs.h:142
static path PathFromString(const std::string &string)
Convert byte string to path object.
Definition: fs.h:165
std::string get_filesystem_error_message(const fs::filesystem_error &e)
Definition: fs.cpp:142
void AddLoggingArgs(ArgsManager &argsman)
Definition: common.cpp:22
void SetLoggingCategories(const ArgsManager &args)
Definition: common.cpp:171
bool StartLogging(const ArgsManager &args)
Definition: common.cpp:199
void SetLoggingLevel(const ArgsManager &args)
Definition: common.cpp:141
void SetLoggingOptions(const ArgsManager &args)
Definition: common.cpp:118
void LogPackageVersion()
Definition: common.cpp:246
std::unique_ptr< Chain > MakeChain(node::NodeContext &node, const CChainParams &params)
Return implementation of Chain interface.
Definition: interfaces.cpp:825
Definition: init.h:28
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
util::Result< void > SanityChecks(const Context &)
Ensure a usable environment with all necessary library support.
Definition: checks.cpp:14
Definition: init.h:31
@ FAILURE_FATAL
Fatal error which should not prompt to reindex.
@ FAILURE
Generic failure which reindexing may fix.
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
Definition: caches.cpp:12
fs::path MempoolPath(const ArgsManager &argsman)
bool ShouldPersistMempool(const ArgsManager &argsman)
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
This sequence can have 4 types of outcomes:
Definition: chainstate.cpp:167
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:271
static constexpr bool DEFAULT_PERSIST_MEMPOOL
Default for -persistmempool, indicating whether the node should attempt to automatically load the mem...
std::atomic_bool fReindex
void ImportBlocks(ChainstateManager &chainman, avalanche::Processor *const avalanche, std::vector< fs::path > vImportFiles)
void ApplyArgsManOptions(const ArgsManager &args, const Config &config, BlockFitter::Options &options)
Apply options from ArgsManager to BlockFitter options.
Definition: blockfitter.cpp:40
void format(std::ostream &out, const char *fmt, const Args &...args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1112
bilingual_str ErrorString(const Result< T > &result)
Definition: result.h:90
void TraceThread(std::string_view thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
Definition: thread.cpp:14
void ThreadRename(std::string &&)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
Definition: threadnames.cpp:48
uint16_t GetListenPort()
Definition: net.cpp:138
bool fDiscover
Definition: net.cpp:126
bool fListen
Definition: net.cpp:127
void SetReachable(enum Network net, bool reachable)
Mark a network as reachable or unreachable (no automatic connects to it)
Definition: net.cpp:318
bool AddLocal(const CService &addr, int nScore)
Definition: net.cpp:279
void Discover()
Look up IP addresses from all interfaces on the machine and add them to the list of local addresses t...
Definition: net.cpp:2297
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:92
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:68
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:75
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:106
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:100
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:96
static const bool DEFAULT_FORCEDNSSEED
Definition: net.h:102
static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:94
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:105
static const int DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS
Maximum number of avalanche enabled outgoing connections by default.
Definition: net.h:82
static const bool DEFAULT_FIXEDSEEDS
Definition: net.h:104
static const int MAX_FEELER_CONNECTIONS
Maximum number of feeler connections.
Definition: net.h:84
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:86
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:98
static const bool DEFAULT_DNSSEED
Definition: net.h:103
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
Definition: net.h:73
@ LOCAL_MANUAL
Definition: net.h:165
static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS
Maximum number of block-relay-only outgoing connections.
Definition: net.h:77
const std::vector< std::string > NET_PERMISSIONS_DOC
static const bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
static const bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN
Default number of non-mempool transactions to keep around for block reconstruction.
static const uint32_t DEFAULT_MAX_ORPHAN_TRANSACTIONS
Default for -maxorphantx, maximum number of orphan transactions kept in memory.
static const bool DEFAULT_PEERBLOCKFILTERS
Network
A network type.
Definition: netaddress.h:44
@ NET_I2P
I2P.
Definition: netaddress.h:59
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:69
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:56
@ NET_IPV6
IPv6.
Definition: netaddress.h:53
@ NET_IPV4
IPv4.
Definition: netaddress.h:50
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:47
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:90
bool Lookup(const std::string &name, std::vector< CService > &vAddr, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function)
Resolve a service string to its corresponding service.
Definition: netbase.cpp:221
bool fNameLookup
Definition: netbase.cpp:38
int nConnectTimeout
Definition: netbase.cpp:37
bool SetNameProxy(const proxyType &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
Definition: netbase.cpp:724
bool IsBadPort(uint16_t port)
Determine if a port is "bad" from the perspective of attempting to connect to a node on that port.
Definition: netbase.cpp:853
bool SetProxy(enum Network net, const proxyType &addrProxy)
Definition: netbase.cpp:704
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:135
ConnectionDirection
Definition: netbase.h:32
static const int DEFAULT_NAME_LOOKUP
-dns default
Definition: netbase.h:30
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
Definition: netbase.h:28
uint32_t nBytesPerSigCheck
Definition: settings.cpp:10
static constexpr uint64_t DEFAULT_MAX_GENERATED_BLOCK_SIZE
Default for -blockmaxsize, which controls the maximum size of block the mining code will create.
Definition: policy.h:25
static constexpr Amount DUST_RELAY_TX_FEE(1000 *SATOSHI)
Min feerate for defining dust.
static constexpr bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
Definition: policy.h:56
static constexpr Amount DEFAULT_MIN_RELAY_TX_FEE_PER_KB(1000 *SATOSHI)
Default for -minrelaytxfee, minimum relay fee for transactions.
static constexpr unsigned int DEFAULT_BYTES_PER_SIGCHECK
Default for -bytespersigcheck .
Definition: policy.h:54
static constexpr Amount DEFAULT_BLOCK_MIN_TX_FEE_PER_KB(1000 *SATOSHI)
Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by min...
static constexpr std::chrono::milliseconds AVALANCHE_DEFAULT_QUERY_TIMEOUT
How long before we consider that a query timed out.
Definition: processor.h:65
static constexpr int AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS
Minimum number of confirmations before a stake utxo is mature enough to be included into a proof.
Definition: proof.h:36
ServiceFlags
nServices flags.
Definition: protocol.h:336
@ NODE_NETWORK_LIMITED
Definition: protocol.h:366
@ NODE_BLOOM
Definition: protocol.h:353
@ NODE_NETWORK
Definition: protocol.h:343
@ NODE_COMPACT_FILTERS
Definition: protocol.h:361
@ NODE_AVALANCHE
Definition: protocol.h:381
void RandAddPeriodic() noexcept
Gather entropy from various expensive sources, and feed them to the PRNG state.
Definition: random.cpp:645
static void RegisterAllRPCCommands(const Config &config, RPCServer &rpcServer, CRPCTable &rpcTable)
Register all context-sensitive RPC commands.
Definition: register.h:42
const char * prefix
Definition: rest.cpp:816
bool(* handler)(Config &config, const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:817
const char * name
Definition: rest.cpp:47
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
Definition: util.cpp:25
static constexpr bool DEFAULT_RPC_DOC_CHECK
Definition: util.h:44
static constexpr bool DEFAULT_ENABLE_RTT
Default for -enablertt.
Definition: rtt.h:20
bool InitScriptExecutionCache(size_t max_size_bytes)
Initializes the script-execution cache.
Definition: scriptcache.cpp:76
static constexpr size_t DEFAULT_MAX_SCRIPT_CACHE_BYTES
Definition: scriptcache.h:45
void SetRPCWarmupFinished()
Mark warmup as done.
Definition: server.cpp:394
void StartRPC()
Definition: server.cpp:349
void StopRPC()
Definition: server.cpp:366
void InterruptRPC()
Definition: server.cpp:355
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:389
CRPCTable tableRPC
Definition: server.cpp:685
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:383
bool AbortNode(const std::string &strMessage, bilingual_str user_message)
Abort with a message.
Definition: shutdown.cpp:20
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
Definition: shutdown.cpp:85
bool InitShutdownState()
Initialize shutdown state.
Definition: shutdown.cpp:43
void StartShutdown()
Request shutdown of the application.
Definition: shutdown.cpp:55
void AbortShutdown()
Clear shutdown flag.
Definition: shutdown.cpp:76
bool InitSignatureCache(size_t max_size_bytes)
Definition: sigcache.cpp:85
static constexpr size_t DEFAULT_MAX_SIG_CACHE_BYTES
Definition: sigcache.h:18
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for nMaxDatacarrierBytes.
Definition: standard.h:36
static const bool DEFAULT_ACCEPT_DATACARRIER
Definition: standard.h:17
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
Definition: strencodings.h:26
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
Definition: string.cpp:10
auto Join(const std::vector< T > &list, const BaseType &separator, UnaryOp unary_op) -> decltype(unary_op(list.at(0)))
Join a list of items.
Definition: string.h:63
Definition: amount.h:19
static constexpr Amount zero() noexcept
Definition: amount.h:32
A BlockHash is a unqiue identifier for a block.
Definition: blockhash.h:13
int m_max_outbound_block_relay
Definition: net.h:830
unsigned int nReceiveFloodSize
Definition: net.h:838
int m_max_outbound_full_relay
Definition: net.h:829
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:844
uint64_t nMaxOutboundLimit
Definition: net.h:839
CClientUIInterface * uiInterface
Definition: net.h:834
std::vector< NetWhitelistPermissions > vWhitelistedRangeIncoming
Definition: net.h:842
int m_max_avalanche_outbound
Definition: net.h:831
std::vector< CService > onion_binds
Definition: net.h:846
int nMaxFeeler
Definition: net.h:833
std::vector< std::string > m_specified_outgoing
Definition: net.h:851
bool whitelist_relay
Definition: net.h:855
int nMaxConnections
Definition: net.h:828
ServiceFlags nLocalServices
Definition: net.h:827
std::vector< std::string > m_added_nodes
Definition: net.h:852
int64_t m_peer_connect_timeout
Definition: net.h:840
std::vector< CService > vBinds
Definition: net.h:845
unsigned int nSendBufferMaxSize
Definition: net.h:837
bool m_i2p_accept_incoming
Definition: net.h:853
std::vector< std::string > vSeedNodes
Definition: net.h:841
BanMan * m_banman
Definition: net.h:836
bool m_use_addrman_outgoing
Definition: net.h:850
std::vector< NetEventsInterface * > m_msgproc
Definition: net.h:835
bool whitelist_forcerelay
Definition: net.h:854
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:849
std::vector< NetWhitelistPermissions > vWhitelistedRangeOutgoing
Definition: net.h:843
int nMaxAddnode
Definition: net.h:832
static const Currency & get()
Definition: amount.cpp:18
std::string ticker
Definition: amount.h:150
std::string name
Definition: base.h:21
bool synced
Definition: base.h:22
BlockHash best_block_hash
Definition: base.h:24
Bilingual messages:
Definition: translation.h:17
bool empty() const
Definition: translation.h:27
std::string translated
Definition: translation.h:19
std::string original
Definition: translation.h:18
Block and header tip information.
Definition: node.h:50
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
Context struct holding the kernel library's logically global state, and passed to external libbitcoin...
Definition: context.h:20
Options struct containing options for constructing a CTxMemPool.
int check_ratio
The ratio used to determine how often sanity checks will run.
int64_t tx_index
Definition: caches.h:18
int64_t coins
Definition: caches.h:17
int64_t block_tree_db
Definition: caches.h:15
int64_t filter_index
Definition: caches.h:19
int64_t coins_db
Definition: caches.h:16
std::function< void()> coins_error_cb
Definition: chainstate.h:37
std::function< bool()> check_interrupt
Definition: chainstate.h:36
NodeContext struct containing references to chain state and connection state.
Definition: context.h:46
#define WAIT_LOCK(cs, name)
Definition: sync.h:317
#define LOCK(cs)
Definition: sync.h:306
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:357
#define TRY_LOCK(cs, name)
Definition: sync.h:314
std::string SysErrorString(int err)
Return system error string from errno value.
Definition: syserror.cpp:14
bool SetupNetworking()
Definition: system.cpp:98
int GetNumCores()
Return the number of cores available on the current system.
Definition: system.cpp:111
static int count
Definition: tests.c:31
int64_t GetTimeMillis()
Returns the system time (not mockable)
Definition: time.cpp:101
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:89
NodeClock::time_point GetAdjustedTime()
Definition: timedata.cpp:35
static const int64_t DEFAULT_MAX_TIME_ADJUSTMENT
Definition: timedata.h:16
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1202
CService DefaultOnionServiceTarget()
Definition: torcontrol.cpp:871
const std::string DEFAULT_TOR_CONTROL
Default control port.
Definition: torcontrol.cpp:38
void InterruptTorControl()
Definition: torcontrol.cpp:853
void StartTorControl(CService onion_service_target)
Definition: torcontrol.cpp:834
void StopTorControl()
Definition: torcontrol.cpp:863
static const bool DEFAULT_LISTEN_ONION
Definition: torcontrol.h:16
bilingual_str _(const char *psz)
Translation function.
Definition: translation.h:68
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:36
util::Result< void > CheckLegacyTxindex(CBlockTreeDB &block_tree_db)
Definition: txdb.cpp:37
static constexpr int64_t MAX_DB_CACHE_MB
max. -dbcache (MiB)
Definition: txdb.h:38
static constexpr int64_t MIN_DB_CACHE_MB
min. -dbcache (MiB)
Definition: txdb.h:36
static constexpr int64_t DEFAULT_DB_BATCH_SIZE
-dbbatchsize default (bytes)
Definition: txdb.h:42
static constexpr int64_t DEFAULT_DB_CACHE_MB
-dbcache default (MiB)
Definition: txdb.h:40
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
Definition: txindex.cpp:16
static constexpr bool DEFAULT_TXINDEX
Definition: txindex.h:15
CClientUIInterface uiInterface
void InitWarning(const bilingual_str &str)
Show warning message.
bool InitError(const bilingual_str &str)
Show error message.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
std::condition_variable g_best_block_cv
Definition: validation.cpp:119
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess how far we are in the verification process at the given block index require cs_main if pindex h...
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
Definition: validation.cpp:100
assert(!tx.IsCoinBase())
static constexpr int DEFAULT_CHECKLEVEL
Definition: validation.h:98
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Require that user allocate at least 550 MiB for block & undo files (blk???.dat and rev?...
Definition: validation.h:112
static const unsigned int MIN_BLOCKS_TO_KEEP
Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ActiveChain().Tip() will not be pr...
Definition: validation.h:96
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
Definition: validation.h:84
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:115
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
Definition: validation.h:86
static const signed int DEFAULT_CHECKBLOCKS
Definition: validation.h:97
static const bool DEFAULT_PEERBLOOMFILTERS
Definition: validation.h:88
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
Definition: validation.h:91
CMainSignals & GetMainSignals()
void UnregisterAllValidationInterfaces()
Unregister all subscribers.
void UnregisterValidationInterface(CValidationInterface *callbacks)
Unregister subscriber.
void RegisterValidationInterface(CValidationInterface *callbacks)
Register subscriber.
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
static constexpr uint32_t AVALANCHE_VOTE_STALE_FACTOR
Scaling factor applied to confidence to determine staleness threshold.
Definition: voterecord.h:35
static constexpr uint32_t AVALANCHE_VOTE_STALE_THRESHOLD
Number of votes before a record may be considered as stale.
Definition: voterecord.h:22
const WalletInitInterface & g_wallet_init_interface
Definition: init.cpp:41
std::unique_ptr< CZMQNotificationInterface > g_zmq_notification_interface
void RegisterZMQRPCCommands(CRPCTable &t)
Definition: zmqrpc.cpp:68