Bitcoin Core  24.99.0
P2P Digital Currency
init.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2022 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)
8 #endif
9 
10 #include <init.h>
11 
12 #include <kernel/checks.h>
13 #include <kernel/mempool_persist.h>
15 
16 #include <addrman.h>
17 #include <banman.h>
18 #include <blockfilter.h>
19 #include <chain.h>
20 #include <chainparams.h>
21 #include <consensus/amount.h>
22 #include <deploymentstatus.h>
23 #include <fs.h>
24 #include <hash.h>
25 #include <httprpc.h>
26 #include <httpserver.h>
27 #include <index/blockfilterindex.h>
28 #include <index/coinstatsindex.h>
29 #include <index/txindex.h>
30 #include <init/common.h>
31 #include <interfaces/chain.h>
32 #include <interfaces/init.h>
33 #include <interfaces/node.h>
34 #include <mapport.h>
35 #include <net.h>
36 #include <net_permissions.h>
37 #include <net_processing.h>
38 #include <netbase.h>
39 #include <netgroup.h>
40 #include <node/blockstorage.h>
41 #include <node/caches.h>
42 #include <node/chainstate.h>
44 #include <node/context.h>
45 #include <node/interface_ui.h>
46 #include <node/mempool_args.h>
48 #include <node/miner.h>
49 #include <node/txreconciliation.h>
51 #include <policy/feerate.h>
52 #include <policy/fees.h>
53 #include <policy/fees_args.h>
54 #include <policy/policy.h>
55 #include <policy/settings.h>
56 #include <protocol.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/sigcache.h>
63 #include <script/standard.h>
64 #include <shutdown.h>
65 #include <sync.h>
66 #include <timedata.h>
67 #include <torcontrol.h>
68 #include <txdb.h>
69 #include <txmempool.h>
70 #include <util/asmap.h>
71 #include <util/check.h>
72 #include <util/moneystr.h>
73 #include <util/strencodings.h>
74 #include <util/string.h>
75 #include <util/syscall_sandbox.h>
76 #include <util/syserror.h>
77 #include <util/system.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 <algorithm>
86 #include <condition_variable>
87 #include <cstdint>
88 #include <cstdio>
89 #include <fstream>
90 #include <functional>
91 #include <set>
92 #include <string>
93 #include <thread>
94 #include <vector>
95 
96 #ifndef WIN32
97 #include <cerrno>
98 #include <signal.h>
99 #include <sys/stat.h>
100 #endif
101 
102 #include <boost/signals2/signal.hpp>
103 
104 #if ENABLE_ZMQ
105 #include <zmq/zmqabstractnotifier.h>
107 #include <zmq/zmqrpc.h>
108 #endif
109 
110 using kernel::DumpMempool;
112 
114 using node::CacheSizes;
120 using node::MempoolPath;
122 using node::NodeContext;
123 using node::ThreadImport;
125 using node::fPruneMode;
126 using node::fReindex;
127 using node::nPruneTarget;
128 
129 static constexpr bool DEFAULT_PROXYRANDOMIZE{true};
130 static constexpr bool DEFAULT_REST_ENABLE{false};
131 static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING{true};
132 
133 #ifdef WIN32
134 // Win32 LevelDB doesn't use filedescriptors, and the ones used for
135 // accessing block files don't count towards the fd_set size limit
136 // 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 
150 {
152 }
153 
154 [[nodiscard]] static bool CreatePidFile(const ArgsManager& args)
155 {
156  std::ofstream file{GetPidFile(args)};
157  if (file) {
158 #ifdef WIN32
159  tfm::format(file, "%d\n", GetCurrentProcessId());
160 #else
161  tfm::format(file, "%d\n", getpid());
162 #endif
163  return true;
164  } else {
165  return InitError(strprintf(_("Unable to create the PID file '%s': %s"), fs::PathToString(GetPidFile(args)), SysErrorString(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
178 // created by AppInit() or the Qt main() function.
179 //
180 // A clean exit happens when StartShutdown() or the SIGTERM
181 // signal handler sets ShutdownRequested(), which makes main thread's
182 // WaitForShutdown() interrupts the thread group.
183 // And then, WaitForShutdown() makes all other on-going threads
184 // in the thread 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
187 // threads 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
191 // shutdown thing.
192 //
193 
194 #if HAVE_SYSTEM
195 static void ShutdownNotify(const ArgsManager& args)
196 {
197  std::vector<std::thread> threads;
198  for (const auto& cmd : args.GetArgs("-shutdownnotify")) {
199  threads.emplace_back(runCommand, cmd);
200  }
201  for (auto& t : threads) {
202  t.join();
203  }
204 }
205 #endif
206 
208 {
209 #if HAVE_SYSTEM
210  ShutdownNotify(*node.args);
211 #endif
214  InterruptRPC();
215  InterruptREST();
218  if (node.connman)
219  node.connman->Interrupt();
220  if (g_txindex) {
221  g_txindex->Interrupt();
222  }
223  ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Interrupt(); });
224  if (g_coin_stats_index) {
225  g_coin_stats_index->Interrupt();
226  }
227 }
228 
230 {
231  static Mutex g_shutdown_mutex;
232  TRY_LOCK(g_shutdown_mutex, lock_shutdown);
233  if (!lock_shutdown) return;
234  LogPrintf("%s: In progress...\n", __func__);
235  Assert(node.args);
236 
241  util::ThreadRename("shutoff");
242  if (node.mempool) node.mempool->AddTransactionsUpdated(1);
243 
244  StopHTTPRPC();
245  StopREST();
246  StopRPC();
247  StopHTTPServer();
248  for (const auto& client : node.chain_clients) {
249  client->flush();
250  }
251  StopMapPort();
252 
253  // Because these depend on each-other, we make sure that neither can be
254  // using the other before destroying them.
255  if (node.peerman) UnregisterValidationInterface(node.peerman.get());
256  if (node.connman) node.connman->Stop();
257 
258  StopTorControl();
259 
260  // After everything has been shut down, but before things get flushed, stop the
261  // CScheduler/checkqueue, scheduler and load block thread.
262  if (node.scheduler) node.scheduler->stop();
263  if (node.chainman && node.chainman->m_load_block.joinable()) node.chainman->m_load_block.join();
265 
266  // After the threads that potentially access these pointers have been stopped,
267  // destruct and reset all to nullptr.
268  node.peerman.reset();
269  node.connman.reset();
270  node.banman.reset();
271  node.addrman.reset();
272  node.netgroupman.reset();
273 
274  if (node.mempool && node.mempool->GetLoadTried() && ShouldPersistMempool(*node.args)) {
275  DumpMempool(*node.mempool, MempoolPath(*node.args));
276  }
277 
278  // Drop transactions we were still watching, and record fee estimations.
279  if (node.fee_estimator) node.fee_estimator->Flush();
280 
281  // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
282  if (node.chainman) {
283  LOCK(cs_main);
284  for (Chainstate* chainstate : node.chainman->GetAll()) {
285  if (chainstate->CanFlushToDisk()) {
286  chainstate->ForceFlushStateToDisk();
287  }
288  }
289  }
290 
291  // After there are no more peers/RPC left to give us new data which may generate
292  // CValidationInterface callbacks, flush them...
294 
295  // Stop and delete all indexes only after flushing background callbacks.
296  if (g_txindex) {
297  g_txindex->Stop();
298  g_txindex.reset();
299  }
300  if (g_coin_stats_index) {
301  g_coin_stats_index->Stop();
302  g_coin_stats_index.reset();
303  }
304  ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Stop(); });
306 
307  // Any future callbacks will be dropped. This should absolutely be safe - if
308  // missing a callback results in an unrecoverable situation, unclean shutdown
309  // would too. The only reason to do the above flushes is to let the wallet catch
310  // up with our current chain to avoid any strange pruning edge cases and make
311  // next startup faster by avoiding rescan.
312 
313  if (node.chainman) {
314  LOCK(cs_main);
315  for (Chainstate* chainstate : node.chainman->GetAll()) {
316  if (chainstate->CanFlushToDisk()) {
317  chainstate->ForceFlushStateToDisk();
318  chainstate->ResetCoinsViews();
319  }
320  }
321  }
322  for (const auto& client : node.chain_clients) {
323  client->stop();
324  }
325 
326 #if ENABLE_ZMQ
331  }
332 #endif
333 
334  node.chain_clients.clear();
337  node.kernel.reset();
338  node.mempool.reset();
339  node.fee_estimator.reset();
340  node.chainman.reset();
341  node.scheduler.reset();
342 
343  try {
344  if (!fs::remove(GetPidFile(*node.args))) {
345  LogPrintf("%s: Unable to remove PID file: File does not exist\n", __func__);
346  }
347  } catch (const fs::filesystem_error& e) {
348  LogPrintf("%s: Unable to remove PID file: %s\n", __func__, fsbridge::get_filesystem_error_message(e));
349  }
350 
351  LogPrintf("%s: done\n", __func__);
352 }
353 
359 #ifndef WIN32
360 static void HandleSIGTERM(int)
361 {
362  StartShutdown();
363 }
364 
365 static void HandleSIGHUP(int)
366 {
367  LogInstance().m_reopen_file = true;
368 }
369 #else
370 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
371 {
372  StartShutdown();
373  Sleep(INFINITE);
374  return true;
375 }
376 #endif
377 
378 #ifndef WIN32
379 static void registerSignalHandler(int signal, void(*handler)(int))
380 {
381  struct sigaction sa;
382  sa.sa_handler = handler;
383  sigemptyset(&sa.sa_mask);
384  sa.sa_flags = 0;
385  sigaction(signal, &sa, nullptr);
386 }
387 #endif
388 
389 static boost::signals2::connection rpc_notify_block_change_connection;
390 static void OnRPCStarted()
391 {
392  rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(std::bind(RPCNotifyBlockChange, std::placeholders::_2));
393 }
394 
395 static void OnRPCStopped()
396 {
398  RPCNotifyBlockChange(nullptr);
399  g_best_block_cv.notify_all();
400  LogPrint(BCLog::RPC, "RPC stopped.\n");
401 }
402 
404 {
405  SetupHelpOptions(argsman);
406  argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now
407 
408  init::AddLoggingArgs(argsman);
409 
410  const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);
411  const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
412  const auto signetBaseParams = CreateBaseChainParams(CBaseChainParams::SIGNET);
413  const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);
414  const auto defaultChainParams = CreateChainParams(argsman, CBaseChainParams::MAIN);
415  const auto testnetChainParams = CreateChainParams(argsman, CBaseChainParams::TESTNET);
416  const auto signetChainParams = CreateChainParams(argsman, CBaseChainParams::SIGNET);
417  const auto regtestChainParams = CreateChainParams(argsman, CBaseChainParams::REGTEST);
418 
419  // Hidden Options
420  std::vector<std::string> hidden_args = {
421  "-dbcrashratio", "-forcecompactdb",
422  // GUI args. These will be overwritten by SetupUIArgs for the GUI
423  "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"};
424 
425  argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
426 #if HAVE_SYSTEM
427  argsman.AddArg("-alertnotify=<cmd>", "Execute command when an alert is raised (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
428 #endif
429  argsman.AddArg("-assumevalid=<hex>", strprintf("If this block is in the chain assume that it and its ancestors are valid and potentially skip their script verification (0 to verify all, default: %s, testnet: %s, signet: %s)", defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnetChainParams->GetConsensus().defaultAssumeValid.GetHex(), signetChainParams->GetConsensus().defaultAssumeValid.GetHex()), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
430  argsman.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
431  argsman.AddArg("-fastprune", "Use smaller block files and lower minimum prune height for testing purposes", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
432 #if HAVE_SYSTEM
433  argsman.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
434 #endif
435  argsman.AddArg("-blockreconstructionextratxn=<n>", strprintf("Extra transactions to keep in memory for compact block reconstructions (default: %u)", DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
436  argsman.AddArg("-blocksonly", strprintf("Whether to reject transactions from network peers. Automatic broadcast and rebroadcast of any transactions from inbound peers is disabled, unless the peer has the 'forcerelay' permission. RPC transactions are not affected. (default: %u)", DEFAULT_BLOCKSONLY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
437  argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
438  argsman.AddArg("-conf=<file>", strprintf("Specify path to read-only configuration file. Relative paths will be prefixed by datadir location (only useable from command line, not configuration file) (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
439  argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
440  argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", nDefaultDbBatchSize), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
441  argsman.AddArg("-dbcache=<n>", strprintf("Maximum database cache size <n> MiB (%d to %d, default: %d). In addition, unused mempool memory is shared for this cache (see -maxmempool).", nMinDbCache, nMaxDbCache, nDefaultDbCache), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
442  argsman.AddArg("-includeconf=<file>", "Specify additional configuration file, relative to the -datadir path (only useable from configuration file, not command line)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
443  argsman.AddArg("-loadblock=<file>", "Imports blocks from external file on startup", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
444  argsman.AddArg("-maxmempool=<n>", strprintf("Keep the transaction memory pool below <n> megabytes (default: %u)", DEFAULT_MAX_MEMPOOL_SIZE_MB), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
445  argsman.AddArg("-maxorphantx=<n>", strprintf("Keep at most <n> unconnectable transactions in memory (default: %u)", DEFAULT_MAX_ORPHAN_TRANSACTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
446  argsman.AddArg("-mempoolexpiry=<n>", strprintf("Do not keep transactions in the mempool longer than <n> hours (default: %u)", DEFAULT_MEMPOOL_EXPIRY_HOURS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
447  argsman.AddArg("-minimumchainwork=<hex>", strprintf("Minimum work assumed to exist on a valid chain in hex (default: %s, testnet: %s, signet: %s)", defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnetChainParams->GetConsensus().nMinimumChainWork.GetHex(), signetChainParams->GetConsensus().nMinimumChainWork.GetHex()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
448  argsman.AddArg("-par=<n>", strprintf("Set the number of script verification threads (%u to %d, 0 = auto, <0 = leave that many cores free, default: %d)",
450  argsman.AddArg("-persistmempool", strprintf("Whether to save the mempool on shutdown and load on restart (default: %u)", DEFAULT_PERSIST_MEMPOOL), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
451  argsman.AddArg("-pid=<file>", strprintf("Specify pid file. Relative paths will be prefixed by a net-specific datadir location. (default: %s)", BITCOIN_PID_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
452  argsman.AddArg("-prune=<n>", strprintf("Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks and enables automatic pruning of old blocks if a target size in MiB is provided. This mode is incompatible with -txindex. "
453  "Warning: Reverting this setting requires re-downloading the entire blockchain. "
454  "(default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, >=%u = automatically prune block files to stay under the specified target size in MiB)", MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
455  argsman.AddArg("-reindex", "Rebuild chain state and block index from the blk*.dat files on disk. This will also rebuild active optional indexes.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
456  argsman.AddArg("-reindex-chainstate", "Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead. Deactivate all optional indexes before running this.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
457  argsman.AddArg("-settings=<file>", strprintf("Specify path to dynamic settings data file. Can be disabled with -nosettings. File is written at runtime and not meant to be edited by users (use %s instead for custom settings). Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
458 #if HAVE_SYSTEM
459  argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
460  argsman.AddArg("-shutdownnotify=<cmd>", "Execute command immediately before beginning shutdown. The need for shutdown may be urgent, so be careful not to delay it long (if the command doesn't require interaction with the server, consider having it fork into the background).", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
461 #endif
462 #ifndef WIN32
463  argsman.AddArg("-sysperms", "Create new files with system default permissions, instead of umask 077 (only effective with disabled wallet functionality)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
464 #else
465  hidden_args.emplace_back("-sysperms");
466 #endif
467  argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
468  argsman.AddArg("-blockfilterindex=<type>",
469  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
470  " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
472 
473  argsman.AddArg("-addnode=<ip>", strprintf("Add a node to connect to and attempt to keep the connection open (see the addnode RPC help for more info). This option can be specified multiple times to add multiple nodes; connections are limited to %u at a time and are counted separately from the -maxconnections limit.", MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
474  argsman.AddArg("-asmap=<file>", strprintf("Specify asn mapping used for bucketing of the peers (default: %s). Relative paths will be prefixed by the net-specific datadir location.", DEFAULT_ASMAP_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
475  argsman.AddArg("-bantime=<n>", strprintf("Default duration (in seconds) of manually configured bans (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
476  argsman.AddArg("-bind=<addr>[:<port>][=onion]", strprintf("Bind to given address and always listen on it (default: 0.0.0.0). Use [host]:port notation for IPv6. Append =onion to tag any incoming connections to that address and port as incoming Tor connections (default: 127.0.0.1:%u=onion, testnet: 127.0.0.1:%u=onion, signet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)", defaultBaseParams->OnionServiceTargetPort(), testnetBaseParams->OnionServiceTargetPort(), signetBaseParams->OnionServiceTargetPort(), regtestBaseParams->OnionServiceTargetPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
477  argsman.AddArg("-cjdnsreachable", "If set, then this host is configured for CJDNS (connecting to fc00::/8 addresses would lead us to the CJDNS network, see doc/cjdns.md) (default: 0)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
478  argsman.AddArg("-connect=<ip>", "Connect only to the specified node; -noconnect disables automatic connections (the rules for this peer are the same as for -addnode). This option can be specified multiple times to connect to multiple nodes.", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
479  argsman.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
480  argsman.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
481  argsman.AddArg("-dnsseed", strprintf("Query for peer addresses via DNS lookup, if low on addresses (default: %u unless -connect used)", DEFAULT_DNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
482  argsman.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
483  argsman.AddArg("-fixedseeds", strprintf("Allow fixed seeds if DNS seeds don't provide peers (default: %u)", DEFAULT_FIXEDSEEDS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
484  argsman.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
485  argsman.AddArg("-listen", "Accept connections from outside (default: 1 if no -proxy or -connect)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
486  argsman.AddArg("-listenonion", strprintf("Automatically create Tor onion service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
487  argsman.AddArg("-maxconnections=<n>", strprintf("Maintain at most <n> connections to peers (default: %u). This limit does not apply to connections manually added via -addnode or the addnode RPC, which have a separate limit of %u.", DEFAULT_MAX_PEER_CONNECTIONS, MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
488  argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
489  argsman.AddArg("-maxsendbuffer=<n>", strprintf("Maximum per-connection send buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXSENDBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
490  argsman.AddArg("-maxtimeadjustment", strprintf("Maximum allowed median peer time offset adjustment. Local perspective of time may be influenced by outbound peers forward or backward by this amount (default: %u seconds).", DEFAULT_MAX_TIME_ADJUSTMENT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
491  argsman.AddArg("-maxuploadtarget=<n>", strprintf("Tries to keep outbound traffic under the given target per 24h. Limit does not apply to peers with 'download' permission or blocks created within past week. 0 = no limit (default: %s). Optional suffix units [k|K|m|M|g|G|t|T] (default: M). Lowercase is 1000 base while uppercase is 1024 base", DEFAULT_MAX_UPLOAD_TARGET), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
492  argsman.AddArg("-onion=<ip:port>", "Use separate SOCKS5 proxy to reach peers via Tor onion services, set -noonion to disable (default: -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
493  argsman.AddArg("-i2psam=<ip:port>", "I2P SAM proxy to reach I2P peers and accept I2P connections (default: none)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
494  argsman.AddArg("-i2pacceptincoming", strprintf("Whether to accept inbound I2P connections (default: %i). Ignored if -i2psam is not set. Listening for inbound I2P connections is done through the SAM proxy, not by binding to a local address and port.", DEFAULT_I2P_ACCEPT_INCOMING), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
495  argsman.AddArg("-onlynet=<net>", "Make automatic outbound connections only to network <net> (" + Join(GetNetworkNames(), ", ") + "). Inbound and manual connections are not affected by this option. It can be specified multiple times to allow multiple networks.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
496  argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
497  argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
498  argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
499  // TODO: remove the sentence "Nodes not using ... incoming connections." once the changes from
500  // https://github.com/bitcoin/bitcoin/pull/23542 have become widespread.
501  argsman.AddArg("-port=<port>", strprintf("Listen for connections on <port>. Nodes not using the default ports (default: %u, testnet: %u, signet: %u, regtest: %u) are unlikely to get incoming connections. Not relevant for I2P (see doc/i2p.md).", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
502  argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled)", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION, OptionsCategory::CONNECTION);
503  argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
504  argsman.AddArg("-seednode=<ip>", "Connect to a node to retrieve peer addresses, and disconnect. This option can be specified multiple times to connect to multiple nodes.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
505  argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
506  argsman.AddArg("-timeout=<n>", strprintf("Specify socket connection timeout in milliseconds. If an initial attempt to connect is unsuccessful after this amount of time, drop it (minimum: 1, default: %d)", DEFAULT_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
507  argsman.AddArg("-peertimeout=<n>", strprintf("Specify a p2p connection timeout delay in seconds. After connecting to a peer, wait this amount of time before considering disconnection based on inactivity (minimum: 1, default: %d)", DEFAULT_PEER_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
508  argsman.AddArg("-torcontrol=<ip>:<port>", strprintf("Tor control port to use if onion listening enabled (default: %s)", DEFAULT_TOR_CONTROL), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
509  argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION);
510 #ifdef USE_UPNP
511 #if USE_UPNP
512  argsman.AddArg("-upnp", "Use UPnP to map the listening port (default: 1 when listening and no -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
513 #else
514  argsman.AddArg("-upnp", strprintf("Use UPnP to map the listening port (default: %u)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
515 #endif
516 #else
517  hidden_args.emplace_back("-upnp");
518 #endif
519 #ifdef USE_NATPMP
520  argsman.AddArg("-natpmp", strprintf("Use NAT-PMP to map the listening port (default: %s)", DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
521 #else
522  hidden_args.emplace_back("-natpmp");
523 #endif // USE_NATPMP
524  argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. "
525  "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". "
526  "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
527 
528  argsman.AddArg("-whitelist=<[permissions@]IP address or network>", "Add permission flags to the peers connecting from the given IP address (e.g. 1.2.3.4) or "
529  "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
530  "-whitebind. Can be specified multiple times." , ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
531 
533 
534 #if ENABLE_ZMQ
535  argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
536  argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
537  argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
538  argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
539  argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
540  argsman.AddArg("-zmqpubhashblockhwm=<n>", strprintf("Set publish hash block outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
541  argsman.AddArg("-zmqpubhashtxhwm=<n>", strprintf("Set publish hash transaction outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
542  argsman.AddArg("-zmqpubrawblockhwm=<n>", strprintf("Set publish raw block outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
543  argsman.AddArg("-zmqpubrawtxhwm=<n>", strprintf("Set publish raw transaction outbound message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
544  argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
545 #else
546  hidden_args.emplace_back("-zmqpubhashblock=<address>");
547  hidden_args.emplace_back("-zmqpubhashtx=<address>");
548  hidden_args.emplace_back("-zmqpubrawblock=<address>");
549  hidden_args.emplace_back("-zmqpubrawtx=<address>");
550  hidden_args.emplace_back("-zmqpubsequence=<n>");
551  hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
552  hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
553  hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
554  hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
555  hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
556 #endif
557 
558  argsman.AddArg("-checkblocks=<n>", strprintf("How many blocks to check at startup (default: %u, 0 = all)", DEFAULT_CHECKBLOCKS), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
559  argsman.AddArg("-checklevel=<n>", strprintf("How thorough the block verification of -checkblocks is: %s (0-4, default: %u)", Join(CHECKLEVEL_DOC, ", "), DEFAULT_CHECKLEVEL), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
560  argsman.AddArg("-checkblockindex", strprintf("Do a consistency check for the block tree, chainstate, and other validation data structures occasionally. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
561  argsman.AddArg("-checkaddrman=<n>", strprintf("Run addrman consistency checks every <n> operations. Use 0 to disable. (default: %u)", DEFAULT_ADDRMAN_CONSISTENCY_CHECKS), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
562  argsman.AddArg("-checkmempool=<n>", strprintf("Run mempool consistency checks every <n> transactions. Use 0 to disable. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
563  argsman.AddArg("-checkpoints", strprintf("Enable rejection of any forks from the known historical chain until block %s (default: %u)", defaultChainParams->Checkpoints().GetHeight(), DEFAULT_CHECKPOINTS_ENABLED), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
564  argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
565  argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
566  argsman.AddArg("-stopatheight", strprintf("Stop running after reaching the given height in the main chain (default: %u)", DEFAULT_STOPATHEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
567  argsman.AddArg("-limitancestorcount=<n>", strprintf("Do not accept transactions if number of in-mempool ancestors is <n> or more (default: %u)", DEFAULT_ANCESTOR_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
568  argsman.AddArg("-limitancestorsize=<n>", strprintf("Do not accept transactions whose size with all in-mempool ancestors exceeds <n> kilobytes (default: %u)", DEFAULT_ANCESTOR_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
569  argsman.AddArg("-limitdescendantcount=<n>", strprintf("Do not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u)", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
570  argsman.AddArg("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
571  argsman.AddArg("-addrmantest", "Allows to test address relay on localhost", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
572  argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
573  argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
574  argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_BYTES >> 20), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
575  argsman.AddArg("-maxtipage=<n>",
576  strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)",
577  Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
579  argsman.AddArg("-printpriority", strprintf("Log transaction fee rate in " + CURRENCY_UNIT + "/kvB when mining blocks (default: %u)", DEFAULT_PRINTPRIORITY), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
580  argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
581 
583 
584  argsman.AddArg("-acceptnonstdtxn", strprintf("Relay and mine \"non-standard\" transactions (%sdefault: %u)", "testnet/regtest only; ", !testnetChainParams->RequireStandard()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
585  argsman.AddArg("-incrementalrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) used to define cost of relay, used for mempool limiting and replacement policy. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_INCREMENTAL_RELAY_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
586  argsman.AddArg("-dustrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) used to define dust, the value of an output such that it will cost more than its value in fees at this fee rate to spend it. (default: %s)", CURRENCY_UNIT, FormatMoney(DUST_RELAY_TX_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
587  argsman.AddArg("-bytespersigop", strprintf("Equivalent bytes per sigop in transactions for relay and mining (default: %u)", DEFAULT_BYTES_PER_SIGOP), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
588  argsman.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
589  argsman.AddArg("-datacarriersize", strprintf("Maximum size of data in data carrier transactions we relay and mine (default: %u)", MAX_OP_RETURN_RELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
590  argsman.AddArg("-mempoolfullrbf", strprintf("Accept transaction replace-by-fee without requiring replaceability signaling (default: %u)", DEFAULT_MEMPOOL_FULL_RBF), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
591  argsman.AddArg("-permitbaremultisig", strprintf("Relay non-P2SH multisig (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
593  argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
595  argsman.AddArg("-whitelistforcerelay", strprintf("Add 'forcerelay' permission to whitelisted inbound peers with default permissions. This will relay transactions even if the transactions were already in the mempool. (default: %d)", DEFAULT_WHITELISTFORCERELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
596  argsman.AddArg("-whitelistrelay", strprintf("Add 'relay' permission to whitelisted inbound peers with default permissions. This will accept relayed transactions even when not relaying transactions (default: %d)", DEFAULT_WHITELISTRELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
597 
598 
599  argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
600  argsman.AddArg("-blockmintxfee=<amt>", strprintf("Set lowest fee rate (in %s/kvB) for transactions to be included in block creation. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE)), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
601  argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
602 
603  argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
604  argsman.AddArg("-rpcallowip=<ip>", "Allow JSON-RPC connections from specified source. Valid for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
605  argsman.AddArg("-rpcauth=<userpw>", "Username and HMAC-SHA-256 hashed password for JSON-RPC connections. The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A canonical python script is included in share/rpcauth. The client then connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> pair of arguments. This option can be specified multiple times", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
606  argsman.AddArg("-rpcbind=<addr>[:port]", "Bind to given address to listen for JSON-RPC connections. Do not expose the RPC server to untrusted networks such as the public internet! This option is ignored unless -rpcallowip is also passed. Port is optional and overrides -rpcport. Use [host]:port notation for IPv6. This option can be specified multiple times (default: 127.0.0.1 and ::1 i.e., localhost)", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);
607  argsman.AddArg("-rpcdoccheck", strprintf("Throw a non-fatal error at runtime if the documentation for an RPC is incorrect (default: %u)", DEFAULT_RPC_DOC_CHECK), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
608  argsman.AddArg("-rpccookiefile=<loc>", "Location of the auth cookie. Relative paths will be prefixed by a net-specific datadir location. (default: data dir)", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
609  argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
610  argsman.AddArg("-rpcport=<port>", strprintf("Listen for JSON-RPC connections on <port> (default: %u, testnet: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);
611  argsman.AddArg("-rpcserialversion", strprintf("Sets the serialization of raw transaction or block hex returned in non-verbose mode, non-segwit(0) or segwit(1) (default: %d)", DEFAULT_RPC_SERIALIZE_VERSION), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
612  argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
613  argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
614  argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
615  argsman.AddArg("-rpcwhitelist=<whitelist>", "Set a whitelist to filter incoming RPC calls for a specific user. The field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc 2>,...,<rpc n>. If multiple whitelists are set for a given user, they are set-intersected. See -rpcwhitelistdefault documentation for information on default whitelist behavior.", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
616  argsman.AddArg("-rpcwhitelistdefault", "Sets default behavior for rpc whitelisting. Unless rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc server acts as if all rpc users are subject to empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault is set to 1 and no -rpcwhitelist is set, rpc server acts as if all rpc users are subject to empty whitelists.", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
617  argsman.AddArg("-rpcworkqueue=<n>", strprintf("Set the depth of the work queue to service RPC calls (default: %d)", DEFAULT_HTTP_WORKQUEUE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
618  argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
619 
620 #if HAVE_DECL_FORK
621  argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
622  argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
623 #else
624  hidden_args.emplace_back("-daemon");
625  hidden_args.emplace_back("-daemonwait");
626 #endif
627 
628 #if defined(USE_SYSCALL_SANDBOX)
629  argsman.AddArg("-sandbox=<mode>", "Use the experimental syscall sandbox in the specified mode (-sandbox=log-and-abort or -sandbox=abort). Allow only expected syscalls to be used by bitcoind. Note that this is an experimental new feature that may cause bitcoind to exit or crash unexpectedly: use with caution. In the \"log-and-abort\" mode the invocation of an unexpected syscall results in a debug handler being invoked which will log the incident and terminate the program (without executing the unexpected syscall). In the \"abort\" mode the invocation of an unexpected syscall results in the entire process being killed immediately by the kernel without executing the unexpected syscall.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
630 #endif // USE_SYSCALL_SANDBOX
631 
632  // Add the hidden options
633  argsman.AddHiddenArgs(hidden_args);
634 }
635 
636 static bool fHaveGenesis = false;
638 static std::condition_variable g_genesis_wait_cv;
639 
640 static void BlockNotifyGenesisWait(const CBlockIndex* pBlockIndex)
641 {
642  if (pBlockIndex != nullptr) {
643  {
645  fHaveGenesis = true;
646  }
647  g_genesis_wait_cv.notify_all();
648  }
649 }
650 
651 #if HAVE_SYSTEM
652 static void StartupNotify(const ArgsManager& args)
653 {
654  std::string cmd = args.GetArg("-startupnotify", "");
655  if (!cmd.empty()) {
656  std::thread t(runCommand, cmd);
657  t.detach(); // thread runs free
658  }
659 }
660 #endif
661 
663 {
664  const ArgsManager& args = *Assert(node.args);
667  if (!InitHTTPServer())
668  return false;
669  StartRPC();
670  node.rpc_interruption_point = RpcInterruptionPoint;
671  if (!StartHTTPRPC(&node))
672  return false;
674  StartHTTPServer();
675  return true;
676 }
677 
678 // Parameter interaction based on rules
680 {
681  // when specifying an explicit binding address, you want to listen on it
682  // even when -connect or -proxy is specified
683  if (args.IsArgSet("-bind")) {
684  if (args.SoftSetBoolArg("-listen", true))
685  LogPrintf("%s: parameter interaction: -bind set -> setting -listen=1\n", __func__);
686  }
687  if (args.IsArgSet("-whitebind")) {
688  if (args.SoftSetBoolArg("-listen", true))
689  LogPrintf("%s: parameter interaction: -whitebind set -> setting -listen=1\n", __func__);
690  }
691 
692  if (args.IsArgSet("-connect")) {
693  // when only connecting to trusted nodes, do not seed via DNS, or listen by default
694  if (args.SoftSetBoolArg("-dnsseed", false))
695  LogPrintf("%s: parameter interaction: -connect set -> setting -dnsseed=0\n", __func__);
696  if (args.SoftSetBoolArg("-listen", false))
697  LogPrintf("%s: parameter interaction: -connect set -> setting -listen=0\n", __func__);
698  }
699 
700  std::string proxy_arg = args.GetArg("-proxy", "");
701  if (proxy_arg != "" && proxy_arg != "0") {
702  // to protect privacy, do not listen by default if a default proxy server is specified
703  if (args.SoftSetBoolArg("-listen", false))
704  LogPrintf("%s: parameter interaction: -proxy set -> setting -listen=0\n", __func__);
705  // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1
706  // to listen locally, so don't rely on this happening through -listen below.
707  if (args.SoftSetBoolArg("-upnp", false))
708  LogPrintf("%s: parameter interaction: -proxy set -> setting -upnp=0\n", __func__);
709  if (args.SoftSetBoolArg("-natpmp", false)) {
710  LogPrintf("%s: parameter interaction: -proxy set -> setting -natpmp=0\n", __func__);
711  }
712  // to protect privacy, do not discover addresses by default
713  if (args.SoftSetBoolArg("-discover", false))
714  LogPrintf("%s: parameter interaction: -proxy set -> setting -discover=0\n", __func__);
715  }
716 
717  if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
718  // do not map ports or try to retrieve public IP when not listening (pointless)
719  if (args.SoftSetBoolArg("-upnp", false))
720  LogPrintf("%s: parameter interaction: -listen=0 -> setting -upnp=0\n", __func__);
721  if (args.SoftSetBoolArg("-natpmp", false)) {
722  LogPrintf("%s: parameter interaction: -listen=0 -> setting -natpmp=0\n", __func__);
723  }
724  if (args.SoftSetBoolArg("-discover", false))
725  LogPrintf("%s: parameter interaction: -listen=0 -> setting -discover=0\n", __func__);
726  if (args.SoftSetBoolArg("-listenonion", false))
727  LogPrintf("%s: parameter interaction: -listen=0 -> setting -listenonion=0\n", __func__);
728  if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
729  LogPrintf("%s: parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n", __func__);
730  }
731  }
732 
733  if (args.IsArgSet("-externalip")) {
734  // if an explicit public IP is specified, do not try to find others
735  if (args.SoftSetBoolArg("-discover", false))
736  LogPrintf("%s: parameter interaction: -externalip set -> setting -discover=0\n", __func__);
737  }
738 
739  if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
740  // disable whitelistrelay in blocksonly mode
741  if (args.SoftSetBoolArg("-whitelistrelay", false))
742  LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n", __func__);
743  // Reduce default mempool size in blocksonly mode to avoid unexpected resource usage
745  LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting -maxmempool=%d\n", __func__, DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB);
746  }
747 
748  // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.
749  if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
750  if (args.SoftSetBoolArg("-whitelistrelay", true))
751  LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n", __func__);
752  }
753  if (args.IsArgSet("-onlynet")) {
754  const auto onlynets = args.GetArgs("-onlynet");
755  bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](const auto& net) {
756  const auto n = ParseNetwork(net);
757  return n == NET_IPV4 || n == NET_IPV6;
758  });
759  if (!clearnet_reachable && args.SoftSetBoolArg("-dnsseed", false)) {
760  LogPrintf("%s: parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n", __func__);
761  }
762  }
763 }
764 
772 {
775 }
776 
777 namespace { // Variables internal to initialization process only
778 
779 int nMaxConnections;
780 int nUserMaxConnections;
781 int nFD;
783 int64_t peer_connect_timeout;
784 std::set<BlockFilterType> g_enabled_filter_types;
785 
786 } // namespace
787 
788 [[noreturn]] static void new_handler_terminate()
789 {
790  // Rather than throwing std::bad-alloc if allocation fails, terminate
791  // immediately to (try to) avoid chain corruption.
792  // Since LogPrintf may itself allocate memory, set the handler directly
793  // to terminate first.
794  std::set_new_handler(std::terminate);
795  LogPrintf("Error: Out of memory. Terminating.\n");
796 
797  // The log was successful, terminate now.
798  std::terminate();
799 };
800 
802 {
803  // ********************************************************* Step 1: setup
804 #ifdef _MSC_VER
805  // Turn off Microsoft heap dump noise
806  _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
807  _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0));
808  // Disable confusing "helpful" text message on abort, Ctrl-C
809  _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
810 #endif
811 #ifdef WIN32
812  // Enable heap terminate-on-corruption
813  HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0);
814 #endif
815  if (!InitShutdownState()) {
816  return InitError(Untranslated("Initializing wait-for-shutdown state failed."));
817  }
818 
819  if (!SetupNetworking()) {
820  return InitError(Untranslated("Initializing networking failed."));
821  }
822 
823 #ifndef WIN32
824  if (!args.GetBoolArg("-sysperms", false)) {
825  umask(077);
826  }
827 
828  // Clean shutdown on SIGTERM
831 
832  // Reopen debug.log on SIGHUP
834 
835  // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly
836  signal(SIGPIPE, SIG_IGN);
837 #else
838  SetConsoleCtrlHandler(consoleCtrlHandler, true);
839 #endif
840 
841  std::set_new_handler(new_handler_terminate);
842 
843  return true;
844 }
845 
846 bool AppInitParameterInteraction(const ArgsManager& args, bool use_syscall_sandbox)
847 {
848  const CChainParams& chainparams = Params();
849  // ********************************************************* Step 2: parameter interactions
850 
851  // also see: InitParameterInteraction()
852 
853  // Error if network-specific options (-addnode, -connect, etc) are
854  // specified in default section of config file, but not overridden
855  // on the command line or in this network's section of the config file.
856  std::string network = args.GetChainName();
857  if (network == CBaseChainParams::SIGNET) {
858  LogPrintf("Signet derived magic (message start): %s\n", HexStr(chainparams.MessageStart()));
859  }
860  bilingual_str errors;
861  for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
862  errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section.") + Untranslated("\n"), arg, network, network);
863  }
864 
865  if (!errors.empty()) {
866  return InitError(errors);
867  }
868 
869  // Warn if unrecognized section name are present in the config file.
870  bilingual_str warnings;
871  for (const auto& section : args.GetUnrecognizedSections()) {
872  warnings += strprintf(Untranslated("%s:%i ") + _("Section [%s] is not recognized.") + Untranslated("\n"), section.m_file, section.m_line, section.m_name);
873  }
874 
875  if (!warnings.empty()) {
876  InitWarning(warnings);
877  }
878 
879  if (!fs::is_directory(gArgs.GetBlocksDirPath())) {
880  return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
881  }
882 
883  // parse and validate enabled filter types
884  std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
885  if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
886  g_enabled_filter_types = AllBlockFilterTypes();
887  } else if (blockfilterindex_value != "0") {
888  const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
889  for (const auto& name : names) {
890  BlockFilterType filter_type;
891  if (!BlockFilterTypeByName(name, filter_type)) {
892  return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
893  }
894  g_enabled_filter_types.insert(filter_type);
895  }
896  }
897 
898  // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
899  if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
900  if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
901  return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
902  }
903 
904  nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
905  }
906 
907  if (args.GetIntArg("-prune", 0)) {
908  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
909  return InitError(_("Prune mode is incompatible with -txindex."));
910  if (args.GetBoolArg("-reindex-chainstate", false)) {
911  return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
912  }
913  }
914 
915  // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
916  if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
917  return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
918  }
919 
920  // -bind and -whitebind can't be set when not listening
921  size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
922  if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
923  return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0"));
924  }
925 
926  // if listen=0, then disallow listenonion=1
927  if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
928  return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1"));
929  }
930 
931  // Make sure enough file descriptors are available
932  int nBind = std::max(nUserBind, size_t(1));
933  nUserMaxConnections = args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
934  nMaxConnections = std::max(nUserMaxConnections, 0);
935 
937 
938 #ifdef USE_POLL
939  int fd_max = nFD;
940 #else
941  int fd_max = FD_SETSIZE;
942 #endif
943  // Trim requested connection counts, to fit into system limitations
944  // <int> in std::min<int>(...) to work around FreeBSD compilation issue described in #2695
945  nMaxConnections = std::max(std::min<int>(nMaxConnections, fd_max - nBind - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE), 0);
946  if (nFD < MIN_CORE_FILEDESCRIPTORS)
947  return InitError(_("Not enough file descriptors available."));
948  nMaxConnections = std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE, nMaxConnections);
949 
950  if (nMaxConnections < nUserMaxConnections)
951  InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), nUserMaxConnections, nMaxConnections));
952 
953  // ********************************************************* Step 3: parameter-to-internal-flags
956 
957  // block pruning; get the amount of disk space (in MiB) to allot for block & undo files
958  int64_t nPruneArg = args.GetIntArg("-prune", 0);
959  if (nPruneArg < 0) {
960  return InitError(_("Prune cannot be configured with a negative value."));
961  }
962  nPruneTarget = (uint64_t) nPruneArg * 1024 * 1024;
963  if (nPruneArg == 1) { // manual pruning: -prune=1
964  nPruneTarget = std::numeric_limits<uint64_t>::max();
965  fPruneMode = true;
966  } else if (nPruneTarget) {
968  return InitError(strprintf(_("Prune configured below the minimum of %d MiB. Please use a higher number."), MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
969  }
970  fPruneMode = true;
971  }
972 
974  if (nConnectTimeout <= 0) {
976  }
977 
978  peer_connect_timeout = args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
979  if (peer_connect_timeout <= 0) {
980  return InitError(Untranslated("peertimeout must be a positive integer."));
981  }
982 
983  // Sanity check argument for min fee for including tx in block
984  // TODO: Harmonize which arguments need sanity checking and where that happens
985  if (args.IsArgSet("-blockmintxfee")) {
986  if (!ParseMoney(args.GetArg("-blockmintxfee", ""))) {
987  return InitError(AmountErrMsg("blockmintxfee", args.GetArg("-blockmintxfee", "")));
988  }
989  }
990 
991  nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);
992 
993  if (!g_wallet_init_interface.ParameterInteraction()) return false;
994 
995  // Option to startup with mocktime set (used for regression testing):
996  SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
997 
998  if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
999  nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
1000 
1001  if (args.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) < 0)
1002  return InitError(Untranslated("rpcserialversion must be non-negative."));
1003 
1004  if (args.GetIntArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) > 1)
1005  return InitError(Untranslated("Unknown rpcserialversion requested."));
1006 
1007  if (args.GetBoolArg("-reindex-chainstate", false)) {
1008  // indexes that must be deactivated to prevent index corruption, see #24630
1009  if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1010  return InitError(_("-reindex-chainstate option is not compatible with -coinstatsindex. Please temporarily disable coinstatsindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes."));
1011  }
1012  if (g_enabled_filter_types.count(BlockFilterType::BASIC)) {
1013  return InitError(_("-reindex-chainstate option is not compatible with -blockfilterindex. Please temporarily disable blockfilterindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes."));
1014  }
1015  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1016  return InitError(_("-reindex-chainstate option is not compatible with -txindex. Please temporarily disable txindex while using -reindex-chainstate, or replace -reindex-chainstate with -reindex to fully rebuild all indexes."));
1017  }
1018  }
1019 
1020 #if defined(USE_SYSCALL_SANDBOX)
1021  if (args.IsArgSet("-sandbox") && !args.IsArgNegated("-sandbox")) {
1022  const std::string sandbox_arg{args.GetArg("-sandbox", "")};
1023  bool log_syscall_violation_before_terminating{false};
1024  if (sandbox_arg == "log-and-abort") {
1025  log_syscall_violation_before_terminating = true;
1026  } else if (sandbox_arg == "abort") {
1027  // log_syscall_violation_before_terminating is false by default.
1028  } else {
1029  return InitError(Untranslated("Unknown syscall sandbox mode (-sandbox=<mode>). Available modes are \"log-and-abort\" and \"abort\"."));
1030  }
1031  // execve(...) is not allowed by the syscall sandbox.
1032  const std::vector<std::string> features_using_execve{
1033  "-alertnotify",
1034  "-blocknotify",
1035  "-signer",
1036  "-startupnotify",
1037  "-walletnotify",
1038  };
1039  for (const std::string& feature_using_execve : features_using_execve) {
1040  if (!args.GetArg(feature_using_execve, "").empty()) {
1041  return InitError(Untranslated(strprintf("The experimental syscall sandbox feature (-sandbox=<mode>) is incompatible with %s (which uses execve).", feature_using_execve)));
1042  }
1043  }
1044  if (!SetupSyscallSandbox(log_syscall_violation_before_terminating)) {
1045  return InitError(Untranslated("Installation of the syscall sandbox failed."));
1046  }
1047  if (use_syscall_sandbox) {
1049  }
1050  LogPrintf("Experimental syscall sandbox enabled (-sandbox=%s): bitcoind will terminate if an unexpected (not allowlisted) syscall is invoked.\n", sandbox_arg);
1051  }
1052 #endif // USE_SYSCALL_SANDBOX
1053 
1054  // Also report errors from parsing before daemonization
1055  {
1056  ChainstateManager::Options chainman_opts_dummy{
1057  .chainparams = chainparams,
1058  };
1059  if (const auto error{ApplyArgsManOptions(args, chainman_opts_dummy)}) {
1060  return InitError(*error);
1061  }
1062  }
1063 
1064  return true;
1065 }
1066 
1067 static bool LockDataDirectory(bool probeOnly)
1068 {
1069  // Make sure only a single Bitcoin process is using the data directory.
1070  const fs::path& datadir = gArgs.GetDataDirNet();
1071  if (!DirIsWritable(datadir)) {
1072  return InitError(strprintf(_("Cannot write to data directory '%s'; check permissions."), fs::PathToString(datadir)));
1073  }
1074  if (!LockDirectory(datadir, ".lock", probeOnly)) {
1075  return InitError(strprintf(_("Cannot obtain a lock on data directory %s. %s is probably already running."), fs::PathToString(datadir), PACKAGE_NAME));
1076  }
1077  return true;
1078 }
1079 
1081 {
1082  // ********************************************************* Step 4: sanity checks
1083  if (auto error = kernel::SanityChecks(kernel)) {
1084  InitError(*error);
1085  return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), PACKAGE_NAME));
1086  }
1087 
1088  // Probe the data directory lock to give an early error message, if possible
1089  // We cannot hold the data directory lock here, as the forking for daemon() hasn't yet happened,
1090  // and a fork will cause weird behavior to it.
1091  return LockDataDirectory(true);
1092 }
1093 
1095 {
1096  // After daemonization get the data directory lock again and hold on to it until exit
1097  // This creates a slight window for a race condition to happen, however this condition is harmless: it
1098  // will at most make us exit without printing a message to console.
1099  if (!LockDataDirectory(false)) {
1100  // Detailed error printed inside LockDataDirectory
1101  return false;
1102  }
1103  return true;
1104 }
1105 
1107 {
1108  node.chain = node.init->makeChain();
1109  return true;
1110 }
1111 
1113 {
1114  const ArgsManager& args = *Assert(node.args);
1115  const CChainParams& chainparams = Params();
1116 
1117  auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
1118  if (!opt_max_upload) {
1119  return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
1120  }
1121 
1122  // ********************************************************* Step 4a: application initialization
1123  if (!CreatePidFile(args)) {
1124  // Detailed error printed inside CreatePidFile().
1125  return false;
1126  }
1127  if (!init::StartLogging(args)) {
1128  // Detailed error printed inside StartLogging().
1129  return false;
1130  }
1131 
1132  LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, nFD);
1133 
1134  // Warn about relative -datadir path.
1135  if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) {
1136  LogPrintf("Warning: relative datadir option '%s' specified, which will be interpreted relative to the " /* Continued */
1137  "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1138  "from a different location, it will be unable to locate the current data files. There could "
1139  "also be data loss if bitcoin is started while in a temporary directory.\n",
1140  args.GetArg("-datadir", ""), fs::PathToString(fs::current_path()));
1141  }
1142 
1143  ValidationCacheSizes validation_cache_sizes{};
1144  ApplyArgsManOptions(args, validation_cache_sizes);
1145  if (!InitSignatureCache(validation_cache_sizes.signature_cache_bytes)
1146  || !InitScriptExecutionCache(validation_cache_sizes.script_execution_cache_bytes))
1147  {
1148  return InitError(strprintf(_("Unable to allocate memory for -maxsigcachesize: '%s' MiB"), args.GetIntArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_BYTES >> 20)));
1149  }
1150 
1151  int script_threads = args.GetIntArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
1152  if (script_threads <= 0) {
1153  // -par=0 means autodetect (number of cores - 1 script threads)
1154  // -par=-n means "leave n cores free" (number of cores - n - 1 script threads)
1155  script_threads += GetNumCores();
1156  }
1157 
1158  // Subtract 1 because the main thread counts towards the par threads
1159  script_threads = std::max(script_threads - 1, 0);
1160 
1161  // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
1162  script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
1163 
1164  LogPrintf("Script verification uses %d additional threads\n", script_threads);
1165  if (script_threads >= 1) {
1166  StartScriptCheckWorkerThreads(script_threads);
1167  }
1168 
1169  assert(!node.scheduler);
1170  node.scheduler = std::make_unique<CScheduler>();
1171 
1172  // Start the lightweight task scheduler thread
1173  node.scheduler->m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { node.scheduler->serviceQueue(); });
1174 
1175  // Gather some entropy once per minute.
1176  node.scheduler->scheduleEvery([]{
1177  RandAddPeriodic();
1178  }, std::chrono::minutes{1});
1179 
1181 
1182  // Create client interfaces for wallets that are supposed to be loaded
1183  // according to -wallet and -disablewallet options. This only constructs
1184  // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1185  // when load() and start() interface methods are called below.
1187  uiInterface.InitWallet();
1188 
1189  /* Register RPC commands regardless of -server setting so they will be
1190  * available in the GUI RPC console even if external calls are disabled.
1191  */
1193  for (const auto& client : node.chain_clients) {
1194  client->registerRpcs();
1195  }
1196 #if ENABLE_ZMQ
1198 #endif
1199 
1200  /* Start the RPC server already. It will be started in "warmup" mode
1201  * and not really process calls already (but it will signify connections
1202  * that the server is there and will be ready later). Warmup mode will
1203  * be disabled when initialisation is finished.
1204  */
1205  if (args.GetBoolArg("-server", false)) {
1206  uiInterface.InitMessage_connect(SetRPCWarmupStatus);
1207  if (!AppInitServers(node))
1208  return InitError(_("Unable to start HTTP server. See debug log for details."));
1209  }
1210 
1211  // ********************************************************* Step 5: verify wallet database integrity
1212  for (const auto& client : node.chain_clients) {
1213  if (!client->verify()) {
1214  return false;
1215  }
1216  }
1217 
1218  // ********************************************************* Step 6: network initialization
1219  // Note that we absolutely cannot open any actual connections
1220  // until the very end ("start node") as the UTXO/block state
1221  // is not yet setup and may end up being set up twice if we
1222  // need to reindex later.
1223 
1224  fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1225  fDiscover = args.GetBoolArg("-discover", true);
1226  const bool ignores_incoming_txs{args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)};
1227 
1228  {
1229 
1230  // Read asmap file if configured
1231  std::vector<bool> asmap;
1232  if (args.IsArgSet("-asmap")) {
1233  fs::path asmap_path = args.GetPathArg("-asmap", DEFAULT_ASMAP_FILENAME);
1234  if (!asmap_path.is_absolute()) {
1235  asmap_path = gArgs.GetDataDirNet() / asmap_path;
1236  }
1237  if (!fs::exists(asmap_path)) {
1238  InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1239  return false;
1240  }
1241  asmap = DecodeAsmap(asmap_path);
1242  if (asmap.size() == 0) {
1243  InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1244  return false;
1245  }
1246  const uint256 asmap_version = SerializeHash(asmap);
1247  LogPrintf("Using asmap version %s for IP bucketing\n", asmap_version.ToString());
1248  } else {
1249  LogPrintf("Using /16 prefix for IP bucketing\n");
1250  }
1251 
1252  // Initialize netgroup manager
1253  assert(!node.netgroupman);
1254  node.netgroupman = std::make_unique<NetGroupManager>(std::move(asmap));
1255 
1256  // Initialize addrman
1257  assert(!node.addrman);
1258  uiInterface.InitMessage(_("Loading P2P addresses…").translated);
1259  if (const auto error{LoadAddrman(*node.netgroupman, args, node.addrman)}) {
1260  return InitError(*error);
1261  }
1262  }
1263 
1264  assert(!node.banman);
1265  node.banman = std::make_unique<BanMan>(gArgs.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1266  assert(!node.connman);
1267  node.connman = std::make_unique<CConnman>(GetRand<uint64_t>(),
1268  GetRand<uint64_t>(),
1269  *node.addrman, *node.netgroupman, args.GetBoolArg("-networkactive", true));
1270 
1271  assert(!node.fee_estimator);
1272  // Don't initialize fee estimation with old data if we don't relay transactions,
1273  // as they would never get updated.
1274  if (!ignores_incoming_txs) node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args));
1275 
1276  // Check port numbers
1277  for (const std::string port_option : {
1278  "-port",
1279  "-rpcport",
1280  }) {
1281  if (args.IsArgSet(port_option)) {
1282  const std::string port = args.GetArg(port_option, "");
1283  uint16_t n;
1284  if (!ParseUInt16(port, &n) || n == 0) {
1285  return InitError(InvalidPortErrMsg(port_option, port));
1286  }
1287  }
1288  }
1289 
1290  for (const std::string port_option : {
1291  "-i2psam",
1292  "-onion",
1293  "-proxy",
1294  "-rpcbind",
1295  "-torcontrol",
1296  "-whitebind",
1297  "-zmqpubhashblock",
1298  "-zmqpubhashtx",
1299  "-zmqpubrawblock",
1300  "-zmqpubrawtx",
1301  "-zmqpubsequence",
1302  }) {
1303  for (const std::string& socket_addr : args.GetArgs(port_option)) {
1304  std::string host_out;
1305  uint16_t port_out{0};
1306  if (!SplitHostPort(socket_addr, port_out, host_out)) {
1307  return InitError(InvalidPortErrMsg(port_option, socket_addr));
1308  }
1309  }
1310  }
1311 
1312  for (const std::string& socket_addr : args.GetArgs("-bind")) {
1313  std::string host_out;
1314  uint16_t port_out{0};
1315  std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('='));
1316  if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
1317  return InitError(InvalidPortErrMsg("-bind", socket_addr));
1318  }
1319  }
1320 
1321  // sanitize comments per BIP-0014, format user agent and check total size
1322  std::vector<std::string> uacomments;
1323  for (const std::string& cmt : args.GetArgs("-uacomment")) {
1324  if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1325  return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1326  uacomments.push_back(cmt);
1327  }
1329  if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1330  return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1332  }
1333 
1334  if (args.IsArgSet("-onlynet")) {
1335  std::set<enum Network> nets;
1336  for (const std::string& snet : args.GetArgs("-onlynet")) {
1337  enum Network net = ParseNetwork(snet);
1338  if (net == NET_UNROUTABLE)
1339  return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1340  nets.insert(net);
1341  }
1342  for (int n = 0; n < NET_MAX; n++) {
1343  enum Network net = (enum Network)n;
1344  assert(IsReachable(net));
1345  if (!nets.count(net))
1346  SetReachable(net, false);
1347  }
1348  }
1349 
1350  if (!args.IsArgSet("-cjdnsreachable")) {
1351  if (args.IsArgSet("-onlynet") && IsReachable(NET_CJDNS)) {
1352  return InitError(
1353  _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1354  "-cjdnsreachable is not provided"));
1355  }
1356  SetReachable(NET_CJDNS, false);
1357  }
1358  // Now IsReachable(NET_CJDNS) is true if:
1359  // 1. -cjdnsreachable is given and
1360  // 2.1. -onlynet is not given or
1361  // 2.2. -onlynet=cjdns is given
1362 
1363  // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit:
1364  // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip
1365  // the DNS seeds by adjusting -dnsseed in InitParameterInteraction.
1366  if (args.GetBoolArg("-dnsseed") == true && !IsReachable(NET_IPV4) && !IsReachable(NET_IPV6)) {
1367  return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1368  };
1369 
1370  // Check for host lookup allowed before parsing any network related parameters
1372 
1373  Proxy onion_proxy;
1374 
1375  bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1376  // -proxy sets a proxy for all outgoing network traffic
1377  // -noproxy (or -proxy=0) as well as the empty string can be used to not set a proxy, this is the default
1378  std::string proxyArg = args.GetArg("-proxy", "");
1379  if (proxyArg != "" && proxyArg != "0") {
1380  CService proxyAddr;
1381  if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
1382  return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg));
1383  }
1384 
1385  Proxy addrProxy = Proxy(proxyAddr, proxyRandomize);
1386  if (!addrProxy.IsValid())
1387  return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg));
1388 
1389  SetProxy(NET_IPV4, addrProxy);
1390  SetProxy(NET_IPV6, addrProxy);
1391  SetProxy(NET_CJDNS, addrProxy);
1392  SetNameProxy(addrProxy);
1393  onion_proxy = addrProxy;
1394  }
1395 
1396  const bool onlynet_used_with_onion{args.IsArgSet("-onlynet") && IsReachable(NET_ONION)};
1397 
1398  // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1399  // -noonion (or -onion=0) disables connecting to .onion entirely
1400  // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1401  std::string onionArg = args.GetArg("-onion", "");
1402  if (onionArg != "") {
1403  if (onionArg == "0") { // Handle -noonion/-onion=0
1404  onion_proxy = Proxy{};
1405  if (onlynet_used_with_onion) {
1406  return InitError(
1407  _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1408  "reaching the Tor network is explicitly forbidden: -onion=0"));
1409  }
1410  } else {
1411  CService addr;
1412  if (!Lookup(onionArg, addr, 9050, fNameLookup) || !addr.IsValid()) {
1413  return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1414  }
1415  onion_proxy = Proxy{addr, proxyRandomize};
1416  }
1417  }
1418 
1419  if (onion_proxy.IsValid()) {
1420  SetProxy(NET_ONION, onion_proxy);
1421  } else {
1422  // If -listenonion is set, then we will (try to) connect to the Tor control port
1423  // later from the torcontrol thread and may retrieve the onion proxy from there.
1424  const bool listenonion_disabled{!args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
1425  if (onlynet_used_with_onion && listenonion_disabled) {
1426  return InitError(
1427  _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1428  "reaching the Tor network is not provided: none of -proxy, -onion or "
1429  "-listenonion is given"));
1430  }
1431  SetReachable(NET_ONION, false);
1432  }
1433 
1434  for (const std::string& strAddr : args.GetArgs("-externalip")) {
1435  CService addrLocal;
1436  if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) && addrLocal.IsValid())
1437  AddLocal(addrLocal, LOCAL_MANUAL);
1438  else
1439  return InitError(ResolveErrMsg("externalip", strAddr));
1440  }
1441 
1442 #if ENABLE_ZMQ
1444 
1447  }
1448 #endif
1449 
1450  // ********************************************************* Step 7: load block chain
1451 
1452  fReindex = args.GetBoolArg("-reindex", false);
1453  bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
1454  ChainstateManager::Options chainman_opts{
1455  .chainparams = chainparams,
1456  .adjusted_time_callback = GetAdjustedTime,
1457  };
1458  Assert(!ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1459 
1460  // cache size calculations
1461  CacheSizes cache_sizes = CalculateCacheSizes(args, g_enabled_filter_types.size());
1462 
1463  LogPrintf("Cache configuration:\n");
1464  LogPrintf("* Using %.1f MiB for block index database\n", cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
1465  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1466  LogPrintf("* Using %.1f MiB for transaction index database\n", cache_sizes.tx_index * (1.0 / 1024 / 1024));
1467  }
1468  for (BlockFilterType filter_type : g_enabled_filter_types) {
1469  LogPrintf("* Using %.1f MiB for %s block filter index database\n",
1470  cache_sizes.filter_index * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type));
1471  }
1472  LogPrintf("* Using %.1f MiB for chain state database\n", cache_sizes.coins_db * (1.0 / 1024 / 1024));
1473 
1474  assert(!node.mempool);
1475  assert(!node.chainman);
1476 
1477  CTxMemPool::Options mempool_opts{
1478  .estimator = node.fee_estimator.get(),
1479  .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
1480  };
1481  if (const auto err{ApplyArgsManOptions(args, chainparams, mempool_opts)}) {
1482  return InitError(*err);
1483  }
1484  mempool_opts.check_ratio = std::clamp<int>(mempool_opts.check_ratio, 0, 1'000'000);
1485 
1486  int64_t descendant_limit_bytes = mempool_opts.limits.descendant_size_vbytes * 40;
1487  if (mempool_opts.max_size_bytes < 0 || mempool_opts.max_size_bytes < descendant_limit_bytes) {
1488  return InitError(strprintf(_("-maxmempool must be at least %d MB"), std::ceil(descendant_limit_bytes / 1'000'000.0)));
1489  }
1490  LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)\n", cache_sizes.coins * (1.0 / 1024 / 1024), mempool_opts.max_size_bytes * (1.0 / 1024 / 1024));
1491 
1492  for (bool fLoaded = false; !fLoaded && !ShutdownRequested();) {
1493  node.mempool = std::make_unique<CTxMemPool>(mempool_opts);
1494 
1495  node.chainman = std::make_unique<ChainstateManager>(chainman_opts);
1496  ChainstateManager& chainman = *node.chainman;
1497 
1499  options.mempool = Assert(node.mempool.get());
1500  options.reindex = node::fReindex;
1501  options.reindex_chainstate = fReindexChainState;
1502  options.prune = chainman.m_blockman.IsPruneMode();
1503  options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
1504  options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
1506  options.coins_error_cb = [] {
1507  uiInterface.ThreadSafeMessageBox(
1508  _("Error reading from database, shutting down."),
1510  };
1511 
1512  uiInterface.InitMessage(_("Loading block index…").translated);
1513  const auto load_block_index_start_time{SteadyClock::now()};
1514  auto catch_exceptions = [](auto&& f) {
1515  try {
1516  return f();
1517  } catch (const std::exception& e) {
1518  LogPrintf("%s\n", e.what());
1519  return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error opening block database"));
1520  }
1521  };
1522  auto [status, error] = catch_exceptions([&]{ return LoadChainstate(chainman, cache_sizes, options); });
1523  if (status == node::ChainstateLoadStatus::SUCCESS) {
1524  uiInterface.InitMessage(_("Verifying blocks…").translated);
1525  if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) {
1526  LogPrintfCategory(BCLog::PRUNE, "pruned datadir may not have more than %d blocks; only checking available blocks\n",
1528  }
1529  std::tie(status, error) = catch_exceptions([&]{ return VerifyLoadedChainstate(chainman, options);});
1530  if (status == node::ChainstateLoadStatus::SUCCESS) {
1531  fLoaded = true;
1532  LogPrintf(" block index %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - load_block_index_start_time));
1533  }
1534  }
1535 
1537  return InitError(error);
1538  }
1539 
1540  if (!fLoaded && !ShutdownRequested()) {
1541  // first suggest a reindex
1542  if (!options.reindex) {
1543  bool fRet = uiInterface.ThreadSafeQuestion(
1544  error + Untranslated(".\n\n") + _("Do you want to rebuild the block database now?"),
1545  error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1547  if (fRet) {
1548  fReindex = true;
1549  AbortShutdown();
1550  } else {
1551  LogPrintf("Aborted block database rebuild. Exiting.\n");
1552  return false;
1553  }
1554  } else {
1555  return InitError(error);
1556  }
1557  }
1558  }
1559 
1560  // As LoadBlockIndex can take several minutes, it's possible the user
1561  // requested to kill the GUI during the last operation. If so, exit.
1562  // As the program has not fully started yet, Shutdown() is possibly overkill.
1563  if (ShutdownRequested()) {
1564  LogPrintf("Shutdown requested. Exiting.\n");
1565  return false;
1566  }
1567 
1568  ChainstateManager& chainman = *Assert(node.chainman);
1569 
1570  assert(!node.peerman);
1571  node.peerman = PeerManager::make(*node.connman, *node.addrman, node.banman.get(),
1572  chainman, *node.mempool, ignores_incoming_txs);
1573  RegisterValidationInterface(node.peerman.get());
1574 
1575  // ********************************************************* Step 8: start indexers
1576  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1577  if (const auto error{WITH_LOCK(cs_main, return CheckLegacyTxindex(*Assert(chainman.m_blockman.m_block_tree_db)))}) {
1578  return InitError(*error);
1579  }
1580 
1581  g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), cache_sizes.tx_index, false, fReindex);
1582  if (!g_txindex->Start()) {
1583  return false;
1584  }
1585  }
1586 
1587  for (const auto& filter_type : g_enabled_filter_types) {
1588  InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, cache_sizes.filter_index, false, fReindex);
1589  if (!GetBlockFilterIndex(filter_type)->Start()) {
1590  return false;
1591  }
1592  }
1593 
1594  if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1595  g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, fReindex);
1596  if (!g_coin_stats_index->Start()) {
1597  return false;
1598  }
1599  }
1600 
1601  // ********************************************************* Step 9: load wallet
1602  for (const auto& client : node.chain_clients) {
1603  if (!client->load()) {
1604  return false;
1605  }
1606  }
1607 
1608  // ********************************************************* Step 10: data directory maintenance
1609 
1610  // if pruning, perform the initial blockstore prune
1611  // after any wallet rescanning has taken place.
1612  if (chainman.m_blockman.IsPruneMode()) {
1613  if (!fReindex) {
1614  LOCK(cs_main);
1615  for (Chainstate* chainstate : chainman.GetAll()) {
1616  uiInterface.InitMessage(_("Pruning blockstore…").translated);
1617  chainstate->PruneAndFlush();
1618  }
1619  }
1620  } else {
1621  LogPrintf("Setting NODE_NETWORK on non-prune mode\n");
1622  nLocalServices = ServiceFlags(nLocalServices | NODE_NETWORK);
1623  }
1624 
1625  // ********************************************************* Step 11: import blocks
1626 
1628  InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(gArgs.GetDataDirNet()))));
1629  return false;
1630  }
1632  InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(gArgs.GetBlocksDirPath()))));
1633  return false;
1634  }
1635 
1636  int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height());
1637 
1638  // On first startup, warn on low block storage space
1639  if (!fReindex && !fReindexChainState && chain_active_height <= 1) {
1640  uint64_t additional_bytes_needed{
1641  chainman.m_blockman.IsPruneMode() ?
1642  chainman.m_blockman.GetPruneTarget() :
1643  chainparams.AssumedBlockchainSize() * 1024 * 1024 * 1024};
1644 
1645  if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) {
1647  "Disk space for %s may not accommodate the block files. " \
1648  "Approximately %u GB of data will be stored in this directory."
1649  ),
1651  chainparams.AssumedBlockchainSize()
1652  ));
1653  }
1654  }
1655 
1656  // Either install a handler to notify us when genesis activates, or set fHaveGenesis directly.
1657  // No locking, as this happens before any background thread is started.
1658  boost::signals2::connection block_notify_genesis_wait_connection;
1659  if (WITH_LOCK(chainman.GetMutex(), return chainman.ActiveChain().Tip() == nullptr)) {
1660  block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
1661  } else {
1662  fHaveGenesis = true;
1663  }
1664 
1665 #if HAVE_SYSTEM
1666  const std::string block_notify = args.GetArg("-blocknotify", "");
1667  if (!block_notify.empty()) {
1668  uiInterface.NotifyBlockTip_connect([block_notify](SynchronizationState sync_state, const CBlockIndex* pBlockIndex) {
1669  if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) return;
1670  std::string command = block_notify;
1671  ReplaceAll(command, "%s", pBlockIndex->GetBlockHash().GetHex());
1672  std::thread t(runCommand, command);
1673  t.detach(); // thread runs free
1674  });
1675  }
1676 #endif
1677 
1678  std::vector<fs::path> vImportFiles;
1679  for (const std::string& strFile : args.GetArgs("-loadblock")) {
1680  vImportFiles.push_back(fs::PathFromString(strFile));
1681  }
1682 
1683  chainman.m_load_block = std::thread(&util::TraceThread, "loadblk", [=, &chainman, &args] {
1684  ThreadImport(chainman, vImportFiles, args, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{});
1685  });
1686 
1687  // Wait for genesis block to be processed
1688  {
1690  // We previously could hang here if StartShutdown() is called prior to
1691  // ThreadImport getting started, so instead we just wait on a timer to
1692  // check ShutdownRequested() regularly.
1693  while (!fHaveGenesis && !ShutdownRequested()) {
1694  g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
1695  }
1696  block_notify_genesis_wait_connection.disconnect();
1697  }
1698 
1699  if (ShutdownRequested()) {
1700  return false;
1701  }
1702 
1703  // ********************************************************* Step 12: start node
1704 
1706  {
1707  LOCK(cs_main);
1708  LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
1709  chain_active_height = chainman.ActiveChain().Height();
1710  if (tip_info) {
1711  tip_info->block_height = chain_active_height;
1712  tip_info->block_time = chainman.ActiveChain().Tip() ? chainman.ActiveChain().Tip()->GetBlockTime() : chainman.GetParams().GenesisBlock().GetBlockTime();
1713  tip_info->verification_progress = GuessVerificationProgress(chainman.GetParams().TxData(), chainman.ActiveChain().Tip());
1714  }
1715  if (tip_info && chainman.m_best_header) {
1716  tip_info->header_height = chainman.m_best_header->nHeight;
1717  tip_info->header_time = chainman.m_best_header->GetBlockTime();
1718  }
1719  }
1720  LogPrintf("nBestHeight = %d\n", chain_active_height);
1721  if (node.peerman) node.peerman->SetBestHeight(chain_active_height);
1722 
1723  // Map ports with UPnP or NAT-PMP.
1725 
1726  CConnman::Options connOptions;
1727  connOptions.nLocalServices = nLocalServices;
1728  connOptions.nMaxConnections = nMaxConnections;
1731  connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
1732  connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
1733  connOptions.uiInterface = &uiInterface;
1734  connOptions.m_banman = node.banman.get();
1735  connOptions.m_msgproc = node.peerman.get();
1736  connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
1737  connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
1738  connOptions.m_added_nodes = args.GetArgs("-addnode");
1739  connOptions.nMaxOutboundLimit = *opt_max_upload;
1740  connOptions.m_peer_connect_timeout = peer_connect_timeout;
1741 
1742  // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
1743  const uint16_t default_bind_port =
1744  static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));
1745 
1746  const auto BadPortWarning = [](const char* prefix, uint16_t port) {
1747  return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and "
1748  "thus it is unlikely that any peer will connect to it. See "
1749  "doc/p2p-bad-ports.md for details and a full list."),
1750  prefix,
1751  port);
1752  };
1753 
1754  for (const std::string& bind_arg : args.GetArgs("-bind")) {
1755  CService bind_addr;
1756  const size_t index = bind_arg.rfind('=');
1757  if (index == std::string::npos) {
1758  if (Lookup(bind_arg, bind_addr, default_bind_port, /*fAllowLookup=*/false)) {
1759  connOptions.vBinds.push_back(bind_addr);
1760  if (IsBadPort(bind_addr.GetPort())) {
1761  InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
1762  }
1763  continue;
1764  }
1765  } else {
1766  const std::string network_type = bind_arg.substr(index + 1);
1767  if (network_type == "onion") {
1768  const std::string truncated_bind_arg = bind_arg.substr(0, index);
1769  if (Lookup(truncated_bind_arg, bind_addr, BaseParams().OnionServiceTargetPort(), false)) {
1770  connOptions.onion_binds.push_back(bind_addr);
1771  continue;
1772  }
1773  }
1774  }
1775  return InitError(ResolveErrMsg("bind", bind_arg));
1776  }
1777 
1778  for (const std::string& strBind : args.GetArgs("-whitebind")) {
1779  NetWhitebindPermissions whitebind;
1781  if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
1782  connOptions.vWhiteBinds.push_back(whitebind);
1783  }
1784 
1785  // If the user did not specify -bind= or -whitebind= then we bind
1786  // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
1787  connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
1788 
1789  // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not
1790  // given, because if they are, then -port= is ignored.
1791  if (connOptions.bind_on_any && args.IsArgSet("-port")) {
1792  const uint16_t port_arg = args.GetIntArg("-port", 0);
1793  if (IsBadPort(port_arg)) {
1794  InitWarning(BadPortWarning("-port", port_arg));
1795  }
1796  }
1797 
1798  CService onion_service_target;
1799  if (!connOptions.onion_binds.empty()) {
1800  onion_service_target = connOptions.onion_binds.front();
1801  } else {
1802  onion_service_target = DefaultOnionServiceTarget();
1803  connOptions.onion_binds.push_back(onion_service_target);
1804  }
1805 
1806  if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
1807  if (connOptions.onion_binds.size() > 1) {
1808  InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
1809  "for the automatically created Tor onion service."),
1810  onion_service_target.ToStringIPPort()));
1811  }
1812  StartTorControl(onion_service_target);
1813  }
1814 
1815  if (connOptions.bind_on_any) {
1816  // Only add all IP addresses of the machine if we would be listening on
1817  // any address - 0.0.0.0 (IPv4) and :: (IPv6).
1818  Discover();
1819  }
1820 
1821  for (const auto& net : args.GetArgs("-whitelist")) {
1822  NetWhitelistPermissions subnet;
1824  if (!NetWhitelistPermissions::TryParse(net, subnet, error)) return InitError(error);
1825  connOptions.vWhitelistedRange.push_back(subnet);
1826  }
1827 
1828  connOptions.vSeedNodes = args.GetArgs("-seednode");
1829 
1830  // Initiate outbound connections unless connect=0
1831  connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
1832  if (!connOptions.m_use_addrman_outgoing) {
1833  const auto connect = args.GetArgs("-connect");
1834  if (connect.size() != 1 || connect[0] != "0") {
1835  connOptions.m_specified_outgoing = connect;
1836  }
1837  }
1838 
1839  const std::string& i2psam_arg = args.GetArg("-i2psam", "");
1840  if (!i2psam_arg.empty()) {
1841  CService addr;
1842  if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) || !addr.IsValid()) {
1843  return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
1844  }
1845  SetProxy(NET_I2P, Proxy{addr});
1846  } else {
1847  if (args.IsArgSet("-onlynet") && IsReachable(NET_I2P)) {
1848  return InitError(
1849  _("Outbound connections restricted to i2p (-onlynet=i2p) but "
1850  "-i2psam is not provided"));
1851  }
1852  SetReachable(NET_I2P, false);
1853  }
1854 
1855  connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING);
1856 
1857  if (!node.connman->Start(*node.scheduler, connOptions)) {
1858  return false;
1859  }
1860 
1861  // ********************************************************* Step 13: finished
1862 
1863  // At this point, the RPC is "started", but still in warmup, which means it
1864  // cannot yet be called. Before we make it callable, we need to make sure
1865  // that the RPC's view of the best block is valid and consistent with
1866  // ChainstateManager's active tip.
1867  //
1868  // If we do not do this, RPC's view of the best block will be height=0 and
1869  // hash=0x0. This will lead to erroroneous responses for things like
1870  // waitforblockheight.
1871  RPCNotifyBlockChange(WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()));
1873 
1874  uiInterface.InitMessage(_("Done loading").translated);
1875 
1876  for (const auto& client : node.chain_clients) {
1877  client->start(*node.scheduler);
1878  }
1879 
1880  BanMan* banman = node.banman.get();
1881  node.scheduler->scheduleEvery([banman]{
1882  banman->DumpBanlist();
1883  }, DUMP_BANS_INTERVAL);
1884 
1885  if (node.peerman) node.peerman->StartScheduledTasks(*node.scheduler);
1886 
1887 #if HAVE_SYSTEM
1888  StartupNotify(args);
1889 #endif
1890 
1891  return true;
1892 }
std::optional< bilingual_str > LoadAddrman(const NetGroupManager &netgroupman, const ArgsManager &args, std::unique_ptr< AddrMan > &addrman)
Returns an error string on failure.
Definition: addrdb.cpp:184
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
Definition: addrman.h:30
static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME
Definition: banman.h:19
static constexpr std::chrono::minutes DUMP_BANS_INTERVAL
How often to dump banned addresses/subnets to disk.
Definition: banman.h:22
#define PACKAGE_NAME
const auto cmd
const auto command
void RPCNotifyBlockChange(const CBlockIndex *pindex)
Callback for when block tip changed.
Definition: blockchain.cpp:245
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:90
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
void ForEachBlockFilterIndex(std::function< void(BlockFilterIndex &)> fn)
Iterate over all running block filter indexes, invoking fn on each.
bool InitBlockFilterIndex(std::function< std::unique_ptr< interfaces::Chain >()> make_chain, BlockFilterType filter_type, size_t n_cache_size, bool f_memory, bool f_wipe)
Initialize a block filter index for the given type if one does not already exist.
static const char *const DEFAULT_BLOCKFILTERINDEX
std::unique_ptr< const CChainParams > CreateChainParams(const ArgsManager &args, const std::string &chain)
Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
const CChainParams & Params()
Return the currently selected parameters.
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:73
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:245
const fs::path & GetBlocksDirPath() const
Get blocks directory path.
Definition: system.cpp:390
bool IsArgNegated(const std::string &strArg) const
Return true if the argument was originally passed as a negated option, i.e.
Definition: system.cpp:586
std::list< SectionInfo > GetUnrecognizedSections() const
Log warnings for unrecognized section names in the config file.
Definition: system.cpp:265
@ NETWORK_ONLY
Definition: system.h:186
@ ALLOW_ANY
disable validation
Definition: system.h:172
@ DISALLOW_ELISION
disallow -foo syntax that doesn't assign any value
Definition: system.h:178
@ DEBUG_ONLY
Definition: system.h:180
@ SENSITIVE
Definition: system.h:188
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: system.cpp:478
bool SoftSetArg(const std::string &strArg, const std::string &strValue)
Set an argument if it doesn't already have a value.
Definition: system.cpp:664
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: system.cpp:487
const fs::path & GetDataDirNet() const
Get data directory path with appended network identifier.
Definition: system.h:295
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
Definition: system.cpp:616
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:591
bool SoftSetBoolArg(const std::string &strArg, bool fValue)
Set a boolean argument if it doesn't already have a value.
Definition: system.cpp:672
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:641
void AddHiddenArgs(const std::vector< std::string > &args)
Add many hidden arguments.
Definition: system.cpp:719
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
Definition: system.cpp:698
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const
Return path argument or default value.
Definition: system.cpp:380
std::string GetChainName() const
Returns the appropriate chain name from the program arguments.
Definition: system.cpp:1060
std::atomic< bool > m_reopen_file
Definition: logging.h:124
Definition: banman.h:59
void DumpBanlist()
Definition: banman.cpp:47
void Stop()
Stops the instance from staying in sync with blockchain updates.
Definition: base.cpp:400
bool Start()
Start initializes the sync state and registers the instance as a ValidationInterface so that it stays...
Definition: base.cpp:381
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 SIGNET
static const std::string MAIN
Chain name strings.
int64_t GetBlockTime() const
Definition: block.h:61
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:151
uint256 GetBlockHash() const
Definition: chain.h:259
int64_t GetBlockTime() const
Definition: chain.h:279
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:163
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:452
int Height() const
Return the maximal height in the chain.
Definition: chain.h:481
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:70
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
Definition: chainparams.h:97
const ChainTxData & TxData() const
Definition: chainparams.h:124
const CMessageHeader::MessageStartChars & MessageStart() const
Definition: chainparams.h:83
uint64_t AssumedBlockchainSize() const
Minimum free space (in GB) needed for data directory.
Definition: chainparams.h:106
const CBlock & GenesisBlock() const
Definition: chainparams.h:95
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:445
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:523
std::string ToStringIPPort() const
Definition: netaddress.cpp:924
uint16_t GetPort() const
Definition: netaddress.cpp:851
static const int DEFAULT_ZMQ_SNDHWM
static CZMQNotificationInterface * Create()
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:441
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:802
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:961
const CChainParams & GetParams() const
Definition: validation.h:877
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:965
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:894
CBlockIndex * m_best_header
Best header we've seen so far (used for getheaders queries' starting points).
Definition: validation.h:924
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:963
std::thread m_load_block
Definition: validation.h:897
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:941
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:900
Different type to mark Mutex at global scope.
Definition: sync.h:141
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)
Definition: netbase.h:49
bool IsValid() const
Definition: netbase.h:54
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.
std::string ToString() const
Definition: uint256.cpp:64
std::string GetHex() const
Definition: uint256.cpp:20
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:31
const CBlockIndex *GetFirstStoredBlock(const CBlockIndex &start_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(bool m_have_pruned
Find the first block that is not pruned.
Definition: blockstorage.h:197
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
Definition: blockstorage.h:180
bool IsPruneMode() const
Whether running in -prune mode.
Definition: blockstorage.h:177
256-bit opaque blob.
Definition: uint256.h:119
std::string FormatSubVersion(const std::string &name, int nClientVersion, const std::vector< std::string > &comments)
Format the subversion field according to BIP 14 spec (https://github.com/bitcoin/bips/blob/master/bip...
static const int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
Definition: clientversion.h:33
const std::string CLIENT_NAME
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
static constexpr bool DEFAULT_COINSTATSINDEX
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:7
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
Definition: error.cpp:62
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
Definition: error.cpp:47
bilingual_str InvalidPortErrMsg(const std::string &optname, const std::string &invalid_value)
Definition: error.cpp:52
const std::string CURRENCY_UNIT
Definition: feerate.h:17
fs::path FeeestPath(const ArgsManager &argsman)
Definition: fees_args.cpp:13
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:263
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
Definition: httprpc.cpp:312
void StopHTTPRPC()
Stop HTTP RPC subsystem.
Definition: httprpc.cpp:317
bool StartHTTPRPC(const std::any &context)
Start HTTP RPC subsystem.
Definition: httprpc.cpp:294
void StartREST(const std::any &context)
Start HTTP REST subsystem.
Definition: rest.cpp:991
void StopREST()
Stop HTTP REST subsystem.
Definition: rest.cpp:1003
void InterruptREST()
Interrupt RPC REST subsystem.
Definition: rest.cpp:999
void InterruptHTTPServer()
Interrupt HTTP server threads.
Definition: httpserver.cpp:433
void StartHTTPServer()
Start HTTP server.
Definition: httpserver.cpp:421
bool InitHTTPServer()
Initialize HTTP server.
Definition: httpserver.cpp:363
void StopHTTPServer()
Stop HTTP server.
Definition: httpserver.cpp:445
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:154
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:207
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:771
static bool AppInitServers(NodeContext &node)
Definition: init.cpp:662
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
Definition: init.cpp:1094
void SetupServerArgs(ArgsManager &argsman)
Register all arguments with the ArgsManager.
Definition: init.cpp:403
#define MIN_CORE_FILEDESCRIPTORS
Definition: init.cpp:139
static bool fHaveGenesis
Definition: init.cpp:636
void Shutdown(NodeContext &node)
Definition: init.cpp:229
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
Definition: init.cpp:360
static GlobalMutex g_genesis_wait_mutex
Definition: init.cpp:637
static void OnRPCStarted()
Definition: init.cpp:390
static void HandleSIGHUP(int)
Definition: init.cpp:365
static fs::path GetPidFile(const ArgsManager &args)
Definition: init.cpp:149
static std::condition_variable g_genesis_wait_cv
Definition: init.cpp:638
static constexpr bool DEFAULT_PROXYRANDOMIZE
Definition: init.cpp:129
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin core: Basic context setup.
Definition: init.cpp:801
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1106
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:679
static constexpr bool DEFAULT_REST_ENABLE
Definition: init.cpp:130
static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex)
Definition: init.cpp:640
static void OnRPCStopped()
Definition: init.cpp:395
static bool LockDataDirectory(bool probeOnly)
Definition: init.cpp:1067
static void registerSignalHandler(int signal, void(*handler)(int))
Definition: init.cpp:379
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
Definition: init.cpp:1112
static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING
Definition: init.cpp:131
static boost::signals2::connection rpc_notify_block_change_connection
Definition: init.cpp:389
static void new_handler_terminate()
Definition: init.cpp:788
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
Definition: init.cpp:1080
bool AppInitParameterInteraction(const ArgsManager &args, bool use_syscall_sandbox)
Initialization: parameter interaction.
Definition: init.cpp:846
static constexpr bool DEFAULT_DAEMON
Default value for -daemon option.
Definition: init.h:14
static constexpr bool DEFAULT_DAEMONWAIT
Default value for -daemonwait option.
Definition: init.h:16
CClientUIInterface uiInterface
void InitWarning(const bilingual_str &str)
Show warning message.
bool InitError(const bilingual_str &str)
Show error message.
BCLog::Logger & LogInstance()
Definition: logging.cpp:20
#define LogPrint(category,...)
Definition: logging.h:245
#define LogPrintfCategory(category,...)
Definition: logging.h:239
#define LogPrintf(...)
Definition: logging.h:236
void StartMapPort(bool use_upnp, bool use_natpmp)
Definition: mapport.cpp:327
void StopMapPort()
Definition: mapport.cpp:335
void InterruptMapPort()
Definition: mapport.cpp:331
static constexpr bool DEFAULT_NATPMP
Definition: mapport.h:10
static constexpr bool DEFAULT_UPNP
Definition: mapport.h:8
static constexpr unsigned int DEFAULT_MAX_MEMPOOL_SIZE_MB
Default for -maxmempool, maximum megabytes of mempool memory usage.
static constexpr bool DEFAULT_MEMPOOL_FULL_RBF
Default for -mempoolfullrbf, if the transaction replaceability signaling is ignored.
static constexpr unsigned int DEFAULT_MEMPOOL_EXPIRY_HOURS
Default for -mempoolexpiry, expiration time for mempool transactions in hours.
static constexpr unsigned int DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB
Default for -maxmempool when blocksonly is set.
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:16
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
Definition: moneystr.cpp:42
@ RPC
Definition: logging.h:47
@ PRUNE
Definition: logging.h:54
void OnStarted(std::function< void()> slot)
Definition: server.cpp:70
void OnStopped(std::function< void()> slot)
Definition: server.cpp:75
static auto quoted(const std::string &s)
Definition: fs.h:94
static bool exists(const path &p)
Definition: fs.h:88
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition: fs.h:150
static path PathFromString(const std::string &string)
Convert byte string to path object.
Definition: fs.h:173
std::string get_filesystem_error_message(const fs::filesystem_error &e)
Definition: fs.cpp:138
void AddLoggingArgs(ArgsManager &argsman)
Definition: common.cpp:24
void SetLoggingCategories(const ArgsManager &args)
Definition: common.cpp:80
bool StartLogging(const ArgsManager &args)
Definition: common.cpp:104
void SetLoggingLevel(const ArgsManager &args)
Definition: common.cpp:60
void SetLoggingOptions(const ArgsManager &args)
Definition: common.cpp:45
void LogPackageVersion()
Definition: common.cpp:141
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
Definition: interfaces.cpp:797
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
std::optional< bilingual_str > SanityChecks(const Context &)
Ensure a usable environment with all necessary library support.
Definition: checks.cpp:16
Definition: init.h:25
bool fPruneMode
static const bool DEFAULT_PRINTPRIORITY
Definition: miner.h:28
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
Definition: caches.cpp:12
fs::path MempoolPath(const ArgsManager &argsman)
uint64_t nPruneTarget
bool ShouldPersistMempool(const ArgsManager &argsman)
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
Definition: blockstorage.h:37
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
This sequence can have 4 types of outcomes:
Definition: chainstate.cpp:31
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:173
std::optional< bilingual_str > ApplyArgsManOptions(const ArgsManager &args, ChainstateManager::Options &opts)
static constexpr bool DEFAULT_PERSIST_MEMPOOL
Default for -persistmempool, indicating whether the node should attempt to automatically load the mem...
void ThreadImport(ChainstateManager &chainman, std::vector< fs::path > vImportFiles, const ArgsManager &args, const fs::path &mempool_path)
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:1060
void TraceThread(std::string_view thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
Definition: thread.cpp:16
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:59
uint16_t GetListenPort()
Definition: net.cpp:128
bool fDiscover
Definition: net.cpp:115
bool AddLocal(const CService &addr_, int nScore)
Definition: net.cpp:285
bool fListen
Definition: net.cpp:116
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:120
void SetReachable(enum Network net, bool reachable)
Mark a network as reachable or unreachable (no automatic connects to it)
Definition: net.cpp:325
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:2154
bool IsReachable(enum Network net)
Definition: net.cpp:333
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:77
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:65
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:69
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:91
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:85
static constexpr bool DEFAULT_FIXEDSEEDS
Definition: net.h:89
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:81
static const bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
Definition: net.h:54
static const bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
Definition: net.h:52
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:90
static const std::string DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:79
static constexpr bool DEFAULT_FORCEDNSSEED
Definition: net.h:87
static constexpr bool DEFAULT_DNSSEED
Definition: net.h:88
static const int MAX_FEELER_CONNECTIONS
Maximum number of feeler connections.
Definition: net.h:73
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:75
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:83
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
Definition: net.h:67
@ LOCAL_MANUAL
Definition: net.h:142
static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS
Maximum number of block-relay-only outgoing connections.
Definition: net.h:71
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
static const bool DEFAULT_PEERBLOOMFILTERS
Network
A network type.
Definition: netaddress.h:44
@ NET_I2P
I2P.
Definition: netaddress.h:58
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:61
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:68
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:55
@ NET_IPV6
IPv6.
Definition: netaddress.h:52
@ NET_IPV4
IPv4.
Definition: netaddress.h:49
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:46
bool SetNameProxy(const Proxy &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
Definition: netbase.cpp:631
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:87
bool SetProxy(enum Network net, const Proxy &addrProxy)
Definition: netbase.cpp:613
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:198
bool fNameLookup
Definition: netbase.cpp:37
int nConnectTimeout
Definition: netbase.cpp:36
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:121
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:724
static const int DEFAULT_NAME_LOOKUP
-dns default
Definition: netbase.h:30
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
Definition: netbase.h:28
ArgsManager args
unsigned int nBytesPerSigOp
Definition: settings.cpp:10
static constexpr unsigned int DEFAULT_BLOCK_MIN_TX_FEE
Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by min...
Definition: policy.h:25
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or rep...
Definition: policy.h:35
static constexpr unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT_KVB
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
Definition: policy.h:61
static constexpr bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
Definition: policy.h:39
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
Definition: policy.h:55
static constexpr unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
Definition: policy.h:63
static constexpr unsigned int DEFAULT_BYTES_PER_SIGOP
Default for -bytespersigop.
Definition: policy.h:37
static constexpr unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT_KVB
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
Definition: policy.h:65
static constexpr unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create.
Definition: policy.h:23
static constexpr unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
Definition: policy.h:59
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: policy.h:57
ServiceFlags
nServices flags
Definition: protocol.h:273
@ NODE_WITNESS
Definition: protocol.h:286
@ NODE_NETWORK_LIMITED
Definition: protocol.h:293
@ NODE_BLOOM
Definition: protocol.h:283
@ NODE_NETWORK
Definition: protocol.h:279
@ NODE_COMPACT_FILTERS
Definition: protocol.h:289
void RandAddPeriodic() noexcept
Gather entropy from various expensive sources, and feed them to the PRNG state.
Definition: random.cpp:582
static void RegisterAllCoreRPCCommands(CRPCTable &t)
Definition: register.h:24
const char * prefix
Definition: rest.cpp:974
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:975
const char * name
Definition: rest.cpp:46
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:21
static constexpr bool DEFAULT_RPC_DOC_CHECK
Definition: util.h:24
void SetRPCWarmupFinished()
Definition: server.cpp:334
void StartRPC()
Definition: server.cpp:287
void StopRPC()
Definition: server.cpp:305
void InterruptRPC()
Definition: server.cpp:294
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:328
CRPCTable tableRPC
Definition: server.cpp:572
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:323
static const unsigned int DEFAULT_RPC_SERIALIZE_VERSION
Definition: server.h:19
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
Definition: shutdown.cpp:89
bool InitShutdownState()
Initialize shutdown state.
Definition: shutdown.cpp:47
void StartShutdown()
Request shutdown of the application.
Definition: shutdown.cpp:58
void AbortShutdown()
Clear shutdown flag.
Definition: shutdown.cpp:79
bool InitSignatureCache(size_t max_size_bytes)
Definition: sigcache.cpp:96
static constexpr size_t DEFAULT_MAX_SIG_CACHE_BYTES
Definition: sigcache.h:19
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for -datacarriersize.
Definition: standard.h:39
static const bool DEFAULT_ACCEPT_DATACARRIER
Definition: standard.h:19
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
Definition: strencodings.h:30
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:109
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
Definition: string.h:68
int m_max_outbound_block_relay
Definition: net.h:674
unsigned int nReceiveFloodSize
Definition: net.h:681
int m_max_outbound_full_relay
Definition: net.h:673
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:686
uint64_t nMaxOutboundLimit
Definition: net.h:682
std::vector< NetWhitelistPermissions > vWhitelistedRange
Definition: net.h:685
CClientUIInterface * uiInterface
Definition: net.h:677
std::vector< CService > onion_binds
Definition: net.h:688
int nMaxFeeler
Definition: net.h:676
std::vector< std::string > m_specified_outgoing
Definition: net.h:693
NetEventsInterface * m_msgproc
Definition: net.h:678
int nMaxConnections
Definition: net.h:672
ServiceFlags nLocalServices
Definition: net.h:671
std::vector< std::string > m_added_nodes
Definition: net.h:694
int64_t m_peer_connect_timeout
Definition: net.h:683
std::vector< CService > vBinds
Definition: net.h:687
unsigned int nSendBufferMaxSize
Definition: net.h:680
bool m_i2p_accept_incoming
Definition: net.h:695
std::vector< std::string > vSeedNodes
Definition: net.h:684
BanMan * m_banman
Definition: net.h:679
bool m_use_addrman_outgoing
Definition: net.h:692
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:691
int nMaxAddnode
Definition: net.h:675
Bilingual messages:
Definition: translation.h:18
bool empty() const
Definition: translation.h:29
std::string translated
Definition: translation.h:20
Block and header tip information.
Definition: node.h:50
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
Context struct holding the kernel library's logically global state, and passed to external libbitcoin...
Definition: context.h:18
Options struct containing options for constructing a CTxMemPool.
CBlockPolicyEstimator * estimator
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:31
std::function< bool()> check_interrupt
Definition: chainstate.h:30
NodeContext struct containing references to chain state and connection state.
Definition: context.h:43
#define WAIT_LOCK(cs, name)
Definition: sync.h:263
#define LOCK(cs)
Definition: sync.h:258
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:302
#define TRY_LOCK(cs, name)
Definition: sync.h:262
void SetSyscallSandboxPolicy(SyscallSandboxPolicy syscall_policy)
Force the current thread (and threads created from the current thread) into a restricted-service oper...
std::string SysErrorString(int err)
Return system error string from errno value.
Definition: syserror.cpp:15
bool error(const char *fmt, const Args &... args)
Definition: system.h:48
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:89
NodeClock::time_point GetAdjustedTime()
Definition: timedata.cpp:35
static const int64_t DEFAULT_MAX_TIME_ADJUSTMENT
Definition: timedata.h:16
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1162
CService DefaultOnionServiceTarget()
Definition: torcontrol.cpp:699
const std::string DEFAULT_TOR_CONTROL
Default control port.
Definition: torcontrol.cpp:34
void InterruptTorControl()
Definition: torcontrol.cpp:680
void StartTorControl(CService onion_service_target)
Definition: torcontrol.cpp:661
void StopTorControl()
Definition: torcontrol.cpp:690
static const bool DEFAULT_LISTEN_ONION
Definition: torcontrol.h:28
bilingual_str _(const char *psz)
Translation function.
Definition: translation.h:65
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:48
std::optional< bilingual_str > CheckLegacyTxindex(CBlockTreeDB &block_tree_db)
Definition: txdb.cpp:34
static const int64_t nMinDbCache
min. -dbcache (MiB)
Definition: txdb.h:36
static const int64_t nDefaultDbBatchSize
-dbbatchsize default (bytes)
Definition: txdb.h:32
static const int64_t nMaxDbCache
max. -dbcache (MiB)
Definition: txdb.h:34
static const int64_t nDefaultDbCache
-dbcache default (MiB)
Definition: txdb.h:30
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:10
static constexpr bool DEFAULT_TXRECONCILIATION_ENABLE
Whether transaction reconciliation protocol should be enabled by default.
std::vector< bool > DecodeAsmap(fs::path path)
Read asmap from provided binary file.
Definition: asmap.cpp:197
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
bool ParseUInt16(std::string_view str, uint16_t *out)
Convert decimal string to unsigned 16-bit integer with strict parse error feedback.
std::optional< uint64_t > ParseByteUnits(std::string_view str, ByteUnit default_multiplier)
Parse a string with suffix unit [k|K|m|M|g|G|t|T].
bool SplitHostPort(std::string_view in, uint16_t &portOut, std::string &hostOut)
Splits socket address string into host string and port value.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
Definition: string.cpp:10
bool LockDirectory(const fs::path &directory, const fs::path &lockfile_name, bool probe_only)
Definition: system.cpp:84
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
Definition: system.cpp:800
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:1388
const char *const BITCOIN_SETTINGS_FILENAME
Definition: system.cpp:71
bool DirIsWritable(const fs::path &directory)
Definition: system.cpp:120
bool SetupNetworking()
Definition: system.cpp:1365
int RaiseFileDescriptorLimit(int nMinFD)
this function tries to raise the file descriptor limit to the requested number.
Definition: system.cpp:1229
ArgsManager gArgs
Definition: system.cpp:73
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
Definition: system.cpp:133
const char *const BITCOIN_CONF_FILENAME
Definition: system.cpp:70
int GetNumCores()
Return the number of cores available on the current system.
Definition: system.cpp:1377
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
std::condition_variable g_best_block_cv
Definition: validation.cpp:109
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...
bool InitScriptExecutionCache(size_t max_size_bytes)
Initializes the script-execution cache.
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
Definition: validation.cpp:93
assert(!tx.IsCoinBase())
static constexpr int DEFAULT_CHECKLEVEL
Definition: validation.h:72
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Definition: validation.h:81
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:70
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
Definition: validation.h:64
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:84
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
Definition: validation.h:66
static const signed int DEFAULT_CHECKBLOCKS
Definition: validation.h:71
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
Definition: validation.h:68
CMainSignals & GetMainSignals()
void UnregisterAllValidationInterfaces()
Unregister all subscribers.
void UnregisterValidationInterface(CValidationInterface *callbacks)
Unregister subscriber.
void RegisterValidationInterface(CValidationInterface *callbacks)
Register subscriber.
const WalletInitInterface & g_wallet_init_interface
Definition: init.cpp:144
CZMQNotificationInterface * g_zmq_notification_interface
void RegisterZMQRPCCommands(CRPCTable &t)
Definition: zmqrpc.cpp:65