Bitcoin ABC  0.26.3
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/mempool_persist.h>
14 
15 #include <addrman.h>
16 #include <avalanche/avalanche.h>
17 #include <avalanche/processor.h>
18 #include <avalanche/proof.h> // For AVALANCHE_LEGACY_PROOF_DEFAULT
19 #include <avalanche/validation.h>
20 #include <avalanche/voterecord.h> // For AVALANCHE_VOTE_STALE_*
21 #include <banman.h>
22 #include <blockfilter.h>
23 #include <chain.h>
24 #include <chainparams.h>
25 #include <compat/sanity.h>
26 #include <config.h>
27 #include <consensus/amount.h>
28 #include <currencyunit.h>
29 #include <flatfile.h>
30 #include <hash.h>
31 #include <httprpc.h>
32 #include <httpserver.h>
33 #include <index/blockfilterindex.h>
34 #include <index/coinstatsindex.h>
35 #include <index/txindex.h>
36 #include <init/common.h>
37 #include <interfaces/chain.h>
38 #include <interfaces/node.h>
39 #include <mapport.h>
40 #include <mempool_args.h>
41 #include <net.h>
42 #include <net_permissions.h>
43 #include <net_processing.h>
44 #include <netbase.h>
45 #include <node/blockmanager_args.h>
46 #include <node/blockstorage.h>
47 #include <node/caches.h>
48 #include <node/chainstate.h>
50 #include <node/context.h>
52 #include <node/miner.h>
53 #include <node/ui_interface.h>
55 #include <policy/policy.h>
56 #include <policy/settings.h>
57 #include <rpc/blockchain.h>
58 #include <rpc/register.h>
59 #include <rpc/server.h>
60 #include <rpc/util.h>
61 #include <scheduler.h>
62 #include <script/scriptcache.h>
63 #include <script/sigcache.h>
64 #include <script/standard.h>
65 #include <shutdown.h>
66 #include <sync.h>
67 #include <timedata.h>
68 #include <torcontrol.h>
69 #include <txdb.h>
70 #include <txmempool.h>
71 #include <txorphanage.h>
72 #include <util/asmap.h>
73 #include <util/check.h>
74 #include <util/fs.h>
75 #include <util/fs_helpers.h>
76 #include <util/moneystr.h>
77 #include <util/string.h>
78 #include <util/thread.h>
79 #include <util/threadnames.h>
80 #include <util/translation.h>
81 #include <validation.h>
82 #include <validationinterface.h>
83 #include <walletinitinterface.h>
84 
85 #include <boost/signals2/signal.hpp>
86 
87 #if ENABLE_CHRONIK
88 #include <chronik-cpp/chronik.h>
89 #endif
90 
91 #if ENABLE_ZMQ
94 #include <zmq/zmqrpc.h>
95 #endif
96 
97 #ifndef WIN32
98 #include <cerrno>
99 #include <csignal>
100 #include <sys/stat.h>
101 #endif
102 #include <algorithm>
103 #include <condition_variable>
104 #include <cstdint>
105 #include <cstdio>
106 #include <fstream>
107 #include <functional>
108 #include <set>
109 #include <string>
110 #include <thread>
111 #include <vector>
112 
114 using kernel::DumpMempool;
116 
118 using node::BlockManager;
119 using node::CacheSizes;
122 using node::fReindex;
124 using node::MempoolPath;
125 using node::NodeContext;
127 using node::ThreadImport;
129 
130 static const bool DEFAULT_PROXYRANDOMIZE = true;
131 static const bool DEFAULT_REST_ENABLE = false;
132 static constexpr bool DEFAULT_CHRONIK = false;
133 
134 #ifdef WIN32
135 // Win32 LevelDB doesn't use filedescriptors, and the ones used for accessing
136 // block files don't count towards the fd_set size limit anyway.
137 #define MIN_CORE_FILEDESCRIPTORS 0
138 #else
139 #define MIN_CORE_FILEDESCRIPTORS 150
140 #endif
141 
142 static const char *DEFAULT_ASMAP_FILENAME = "ip_asn.map";
143 
147 static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";
148 
149 static fs::path GetPidFile(const ArgsManager &args) {
151 }
152 
153 [[nodiscard]] static bool CreatePidFile(const ArgsManager &args) {
154  std::ofstream file{GetPidFile(args)};
155  if (file) {
156 #ifdef WIN32
157  tfm::format(file, "%d\n", GetCurrentProcessId());
158 #else
159  tfm::format(file, "%d\n", getpid());
160 #endif
161  return true;
162  } else {
163  return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
165  std::strerror(errno)));
166  }
167 }
168 
170 //
171 // Shutdown
172 //
173 
174 //
175 // Thread management and startup/shutdown:
176 //
177 // The network-processing threads are all part of a thread group created by
178 // AppInit() or the Qt main() function.
179 //
180 // A clean exit happens when StartShutdown() or the SIGTERM signal handler sets
181 // fRequestShutdown, which makes main thread's WaitForShutdown() interrupts the
182 // thread group.
183 // And then, WaitForShutdown() makes all other on-going threads in the thread
184 // group join the main thread.
185 // Shutdown() is then called to clean up database connections, and stop other
186 // threads that should only be stopped after the main network-processing threads
187 // have exited.
188 //
189 // Shutdown for Qt is very similar, only it uses a QTimer to detect
190 // ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
191 //
192 
196  InterruptRPC();
197  InterruptREST();
200  if (g_avalanche) {
201  // Avalanche needs to be stopped before we interrupt the thread group as
202  // the scheduler will stop working then.
203  g_avalanche->stopEventLoop();
204  }
205  if (node.connman) {
206  node.connman->Interrupt();
207  }
208  if (g_txindex) {
209  g_txindex->Interrupt();
210  }
211  ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Interrupt(); });
212  if (g_coin_stats_index) {
213  g_coin_stats_index->Interrupt();
214  }
215 }
216 
218  static Mutex g_shutdown_mutex;
219  TRY_LOCK(g_shutdown_mutex, lock_shutdown);
220  if (!lock_shutdown) {
221  return;
222  }
223  LogPrintf("%s: In progress...\n", __func__);
224  Assert(node.args);
225 
230  util::ThreadRename("shutoff");
231  if (node.mempool) {
232  node.mempool->AddTransactionsUpdated(1);
233  }
234 
235  StopHTTPRPC();
236  StopREST();
237  StopRPC();
238  StopHTTPServer();
239  for (const auto &client : node.chain_clients) {
240  client->flush();
241  }
242  StopMapPort();
243 
244  // Because avalanche and the network depend on each other, it is important
245  // to shut them down in this order:
246  // 1. Stop avalanche event loop.
247  // 2. Shutdown network processing.
248  // 3. Destroy avalanche::Processor.
249  // 4. Destroy CConnman
250  if (g_avalanche) {
251  g_avalanche->stopEventLoop();
252  }
253 
254  // Because these depend on each-other, we make sure that neither can be
255  // using the other before destroying them.
256  if (node.peerman) {
257  UnregisterValidationInterface(node.peerman.get());
258  }
259  if (node.connman) {
260  node.connman->Stop();
261  }
262 
263  StopTorControl();
264 
265  // After everything has been shut down, but before things get flushed, stop
266  // the CScheduler/checkqueue, scheduler and load block thread.
267  if (node.scheduler) {
268  node.scheduler->stop();
269  }
270  if (node.chainman && node.chainman->m_load_block.joinable()) {
271  node.chainman->m_load_block.join();
272  }
274 
275  // After the threads that potentially access these pointers have been
276  // stopped, destruct and reset all to nullptr.
277  node.peerman.reset();
278 
279  // Destroy various global instances
280  g_avalanche.reset();
281  node.connman.reset();
282  node.banman.reset();
283  node.addrman.reset();
284 
285  if (node.mempool && node.mempool->GetLoadTried() &&
286  ShouldPersistMempool(*node.args)) {
287  DumpMempool(*node.mempool, MempoolPath(*node.args));
288  }
289 
290  // FlushStateToDisk generates a ChainStateFlushed callback, which we should
291  // avoid missing
292  if (node.chainman) {
293  LOCK(cs_main);
294  for (Chainstate *chainstate : node.chainman->GetAll()) {
295  if (chainstate->CanFlushToDisk()) {
296  chainstate->ForceFlushStateToDisk();
297  }
298  }
299  }
300 
301  // After there are no more peers/RPC left to give us new data which may
302  // generate CValidationInterface callbacks, flush them...
304 
305 #if ENABLE_CHRONIK
306  if (node.args->GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
307  chronik::Stop();
308  }
309 #endif
310 
311  // Stop and delete all indexes only after flushing background callbacks.
312  if (g_txindex) {
313  g_txindex->Stop();
314  g_txindex.reset();
315  }
316  if (g_coin_stats_index) {
317  g_coin_stats_index->Stop();
318  g_coin_stats_index.reset();
319  }
320  ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Stop(); });
322 
323  // Any future callbacks will be dropped. This should absolutely be safe - if
324  // missing a callback results in an unrecoverable situation, unclean
325  // shutdown would too. The only reason to do the above flushes is to let the
326  // wallet catch up with our current chain to avoid any strange pruning edge
327  // cases and make next startup faster by avoiding rescan.
328 
329  if (node.chainman) {
330  LOCK(cs_main);
331  for (Chainstate *chainstate : node.chainman->GetAll()) {
332  if (chainstate->CanFlushToDisk()) {
333  chainstate->ForceFlushStateToDisk();
334  chainstate->ResetCoinsViews();
335  }
336  }
337  }
338  for (const auto &client : node.chain_clients) {
339  client->stop();
340  }
341 
342 #if ENABLE_ZMQ
346  }
347 #endif
348 
349  node.chain_clients.clear();
353  node.mempool.reset();
354  node.chainman.reset();
355  node.scheduler.reset();
356 
357  try {
358  if (!fs::remove(GetPidFile(*node.args))) {
359  LogPrintf("%s: Unable to remove PID file: File does not exist\n",
360  __func__);
361  }
362  } catch (const fs::filesystem_error &e) {
363  LogPrintf("%s: Unable to remove PID file: %s\n", __func__,
365  }
366 
367  LogPrintf("%s: done\n", __func__);
368 }
369 
375 #ifndef WIN32
376 static void HandleSIGTERM(int) {
377  StartShutdown();
378 }
379 
380 static void HandleSIGHUP(int) {
381  LogInstance().m_reopen_file = true;
382 }
383 #else
384 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) {
385  StartShutdown();
386  Sleep(INFINITE);
387  return true;
388 }
389 #endif
390 
391 #ifndef WIN32
392 static void registerSignalHandler(int signal, void (*handler)(int)) {
393  struct sigaction sa;
394  sa.sa_handler = handler;
395  sigemptyset(&sa.sa_mask);
396  sa.sa_flags = 0;
397  sigaction(signal, &sa, NULL);
398 }
399 #endif
400 
401 static boost::signals2::connection rpc_notify_block_change_connection;
402 static void OnRPCStarted() {
403  rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(
404  std::bind(RPCNotifyBlockChange, std::placeholders::_2));
405 }
406 
407 static void OnRPCStopped() {
409  RPCNotifyBlockChange(nullptr);
410  g_best_block_cv.notify_all();
411  LogPrint(BCLog::RPC, "RPC stopped.\n");
412 }
413 
415  assert(!node.args);
416  node.args = &gArgs;
417  ArgsManager &argsman = *node.args;
418 
419  SetupHelpOptions(argsman);
420  SetupCurrencyUnitOptions(argsman);
421  // server-only for now
422  argsman.AddArg("-help-debug",
423  "Print help message with debugging options and exit", false,
425 
426  init::AddLoggingArgs(argsman);
427 
428  const auto defaultBaseParams =
430  const auto testnetBaseParams =
432  const auto regtestBaseParams =
434  const auto defaultChainParams =
436  const auto testnetChainParams =
438  const auto regtestChainParams =
440 
441  // Hidden Options
442  std::vector<std::string> hidden_args = {
443  "-dbcrashratio",
444  "-forcecompactdb",
445  "-maxaddrtosend",
446  "-parkdeepreorg",
447  "-automaticunparking",
448  "-replayprotectionactivationtime",
449  "-enableminerfund",
450  "-chronikallowpause",
451  "-chronikcors",
452  // GUI args. These will be overwritten by SetupUIArgs for the GUI
453  "-allowselfsignedrootcertificates",
454  "-choosedatadir",
455  "-lang=<lang>",
456  "-min",
457  "-resetguisettings",
458  "-rootcertificates=<file>",
459  "-splash",
460  "-uiplatform",
461  // TODO remove after the Nov. 2024 upgrade
462  "-augustoactivationtime",
463  };
464 
465  // Set all of the args and their help
466  // When adding new options to the categories, please keep and ensure
467  // alphabetical ordering. Do not translate _(...) -help-debug options, Many
468  // technical terms, and only a very small audience, so is unnecessary stress
469  // to translators.
470  argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
472 #if defined(HAVE_SYSTEM)
473  argsman.AddArg(
474  "-alertnotify=<cmd>",
475  "Execute command when a relevant alert is received or we see "
476  "a really long fork (%s in cmd is replaced by message)",
478 #endif
479  argsman.AddArg(
480  "-assumevalid=<hex>",
481  strprintf(
482  "If this block is in the chain assume that it and its ancestors "
483  "are valid and potentially skip their script verification (0 to "
484  "verify all, default: %s, testnet: %s)",
485  defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
486  testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
488  argsman.AddArg("-blocksdir=<dir>",
489  "Specify directory to hold blocks subdirectory for *.dat "
490  "files (default: <datadir>)",
492  argsman.AddArg("-fastprune",
493  "Use smaller block files and lower minimum prune height for "
494  "testing purposes",
497 #if defined(HAVE_SYSTEM)
498  argsman.AddArg("-blocknotify=<cmd>",
499  "Execute command when the best block changes (%s in cmd is "
500  "replaced by block hash)",
502 #endif
503  argsman.AddArg("-blockreconstructionextratxn=<n>",
504  strprintf("Extra transactions to keep in memory for compact "
505  "block reconstructions (default: %u)",
508  argsman.AddArg(
509  "-blocksonly",
510  strprintf("Whether to reject transactions from network peers. "
511  "Automatic broadcast and rebroadcast of any transactions "
512  "from inbound peers is disabled, unless the peer has the "
513  "'forcerelay' permission. RPC transactions are"
514  " not affected. (default: %u)",
517  argsman.AddArg("-coinstatsindex",
518  strprintf("Maintain coinstats index used by the "
519  "gettxoutsetinfo RPC (default: %u)",
522  argsman.AddArg(
523  "-conf=<file>",
524  strprintf("Specify path to read-only configuration file. Relative "
525  "paths will be prefixed by datadir location. (default: %s)",
528  argsman.AddArg("-datadir=<dir>", "Specify data directory",
530  argsman.AddArg(
531  "-dbbatchsize",
532  strprintf("Maximum database write batch size in bytes (default: %u)",
536  argsman.AddArg(
537  "-dbcache=<n>",
538  strprintf("Set database cache size in MiB (%d to %d, default: %d)",
541  argsman.AddArg(
542  "-includeconf=<file>",
543  "Specify additional configuration file, relative to the -datadir path "
544  "(only useable from configuration file, not command line)",
546  argsman.AddArg("-loadblock=<file>",
547  "Imports blocks from external file on startup",
549  argsman.AddArg("-maxmempool=<n>",
550  strprintf("Keep the transaction memory pool below <n> "
551  "megabytes (default: %u)",
554  argsman.AddArg("-maxorphantx=<n>",
555  strprintf("Keep at most <n> unconnectable transactions in "
556  "memory (default: %u)",
559  argsman.AddArg("-mempoolexpiry=<n>",
560  strprintf("Do not keep transactions in the mempool longer "
561  "than <n> hours (default: %u)",
564  argsman.AddArg(
565  "-minimumchainwork=<hex>",
566  strprintf(
567  "Minimum work assumed to exist on a valid chain in hex "
568  "(default: %s, testnet: %s)",
569  defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
570  testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
573  argsman.AddArg(
574  "-par=<n>",
575  strprintf("Set the number of script verification threads (%u to %d, 0 "
576  "= auto, <0 = leave that many cores free, default: %d)",
580  argsman.AddArg("-persistmempool",
581  strprintf("Whether to save the mempool on shutdown and load "
582  "on restart (default: %u)",
585  argsman.AddArg(
586  "-pid=<file>",
587  strprintf("Specify pid file. Relative paths will be prefixed "
588  "by a net-specific datadir location. (default: %s)",
591  argsman.AddArg(
592  "-prune=<n>",
593  strprintf("Reduce storage requirements by enabling pruning (deleting) "
594  "of old blocks. This allows the pruneblockchain RPC to be "
595  "called to delete specific blocks, and enables automatic "
596  "pruning of old blocks if a target size in MiB is provided. "
597  "This mode is incompatible with -txindex, -coinstatsindex "
598  "and -rescan. Warning: Reverting this setting requires "
599  "re-downloading the entire blockchain. (default: 0 = disable "
600  "pruning blocks, 1 = allow manual pruning via RPC, >=%u = "
601  "automatically prune block files to stay under the specified "
602  "target size in MiB)",
603  MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
605  argsman.AddArg(
606  "-reindex-chainstate",
607  "Rebuild chain state from the currently indexed blocks. When "
608  "in pruning mode or if blocks on disk might be corrupted, use "
609  "full -reindex instead.",
611  argsman.AddArg(
612  "-reindex",
613  "Rebuild chain state and block index from the blk*.dat files on disk",
615  argsman.AddArg(
616  "-settings=<file>",
617  strprintf(
618  "Specify path to dynamic settings data file. Can be disabled with "
619  "-nosettings. File is written at runtime and not meant to be "
620  "edited by users (use %s instead for custom settings). Relative "
621  "paths will be prefixed by datadir location. (default: %s)",
624 #if HAVE_SYSTEM
625  argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.",
627 #endif
628 #ifndef WIN32
629  argsman.AddArg(
630  "-sysperms",
631  "Create new files with system default permissions, instead of umask "
632  "077 (only effective with disabled wallet functionality)",
634 #else
635  hidden_args.emplace_back("-sysperms");
636 #endif
637  argsman.AddArg("-txindex",
638  strprintf("Maintain a full transaction index, used by the "
639  "getrawtransaction rpc call (default: %d)",
642 #if ENABLE_CHRONIK
643  argsman.AddArg(
644  "-chronik",
645  strprintf("Enable the Chronik indexer, which can be read via a "
646  "dedicated HTTP/Protobuf interface (default: %d)",
649  argsman.AddArg(
650  "-chronikbind=<addr>[:port]",
651  strprintf(
652  "Bind the Chronik indexer to the given address to listen for "
653  "HTTP/Protobuf connections to access the index. Unlike the "
654  "JSON-RPC, it's ok to have this publicly exposed on the internet. "
655  "This option can be specified multiple times (default: %s; default "
656  "port: %u, testnet: %u, regtest: %u)",
657  Join(chronik::DEFAULT_BINDS, ", "),
658  defaultBaseParams->ChronikPort(), testnetBaseParams->ChronikPort(),
659  regtestBaseParams->ChronikPort()),
662  argsman.AddArg("-chroniktokenindex",
663  "Enable token indexing in Chronik (default: 1)",
665  argsman.AddArg("-chroniklokadidindex",
666  "Enable LOKAD ID indexing in Chronik (default: 1)",
668  argsman.AddArg("-chronikreindex",
669  "Reindex the Chronik indexer from genesis, but leave the "
670  "other indexes untouched",
672  argsman.AddArg(
673  "-chroniktxnumcachebuckets",
674  strprintf(
675  "Tuning param of the TxNumCache, specifies how many buckets "
676  "to use on the belt. Caution against setting this too high, "
677  "it may slow down indexing. Set to 0 to disable. (default: %d)",
678  chronik::DEFAULT_TX_NUM_CACHE_BUCKETS),
680  argsman.AddArg(
681  "-chroniktxnumcachebucketsize",
682  strprintf(
683  "Tuning param of the TxNumCache, specifies the size of each bucket "
684  "on the belt. Unlike the number of buckets, this may be increased "
685  "without much danger of slowing the indexer down. The total cache "
686  "size will be `num_buckets * bucket_size * 40B`, so by default the "
687  "cache will require %dkB of memory. (default: %d)",
688  chronik::DEFAULT_TX_NUM_CACHE_BUCKETS *
689  chronik::DEFAULT_TX_NUM_CACHE_BUCKET_SIZE * 40 / 1000,
690  chronik::DEFAULT_TX_NUM_CACHE_BUCKET_SIZE),
692  argsman.AddArg("-chronikperfstats",
693  "Output some performance statistics (e.g. num cache hits, "
694  "seconds spent) into a <datadir>/perf folder. (default: 0)",
696 #endif
697  argsman.AddArg(
698  "-blockfilterindex=<type>",
699  strprintf("Maintain an index of compact filters by block "
700  "(default: %s, values: %s).",
702  " If <type> is not supplied or if <type> = 1, indexes for "
703  "all known types are enabled.",
705  argsman.AddArg(
706  "-usecashaddr",
707  "Use Cash Address for destination encoding instead of base58 "
708  "(activate by default on Jan, 14)",
710 
711  argsman.AddArg(
712  "-addnode=<ip>",
713  "Add a node to connect to and attempt to keep the connection "
714  "open (see the `addnode` RPC command help for more info)",
717  argsman.AddArg("-asmap=<file>",
718  strprintf("Specify asn mapping used for bucketing of the "
719  "peers (default: %s). Relative paths will be "
720  "prefixed by the net-specific datadir location.",
723  argsman.AddArg("-bantime=<n>",
724  strprintf("Default duration (in seconds) of manually "
725  "configured bans (default: %u)",
728  argsman.AddArg(
729  "-bind=<addr>[:<port>][=onion]",
730  strprintf("Bind to given address and always listen on it (default: "
731  "0.0.0.0). Use [host]:port notation for IPv6. Append =onion "
732  "to tag any incoming connections to that address and port as "
733  "incoming Tor connections (default: 127.0.0.1:%u=onion, "
734  "testnet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)",
735  defaultBaseParams->OnionServiceTargetPort(),
736  testnetBaseParams->OnionServiceTargetPort(),
737  regtestBaseParams->OnionServiceTargetPort()),
740  argsman.AddArg(
741  "-connect=<ip>",
742  "Connect only to the specified node(s); -connect=0 disables automatic "
743  "connections (the rules for this peer are the same as for -addnode)",
746  argsman.AddArg(
747  "-discover",
748  "Discover own IP addresses (default: 1 when listening and no "
749  "-externalip or -proxy)",
751  argsman.AddArg("-dns",
752  strprintf("Allow DNS lookups for -addnode, -seednode and "
753  "-connect (default: %d)",
756  argsman.AddArg(
757  "-dnsseed",
758  strprintf(
759  "Query for peer addresses via DNS lookup, if low on addresses "
760  "(default: %u unless -connect used)",
763  argsman.AddArg("-externalip=<ip>", "Specify your own public address",
765  argsman.AddArg(
766  "-fixedseeds",
767  strprintf(
768  "Allow fixed seeds if DNS seeds don't provide peers (default: %u)",
771  argsman.AddArg(
772  "-forcednsseed",
773  strprintf(
774  "Always query for peer addresses via DNS lookup (default: %d)",
777  argsman.AddArg("-overridednsseed",
778  "If set, only use the specified DNS seed when "
779  "querying for peer addresses via DNS lookup.",
781  argsman.AddArg(
782  "-listen",
783  "Accept connections from outside (default: 1 if no -proxy or -connect)",
785  argsman.AddArg(
786  "-listenonion",
787  strprintf("Automatically create Tor onion service (default: %d)",
790  argsman.AddArg(
791  "-maxconnections=<n>",
792  strprintf("Maintain at most <n> connections to peers. The effective "
793  "limit depends on system limitations and might be lower than "
794  "the specified value (default: %u)",
797  argsman.AddArg("-maxreceivebuffer=<n>",
798  strprintf("Maximum per-connection receive buffer, <n>*1000 "
799  "bytes (default: %u)",
802  argsman.AddArg(
803  "-maxsendbuffer=<n>",
804  strprintf(
805  "Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
808  argsman.AddArg(
809  "-maxtimeadjustment",
810  strprintf("Maximum allowed median peer time offset adjustment. Local "
811  "perspective of time may be influenced by peers forward or "
812  "backward by this amount. (default: %u seconds)",
815  argsman.AddArg("-onion=<ip:port>",
816  strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
817  "onion services (default: %s)",
818  "-proxy"),
820  argsman.AddArg("-i2psam=<ip:port>",
821  "I2P SAM proxy to reach I2P peers and accept I2P "
822  "connections (default: none)",
824  argsman.AddArg(
825  "-i2pacceptincoming",
826  "If set and -i2psam is also set then incoming I2P connections are "
827  "accepted via the SAM proxy. If this is not set but -i2psam is set "
828  "then only outgoing connections will be made to the I2P network. "
829  "Ignored if -i2psam is not set. Listening for incoming I2P connections "
830  "is done through the SAM proxy, not by binding to a local address and "
831  "port (default: 1)",
833 
834  argsman.AddArg(
835  "-onlynet=<net>",
836  "Make outgoing connections only through network <net> (" +
837  Join(GetNetworkNames(), ", ") +
838  "). Incoming connections are not affected by this option. This "
839  "option can be specified multiple times to allow multiple "
840  "networks. Warning: if it is used with non-onion networks "
841  "and the -onion or -proxy option is set, then outbound onion "
842  "connections will still be made; use -noonion or -onion=0 to "
843  "disable outbound onion connections in this case",
845  argsman.AddArg("-peerbloomfilters",
846  strprintf("Support filtering of blocks and transaction with "
847  "bloom filters (default: %d)",
850  argsman.AddArg(
851  "-peerblockfilters",
852  strprintf(
853  "Serve compact block filters to peers per BIP 157 (default: %u)",
856  argsman.AddArg("-permitbaremultisig",
857  strprintf("Relay non-P2SH multisig (default: %d)",
860  // TODO: remove the sentence "Nodes not using ... incoming connections."
861  // once the changes from https://github.com/bitcoin/bitcoin/pull/23542 have
862  // become widespread.
863  argsman.AddArg("-port=<port>",
864  strprintf("Listen for connections on <port>. Nodes not "
865  "using the default ports (default: %u, "
866  "testnet: %u, regtest: %u) are unlikely to get "
867  "incoming connections. Not relevant for I2P (see "
868  "doc/i2p.md).",
869  defaultChainParams->GetDefaultPort(),
870  testnetChainParams->GetDefaultPort(),
871  regtestChainParams->GetDefaultPort()),
874  argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
876  argsman.AddArg(
877  "-proxyrandomize",
878  strprintf("Randomize credentials for every proxy connection. "
879  "This enables Tor stream isolation (default: %d)",
882  argsman.AddArg(
883  "-seednode=<ip>",
884  "Connect to a node to retrieve peer addresses, and disconnect",
886  argsman.AddArg(
887  "-networkactive",
888  "Enable all P2P network activity (default: 1). Can be changed "
889  "by the setnetworkactive RPC command",
891  argsman.AddArg("-timeout=<n>",
892  strprintf("Specify connection timeout in milliseconds "
893  "(minimum: 1, default: %d)",
896  argsman.AddArg(
897  "-peertimeout=<n>",
898  strprintf("Specify p2p connection timeout in seconds. This option "
899  "determines the amount of time a peer may be inactive before "
900  "the connection to it is dropped. (minimum: 1, default: %d)",
903  argsman.AddArg(
904  "-torcontrol=<ip>:<port>",
905  strprintf(
906  "Tor control port to use if onion listening enabled (default: %s)",
909  argsman.AddArg("-torpassword=<pass>",
910  "Tor control port password (default: empty)",
913 #ifdef USE_UPNP
914 #if USE_UPNP
915  argsman.AddArg("-upnp",
916  "Use UPnP to map the listening port (default: 1 when "
917  "listening and no -proxy)",
919 #else
920  argsman.AddArg(
921  "-upnp",
922  strprintf("Use UPnP to map the listening port (default: %u)", 0),
924 #endif
925 #else
926  hidden_args.emplace_back("-upnp");
927 #endif
928 #ifdef USE_NATPMP
929  argsman.AddArg(
930  "-natpmp",
931  strprintf("Use NAT-PMP to map the listening port (default: %s)",
932  DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"),
934 #else
935  hidden_args.emplace_back("-natpmp");
936 #endif // USE_NATPMP
937  argsman.AddArg(
938  "-whitebind=<[permissions@]addr>",
939  "Bind to the given address and add permission flags to the peers "
940  "connecting to it."
941  "Use [host]:port notation for IPv6. Allowed permissions: " +
942  Join(NET_PERMISSIONS_DOC, ", ") +
943  ". "
944  "Specify multiple permissions separated by commas (default: "
945  "download,noban,mempool,relay). Can be specified multiple times.",
947 
948  argsman.AddArg("-whitelist=<[permissions@]IP address or network>",
949  "Add permission flags to the peers connecting from the "
950  "given IP address (e.g. 1.2.3.4) or CIDR-notated network "
951  "(e.g. 1.2.3.0/24). "
952  "Uses the same permissions as -whitebind. Can be specified "
953  "multiple times.",
955  argsman.AddArg(
956  "-maxuploadtarget=<n>",
957  strprintf("Tries to keep outbound traffic under the given target (in "
958  "MiB per 24h). Limit does not apply to peers with 'download' "
959  "permission. 0 = no limit (default: %d)",
962 
964 
965 #if ENABLE_ZMQ
966  argsman.AddArg("-zmqpubhashblock=<address>",
967  "Enable publish hash block in <address>",
969  argsman.AddArg("-zmqpubhashtx=<address>",
970  "Enable publish hash transaction in <address>",
972  argsman.AddArg("-zmqpubrawblock=<address>",
973  "Enable publish raw block in <address>",
975  argsman.AddArg("-zmqpubrawtx=<address>",
976  "Enable publish raw transaction in <address>",
978  argsman.AddArg("-zmqpubsequence=<address>",
979  "Enable publish hash block and tx sequence in <address>",
981  argsman.AddArg(
982  "-zmqpubhashblockhwm=<n>",
983  strprintf("Set publish hash block outbound message high water "
984  "mark (default: %d)",
987  argsman.AddArg(
988  "-zmqpubhashtxhwm=<n>",
989  strprintf("Set publish hash transaction outbound message high "
990  "water mark (default: %d)",
992  false, OptionsCategory::ZMQ);
993  argsman.AddArg(
994  "-zmqpubrawblockhwm=<n>",
995  strprintf("Set publish raw block outbound message high water "
996  "mark (default: %d)",
999  argsman.AddArg(
1000  "-zmqpubrawtxhwm=<n>",
1001  strprintf("Set publish raw transaction outbound message high "
1002  "water mark (default: %d)",
1005  argsman.AddArg("-zmqpubsequencehwm=<n>",
1006  strprintf("Set publish hash sequence message high water mark"
1007  " (default: %d)",
1010 #else
1011  hidden_args.emplace_back("-zmqpubhashblock=<address>");
1012  hidden_args.emplace_back("-zmqpubhashtx=<address>");
1013  hidden_args.emplace_back("-zmqpubrawblock=<address>");
1014  hidden_args.emplace_back("-zmqpubrawtx=<address>");
1015  hidden_args.emplace_back("-zmqpubsequence=<n>");
1016  hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
1017  hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
1018  hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
1019  hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
1020  hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
1021 #endif
1022 
1023  argsman.AddArg(
1024  "-checkblocks=<n>",
1025  strprintf("How many blocks to check at startup (default: %u, 0 = all)",
1029  argsman.AddArg("-checklevel=<n>",
1030  strprintf("How thorough the block verification of "
1031  "-checkblocks is: %s (0-4, default: %u)",
1035  argsman.AddArg("-checkblockindex",
1036  strprintf("Do a consistency check for the block tree, "
1037  "chainstate, and other validation data structures "
1038  "occasionally. (default: %u, regtest: %u)",
1039  defaultChainParams->DefaultConsistencyChecks(),
1040  regtestChainParams->DefaultConsistencyChecks()),
1043  argsman.AddArg("-checkaddrman=<n>",
1044  strprintf("Run addrman consistency checks every <n> "
1045  "operations. Use 0 to disable. (default: %u)",
1049  argsman.AddArg(
1050  "-checkmempool=<n>",
1051  strprintf("Run mempool consistency checks every <n> transactions. Use "
1052  "0 to disable. (default: %u, regtest: %u)",
1053  defaultChainParams->DefaultConsistencyChecks(),
1054  regtestChainParams->DefaultConsistencyChecks()),
1057  argsman.AddArg("-checkpoints",
1058  strprintf("Only accept block chain matching built-in "
1059  "checkpoints (default: %d)",
1063  argsman.AddArg("-deprecatedrpc=<method>",
1064  "Allows deprecated RPC method(s) to be used",
1067  argsman.AddArg(
1068  "-stopafterblockimport",
1069  strprintf("Stop running after importing blocks from disk (default: %d)",
1073  argsman.AddArg("-stopatheight",
1074  strprintf("Stop running after reaching the given height in "
1075  "the main chain (default: %u)",
1079  argsman.AddArg("-addrmantest", "Allows to test address relay on localhost",
1082  argsman.AddArg("-capturemessages", "Capture all P2P messages to disk",
1085  argsman.AddArg("-mocktime=<n>",
1086  "Replace actual time with " + UNIX_EPOCH_TIME +
1087  " (default: 0)",
1090  argsman.AddArg(
1091  "-maxsigcachesize=<n>",
1092  strprintf("Limit size of signature cache to <n> MiB (default: %u)",
1096  argsman.AddArg(
1097  "-maxscriptcachesize=<n>",
1098  strprintf("Limit size of script cache to <n> MiB (default: %u)",
1102  argsman.AddArg("-maxtipage=<n>",
1103  strprintf("Maximum tip age in seconds to consider node in "
1104  "initial block download (default: %u)",
1105  Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
1108 
1109  argsman.AddArg("-uacomment=<cmt>",
1110  "Append comment to the user agent string",
1112  argsman.AddArg("-uaclientname=<clientname>", "Set user agent client name",
1114  argsman.AddArg("-uaclientversion=<clientversion>",
1115  "Set user agent client version", ArgsManager::ALLOW_ANY,
1117 
1118  SetupChainParamsBaseOptions(argsman);
1119 
1120  argsman.AddArg(
1121  "-acceptnonstdtxn",
1122  strprintf(
1123  "Relay and mine \"non-standard\" transactions (%sdefault: %u)",
1124  "testnet/regtest only; ", defaultChainParams->RequireStandard()),
1127  argsman.AddArg("-excessiveblocksize=<n>",
1128  strprintf("Do not accept blocks larger than this limit, in "
1129  "bytes (default: %d)",
1133  const auto &ticker = Currency::get().ticker;
1134  argsman.AddArg(
1135  "-dustrelayfee=<amt>",
1136  strprintf("Fee rate (in %s/kB) used to define dust, the value of an "
1137  "output such that it will cost about 1/3 of its value in "
1138  "fees at this fee rate to spend it. (default: %s)",
1139  ticker, FormatMoney(DUST_RELAY_TX_FEE)),
1142 
1143  argsman.AddArg(
1144  "-bytespersigcheck",
1145  strprintf("Equivalent bytes per sigCheck in transactions for relay and "
1146  "mining (default: %u).",
1149  argsman.AddArg(
1150  "-bytespersigop",
1151  strprintf("DEPRECATED: Equivalent bytes per sigCheck in transactions "
1152  "for relay and mining (default: %u). This has been "
1153  "deprecated since v0.26.8 and will be removed in the future, "
1154  "please use -bytespersigcheck instead.",
1157  argsman.AddArg(
1158  "-datacarrier",
1159  strprintf("Relay and mine data carrier transactions (default: %d)",
1162  argsman.AddArg(
1163  "-datacarriersize",
1164  strprintf("Maximum size of data in data carrier transactions "
1165  "we relay and mine (default: %u)",
1168  argsman.AddArg(
1169  "-minrelaytxfee=<amt>",
1170  strprintf("Fees (in %s/kB) smaller than this are rejected for "
1171  "relaying, mining and transaction creation (default: %s)",
1174  argsman.AddArg(
1175  "-whitelistrelay",
1176  strprintf("Add 'relay' permission to whitelisted inbound peers "
1177  "with default permissions. This will accept relayed "
1178  "transactions even when not relaying transactions "
1179  "(default: %d)",
1182  argsman.AddArg(
1183  "-whitelistforcerelay",
1184  strprintf("Add 'forcerelay' permission to whitelisted inbound peers"
1185  " with default permissions. This will relay transactions "
1186  "even if the transactions were already in the mempool "
1187  "(default: %d)",
1190 
1191  argsman.AddArg("-blockmaxsize=<n>",
1192  strprintf("Set maximum block size in bytes (default: %d)",
1195  argsman.AddArg(
1196  "-blockmintxfee=<amt>",
1197  strprintf("Set lowest fee rate (in %s/kB) for transactions to "
1198  "be included in block creation. (default: %s)",
1201 
1202  argsman.AddArg("-blockversion=<n>",
1203  "Override block version to test forking scenarios",
1206 
1207  argsman.AddArg("-server", "Accept command line and JSON-RPC commands",
1209  argsman.AddArg("-rest",
1210  strprintf("Accept public REST requests (default: %d)",
1213  argsman.AddArg(
1214  "-rpcbind=<addr>[:port]",
1215  "Bind to given address to listen for JSON-RPC connections. Do not "
1216  "expose the RPC server to untrusted networks such as the public "
1217  "internet! This option is ignored unless -rpcallowip is also passed. "
1218  "Port is optional and overrides -rpcport. Use [host]:port notation "
1219  "for IPv6. This option can be specified multiple times (default: "
1220  "127.0.0.1 and ::1 i.e., localhost)",
1224  argsman.AddArg(
1225  "-rpccookiefile=<loc>",
1226  "Location of the auth cookie. Relative paths will be prefixed "
1227  "by a net-specific datadir location. (default: data dir)",
1229  argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
1232  argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
1235  argsman.AddArg(
1236  "-rpcwhitelist=<whitelist>",
1237  "Set a whitelist to filter incoming RPC calls for a specific user. The "
1238  "field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc "
1239  "2>,...,<rpc n>. If multiple whitelists are set for a given user, they "
1240  "are set-intersected. See -rpcwhitelistdefault documentation for "
1241  "information on default whitelist behavior.",
1243  argsman.AddArg(
1244  "-rpcwhitelistdefault",
1245  "Sets default behavior for rpc whitelisting. Unless "
1246  "rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc "
1247  "server acts as if all rpc users are subject to "
1248  "empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault "
1249  "is set to 1 and no -rpcwhitelist is set, rpc server acts as if all "
1250  "rpc users are subject to empty whitelists.",
1252  argsman.AddArg(
1253  "-rpcauth=<userpw>",
1254  "Username and HMAC-SHA-256 hashed password for JSON-RPC connections. "
1255  "The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A "
1256  "canonical python script is included in share/rpcauth. The client then "
1257  "connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> "
1258  "pair of arguments. This option can be specified multiple times",
1260  argsman.AddArg("-rpcport=<port>",
1261  strprintf("Listen for JSON-RPC connections on <port> "
1262  "(default: %u, testnet: %u, regtest: %u)",
1263  defaultBaseParams->RPCPort(),
1264  testnetBaseParams->RPCPort(),
1265  regtestBaseParams->RPCPort()),
1268  argsman.AddArg(
1269  "-rpcallowip=<ip>",
1270  "Allow JSON-RPC connections from specified source. Valid for "
1271  "<ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. "
1272  "1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). "
1273  "This option can be specified multiple times",
1275  argsman.AddArg(
1276  "-rpcthreads=<n>",
1277  strprintf(
1278  "Set the number of threads to service RPC calls (default: %d)",
1281  argsman.AddArg(
1282  "-rpccorsdomain=value",
1283  "Domain from which to accept cross origin requests (browser enforced)",
1285 
1286  argsman.AddArg("-rpcworkqueue=<n>",
1287  strprintf("Set the depth of the work queue to service RPC "
1288  "calls (default: %d)",
1292  argsman.AddArg("-rpcservertimeout=<n>",
1293  strprintf("Timeout during HTTP requests (default: %d)",
1297 
1298 #if HAVE_DECL_FORK
1299  argsman.AddArg("-daemon",
1300  strprintf("Run in the background as a daemon and accept "
1301  "commands (default: %d)",
1302  DEFAULT_DAEMON),
1304  argsman.AddArg("-daemonwait",
1305  strprintf("Wait for initialization to be finished before "
1306  "exiting. This implies -daemon (default: %d)",
1309 #else
1310  hidden_args.emplace_back("-daemon");
1311  hidden_args.emplace_back("-daemonwait");
1312 #endif
1313 
1314  // Avalanche options.
1315  argsman.AddArg("-avalanche",
1316  strprintf("Enable the avalanche feature (default: %u)",
1319  argsman.AddArg(
1320  "-avalanchestakingrewards",
1321  strprintf("Enable the avalanche staking rewards feature (default: %u, "
1322  "testnet: %u, regtest: %u)",
1323  defaultChainParams->GetConsensus().enableStakingRewards,
1324  testnetChainParams->GetConsensus().enableStakingRewards,
1325  regtestChainParams->GetConsensus().enableStakingRewards),
1327  argsman.AddArg("-avalancheconflictingproofcooldown",
1328  strprintf("Mandatory cooldown before a proof conflicting "
1329  "with an already registered one can be considered "
1330  "in seconds (default: %u)",
1333  argsman.AddArg("-avalanchepeerreplacementcooldown",
1334  strprintf("Mandatory cooldown before a peer can be replaced "
1335  "in seconds (default: %u)",
1338  argsman.AddArg(
1339  "-avaminquorumstake",
1340  strprintf(
1341  "Minimum amount of known stake for a usable quorum (default: %s)",
1344  argsman.AddArg(
1345  "-avaminquorumconnectedstakeratio",
1346  strprintf("Minimum proportion of known stake we"
1347  " need nodes for to have a usable quorum (default: %s)",
1350  argsman.AddArg(
1351  "-avaminavaproofsnodecount",
1352  strprintf("Minimum number of node that needs to send us an avaproofs"
1353  " message before we consider we have a usable quorum"
1354  " (default: %s)",
1357  argsman.AddArg(
1358  "-avastalevotethreshold",
1359  strprintf("Number of avalanche votes before a voted item goes stale "
1360  "when voting confidence is low (default: %u)",
1363  argsman.AddArg(
1364  "-avastalevotefactor",
1365  strprintf(
1366  "Factor affecting the number of avalanche votes before a voted "
1367  "item goes stale when voting confidence is high (default: %u)",
1370  argsman.AddArg("-avacooldown",
1371  strprintf("Mandatory cooldown between two avapoll in "
1372  "milliseconds (default: %u)",
1375  argsman.AddArg(
1376  "-avatimeout",
1377  strprintf("Avalanche query timeout in milliseconds (default: %u)",
1380  argsman.AddArg(
1381  "-avadelegation",
1382  "Avalanche proof delegation to the master key used by this node "
1383  "(default: none). Should be used in conjunction with -avaproof and "
1384  "-avamasterkey",
1386  argsman.AddArg("-avaproof",
1387  "Avalanche proof to be used by this node (default: none)",
1389  argsman.AddArg(
1390  "-avaproofstakeutxoconfirmations",
1391  strprintf(
1392  "Minimum number of confirmations before a stake utxo is mature"
1393  " enough to be included into a proof. Utxos in the mempool are not "
1394  "accepted (i.e this value must be greater than 0) (default: %s)",
1397  argsman.AddArg("-avaproofstakeutxodustthreshold",
1398  strprintf("Minimum value each stake utxo must have to be "
1399  "considered valid (default: %s)",
1402  argsman.AddArg("-avamasterkey",
1403  "Master key associated with the proof. If a proof is "
1404  "required, this is mandatory.",
1407  argsman.AddArg("-avasessionkey", "Avalanche session key (default: random)",
1410  argsman.AddArg(
1411  "-maxavalancheoutbound",
1412  strprintf(
1413  "Set the maximum number of avalanche outbound peers to connect to. "
1414  "Note that this option takes precedence over the -maxconnections "
1415  "option (default: %u).",
1418  argsman.AddArg(
1419  "-persistavapeers",
1420  strprintf("Whether to save the avalanche peers upon shutdown and load "
1421  "them upon startup (default: %u).",
1424 
1425  hidden_args.emplace_back("-avalanchepreconsensus");
1426 
1427  // Add the hidden options
1428  argsman.AddHiddenArgs(hidden_args);
1429 }
1430 
1431 std::string LicenseInfo() {
1432  const std::string URL_SOURCE_CODE =
1433  "<https://github.com/Bitcoin-ABC/bitcoin-abc>";
1434  const std::string URL_WEBSITE = "<https://www.bitcoinabc.org>";
1435 
1436  return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009,
1437  COPYRIGHT_YEAR) +
1438  " ") +
1439  "\n" + "\n" +
1440  strprintf(_("Please contribute if you find %s useful. "
1441  "Visit %s for further information about the software.")
1442  .translated,
1443  PACKAGE_NAME, URL_WEBSITE) +
1444  "\n" +
1445  strprintf(_("The source code is available from %s.").translated,
1446  URL_SOURCE_CODE) +
1447  "\n" + "\n" + _("This is experimental software.").translated + "\n" +
1448  strprintf(_("Distributed under the MIT software license, see the "
1449  "accompanying file %s or %s")
1450  .translated,
1451  "COPYING", "<https://opensource.org/licenses/MIT>") +
1452  "\n" + "\n" +
1453  strprintf(_("This product includes software developed by the "
1454  "OpenSSL Project for use in the OpenSSL Toolkit %s and "
1455  "cryptographic software written by Eric Young and UPnP "
1456  "software written by Thomas Bernard.")
1457  .translated,
1458  "<https://www.openssl.org>") +
1459  "\n";
1460 }
1461 
1462 static bool fHaveGenesis = false;
1464 static std::condition_variable g_genesis_wait_cv;
1465 
1466 static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex) {
1467  if (pBlockIndex != nullptr) {
1468  {
1470  fHaveGenesis = true;
1471  }
1472  g_genesis_wait_cv.notify_all();
1473  }
1474 }
1475 
1476 #if HAVE_SYSTEM
1477 static void StartupNotify(const ArgsManager &args) {
1478  std::string cmd = args.GetArg("-startupnotify", "");
1479  if (!cmd.empty()) {
1480  std::thread t(runCommand, cmd);
1481  // thread runs free
1482  t.detach();
1483  }
1484 }
1485 #endif
1486 
1487 static bool AppInitServers(Config &config,
1488  HTTPRPCRequestProcessor &httpRPCRequestProcessor,
1489  NodeContext &node) {
1490  const ArgsManager &args = *Assert(node.args);
1493  if (!InitHTTPServer(config)) {
1494  return false;
1495  }
1496 
1497  StartRPC();
1498  node.rpc_interruption_point = RpcInterruptionPoint;
1499 
1500  if (!StartHTTPRPC(httpRPCRequestProcessor)) {
1501  return false;
1502  }
1503  if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
1504  StartREST(&node);
1505  }
1506 
1507  StartHTTPServer();
1508  return true;
1509 }
1510 
1511 // Parameter interaction based on rules
1513  // when specifying an explicit binding address, you want to listen on it
1514  // even when -connect or -proxy is specified.
1515  if (args.IsArgSet("-bind")) {
1516  if (args.SoftSetBoolArg("-listen", true)) {
1517  LogPrintf(
1518  "%s: parameter interaction: -bind set -> setting -listen=1\n",
1519  __func__);
1520  }
1521  }
1522  if (args.IsArgSet("-whitebind")) {
1523  if (args.SoftSetBoolArg("-listen", true)) {
1524  LogPrintf("%s: parameter interaction: -whitebind set -> setting "
1525  "-listen=1\n",
1526  __func__);
1527  }
1528  }
1529 
1530  if (args.IsArgSet("-connect")) {
1531  // when only connecting to trusted nodes, do not seed via DNS, or listen
1532  // by default.
1533  if (args.SoftSetBoolArg("-dnsseed", false)) {
1534  LogPrintf("%s: parameter interaction: -connect set -> setting "
1535  "-dnsseed=0\n",
1536  __func__);
1537  }
1538  if (args.SoftSetBoolArg("-listen", false)) {
1539  LogPrintf("%s: parameter interaction: -connect set -> setting "
1540  "-listen=0\n",
1541  __func__);
1542  }
1543  }
1544 
1545  if (args.IsArgSet("-proxy")) {
1546  // to protect privacy, do not listen by default if a default proxy
1547  // server is specified.
1548  if (args.SoftSetBoolArg("-listen", false)) {
1549  LogPrintf(
1550  "%s: parameter interaction: -proxy set -> setting -listen=0\n",
1551  __func__);
1552  }
1553  // to protect privacy, do not map ports when a proxy is set. The user
1554  // may still specify -listen=1 to listen locally, so don't rely on this
1555  // happening through -listen below.
1556  if (args.SoftSetBoolArg("-upnp", false)) {
1557  LogPrintf(
1558  "%s: parameter interaction: -proxy set -> setting -upnp=0\n",
1559  __func__);
1560  }
1561  if (args.SoftSetBoolArg("-natpmp", false)) {
1562  LogPrintf(
1563  "%s: parameter interaction: -proxy set -> setting -natpmp=0\n",
1564  __func__);
1565  }
1566  // to protect privacy, do not discover addresses by default
1567  if (args.SoftSetBoolArg("-discover", false)) {
1568  LogPrintf("%s: parameter interaction: -proxy set -> setting "
1569  "-discover=0\n",
1570  __func__);
1571  }
1572  }
1573 
1574  if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
1575  // do not map ports or try to retrieve public IP when not listening
1576  // (pointless)
1577  if (args.SoftSetBoolArg("-upnp", false)) {
1578  LogPrintf(
1579  "%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
1580  __func__);
1581  }
1582  if (args.SoftSetBoolArg("-natpmp", false)) {
1583  LogPrintf(
1584  "%s: parameter interaction: -listen=0 -> setting -natpmp=0\n",
1585  __func__);
1586  }
1587  if (args.SoftSetBoolArg("-discover", false)) {
1588  LogPrintf(
1589  "%s: parameter interaction: -listen=0 -> setting -discover=0\n",
1590  __func__);
1591  }
1592  if (args.SoftSetBoolArg("-listenonion", false)) {
1593  LogPrintf("%s: parameter interaction: -listen=0 -> setting "
1594  "-listenonion=0\n",
1595  __func__);
1596  }
1597  if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
1598  LogPrintf("%s: parameter interaction: -listen=0 -> setting "
1599  "-i2pacceptincoming=0\n",
1600  __func__);
1601  }
1602  }
1603 
1604  if (args.IsArgSet("-externalip")) {
1605  // if an explicit public IP is specified, do not try to find others
1606  if (args.SoftSetBoolArg("-discover", false)) {
1607  LogPrintf("%s: parameter interaction: -externalip set -> setting "
1608  "-discover=0\n",
1609  __func__);
1610  }
1611  }
1612 
1613  // disable whitelistrelay in blocksonly mode
1614  if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
1615  if (args.SoftSetBoolArg("-whitelistrelay", false)) {
1616  LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
1617  "-whitelistrelay=0\n",
1618  __func__);
1619  }
1620  }
1621 
1622  // Forcing relay from whitelisted hosts implies we will accept relays from
1623  // them in the first place.
1624  if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
1625  if (args.SoftSetBoolArg("-whitelistrelay", true)) {
1626  LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
1627  "setting -whitelistrelay=1\n",
1628  __func__);
1629  }
1630  }
1631 
1632  // If avalanche is set, soft set all the feature flags accordingly.
1633  if (args.IsArgSet("-avalanche")) {
1634  const bool fAvalanche =
1635  args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
1636  args.SoftSetBoolArg("-automaticunparking", !fAvalanche);
1637  }
1638 }
1639 
1646 void InitLogging(const ArgsManager &args) {
1649 }
1650 
1651 namespace { // Variables internal to initialization process only
1652 
1653 int nMaxConnections;
1654 int nUserMaxConnections;
1655 int nFD;
1657 int64_t peer_connect_timeout;
1658 std::set<BlockFilterType> g_enabled_filter_types;
1659 
1660 } // namespace
1661 
1662 [[noreturn]] static void new_handler_terminate() {
1663  // Rather than throwing std::bad-alloc if allocation fails, terminate
1664  // immediately to (try to) avoid chain corruption. Since LogPrintf may
1665  // itself allocate memory, set the handler directly to terminate first.
1666  std::set_new_handler(std::terminate);
1667  LogPrintf("Error: Out of memory. Terminating.\n");
1668 
1669  // The log was successful, terminate now.
1670  std::terminate();
1671 };
1672 
1673 bool AppInitBasicSetup(const ArgsManager &args) {
1674 // Step 1: setup
1675 #ifdef _MSC_VER
1676  // Turn off Microsoft heap dump noise
1677  _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
1678  _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
1679  OPEN_EXISTING, 0, 0));
1680  // Disable confusing "helpful" text message on abort, Ctrl-C
1681  _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
1682 #endif
1683 #ifdef WIN32
1684  // Enable Data Execution Prevention (DEP)
1685  SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
1686 #endif
1687  if (!InitShutdownState()) {
1688  return InitError(
1689  Untranslated("Initializing wait-for-shutdown state failed."));
1690  }
1691 
1692  if (!SetupNetworking()) {
1693  return InitError(Untranslated("Initializing networking failed"));
1694  }
1695 
1696 #ifndef WIN32
1697  if (!args.GetBoolArg("-sysperms", false)) {
1698  umask(077);
1699  }
1700 
1701  // Clean shutdown on SIGTERM
1704 
1705  // Reopen debug.log on SIGHUP
1707 
1708  // Ignore SIGPIPE, otherwise it will bring the daemon down if the client
1709  // closes unexpectedly
1710  signal(SIGPIPE, SIG_IGN);
1711 #else
1712  SetConsoleCtrlHandler(consoleCtrlHandler, true);
1713 #endif
1714 
1715  std::set_new_handler(new_handler_terminate);
1716 
1717  return true;
1718 }
1719 
1720 bool AppInitParameterInteraction(Config &config, const ArgsManager &args) {
1721  const CChainParams &chainparams = config.GetChainParams();
1722  // Step 2: parameter interactions
1723 
1724  // also see: InitParameterInteraction()
1725 
1726  // Error if network-specific options (-addnode, -connect, etc) are
1727  // specified in default section of config file, but not overridden
1728  // on the command line or in this network's section of the config file.
1729  std::string network = args.GetChainName();
1730  bilingual_str errors;
1731  for (const auto &arg : args.GetUnsuitableSectionOnlyArgs()) {
1732  errors += strprintf(_("Config setting for %s only applied on %s "
1733  "network when in [%s] section.") +
1734  Untranslated("\n"),
1735  arg, network, network);
1736  }
1737 
1738  if (!errors.empty()) {
1739  return InitError(errors);
1740  }
1741 
1742  // Warn if unrecognized section name are present in the config file.
1743  bilingual_str warnings;
1744  for (const auto &section : args.GetUnrecognizedSections()) {
1745  warnings += strprintf(Untranslated("%s:%i ") +
1746  _("Section [%s] is not recognized.") +
1747  Untranslated("\n"),
1748  section.m_file, section.m_line, section.m_name);
1749  }
1750 
1751  if (!warnings.empty()) {
1752  InitWarning(warnings);
1753  }
1754 
1755  if (!fs::is_directory(args.GetBlocksDirPath())) {
1756  return InitError(
1757  strprintf(_("Specified blocks directory \"%s\" does not exist."),
1758  args.GetArg("-blocksdir", "")));
1759  }
1760 
1761  // parse and validate enabled filter types
1762  std::string blockfilterindex_value =
1763  args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
1764  if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
1765  g_enabled_filter_types = AllBlockFilterTypes();
1766  } else if (blockfilterindex_value != "0") {
1767  const std::vector<std::string> names =
1768  args.GetArgs("-blockfilterindex");
1769  for (const auto &name : names) {
1770  BlockFilterType filter_type;
1771  if (!BlockFilterTypeByName(name, filter_type)) {
1772  return InitError(
1773  strprintf(_("Unknown -blockfilterindex value %s."), name));
1774  }
1775  g_enabled_filter_types.insert(filter_type);
1776  }
1777  }
1778 
1779  // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index
1780  // are both enabled.
1781  if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
1782  if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
1783  return InitError(
1784  _("Cannot set -peerblockfilters without -blockfilterindex."));
1785  }
1786 
1787  nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
1788  }
1789 
1790  // if using block pruning, then disallow txindex, coinstatsindex and chronik
1791  if (args.GetIntArg("-prune", 0)) {
1792  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1793  return InitError(_("Prune mode is incompatible with -txindex."));
1794  }
1795  if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1796  return InitError(
1797  _("Prune mode is incompatible with -coinstatsindex."));
1798  }
1799  if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
1800  return InitError(_("Prune mode is incompatible with -chronik."));
1801  }
1802  }
1803 
1804  // -bind and -whitebind can't be set when not listening
1805  size_t nUserBind =
1806  args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
1807  if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
1808  return InitError(Untranslated(
1809  "Cannot set -bind or -whitebind together with -listen=0"));
1810  }
1811 
1812  // Make sure enough file descriptors are available
1813  int nBind = std::max(nUserBind, size_t(1));
1814  nUserMaxConnections =
1815  args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
1816  nMaxConnections = std::max(nUserMaxConnections, 0);
1817 
1818  // -maxavalancheoutbound takes precedence over -maxconnections
1819  const int maxAvalancheOutbound = args.GetIntArg(
1820  "-maxavalancheoutbound", DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS);
1821  if (isAvalancheEnabled(args) && maxAvalancheOutbound > nMaxConnections) {
1822  nMaxConnections = std::max(maxAvalancheOutbound, nMaxConnections);
1823  // Indicate the value set by the user
1824  LogPrintf("Increasing -maxconnections from %d to %d to comply with "
1825  "-maxavalancheoutbound\n",
1826  nUserMaxConnections, nMaxConnections);
1827  }
1828 
1829  // Trim requested connection counts, to fit into system limitations
1830  // <int> in std::min<int>(...) to work around FreeBSD compilation issue
1831  // described in #2695
1833  nMaxConnections + nBind + MIN_CORE_FILEDESCRIPTORS +
1835 #ifdef USE_POLL
1836  int fd_max = nFD;
1837 #else
1838  int fd_max = FD_SETSIZE;
1839 #endif
1840  nMaxConnections = std::max(
1841  std::min<int>(nMaxConnections,
1842  fd_max - nBind - MIN_CORE_FILEDESCRIPTORS -
1844  0);
1845  if (nFD < MIN_CORE_FILEDESCRIPTORS) {
1846  return InitError(_("Not enough file descriptors available."));
1847  }
1848  nMaxConnections =
1850  nMaxConnections);
1851 
1852  if (nMaxConnections < nUserMaxConnections) {
1853  // Not categorizing as "Warning" because this is the normal behavior for
1854  // platforms using the select() interface for which FD_SETSIZE is
1855  // usually 1024.
1856  LogPrintf("Reducing -maxconnections from %d to %d, because of system "
1857  "limitations.\n",
1858  nUserMaxConnections, nMaxConnections);
1859  }
1860 
1861  // Step 3: parameter-to-internal-flags
1863 
1864  // Configure excessive block size.
1865  const int64_t nProposedExcessiveBlockSize =
1866  args.GetIntArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
1867  if (nProposedExcessiveBlockSize <= 0 ||
1868  !config.SetMaxBlockSize(nProposedExcessiveBlockSize)) {
1869  return InitError(
1870  _("Excessive block size must be > 1,000,000 bytes (1MB)"));
1871  }
1872 
1873  // Check blockmaxsize does not exceed maximum accepted block size.
1874  const int64_t nProposedMaxGeneratedBlockSize =
1875  args.GetIntArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
1876  if (nProposedMaxGeneratedBlockSize <= 0) {
1877  return InitError(_("Max generated block size must be greater than 0"));
1878  }
1879  if (uint64_t(nProposedMaxGeneratedBlockSize) > config.GetMaxBlockSize()) {
1880  return InitError(_("Max generated block size (blockmaxsize) cannot "
1881  "exceed the excessive block size "
1882  "(excessiveblocksize)"));
1883  }
1884 
1886  if (nConnectTimeout <= 0) {
1888  }
1889 
1890  peer_connect_timeout =
1891  args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
1892  if (peer_connect_timeout <= 0) {
1893  return InitError(Untranslated(
1894  "peertimeout cannot be configured with a negative value."));
1895  }
1896 
1897  // Sanity check argument for min fee for including tx in block
1898  // TODO: Harmonize which arguments need sanity checking and where that
1899  // happens.
1900  if (args.IsArgSet("-blockmintxfee")) {
1901  Amount n = Amount::zero();
1902  if (!ParseMoney(args.GetArg("-blockmintxfee", ""), n)) {
1903  return InitError(AmountErrMsg("blockmintxfee",
1904  args.GetArg("-blockmintxfee", "")));
1905  }
1906  }
1907 
1909  args.IsArgSet("-bytespersigcheck")
1910  ? args.GetIntArg("-bytespersigcheck", nBytesPerSigCheck)
1911  : args.GetIntArg("-bytespersigop", nBytesPerSigCheck);
1912 
1914  return false;
1915  }
1916 
1917  // Option to startup with mocktime set (used for regression testing):
1918  SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
1919 
1920  if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
1921  nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
1922  }
1923 
1924  if (args.IsArgSet("-proxy") && args.GetArg("-proxy", "").empty()) {
1925  return InitError(_(
1926  "No proxy server specified. Use -proxy=<ip> or -proxy=<ip:port>."));
1927  }
1928 
1929  // Avalanche parameters
1930  const int64_t stakeUtxoMinConfirmations =
1931  args.GetIntArg("-avaproofstakeutxoconfirmations",
1933 
1934  if (!chainparams.IsTestChain() &&
1935  stakeUtxoMinConfirmations !=
1937  return InitError(_("Avalanche stake UTXO minimum confirmations can "
1938  "only be set on test chains."));
1939  }
1940 
1941  if (stakeUtxoMinConfirmations <= 0) {
1942  return InitError(_("Avalanche stake UTXO minimum confirmations must be "
1943  "a positive integer."));
1944  }
1945 
1946  if (args.IsArgSet("-avaproofstakeutxodustthreshold")) {
1947  Amount amount = Amount::zero();
1948  auto parsed = ParseMoney(
1949  args.GetArg("-avaproofstakeutxodustthreshold", ""), amount);
1950  if (!parsed || Amount::zero() == amount) {
1951  return InitError(AmountErrMsg(
1952  "avaproofstakeutxodustthreshold",
1953  args.GetArg("-avaproofstakeutxodustthreshold", "")));
1954  }
1955 
1956  if (!chainparams.IsTestChain() &&
1957  amount != avalanche::PROOF_DUST_THRESHOLD) {
1958  return InitError(_("Avalanche stake UTXO dust threshold can "
1959  "only be set on test chains."));
1960  }
1961  }
1962 
1963  // This is a staking node
1964  if (isAvalancheEnabled(args) && args.IsArgSet("-avaproof")) {
1965  if (!args.GetBoolArg("-listen", true)) {
1966  return InitError(_("Running a staking node requires accepting "
1967  "inbound connections. Please enable -listen."));
1968  }
1969  if (args.IsArgSet("-proxy")) {
1970  return InitError(_("Running a staking node behind a proxy is not "
1971  "supported. Please disable -proxy."));
1972  }
1973  if (args.IsArgSet("-i2psam")) {
1974  return InitError(_("Running a staking node behind I2P is not "
1975  "supported. Please disable -i2psam."));
1976  }
1977  if (args.IsArgSet("-onlynet")) {
1978  return InitError(
1979  _("Restricting the outbound network is not supported when "
1980  "running a staking node. Please disable -onlynet."));
1981  }
1982  }
1983 
1984  // Also report errors from parsing before daemonization
1985  {
1986  ChainstateManager::Options chainman_opts_dummy{
1987  .config = config,
1988  .datadir = args.GetDataDirNet(),
1989  };
1990  if (const auto error{ApplyArgsManOptions(args, chainman_opts_dummy)}) {
1991  return InitError(*error);
1992  }
1993  BlockManager::Options blockman_opts_dummy{
1994  .chainparams = chainman_opts_dummy.config.GetChainParams(),
1995  .blocks_dir = args.GetBlocksDirPath(),
1996  };
1997  if (const auto error{ApplyArgsManOptions(args, blockman_opts_dummy)}) {
1998  return InitError(*error);
1999  }
2000  }
2001 
2002  return true;
2003 }
2004 
2005 static bool LockDataDirectory(bool probeOnly) {
2006  // Make sure only a single Bitcoin process is using the data directory.
2007  fs::path datadir = gArgs.GetDataDirNet();
2008  if (!DirIsWritable(datadir)) {
2009  return InitError(strprintf(
2010  _("Cannot write to data directory '%s'; check permissions."),
2011  fs::PathToString(datadir)));
2012  }
2013  if (!LockDirectory(datadir, ".lock", probeOnly)) {
2014  return InitError(strprintf(_("Cannot obtain a lock on data directory "
2015  "%s. %s is probably already running."),
2016  fs::PathToString(datadir), PACKAGE_NAME));
2017  }
2018  return true;
2019 }
2020 
2022  // Step 4: sanity checks
2023 
2024  init::SetGlobals();
2025 
2026  // Sanity check
2027  if (!init::SanityChecks()) {
2028  return InitError(strprintf(
2029  _("Initialization sanity check failed. %s is shutting down."),
2030  PACKAGE_NAME));
2031  }
2032 
2033  // Probe the data directory lock to give an early error message, if possible
2034  // We cannot hold the data directory lock here, as the forking for daemon()
2035  // hasn't yet happened, and a fork will cause weird behavior to it.
2036  return LockDataDirectory(true);
2037 }
2038 
2040  // After daemonization get the data directory lock again and hold on to it
2041  // until exit. This creates a slight window for a race condition to happen,
2042  // however this condition is harmless: it will at most make us exit without
2043  // printing a message to console.
2044  if (!LockDataDirectory(false)) {
2045  // Detailed error printed inside LockDataDirectory
2046  return false;
2047  }
2048  return true;
2049 }
2050 
2052  node.chain = interfaces::MakeChain(node, Params());
2053  // Create client interfaces for wallets that are supposed to be loaded
2054  // according to -wallet and -disablewallet options. This only constructs
2055  // the interfaces, it doesn't load wallet data. Wallets actually get loaded
2056  // when load() and start() interface methods are called below.
2058  return true;
2059 }
2060 
2061 bool AppInitMain(Config &config, RPCServer &rpcServer,
2062  HTTPRPCRequestProcessor &httpRPCRequestProcessor,
2063  NodeContext &node,
2065  // Step 4a: application initialization
2066  const ArgsManager &args = *Assert(node.args);
2067  const CChainParams &chainparams = config.GetChainParams();
2068 
2069  if (!CreatePidFile(args)) {
2070  // Detailed error printed inside CreatePidFile().
2071  return false;
2072  }
2073  if (!init::StartLogging(args)) {
2074  // Detailed error printed inside StartLogging().
2075  return false;
2076  }
2077 
2078  LogPrintf("Using at most %i automatic connections (%i file descriptors "
2079  "available)\n",
2080  nMaxConnections, nFD);
2081 
2082  // Warn about relative -datadir path.
2083  if (args.IsArgSet("-datadir") &&
2084  !args.GetPathArg("-datadir").is_absolute()) {
2085  LogPrintf("Warning: relative datadir option '%s' specified, which will "
2086  "be interpreted relative to the current working directory "
2087  "'%s'. This is fragile, because if bitcoin is started in the "
2088  "future from a different location, it will be unable to "
2089  "locate the current data files. There could also be data "
2090  "loss if bitcoin is started while in a temporary "
2091  "directory.\n",
2092  args.GetArg("-datadir", ""),
2093  fs::PathToString(fs::current_path()));
2094  }
2095 
2096  ValidationCacheSizes validation_cache_sizes{};
2097  ApplyArgsManOptions(args, validation_cache_sizes);
2098 
2099  if (!InitSignatureCache(validation_cache_sizes.signature_cache_bytes)) {
2100  return InitError(strprintf(
2101  _("Unable to allocate memory for -maxsigcachesize: '%s' MiB"),
2102  args.GetIntArg("-maxsigcachesize",
2103  DEFAULT_MAX_SIG_CACHE_BYTES >> 20)));
2104  }
2106  validation_cache_sizes.script_execution_cache_bytes)) {
2107  return InitError(strprintf(
2108  _("Unable to allocate memory for -maxscriptcachesize: '%s' MiB"),
2109  args.GetIntArg("-maxscriptcachesize",
2111  }
2112 
2113  int script_threads = args.GetIntArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
2114  if (script_threads <= 0) {
2115  // -par=0 means autodetect (number of cores - 1 script threads)
2116  // -par=-n means "leave n cores free" (number of cores - n - 1 script
2117  // threads)
2118  script_threads += GetNumCores();
2119  }
2120 
2121  // Subtract 1 because the main thread counts towards the par threads
2122  script_threads = std::max(script_threads - 1, 0);
2123 
2124  // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
2125  script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
2126 
2127  LogPrintf("Script verification uses %d additional threads\n",
2128  script_threads);
2129  if (script_threads >= 1) {
2130  StartScriptCheckWorkerThreads(script_threads);
2131  }
2132 
2133  assert(!node.scheduler);
2134  node.scheduler = std::make_unique<CScheduler>();
2135 
2136  // Start the lightweight task scheduler thread
2137  node.scheduler->m_service_thread =
2138  std::thread(&util::TraceThread, "scheduler",
2139  [&] { node.scheduler->serviceQueue(); });
2140 
2141  // Gather some entropy once per minute.
2142  node.scheduler->scheduleEvery(
2143  [] {
2144  RandAddPeriodic();
2145  return true;
2146  },
2147  std::chrono::minutes{1});
2148 
2150 
2155  RegisterAllRPCCommands(config, rpcServer, tableRPC);
2156  for (const auto &client : node.chain_clients) {
2157  client->registerRpcs();
2158  }
2159 #if ENABLE_ZMQ
2161 #endif
2162 
2169  if (args.GetBoolArg("-server", false)) {
2170  uiInterface.InitMessage_connect(SetRPCWarmupStatus);
2171  if (!AppInitServers(config, httpRPCRequestProcessor, node)) {
2172  return InitError(
2173  _("Unable to start HTTP server. See debug log for details."));
2174  }
2175  }
2176 
2177  // Step 5: verify wallet database integrity
2178  for (const auto &client : node.chain_clients) {
2179  if (!client->verify()) {
2180  return false;
2181  }
2182  }
2183 
2184  // Step 6: network initialization
2185 
2186  // Note that we absolutely cannot open any actual connections
2187  // until the very end ("start node") as the UTXO/block state
2188  // is not yet setup and may end up being set up twice if we
2189  // need to reindex later.
2190 
2191  fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
2192  fDiscover = args.GetBoolArg("-discover", true);
2193 
2194  {
2195  // Initialize addrman
2196  assert(!node.addrman);
2197 
2198  // Read asmap file if configured
2199  std::vector<bool> asmap;
2200  if (args.IsArgSet("-asmap")) {
2201  fs::path asmap_path =
2202  args.GetPathArg("-asmap", DEFAULT_ASMAP_FILENAME);
2203  if (!asmap_path.is_absolute()) {
2204  asmap_path = args.GetDataDirNet() / asmap_path;
2205  }
2206  if (!fs::exists(asmap_path)) {
2207  InitError(strprintf(_("Could not find asmap file %s"),
2208  fs::quoted(fs::PathToString(asmap_path))));
2209  return false;
2210  }
2211  asmap = DecodeAsmap(asmap_path);
2212  if (asmap.size() == 0) {
2213  InitError(strprintf(_("Could not parse asmap file %s"),
2214  fs::quoted(fs::PathToString(asmap_path))));
2215  return false;
2216  }
2217  const uint256 asmap_version = SerializeHash(asmap);
2218  LogPrintf("Using asmap version %s for IP bucketing\n",
2219  asmap_version.ToString());
2220  } else {
2221  LogPrintf("Using /16 prefix for IP bucketing\n");
2222  }
2223 
2224  uiInterface.InitMessage(_("Loading P2P addresses...").translated);
2225  auto addrman{LoadAddrman(chainparams, asmap, args)};
2226  if (!addrman) {
2227  return InitError(util::ErrorString(addrman));
2228  }
2229  node.addrman = std::move(*addrman);
2230  }
2231 
2232  assert(!node.banman);
2233  node.banman = std::make_unique<BanMan>(
2234  args.GetDataDirNet() / "banlist.dat", config.GetChainParams(),
2235  &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
2236  assert(!node.connman);
2237  node.connman = std::make_unique<CConnman>(
2238  config, GetRand<uint64_t>(), GetRand<uint64_t>(), *node.addrman,
2239  args.GetBoolArg("-networkactive", true));
2240 
2241  // sanitize comments per BIP-0014, format user agent and check total size
2242  std::vector<std::string> uacomments;
2243  for (const std::string &cmt : args.GetArgs("-uacomment")) {
2244  if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) {
2245  return InitError(strprintf(
2246  _("User Agent comment (%s) contains unsafe characters."), cmt));
2247  }
2248  uacomments.push_back(cmt);
2249  }
2250  const std::string client_name = args.GetArg("-uaclientname", CLIENT_NAME);
2251  const std::string client_version =
2252  args.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));
2253  if (client_name != SanitizeString(client_name, SAFE_CHARS_UA_COMMENT)) {
2254  return InitError(strprintf(
2255  _("-uaclientname (%s) contains invalid characters."), client_name));
2256  }
2257  if (client_version !=
2258  SanitizeString(client_version, SAFE_CHARS_UA_COMMENT)) {
2259  return InitError(
2260  strprintf(_("-uaclientversion (%s) contains invalid characters."),
2261  client_version));
2262  }
2263  const std::string strSubVersion =
2264  FormatUserAgent(client_name, client_version, uacomments);
2265  if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
2266  return InitError(strprintf(
2267  _("Total length of network version string (%i) exceeds maximum "
2268  "length (%i). Reduce the number or size of uacomments."),
2269  strSubVersion.size(), MAX_SUBVERSION_LENGTH));
2270  }
2271 
2272  if (args.IsArgSet("-onlynet")) {
2273  std::set<enum Network> nets;
2274  for (const std::string &snet : args.GetArgs("-onlynet")) {
2275  enum Network net = ParseNetwork(snet);
2276  if (net == NET_UNROUTABLE) {
2277  return InitError(strprintf(
2278  _("Unknown network specified in -onlynet: '%s'"), snet));
2279  }
2280  nets.insert(net);
2281  }
2282  for (int n = 0; n < NET_MAX; n++) {
2283  enum Network net = (enum Network)n;
2284  if (!nets.count(net)) {
2285  SetReachable(net, false);
2286  }
2287  }
2288  }
2289 
2290  // Check for host lookup allowed before parsing any network related
2291  // parameters
2292  fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
2293 
2294  bool proxyRandomize =
2295  args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
2296  // -proxy sets a proxy for all outgoing network traffic
2297  // -noproxy (or -proxy=0) as well as the empty string can be used to not set
2298  // a proxy, this is the default
2299  std::string proxyArg = args.GetArg("-proxy", "");
2300  SetReachable(NET_ONION, false);
2301  if (proxyArg != "" && proxyArg != "0") {
2302  CService proxyAddr;
2303  if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
2304  return InitError(strprintf(
2305  _("Invalid -proxy address or hostname: '%s'"), proxyArg));
2306  }
2307 
2308  proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
2309  if (!addrProxy.IsValid()) {
2310  return InitError(strprintf(
2311  _("Invalid -proxy address or hostname: '%s'"), proxyArg));
2312  }
2313 
2314  SetProxy(NET_IPV4, addrProxy);
2315  SetProxy(NET_IPV6, addrProxy);
2316  SetProxy(NET_ONION, addrProxy);
2317  SetNameProxy(addrProxy);
2318  // by default, -proxy sets onion as reachable, unless -noonion later
2319  SetReachable(NET_ONION, true);
2320  }
2321 
2322  // -onion can be used to set only a proxy for .onion, or override normal
2323  // proxy for .onion addresses.
2324  // -noonion (or -onion=0) disables connecting to .onion entirely. An empty
2325  // string is used to not override the onion proxy (in which case it defaults
2326  // to -proxy set above, or none)
2327  std::string onionArg = args.GetArg("-onion", "");
2328  if (onionArg != "") {
2329  if (onionArg == "0") {
2330  // Handle -noonion/-onion=0
2331  SetReachable(NET_ONION, false);
2332  } else {
2333  CService onionProxy;
2334  if (!Lookup(onionArg, onionProxy, 9050, fNameLookup)) {
2335  return InitError(strprintf(
2336  _("Invalid -onion address or hostname: '%s'"), onionArg));
2337  }
2338  proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
2339  if (!addrOnion.IsValid()) {
2340  return InitError(strprintf(
2341  _("Invalid -onion address or hostname: '%s'"), onionArg));
2342  }
2343  SetProxy(NET_ONION, addrOnion);
2344  SetReachable(NET_ONION, true);
2345  }
2346  }
2347 
2348  for (const std::string &strAddr : args.GetArgs("-externalip")) {
2349  CService addrLocal;
2350  if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) &&
2351  addrLocal.IsValid()) {
2352  AddLocal(addrLocal, LOCAL_MANUAL);
2353  } else {
2354  return InitError(ResolveErrMsg("externalip", strAddr));
2355  }
2356  }
2357 
2358 #if ENABLE_ZMQ
2360  [&chainman = node.chainman](CBlock &block, const CBlockIndex &index) {
2361  assert(chainman);
2362  return chainman->m_blockman.ReadBlockFromDisk(block, index);
2363  });
2364 
2367  }
2368 #endif
2369 
2370  // Step 7: load block chain
2371 
2372  fReindex = args.GetBoolArg("-reindex", false);
2373  bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
2374 
2375  ChainstateManager::Options chainman_opts{
2376  .config = config,
2377  .datadir = args.GetDataDirNet(),
2378  .adjusted_time_callback = GetAdjustedTime,
2379  };
2380  // no error can happen, already checked in AppInitParameterInteraction
2381  Assert(!ApplyArgsManOptions(args, chainman_opts));
2382 
2383  if (chainman_opts.checkpoints_enabled) {
2384  LogPrintf("Checkpoints will be verified.\n");
2385  } else {
2386  LogPrintf("Skipping checkpoint verification.\n");
2387  }
2388 
2389  BlockManager::Options blockman_opts{
2390  .chainparams = chainman_opts.config.GetChainParams(),
2391  .blocks_dir = args.GetBlocksDirPath(),
2392  };
2393  // no error can happen, already checked in AppInitParameterInteraction
2394  Assert(!ApplyArgsManOptions(args, blockman_opts));
2395 
2396  // cache size calculations
2397  CacheSizes cache_sizes =
2398  CalculateCacheSizes(args, g_enabled_filter_types.size());
2399 
2400  LogPrintf("Cache configuration:\n");
2401  LogPrintf("* Using %.1f MiB for block index database\n",
2402  cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
2403  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
2404  LogPrintf("* Using %.1f MiB for transaction index database\n",
2405  cache_sizes.tx_index * (1.0 / 1024 / 1024));
2406  }
2407  for (BlockFilterType filter_type : g_enabled_filter_types) {
2408  LogPrintf("* Using %.1f MiB for %s block filter index database\n",
2409  cache_sizes.filter_index * (1.0 / 1024 / 1024),
2410  BlockFilterTypeName(filter_type));
2411  }
2412  LogPrintf("* Using %.1f MiB for chain state database\n",
2413  cache_sizes.coins_db * (1.0 / 1024 / 1024));
2414 
2415  assert(!node.mempool);
2416  assert(!node.chainman);
2417 
2418  CTxMemPool::Options mempool_opts{
2419  .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
2420  };
2421  if (const auto err{ApplyArgsManOptions(args, chainparams, mempool_opts)}) {
2422  return InitError(*err);
2423  }
2424  mempool_opts.check_ratio =
2425  std::clamp<int>(mempool_opts.check_ratio, 0, 1'000'000);
2426 
2427  // FIXME: this legacy limit comes from the DEFAULT_DESCENDANT_SIZE_LIMIT
2428  // (101) that was enforced before the wellington activation. While it's
2429  // still a good idea to have some minimum mempool size, using this value as
2430  // a threshold is no longer relevant.
2431  int64_t nMempoolSizeMin = 101 * 1000 * 40;
2432  if (mempool_opts.max_size_bytes < 0 ||
2433  (!chainparams.IsTestChain() &&
2434  mempool_opts.max_size_bytes < nMempoolSizeMin)) {
2435  return InitError(strprintf(_("-maxmempool must be at least %d MB"),
2436  std::ceil(nMempoolSizeMin / 1000000.0)));
2437  }
2438  LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
2439  "unused mempool space)\n",
2440  cache_sizes.coins * (1.0 / 1024 / 1024),
2441  mempool_opts.max_size_bytes * (1.0 / 1024 / 1024));
2442 
2443  for (bool fLoaded = false; !fLoaded && !ShutdownRequested();) {
2444  node.mempool = std::make_unique<CTxMemPool>(mempool_opts);
2445 
2446  node.chainman =
2447  std::make_unique<ChainstateManager>(chainman_opts, blockman_opts);
2448  ChainstateManager &chainman = *node.chainman;
2449 
2451  options.mempool = Assert(node.mempool.get());
2452  options.reindex = node::fReindex;
2453  options.reindex_chainstate = fReindexChainState;
2454  options.prune = chainman.m_blockman.IsPruneMode();
2455  options.check_blocks =
2456  args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
2457  options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
2458  options.require_full_verification =
2459  args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
2461  options.coins_error_cb = [] {
2462  uiInterface.ThreadSafeMessageBox(
2463  _("Error reading from database, shutting down."), "",
2465  };
2466 
2467  uiInterface.InitMessage(_("Loading block index...").translated);
2468 
2469  const int64_t load_block_index_start_time = GetTimeMillis();
2470  auto catch_exceptions = [](auto &&f) {
2471  try {
2472  return f();
2473  } catch (const std::exception &e) {
2474  LogPrintf("%s\n", e.what());
2475  return std::make_tuple(node::ChainstateLoadStatus::FAILURE,
2476  _("Error opening block database"));
2477  }
2478  };
2479  auto [status, error] = catch_exceptions(
2480  [&] { return LoadChainstate(chainman, cache_sizes, options); });
2481  if (status == node::ChainstateLoadStatus::SUCCESS) {
2482  uiInterface.InitMessage(_("Verifying blocks...").translated);
2483  if (chainman.m_blockman.m_have_pruned &&
2484  options.check_blocks > MIN_BLOCKS_TO_KEEP) {
2485  LogPrintf("Prune: pruned datadir may not have more than %d "
2486  "blocks; only checking available blocks\n",
2488  }
2489  std::tie(status, error) = catch_exceptions(
2490  [&] { return VerifyLoadedChainstate(chainman, options); });
2491  if (status == node::ChainstateLoadStatus::SUCCESS) {
2492  fLoaded = true;
2493  LogPrintf(" block index %15dms\n",
2494  GetTimeMillis() - load_block_index_start_time);
2495  }
2496  }
2497 
2500  status ==
2502  return InitError(error);
2503  }
2504 
2505  if (!fLoaded && !ShutdownRequested()) {
2506  // first suggest a reindex
2507  if (!options.reindex) {
2508  bool fRet = uiInterface.ThreadSafeQuestion(
2509  error + Untranslated(".\n\n") +
2510  _("Do you want to rebuild the block database now?"),
2511  error.original + ".\nPlease restart with -reindex or "
2512  "-reindex-chainstate to recover.",
2513  "",
2516  if (fRet) {
2517  fReindex = true;
2518  AbortShutdown();
2519  } else {
2520  LogPrintf("Aborted block database rebuild. Exiting.\n");
2521  return false;
2522  }
2523  } else {
2524  return InitError(error);
2525  }
2526  }
2527  }
2528 
2529  // As LoadBlockIndex can take several minutes, it's possible the user
2530  // requested to kill the GUI during the last operation. If so, exit.
2531  // As the program has not fully started yet, Shutdown() is possibly
2532  // overkill.
2533  if (ShutdownRequested()) {
2534  LogPrintf("Shutdown requested. Exiting.\n");
2535  return false;
2536  }
2537 
2538  ChainstateManager &chainman = *Assert(node.chainman);
2539 
2540  assert(!node.peerman);
2541  node.peerman = PeerManager::make(
2542  *node.connman, *node.addrman, node.banman.get(), chainman,
2543  *node.mempool, args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY));
2544  RegisterValidationInterface(node.peerman.get());
2545 
2546  // Encoded addresses using cashaddr instead of base58.
2547  // We do this by default to avoid confusion with BTC addresses.
2548  config.SetCashAddrEncoding(args.GetBoolArg("-usecashaddr", true));
2549 
2550  // Step 7.5 (I guess ?): Initialize Avalanche.
2551  bilingual_str avalancheError;
2553  args, *node.chain, node.connman.get(), chainman, node.mempool.get(),
2554  *node.scheduler, avalancheError);
2555  if (!g_avalanche) {
2556  InitError(avalancheError);
2557  return false;
2558  }
2559 
2560  if (isAvalancheEnabled(args) &&
2561  g_avalanche->isAvalancheServiceAvailable()) {
2562  nLocalServices = ServiceFlags(nLocalServices | NODE_AVALANCHE);
2563  }
2564 
2565  // Step 8: load indexers
2566  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
2567  auto result{
2569  chainman.m_blockman.m_block_tree_db)))};
2570  if (!result) {
2571  return InitError(util::ErrorString(result));
2572  }
2573 
2574  g_txindex =
2575  std::make_unique<TxIndex>(cache_sizes.tx_index, false, fReindex);
2576  if (!g_txindex->Start(chainman.ActiveChainstate())) {
2577  return false;
2578  }
2579  }
2580 
2581  for (const auto &filter_type : g_enabled_filter_types) {
2582  InitBlockFilterIndex(filter_type, cache_sizes.filter_index, false,
2583  fReindex);
2584  if (!GetBlockFilterIndex(filter_type)
2585  ->Start(chainman.ActiveChainstate())) {
2586  return false;
2587  }
2588  }
2589 
2590  if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
2591  g_coin_stats_index = std::make_unique<CoinStatsIndex>(
2592  /* cache size */ 0, false, fReindex);
2593  if (!g_coin_stats_index->Start(chainman.ActiveChainstate())) {
2594  return false;
2595  }
2596  }
2597 
2598 #if ENABLE_CHRONIK
2599  if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
2600  const bool fReindexChronik =
2601  fReindex || args.GetBoolArg("-chronikreindex", false);
2602  if (!chronik::Start(config, node, fReindexChronik)) {
2603  return false;
2604  }
2605  }
2606 #endif
2607 
2608  // Step 9: load wallet
2609  for (const auto &client : node.chain_clients) {
2610  if (!client->load()) {
2611  return false;
2612  }
2613  }
2614 
2615  // Step 10: data directory maintenance
2616 
2617  // if pruning, unset the service bit and perform the initial blockstore
2618  // prune after any wallet rescanning has taken place.
2619  if (chainman.m_blockman.IsPruneMode()) {
2620  LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
2621  nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
2622  if (!fReindex) {
2623  LOCK(cs_main);
2624  for (Chainstate *chainstate : chainman.GetAll()) {
2625  uiInterface.InitMessage(_("Pruning blockstore...").translated);
2626  chainstate->PruneAndFlush();
2627  }
2628  }
2629  }
2630 
2631  // Step 11: import blocks
2632  if (!CheckDiskSpace(args.GetDataDirNet())) {
2633  InitError(
2634  strprintf(_("Error: Disk space is low for %s"),
2636  return false;
2637  }
2638  if (!CheckDiskSpace(args.GetBlocksDirPath())) {
2639  InitError(
2640  strprintf(_("Error: Disk space is low for %s"),
2642  return false;
2643  }
2644 
2645  // Either install a handler to notify us when genesis activates, or set
2646  // fHaveGenesis directly.
2647  // No locking, as this happens before any background thread is started.
2648  boost::signals2::connection block_notify_genesis_wait_connection;
2649  if (WITH_LOCK(chainman.GetMutex(),
2650  return chainman.ActiveChain().Tip() == nullptr)) {
2651  block_notify_genesis_wait_connection =
2652  uiInterface.NotifyBlockTip_connect(
2653  std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
2654  } else {
2655  fHaveGenesis = true;
2656  }
2657 
2658 #if defined(HAVE_SYSTEM)
2659  const std::string block_notify = args.GetArg("-blocknotify", "");
2660  if (!block_notify.empty()) {
2661  uiInterface.NotifyBlockTip_connect([block_notify](
2662  SynchronizationState sync_state,
2663  const CBlockIndex *pBlockIndex) {
2664  if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) {
2665  return;
2666  }
2667  std::string command = block_notify;
2668  ReplaceAll(command, "%s", pBlockIndex->GetBlockHash().GetHex());
2669  std::thread t(runCommand, command);
2670  // thread runs free
2671  t.detach();
2672  });
2673  }
2674 #endif
2675 
2676  std::vector<fs::path> vImportFiles;
2677  for (const std::string &strFile : args.GetArgs("-loadblock")) {
2678  vImportFiles.push_back(fs::PathFromString(strFile));
2679  }
2680 
2681  chainman.m_load_block =
2682  std::thread(&util::TraceThread, "loadblk", [=, &chainman, &args] {
2683  ThreadImport(chainman, vImportFiles,
2684  ShouldPersistMempool(args) ? MempoolPath(args)
2685  : fs::path{});
2686  });
2687 
2688  // Wait for genesis block to be processed
2689  {
2691  // We previously could hang here if StartShutdown() is called prior to
2692  // ThreadImport getting started, so instead we just wait on a timer to
2693  // check ShutdownRequested() regularly.
2694  while (!fHaveGenesis && !ShutdownRequested()) {
2695  g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
2696  }
2697  block_notify_genesis_wait_connection.disconnect();
2698  }
2699 
2700  if (ShutdownRequested()) {
2701  return false;
2702  }
2703 
2704  // Step 12: start node
2705 
2706  int chain_active_height;
2707 
2709  {
2710  LOCK(cs_main);
2711  LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
2712  chain_active_height = chainman.ActiveChain().Height();
2713  if (tip_info) {
2714  tip_info->block_height = chain_active_height;
2715  tip_info->block_time =
2716  chainman.ActiveChain().Tip()
2717  ? chainman.ActiveChain().Tip()->GetBlockTime()
2718  : chainman.GetParams().GenesisBlock().GetBlockTime();
2720  chainman.GetParams().TxData(), chainman.ActiveChain().Tip());
2721  }
2722  if (tip_info && chainman.m_best_header) {
2723  tip_info->header_height = chainman.m_best_header->nHeight;
2724  tip_info->header_time = chainman.m_best_header->GetBlockTime();
2725  }
2726  }
2727  LogPrintf("nBestHeight = %d\n", chain_active_height);
2728  if (node.peerman) {
2729  node.peerman->SetBestHeight(chain_active_height);
2730  }
2731 
2732  // Map ports with UPnP or NAT-PMP.
2733  StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP),
2734  args.GetBoolArg("-natpmp", DEFAULT_NATPMP));
2735 
2736  CConnman::Options connOptions;
2737  connOptions.nLocalServices = nLocalServices;
2738  connOptions.nMaxConnections = nMaxConnections;
2739  connOptions.m_max_avalanche_outbound =
2741  ? args.GetIntArg("-maxavalancheoutbound",
2743  : 0;
2744  connOptions.m_max_outbound_full_relay = std::min(
2746  connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound);
2747  connOptions.m_max_outbound_block_relay = std::min(
2749  connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound -
2750  connOptions.m_max_outbound_full_relay);
2751  connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
2752  connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
2753  connOptions.uiInterface = &uiInterface;
2754  connOptions.m_banman = node.banman.get();
2755  connOptions.m_msgproc.push_back(node.peerman.get());
2756  if (g_avalanche) {
2757  connOptions.m_msgproc.push_back(g_avalanche.get());
2758  }
2759  connOptions.nSendBufferMaxSize =
2760  1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
2761  connOptions.nReceiveFloodSize =
2762  1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
2763  connOptions.m_added_nodes = args.GetArgs("-addnode");
2764 
2765  connOptions.nMaxOutboundLimit =
2766  1024 * 1024 *
2767  args.GetIntArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
2768  connOptions.m_peer_connect_timeout = peer_connect_timeout;
2769 
2770  // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
2771  const uint16_t default_bind_port = static_cast<uint16_t>(
2772  args.GetIntArg("-port", config.GetChainParams().GetDefaultPort()));
2773 
2774  const auto BadPortWarning = [](const char *prefix, uint16_t port) {
2775  return strprintf(_("%s request to listen on port %u. This port is "
2776  "considered \"bad\" and "
2777  "thus it is unlikely that any Bitcoin ABC peers "
2778  "connect to it. See "
2779  "doc/p2p-bad-ports.md for details and a full list."),
2780  prefix, port);
2781  };
2782 
2783  for (const std::string &bind_arg : args.GetArgs("-bind")) {
2784  CService bind_addr;
2785  const size_t index = bind_arg.rfind('=');
2786  if (index == std::string::npos) {
2787  if (Lookup(bind_arg, bind_addr, default_bind_port,
2788  /*fAllowLookup=*/false)) {
2789  connOptions.vBinds.push_back(bind_addr);
2790  if (IsBadPort(bind_addr.GetPort())) {
2791  InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
2792  }
2793  continue;
2794  }
2795  } else {
2796  const std::string network_type = bind_arg.substr(index + 1);
2797  if (network_type == "onion") {
2798  const std::string truncated_bind_arg =
2799  bind_arg.substr(0, index);
2800  if (Lookup(truncated_bind_arg, bind_addr,
2801  BaseParams().OnionServiceTargetPort(), false)) {
2802  connOptions.onion_binds.push_back(bind_addr);
2803  continue;
2804  }
2805  }
2806  }
2807  return InitError(ResolveErrMsg("bind", bind_arg));
2808  }
2809 
2810  for (const std::string &strBind : args.GetArgs("-whitebind")) {
2811  NetWhitebindPermissions whitebind;
2813  if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) {
2814  return InitError(error);
2815  }
2816  connOptions.vWhiteBinds.push_back(whitebind);
2817  }
2818 
2819  // If the user did not specify -bind= or -whitebind= then we bind
2820  // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
2821  connOptions.bind_on_any =
2822  args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
2823 
2824  // Emit a warning if a bad port is given to -port= but only if -bind and
2825  // -whitebind are not given, because if they are, then -port= is ignored.
2826  if (connOptions.bind_on_any && args.IsArgSet("-port")) {
2827  const uint16_t port_arg = args.GetIntArg("-port", 0);
2828  if (IsBadPort(port_arg)) {
2829  InitWarning(BadPortWarning("-port", port_arg));
2830  }
2831  }
2832 
2833  CService onion_service_target;
2834  if (!connOptions.onion_binds.empty()) {
2835  onion_service_target = connOptions.onion_binds.front();
2836  } else {
2837  onion_service_target = DefaultOnionServiceTarget();
2838  connOptions.onion_binds.push_back(onion_service_target);
2839  }
2840 
2841  if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
2842  if (connOptions.onion_binds.size() > 1) {
2844  _("More than one onion bind address is provided. Using %s "
2845  "for the automatically created Tor onion service."),
2846  onion_service_target.ToStringIPPort()));
2847  }
2848  StartTorControl(onion_service_target);
2849  }
2850 
2851  if (connOptions.bind_on_any) {
2852  // Only add all IP addresses of the machine if we would be listening on
2853  // any address - 0.0.0.0 (IPv4) and :: (IPv6).
2854  Discover();
2855  }
2856 
2857  for (const auto &net : args.GetArgs("-whitelist")) {
2858  NetWhitelistPermissions subnet;
2860  if (!NetWhitelistPermissions::TryParse(net, subnet, error)) {
2861  return InitError(error);
2862  }
2863  connOptions.vWhitelistedRange.push_back(subnet);
2864  }
2865 
2866  connOptions.vSeedNodes = args.GetArgs("-seednode");
2867 
2868  // Initiate outbound connections unless connect=0
2869  connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
2870  if (!connOptions.m_use_addrman_outgoing) {
2871  const auto connect = args.GetArgs("-connect");
2872  if (connect.size() != 1 || connect[0] != "0") {
2873  connOptions.m_specified_outgoing = connect;
2874  }
2875  }
2876 
2877  const std::string &i2psam_arg = args.GetArg("-i2psam", "");
2878  if (!i2psam_arg.empty()) {
2879  CService addr;
2880  if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) || !addr.IsValid()) {
2881  return InitError(strprintf(
2882  _("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
2883  }
2884  SetReachable(NET_I2P, true);
2885  SetProxy(NET_I2P, proxyType{addr});
2886  } else {
2887  SetReachable(NET_I2P, false);
2888  }
2889 
2890  connOptions.m_i2p_accept_incoming =
2891  args.GetBoolArg("-i2pacceptincoming", true);
2892 
2893  if (!node.connman->Start(*node.scheduler, connOptions)) {
2894  return false;
2895  }
2896 
2897  // Step 13: finished
2898 
2899  // At this point, the RPC is "started", but still in warmup, which means it
2900  // cannot yet be called. Before we make it callable, we need to make sure
2901  // that the RPC's view of the best block is valid and consistent with
2902  // ChainstateManager's active tip.
2903  //
2904  // If we do not do this, RPC's view of the best block will be height=0 and
2905  // hash=0x0. This will lead to erroroneous responses for things like
2906  // waitforblockheight.
2908  WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()));
2910 
2911  uiInterface.InitMessage(_("Done loading").translated);
2912 
2913  for (const auto &client : node.chain_clients) {
2914  client->start(*node.scheduler);
2915  }
2916 
2917  BanMan *banman = node.banman.get();
2918  node.scheduler->scheduleEvery(
2919  [banman] {
2920  banman->DumpBanlist();
2921  return true;
2922  },
2924 
2925  if (node.peerman) {
2926  node.peerman->StartScheduledTasks(*node.scheduler);
2927  }
2928 
2929  // Start Avalanche's event loop.
2930  g_avalanche->startEventLoop(*node.scheduler);
2931 
2932 #if HAVE_SYSTEM
2933  StartupNotify(args);
2934 #endif
2935 
2936  return true;
2937 }
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:165
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
Definition: addrman.h:29
std::vector< bool > DecodeAsmap(fs::path path)
Read asmap from provided binary file.
Definition: asmap.cpp:294
bool isAvalancheEnabled(const ArgsManager &argsman)
Definition: avalanche.cpp:9
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
std::unique_ptr< avalanche::Processor > g_avalanche
Global avalanche instance.
Definition: processor.cpp:38
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:233
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
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.
const std::set< BlockFilterType > & AllBlockFilterTypes()
Get a list of known filter types.
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(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 std::string &chain)
Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
Definition: chainparams.cpp:32
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:18
const CBaseChainParams & BaseParams()
Return the currently selected parameters.
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const std::string &chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 18445) have been chosen arbitrarily to...
static constexpr bool DEFAULT_CHECKPOINTS_ENABLED
static constexpr auto DEFAULT_MAX_TIP_AGE
#define Assert(val)
Identity function.
Definition: check.h:84
const 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: system.cpp:165
const fs::path & GetBlocksDirPath() const
Get blocks directory path.
Definition: system.cpp:321
@ NETWORK_ONLY
Definition: system.h:124
@ ALLOW_ANY
Definition: system.h:117
@ DEBUG_ONLY
Definition: system.h:118
@ ALLOW_INT
Definition: system.h:115
@ ALLOW_BOOL
Definition: system.h:114
@ ALLOW_STRING
Definition: system.h:116
@ SENSITIVE
Definition: system.h:126
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: system.cpp:391
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: system.cpp:401
const fs::path & GetDataDirNet() const
Get data directory path with appended network identifier.
Definition: system.h:224
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
Definition: system.cpp:546
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:514
bool SoftSetBoolArg(const std::string &strArg, bool fValue)
Set a boolean argument if it doesn't already have a value.
Definition: system.cpp:609
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:576
void AddHiddenArgs(const std::vector< std::string > &args)
Add many hidden arguments.
Definition: system.cpp:662
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
Definition: system.cpp:640
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const
Return path argument or default value.
Definition: system.cpp:307
const std::list< SectionInfo > GetUnrecognizedSections() const
Log warnings for unrecognized section names in the config file.
Definition: system.cpp:189
std::string GetChainName() const
Looks for -regtest, -testnet and returns the appropriate BIP70 chain name.
Definition: system.cpp:1010
std::atomic< bool > m_reopen_file
Definition: logging.h:111
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:391
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
static const std::string REGTEST
static const std::string TESTNET
static const std::string MAIN
BIP70 chain name strings (main, test or regtest)
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:180
BlockHash GetBlockHash() const
Definition: blockindex.h:146
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:150
int Height() const
Return the maximal height in the chain.
Definition: chain.h:186
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:80
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
Definition: chainparams.h:107
const ChainTxData & TxData() const
Definition: chainparams.h:140
bool IsTestChain() const
If this chain is exclusively used for testing.
Definition: chainparams.h:111
uint16_t GetDefaultPort() const
Definition: chainparams.h:95
const CBlock & GenesisBlock() const
Definition: chainparams.h:105
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:479
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:626
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:1141
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1348
const CChainParams & GetParams() const
Definition: validation.h:1235
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1358
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1262
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1354
std::thread m_load_block
Definition: validation.h:1267
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:1315
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1270
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
static bool TryParse(const std::string &str, NetWhitebindPermissions &output, bilingual_str &error)
static bool TryParse(const std::string &str, NetWhitelistPermissions &output, bilingual_str &error)
static std::unique_ptr< PeerManager > make(CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, bool ignore_incoming_txs)
Class for registering and managing all RPC calls.
Definition: server.h:39
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:220
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:71
const CBlockIndex *GetFirstStoredBlock(const CBlockIndex &start_block) EXCLUSIVE_LOCKS_REQUIRED(bool m_have_pruned
Find the first block that is not pruned.
Definition: blockstorage.h:261
bool IsPruneMode() const
Whether running in -prune mode.
Definition: blockstorage.h:232
bool IsValid() const
Definition: netbase.h:38
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:51
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
Definition: error.cpp:42
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
uint256 SerializeHash(const T &obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
Compute the 256-bit hash of an object's serialization.
Definition: hash.h:192
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
Definition: httprpc.cpp:470
void StopHTTPRPC()
Stop HTTP RPC subsystem.
Definition: httprpc.cpp:474
bool StartHTTPRPC(HTTPRPCRequestProcessor &httpRPCRequestProcessor)
Start HTTP RPC subsystem.
Definition: httprpc.cpp:449
void StartREST(const std::any &context)
Start HTTP REST subsystem.
Definition: rest.cpp:832
void StopREST()
Stop HTTP REST subsystem.
Definition: rest.cpp:844
void InterruptREST()
Interrupt RPC REST subsystem.
Definition: rest.cpp:842
void InterruptHTTPServer()
Interrupt HTTP server threads.
Definition: httpserver.cpp:472
void StartHTTPServer()
Start HTTP server.
Definition: httpserver.cpp:460
void StopHTTPServer()
Stop HTTP server.
Definition: httpserver.cpp:483
bool InitHTTPServer(Config &config)
Initialize HTTP server.
Definition: httpserver.cpp:382
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:147
static bool CreatePidFile(const ArgsManager &args)
Definition: init.cpp:153
static const bool DEFAULT_PROXYRANDOMIZE
Definition: init.cpp:130
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:193
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:1646
bool AppInitLockDataDirectory()
Lock bitcoin data directory.
Definition: init.cpp:2039
void SetupServerArgs(NodeContext &node)
Register all arguments with the ArgsManager.
Definition: init.cpp:414
static bool AppInitServers(Config &config, HTTPRPCRequestProcessor &httpRPCRequestProcessor, NodeContext &node)
Definition: init.cpp:1487
#define MIN_CORE_FILEDESCRIPTORS
Definition: init.cpp:139
static bool fHaveGenesis
Definition: init.cpp:1462
void Shutdown(NodeContext &node)
Definition: init.cpp:217
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
Definition: init.cpp:376
static GlobalMutex g_genesis_wait_mutex
Definition: init.cpp:1463
static void OnRPCStarted()
Definition: init.cpp:402
static void HandleSIGHUP(int)
Definition: init.cpp:380
static fs::path GetPidFile(const ArgsManager &args)
Definition: init.cpp:149
static std::condition_variable g_genesis_wait_cv
Definition: init.cpp:1464
bool AppInitMain(Config &config, RPCServer &rpcServer, HTTPRPCRequestProcessor &httpRPCRequestProcessor, NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin main initialization.
Definition: init.cpp:2061
static constexpr bool DEFAULT_CHRONIK
Definition: init.cpp:132
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin: Basic context setup.
Definition: init.cpp:1673
bool AppInitSanityChecks()
Initialization sanity checks: ecc init, sanity checks, dir lock.
Definition: init.cpp:2021
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:2051
static const char * DEFAULT_ASMAP_FILENAME
Definition: init.cpp:142
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:1512
static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex)
Definition: init.cpp:1466
static void OnRPCStopped()
Definition: init.cpp:407
static bool LockDataDirectory(bool probeOnly)
Definition: init.cpp:2005
static void registerSignalHandler(int signal, void(*handler)(int))
Definition: init.cpp:392
std::string LicenseInfo()
Returns licensing information (for -version)
Definition: init.cpp:1431
bool AppInitParameterInteraction(Config &config, const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:1720
static const bool DEFAULT_REST_ENABLE
Definition: init.cpp:131
static boost::signals2::connection rpc_notify_block_change_connection
Definition: init.cpp:401
static void new_handler_terminate()
Definition: init.cpp:1662
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:20
bool error(const char *fmt, const Args &...args)
Definition: logging.h:225
#define LogPrint(category,...)
Definition: logging.h:210
#define LogPrintf(...)
Definition: logging.h:206
void StartMapPort(bool use_upnp, bool use_natpmp)
Definition: mapport.cpp:358
void StopMapPort()
Definition: mapport.cpp:364
void InterruptMapPort()
Definition: mapport.cpp:361
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:47
void OnStarted(std::function< void()> slot)
Definition: server.cpp:111
void OnStopped(std::function< void()> slot)
Definition: server.cpp:115
static constexpr Amount PROOF_DUST_THRESHOLD
Minimum amount per utxo.
Definition: proof.h:40
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:140
void AddLoggingArgs(ArgsManager &argsman)
Definition: common.cpp:65
void SetLoggingCategories(const ArgsManager &args)
Definition: common.cpp:161
bool SanityChecks()
Ensure a usable environment with all necessary library support.
Definition: common.cpp:43
void SetGlobals()
Definition: common.cpp:30
bool StartLogging(const ArgsManager &args)
Definition: common.cpp:189
void SetLoggingOptions(const ArgsManager &args)
Definition: common.cpp:140
void UnsetGlobals()
Definition: common.cpp:38
void LogPackageVersion()
Definition: common.cpp:237
std::unique_ptr< Chain > MakeChain(node::NodeContext &node, const CChainParams &params)
Return implementation of Chain interface.
Definition: interfaces.cpp:795
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
Definition: init.h:28
@ 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)
std::optional< bilingual_str > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
This sequence can have 4 types of outcomes:
Definition: chainstate.cpp:167
void ThreadImport(ChainstateManager &chainman, std::vector< fs::path > vImportFiles, const fs::path &mempool_path)
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:262
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 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:78
void TraceThread(const char *thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
Definition: thread.cpp:13
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:137
bool fDiscover
Definition: net.cpp:125
bool fListen
Definition: net.cpp:126
void SetReachable(enum Network net, bool reachable)
Mark a network as reachable or unreachable (no automatic connects to it)
Definition: net.cpp:317
bool AddLocal(const CService &addr, int nScore)
Definition: net.cpp:278
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:2790
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:93
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:69
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:76
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:107
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:101
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:97
static const bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
Definition: net.h:57
static const bool DEFAULT_FORCEDNSSEED
Definition: net.h:103
static const bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
Definition: net.h:55
static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:95
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:106
static const int DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS
Maximum number of avalanche enabled outgoing connections by default.
Definition: net.h:83
static const bool DEFAULT_FIXEDSEEDS
Definition: net.h:105
static const int MAX_FEELER_CONNECTIONS
Maximum number of feeler connections.
Definition: net.h:85
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:87
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:99
static const bool DEFAULT_DNSSEED
Definition: net.h:104
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
Definition: net.h:74
@ LOCAL_MANUAL
Definition: net.h:242
static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS
Maximum number of block-relay-only outgoing connections.
Definition: net.h:78
const std::vector< std::string > NET_PERMISSIONS_DOC
static const unsigned int DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN
Default number of orphan+recently-replaced txn to keep around for block reconstruction.
static const unsigned int 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:91
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:222
bool fNameLookup
Definition: netbase.cpp:38
int nConnectTimeout
Definition: netbase.cpp:37
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:136
bool SetNameProxy(const proxyType &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
Definition: netbase.cpp:730
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:859
bool SetProxy(enum Network net, const proxyType &addrProxy)
Definition: netbase.cpp:710
static const int DEFAULT_NAME_LOOKUP
-dns default
Definition: netbase.h:29
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
Definition: netbase.h:27
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:57
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:35
ServiceFlags
nServices flags.
Definition: protocol.h:335
@ NODE_NETWORK_LIMITED
Definition: protocol.h:365
@ NODE_BLOOM
Definition: protocol.h:352
@ NODE_NETWORK
Definition: protocol.h:342
@ NODE_COMPACT_FILTERS
Definition: protocol.h:360
@ NODE_AVALANCHE
Definition: protocol.h:380
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:817
bool(* handler)(Config &config, const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:818
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: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:396
void StartRPC()
Definition: server.cpp:351
void StopRPC()
Definition: server.cpp:368
void InterruptRPC()
Definition: server.cpp:357
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:391
CRPCTable tableRPC
Definition: server.cpp:610
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:385
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:84
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
std::string SanitizeString(const std::string &str, int rule)
Remove unsafe chars.
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
Definition: strencodings.h:24
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:54
Definition: amount.h:19
static constexpr Amount zero() noexcept
Definition: amount.h:32
int m_max_outbound_block_relay
Definition: net.h:858
unsigned int nReceiveFloodSize
Definition: net.h:866
int m_max_outbound_full_relay
Definition: net.h:857
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:871
uint64_t nMaxOutboundLimit
Definition: net.h:867
std::vector< NetWhitelistPermissions > vWhitelistedRange
Definition: net.h:870
CClientUIInterface * uiInterface
Definition: net.h:862
int m_max_avalanche_outbound
Definition: net.h:859
std::vector< CService > onion_binds
Definition: net.h:873
int nMaxFeeler
Definition: net.h:861
std::vector< std::string > m_specified_outgoing
Definition: net.h:878
int nMaxConnections
Definition: net.h:856
ServiceFlags nLocalServices
Definition: net.h:855
std::vector< std::string > m_added_nodes
Definition: net.h:879
int64_t m_peer_connect_timeout
Definition: net.h:868
std::vector< CService > vBinds
Definition: net.h:872
unsigned int nSendBufferMaxSize
Definition: net.h:865
bool m_i2p_accept_incoming
Definition: net.h:880
std::vector< std::string > vSeedNodes
Definition: net.h:869
BanMan * m_banman
Definition: net.h:864
bool m_use_addrman_outgoing
Definition: net.h:877
std::vector< NetEventsInterface * > m_msgproc
Definition: net.h:863
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:876
int nMaxAddnode
Definition: net.h:860
static const Currency & get()
Definition: amount.cpp:18
std::string ticker
Definition: amount.h:150
Bilingual messages:
Definition: translation.h:17
bool empty() const
Definition: translation.h:27
std::string translated
Definition: translation.h:19
Block and header tip information.
Definition: node.h:49
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
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:38
#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
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
Definition: system.cpp:757
fs::path AbsPathForConfigVal(const fs::path &path, bool net_specific)
Most paths passed as configuration arguments are treated as relative to the datadir if they are not a...
Definition: system.cpp:1172
const char *const BITCOIN_SETTINGS_FILENAME
Definition: system.cpp:66
std::string CopyrightHolders(const std::string &strPrefix)
Definition: system.cpp:1162
bool SetupNetworking()
Definition: system.cpp:1145
ArgsManager gArgs
Definition: system.cpp:68
const char *const BITCOIN_CONF_FILENAME
Definition: system.cpp:65
int GetNumCores()
Return the number of cores available on the current system.
Definition: system.cpp:1158
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:34
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:870
const std::string DEFAULT_TOR_CONTROL
Default control port.
Definition: torcontrol.cpp:37
void InterruptTorControl()
Definition: torcontrol.cpp:852
void StartTorControl(CService onion_service_target)
Definition: torcontrol.cpp:833
void StopTorControl()
Definition: torcontrol.cpp:862
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.
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
std::condition_variable g_best_block_cv
Definition: validation.cpp:112
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:95
assert(!tx.IsCoinBase())
static constexpr int DEFAULT_CHECKLEVEL
Definition: validation.h:97
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:111
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:95
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
Definition: validation.h:83
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:114
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
Definition: validation.h:85
static const signed int DEFAULT_CHECKBLOCKS
Definition: validation.h:96
static const bool DEFAULT_PEERBLOOMFILTERS
Definition: validation.h:87
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
Definition: validation.h:90
CMainSignals & GetMainSignals()
void UnregisterAllValidationInterfaces()
Unregister all subscribers.
void UnregisterValidationInterface(CValidationInterface *callbacks)
Unregister subscriber.
void RegisterValidationInterface(CValidationInterface *callbacks)
Register subscriber.
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