Bitcoin Core  22.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-2020 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 <addrman.h>
13 #include <amount.h>
14 #include <banman.h>
15 #include <blockfilter.h>
16 #include <chain.h>
17 #include <chainparams.h>
18 #include <compat/sanity.h>
19 #include <deploymentstatus.h>
20 #include <fs.h>
21 #include <hash.h>
22 #include <httprpc.h>
23 #include <httpserver.h>
24 #include <index/blockfilterindex.h>
25 #include <index/coinstatsindex.h>
26 #include <index/txindex.h>
27 #include <init/common.h>
28 #include <interfaces/chain.h>
29 #include <interfaces/init.h>
30 #include <interfaces/node.h>
31 #include <mapport.h>
32 #include <miner.h>
33 #include <net.h>
34 #include <net_permissions.h>
35 #include <net_processing.h>
36 #include <netbase.h>
37 #include <node/blockstorage.h>
38 #include <node/context.h>
39 #include <node/ui_interface.h>
40 #include <policy/feerate.h>
41 #include <policy/fees.h>
42 #include <policy/policy.h>
43 #include <policy/settings.h>
44 #include <protocol.h>
45 #include <rpc/blockchain.h>
46 #include <rpc/register.h>
47 #include <rpc/server.h>
48 #include <rpc/util.h>
49 #include <scheduler.h>
50 #include <script/sigcache.h>
51 #include <script/standard.h>
52 #include <shutdown.h>
53 #include <sync.h>
54 #include <timedata.h>
55 #include <torcontrol.h>
56 #include <txdb.h>
57 #include <txmempool.h>
58 #include <txorphanage.h>
59 #include <util/asmap.h>
60 #include <util/check.h>
61 #include <util/moneystr.h>
62 #include <util/string.h>
63 #include <util/system.h>
64 #include <util/thread.h>
65 #include <util/threadnames.h>
66 #include <util/translation.h>
67 #include <validation.h>
68 #include <validationinterface.h>
69 #include <walletinitinterface.h>
70 
71 #include <functional>
72 #include <set>
73 #include <stdint.h>
74 #include <stdio.h>
75 #include <thread>
76 #include <vector>
77 
78 #ifndef WIN32
79 #include <attributes.h>
80 #include <cerrno>
81 #include <signal.h>
82 #include <sys/stat.h>
83 #endif
84 
85 #include <boost/algorithm/string/replace.hpp>
86 #include <boost/signals2/signal.hpp>
87 
88 #if ENABLE_ZMQ
91 #include <zmq/zmqrpc.h>
92 #endif
93 
94 static const bool DEFAULT_PROXYRANDOMIZE = true;
95 static const bool DEFAULT_REST_ENABLE = false;
96 
97 #ifdef WIN32
98 // Win32 LevelDB doesn't use filedescriptors, and the ones used for
99 // accessing block files don't count towards the fd_set size limit
100 // anyway.
101 #define MIN_CORE_FILEDESCRIPTORS 0
102 #else
103 #define MIN_CORE_FILEDESCRIPTORS 150
104 #endif
105 
106 static const char* DEFAULT_ASMAP_FILENAME="ip_asn.map";
107 
111 static const char* BITCOIN_PID_FILENAME = "bitcoind.pid";
112 
113 static fs::path GetPidFile(const ArgsManager& args)
114 {
115  return AbsPathForConfigVal(fs::path(args.GetArg("-pid", BITCOIN_PID_FILENAME)));
116 }
117 
118 [[nodiscard]] static bool CreatePidFile(const ArgsManager& args)
119 {
120  fsbridge::ofstream file{GetPidFile(args)};
121  if (file) {
122 #ifdef WIN32
123  tfm::format(file, "%d\n", GetCurrentProcessId());
124 #else
125  tfm::format(file, "%d\n", getpid());
126 #endif
127  return true;
128  } else {
129  return InitError(strprintf(_("Unable to create the PID file '%s': %s"), GetPidFile(args).string(), std::strerror(errno)));
130  }
131 }
132 
134 //
135 // Shutdown
136 //
137 
138 //
139 // Thread management and startup/shutdown:
140 //
141 // The network-processing threads are all part of a thread group
142 // created by AppInit() or the Qt main() function.
143 //
144 // A clean exit happens when StartShutdown() or the SIGTERM
145 // signal handler sets ShutdownRequested(), which makes main thread's
146 // WaitForShutdown() interrupts the thread group.
147 // And then, WaitForShutdown() makes all other on-going threads
148 // in the thread group join the main thread.
149 // Shutdown() is then called to clean up database connections, and stop other
150 // threads that should only be stopped after the main network-processing
151 // threads have exited.
152 //
153 // Shutdown for Qt is very similar, only it uses a QTimer to detect
154 // ShutdownRequested() getting set, and then does the normal Qt
155 // shutdown thing.
156 //
157 
159 {
162  InterruptRPC();
163  InterruptREST();
166  if (node.connman)
167  node.connman->Interrupt();
168  if (g_txindex) {
169  g_txindex->Interrupt();
170  }
171  ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Interrupt(); });
172  if (g_coin_stats_index) {
173  g_coin_stats_index->Interrupt();
174  }
175 }
176 
178 {
179  static Mutex g_shutdown_mutex;
180  TRY_LOCK(g_shutdown_mutex, lock_shutdown);
181  if (!lock_shutdown) return;
182  LogPrintf("%s: In progress...\n", __func__);
183  Assert(node.args);
184 
189  util::ThreadRename("shutoff");
190  if (node.mempool) node.mempool->AddTransactionsUpdated(1);
191 
192  StopHTTPRPC();
193  StopREST();
194  StopRPC();
195  StopHTTPServer();
196  for (const auto& client : node.chain_clients) {
197  client->flush();
198  }
199  StopMapPort();
200 
201  // Because these depend on each-other, we make sure that neither can be
202  // using the other before destroying them.
203  if (node.peerman) UnregisterValidationInterface(node.peerman.get());
204  if (node.connman) node.connman->Stop();
205 
206  StopTorControl();
207 
208  // After everything has been shut down, but before things get flushed, stop the
209  // CScheduler/checkqueue, scheduler and load block thread.
210  if (node.scheduler) node.scheduler->stop();
211  if (node.chainman && node.chainman->m_load_block.joinable()) node.chainman->m_load_block.join();
213 
214  // After the threads that potentially access these pointers have been stopped,
215  // destruct and reset all to nullptr.
216  node.peerman.reset();
217  node.connman.reset();
218  node.banman.reset();
219  node.addrman.reset();
220 
221  if (node.mempool && node.mempool->IsLoaded() && node.args->GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
222  DumpMempool(*node.mempool);
223  }
224 
225  // Drop transactions we were still watching, and record fee estimations.
226  if (node.fee_estimator) node.fee_estimator->Flush();
227 
228  // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
229  if (node.chainman) {
230  LOCK(cs_main);
231  for (CChainState* chainstate : node.chainman->GetAll()) {
232  if (chainstate->CanFlushToDisk()) {
233  chainstate->ForceFlushStateToDisk();
234  }
235  }
236  }
237 
238  // After there are no more peers/RPC left to give us new data which may generate
239  // CValidationInterface callbacks, flush them...
241 
242  // Stop and delete all indexes only after flushing background callbacks.
243  if (g_txindex) {
244  g_txindex->Stop();
245  g_txindex.reset();
246  }
247  if (g_coin_stats_index) {
248  g_coin_stats_index->Stop();
249  g_coin_stats_index.reset();
250  }
251  ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Stop(); });
253 
254  // Any future callbacks will be dropped. This should absolutely be safe - if
255  // missing a callback results in an unrecoverable situation, unclean shutdown
256  // would too. The only reason to do the above flushes is to let the wallet catch
257  // up with our current chain to avoid any strange pruning edge cases and make
258  // next startup faster by avoiding rescan.
259 
260  if (node.chainman) {
261  LOCK(cs_main);
262  for (CChainState* chainstate : node.chainman->GetAll()) {
263  if (chainstate->CanFlushToDisk()) {
264  chainstate->ForceFlushStateToDisk();
265  chainstate->ResetCoinsViews();
266  }
267  }
268  }
269  for (const auto& client : node.chain_clients) {
270  client->stop();
271  }
272 
273 #if ENABLE_ZMQ
278  }
279 #endif
280 
281  node.chain_clients.clear();
285  node.mempool.reset();
286  node.fee_estimator.reset();
287  node.chainman.reset();
288  node.scheduler.reset();
289 
290  try {
291  if (!fs::remove(GetPidFile(*node.args))) {
292  LogPrintf("%s: Unable to remove PID file: File does not exist\n", __func__);
293  }
294  } catch (const fs::filesystem_error& e) {
295  LogPrintf("%s: Unable to remove PID file: %s\n", __func__, fsbridge::get_filesystem_error_message(e));
296  }
297 
298  node.args = nullptr;
299  LogPrintf("%s: done\n", __func__);
300 }
301 
307 #ifndef WIN32
308 static void HandleSIGTERM(int)
309 {
310  StartShutdown();
311 }
312 
313 static void HandleSIGHUP(int)
314 {
315  LogInstance().m_reopen_file = true;
316 }
317 #else
318 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
319 {
320  StartShutdown();
321  Sleep(INFINITE);
322  return true;
323 }
324 #endif
325 
326 #ifndef WIN32
327 static void registerSignalHandler(int signal, void(*handler)(int))
328 {
329  struct sigaction sa;
330  sa.sa_handler = handler;
331  sigemptyset(&sa.sa_mask);
332  sa.sa_flags = 0;
333  sigaction(signal, &sa, nullptr);
334 }
335 #endif
336 
337 static boost::signals2::connection rpc_notify_block_change_connection;
338 static void OnRPCStarted()
339 {
340  rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(std::bind(RPCNotifyBlockChange, std::placeholders::_2));
341 }
342 
343 static void OnRPCStopped()
344 {
346  RPCNotifyBlockChange(nullptr);
347  g_best_block_cv.notify_all();
348  LogPrint(BCLog::RPC, "RPC stopped.\n");
349 }
350 
352 {
353  SetupHelpOptions(argsman);
354  argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now
355 
356  init::AddLoggingArgs(argsman);
357 
358  const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);
359  const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
360  const auto signetBaseParams = CreateBaseChainParams(CBaseChainParams::SIGNET);
361  const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);
362  const auto defaultChainParams = CreateChainParams(argsman, CBaseChainParams::MAIN);
363  const auto testnetChainParams = CreateChainParams(argsman, CBaseChainParams::TESTNET);
364  const auto signetChainParams = CreateChainParams(argsman, CBaseChainParams::SIGNET);
365  const auto regtestChainParams = CreateChainParams(argsman, CBaseChainParams::REGTEST);
366 
367  // Hidden Options
368  std::vector<std::string> hidden_args = {
369  "-dbcrashratio", "-forcecompactdb",
370  // GUI args. These will be overwritten by SetupUIArgs for the GUI
371  "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"};
372 
373  argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
374 #if HAVE_SYSTEM
375  argsman.AddArg("-alertnotify=<cmd>", "Execute command when a relevant alert is received or we see a really long fork (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
376 #endif
377  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);
378  argsman.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
379  argsman.AddArg("-fastprune", "Use smaller block files and lower minimum prune height for testing purposes", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
380 #if HAVE_SYSTEM
381  argsman.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
382 #endif
383  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);
384  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);
385  argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
386  argsman.AddArg("-conf=<file>", strprintf("Specify path to read-only configuration file. Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
387  argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
388  argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", nDefaultDbBatchSize), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
389  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);
390  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);
391  argsman.AddArg("-loadblock=<file>", "Imports blocks from external file on startup", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
392  argsman.AddArg("-maxmempool=<n>", strprintf("Keep the transaction memory pool below <n> megabytes (default: %u)", DEFAULT_MAX_MEMPOOL_SIZE), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
393  argsman.AddArg("-maxorphantx=<n>", strprintf("Keep at most <n> unconnectable transactions in memory (default: %u)", DEFAULT_MAX_ORPHAN_TRANSACTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
394  argsman.AddArg("-mempoolexpiry=<n>", strprintf("Do not keep transactions in the mempool longer than <n> hours (default: %u)", DEFAULT_MEMPOOL_EXPIRY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
395  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);
396  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)",
398  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);
399  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);
400  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, -coinstatsindex and -rescan. "
401  "Warning: Reverting this setting requires re-downloading the entire blockchain. "
402  "(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);
403  argsman.AddArg("-reindex", "Rebuild chain state and block index from the blk*.dat files on disk", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
404  argsman.AddArg("-reindex-chainstate", "Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
405  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);
406 #if HAVE_SYSTEM
407  argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
408 #endif
409 #ifndef WIN32
410  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);
411 #else
412  hidden_args.emplace_back("-sysperms");
413 #endif
414  argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
415  argsman.AddArg("-blockfilterindex=<type>",
416  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
417  " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
419 
420  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);
421  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);
422  argsman.AddArg("-bantime=<n>", strprintf("Default duration (in seconds) of manually configured bans (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
423  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);
424  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);
425  argsman.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
426  argsman.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
427  argsman.AddArg("-dnsseed", strprintf("Query for peer addresses via DNS lookup, if low on addresses (default: %u unless -connect used)", DEFAULT_DNSSEED), ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
428  argsman.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
429  argsman.AddArg("-fixedseeds", strprintf("Allow fixed seeds if DNS seeds don't provide peers (default: %u)", DEFAULT_FIXEDSEEDS), ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
430  argsman.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
431  argsman.AddArg("-listen", "Accept connections from outside (default: 1 if no -proxy or -connect)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
432  argsman.AddArg("-listenonion", strprintf("Automatically create Tor onion service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
433  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);
434  argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
435  argsman.AddArg("-maxsendbuffer=<n>", strprintf("Maximum per-connection send buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXSENDBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
436  argsman.AddArg("-maxtimeadjustment", strprintf("Maximum allowed median peer time offset adjustment. Local perspective of time may be influenced by peers forward or backward by this amount. (default: %u seconds)", DEFAULT_MAX_TIME_ADJUSTMENT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
437  argsman.AddArg("-maxuploadtarget=<n>", strprintf("Tries to keep outbound traffic under the given target (in MiB per 24h). Limit does not apply to peers with 'download' permission. 0 = no limit (default: %d)", DEFAULT_MAX_UPLOAD_TARGET), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
438  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);
439  argsman.AddArg("-i2psam=<ip:port>", "I2P SAM proxy to reach I2P peers and accept I2P connections (default: none)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
440  argsman.AddArg("-i2pacceptincoming", "If set and -i2psam is also set then incoming I2P connections are accepted via the SAM proxy. If this is not set but -i2psam is set then only outgoing connections will be made to the I2P network. Ignored if -i2psam is not set. Listening for incoming I2P connections is done through the SAM proxy, not by binding to a local address and port (default: 1)", ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
441  argsman.AddArg("-onlynet=<net>", "Make outgoing connections only through network <net> (" + Join(GetNetworkNames(), ", ") + "). Incoming connections are not affected by this option. This option can be specified multiple times to allow multiple networks. Warning: if it is used with non-onion networks and the -onion or -proxy option is set, then outbound onion connections will still be made; use -noonion or -onion=0 to disable outbound onion connections in this case.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
442  argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
443  argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
444  argsman.AddArg("-permitbaremultisig", strprintf("Relay non-P2SH multisig (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
445  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);
446  argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
447  argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
448  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);
449  argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
450  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);
451  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);
452  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);
453  argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION);
454 #ifdef USE_UPNP
455 #if USE_UPNP
456  argsman.AddArg("-upnp", "Use UPnP to map the listening port (default: 1 when listening and no -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
457 #else
458  argsman.AddArg("-upnp", strprintf("Use UPnP to map the listening port (default: %u)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
459 #endif
460 #else
461  hidden_args.emplace_back("-upnp");
462 #endif
463 #ifdef USE_NATPMP
464  argsman.AddArg("-natpmp", strprintf("Use NAT-PMP to map the listening port (default: %s)", DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"), ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
465 #else
466  hidden_args.emplace_back("-natpmp");
467 #endif // USE_NATPMP
468  argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. "
469  "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". "
470  "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
471 
472  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 "
473  "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
474  "-whitebind. Can be specified multiple times." , ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
475 
477 
478 #if ENABLE_ZMQ
479  argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
480  argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
481  argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
482  argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
483  argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
484  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);
485  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);
486  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);
487  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);
488  argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
489 #else
490  hidden_args.emplace_back("-zmqpubhashblock=<address>");
491  hidden_args.emplace_back("-zmqpubhashtx=<address>");
492  hidden_args.emplace_back("-zmqpubrawblock=<address>");
493  hidden_args.emplace_back("-zmqpubrawtx=<address>");
494  hidden_args.emplace_back("-zmqpubsequence=<n>");
495  hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
496  hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
497  hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
498  hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
499  hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
500 #endif
501 
502  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);
503  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);
504  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);
505  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);
506  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);
507  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);
508  argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
509  argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
510  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);
511  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);
512  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), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
513  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);
514  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), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
515  argsman.AddArg("-addrmantest", "Allows to test address relay on localhost", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
516  argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_BOOL | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
517  argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
518  argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_MAX_SIG_CACHE_SIZE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
519  argsman.AddArg("-maxtipage=<n>", strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)", DEFAULT_MAX_TIP_AGE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
520  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);
521  argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
522 
524 
525  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);
526  argsman.AddArg("-incrementalrelayfee=<amt>", strprintf("Fee rate (in %s/kvB) used to define cost of relay, used for mempool limiting and BIP 125 replacement. (default: %s)", CURRENCY_UNIT, FormatMoney(DEFAULT_INCREMENTAL_RELAY_FEE)), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::NODE_RELAY);
527  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);
528  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);
529  argsman.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
530  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);
531  argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
533  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);
534  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);
535 
536 
537  argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
538  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);
539  argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
540 
541  argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
542  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);
543  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);
544  argsman.AddArg("-rpcbind=<addr>[:port]", "Bind to given address to listen for JSON-RPC connections. Do not expose the RPC server to untrusted networks such as the public internet! This option is ignored unless -rpcallowip is also passed. Port is optional and overrides -rpcport. Use [host]:port notation for IPv6. This option can be specified multiple times (default: 127.0.0.1 and ::1 i.e., localhost)", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
545  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);
546  argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
547  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);
548  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);
549  argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
550  argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
551  argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
552  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);
553  argsman.AddArg("-rpcwhitelistdefault", "Sets default behavior for rpc whitelisting. Unless rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc server acts as if all rpc users are subject to empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault is set to 1 and no -rpcwhitelist is set, rpc server acts as if all rpc users are subject to empty whitelists.", ArgsManager::ALLOW_BOOL, OptionsCategory::RPC);
554  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);
555  argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
556 
557 #if HAVE_DECL_FORK
558  argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
559  argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
560 #else
561  hidden_args.emplace_back("-daemon");
562  hidden_args.emplace_back("-daemonwait");
563 #endif
564 
565  // Add the hidden options
566  argsman.AddHiddenArgs(hidden_args);
567 }
568 
569 std::string LicenseInfo()
570 {
571  const std::string URL_SOURCE_CODE = "<https://github.com/bitcoin/bitcoin>";
572 
573  return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009, COPYRIGHT_YEAR) + " ") + "\n" +
574  "\n" +
575  strprintf(_("Please contribute if you find %s useful. "
576  "Visit %s for further information about the software.").translated,
577  PACKAGE_NAME, "<" PACKAGE_URL ">") +
578  "\n" +
579  strprintf(_("The source code is available from %s.").translated,
580  URL_SOURCE_CODE) +
581  "\n" +
582  "\n" +
583  _("This is experimental software.").translated + "\n" +
584  strprintf(_("Distributed under the MIT software license, see the accompanying file %s or %s").translated, "COPYING", "<https://opensource.org/licenses/MIT>") +
585  "\n";
586 }
587 
588 static bool fHaveGenesis = false;
590 static std::condition_variable g_genesis_wait_cv;
591 
592 static void BlockNotifyGenesisWait(const CBlockIndex* pBlockIndex)
593 {
594  if (pBlockIndex != nullptr) {
595  {
597  fHaveGenesis = true;
598  }
599  g_genesis_wait_cv.notify_all();
600  }
601 }
602 
603 #if HAVE_SYSTEM
604 static void StartupNotify(const ArgsManager& args)
605 {
606  std::string cmd = args.GetArg("-startupnotify", "");
607  if (!cmd.empty()) {
608  std::thread t(runCommand, cmd);
609  t.detach(); // thread runs free
610  }
611 }
612 #endif
613 
615 {
616  const ArgsManager& args = *Assert(node.args);
619  if (!InitHTTPServer())
620  return false;
621  StartRPC();
622  node.rpc_interruption_point = RpcInterruptionPoint;
623  if (!StartHTTPRPC(&node))
624  return false;
625  if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) StartREST(&node);
626  StartHTTPServer();
627  return true;
628 }
629 
630 // Parameter interaction based on rules
632 {
633  // when specifying an explicit binding address, you want to listen on it
634  // even when -connect or -proxy is specified
635  if (args.IsArgSet("-bind")) {
636  if (args.SoftSetBoolArg("-listen", true))
637  LogPrintf("%s: parameter interaction: -bind set -> setting -listen=1\n", __func__);
638  }
639  if (args.IsArgSet("-whitebind")) {
640  if (args.SoftSetBoolArg("-listen", true))
641  LogPrintf("%s: parameter interaction: -whitebind set -> setting -listen=1\n", __func__);
642  }
643 
644  if (args.IsArgSet("-connect")) {
645  // when only connecting to trusted nodes, do not seed via DNS, or listen by default
646  if (args.SoftSetBoolArg("-dnsseed", false))
647  LogPrintf("%s: parameter interaction: -connect set -> setting -dnsseed=0\n", __func__);
648  if (args.SoftSetBoolArg("-listen", false))
649  LogPrintf("%s: parameter interaction: -connect set -> setting -listen=0\n", __func__);
650  }
651 
652  if (args.IsArgSet("-proxy")) {
653  // to protect privacy, do not listen by default if a default proxy server is specified
654  if (args.SoftSetBoolArg("-listen", false))
655  LogPrintf("%s: parameter interaction: -proxy set -> setting -listen=0\n", __func__);
656  // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1
657  // to listen locally, so don't rely on this happening through -listen below.
658  if (args.SoftSetBoolArg("-upnp", false))
659  LogPrintf("%s: parameter interaction: -proxy set -> setting -upnp=0\n", __func__);
660  if (args.SoftSetBoolArg("-natpmp", false)) {
661  LogPrintf("%s: parameter interaction: -proxy set -> setting -natpmp=0\n", __func__);
662  }
663  // to protect privacy, do not discover addresses by default
664  if (args.SoftSetBoolArg("-discover", false))
665  LogPrintf("%s: parameter interaction: -proxy set -> setting -discover=0\n", __func__);
666  }
667 
668  if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
669  // do not map ports or try to retrieve public IP when not listening (pointless)
670  if (args.SoftSetBoolArg("-upnp", false))
671  LogPrintf("%s: parameter interaction: -listen=0 -> setting -upnp=0\n", __func__);
672  if (args.SoftSetBoolArg("-natpmp", false)) {
673  LogPrintf("%s: parameter interaction: -listen=0 -> setting -natpmp=0\n", __func__);
674  }
675  if (args.SoftSetBoolArg("-discover", false))
676  LogPrintf("%s: parameter interaction: -listen=0 -> setting -discover=0\n", __func__);
677  if (args.SoftSetBoolArg("-listenonion", false))
678  LogPrintf("%s: parameter interaction: -listen=0 -> setting -listenonion=0\n", __func__);
679  if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
680  LogPrintf("%s: parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n", __func__);
681  }
682  }
683 
684  if (args.IsArgSet("-externalip")) {
685  // if an explicit public IP is specified, do not try to find others
686  if (args.SoftSetBoolArg("-discover", false))
687  LogPrintf("%s: parameter interaction: -externalip set -> setting -discover=0\n", __func__);
688  }
689 
690  // disable whitelistrelay in blocksonly mode
691  if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
692  if (args.SoftSetBoolArg("-whitelistrelay", false))
693  LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n", __func__);
694  }
695 
696  // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.
697  if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
698  if (args.SoftSetBoolArg("-whitelistrelay", true))
699  LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n", __func__);
700  }
701 }
702 
709 void InitLogging(const ArgsManager& args)
710 {
713 }
714 
715 namespace { // Variables internal to initialization process only
716 
717 int nMaxConnections;
718 int nUserMaxConnections;
719 int nFD;
721 int64_t peer_connect_timeout;
722 std::set<BlockFilterType> g_enabled_filter_types;
723 
724 } // namespace
725 
726 [[noreturn]] static void new_handler_terminate()
727 {
728  // Rather than throwing std::bad-alloc if allocation fails, terminate
729  // immediately to (try to) avoid chain corruption.
730  // Since LogPrintf may itself allocate memory, set the handler directly
731  // to terminate first.
732  std::set_new_handler(std::terminate);
733  LogPrintf("Error: Out of memory. Terminating.\n");
734 
735  // The log was successful, terminate now.
736  std::terminate();
737 };
738 
740 {
741  // ********************************************************* Step 1: setup
742 #ifdef _MSC_VER
743  // Turn off Microsoft heap dump noise
744  _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
745  _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0));
746  // Disable confusing "helpful" text message on abort, Ctrl-C
747  _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
748 #endif
749 #ifdef WIN32
750  // Enable heap terminate-on-corruption
751  HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0);
752 #endif
753  if (!InitShutdownState()) {
754  return InitError(Untranslated("Initializing wait-for-shutdown state failed."));
755  }
756 
757  if (!SetupNetworking()) {
758  return InitError(Untranslated("Initializing networking failed."));
759  }
760 
761 #ifndef WIN32
762  if (!args.GetBoolArg("-sysperms", false)) {
763  umask(077);
764  }
765 
766  // Clean shutdown on SIGTERM
769 
770  // Reopen debug.log on SIGHUP
772 
773  // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly
774  signal(SIGPIPE, SIG_IGN);
775 #else
776  SetConsoleCtrlHandler(consoleCtrlHandler, true);
777 #endif
778 
779  std::set_new_handler(new_handler_terminate);
780 
781  return true;
782 }
783 
785 {
786  const CChainParams& chainparams = Params();
787  // ********************************************************* Step 2: parameter interactions
788 
789  // also see: InitParameterInteraction()
790 
791  // Error if network-specific options (-addnode, -connect, etc) are
792  // specified in default section of config file, but not overridden
793  // on the command line or in this network's section of the config file.
794  std::string network = args.GetChainName();
795  if (network == CBaseChainParams::SIGNET) {
796  LogPrintf("Signet derived magic (message start): %s\n", HexStr(chainparams.MessageStart()));
797  }
798  bilingual_str errors;
799  for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
800  errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section.") + Untranslated("\n"), arg, network, network);
801  }
802 
803  if (!errors.empty()) {
804  return InitError(errors);
805  }
806 
807  // Warn if unrecognized section name are present in the config file.
808  bilingual_str warnings;
809  for (const auto& section : args.GetUnrecognizedSections()) {
810  warnings += strprintf(Untranslated("%s:%i ") + _("Section [%s] is not recognized.") + Untranslated("\n"), section.m_file, section.m_line, section.m_name);
811  }
812 
813  if (!warnings.empty()) {
814  InitWarning(warnings);
815  }
816 
817  if (!fs::is_directory(gArgs.GetBlocksDirPath())) {
818  return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
819  }
820 
821  // parse and validate enabled filter types
822  std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
823  if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
824  g_enabled_filter_types = AllBlockFilterTypes();
825  } else if (blockfilterindex_value != "0") {
826  const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
827  for (const auto& name : names) {
828  BlockFilterType filter_type;
829  if (!BlockFilterTypeByName(name, filter_type)) {
830  return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
831  }
832  g_enabled_filter_types.insert(filter_type);
833  }
834  }
835 
836  // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
837  if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
838  if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
839  return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
840  }
841 
842  nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
843  }
844 
845  // if using block pruning, then disallow txindex and coinstatsindex
846  if (args.GetArg("-prune", 0)) {
847  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
848  return InitError(_("Prune mode is incompatible with -txindex."));
849  if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX))
850  return InitError(_("Prune mode is incompatible with -coinstatsindex."));
851  }
852 
853  // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
854  if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
855  return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
856  }
857 
858  // -bind and -whitebind can't be set when not listening
859  size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
860  if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
861  return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0"));
862  }
863 
864  // if listen=0, then disallow listenonion=1
865  if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
866  return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1"));
867  }
868 
869  // Make sure enough file descriptors are available
870  int nBind = std::max(nUserBind, size_t(1));
871  nUserMaxConnections = args.GetArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
872  nMaxConnections = std::max(nUserMaxConnections, 0);
873 
874  // Trim requested connection counts, to fit into system limitations
875  // <int> in std::min<int>(...) to work around FreeBSD compilation issue described in #2695
877 
878 #ifdef USE_POLL
879  int fd_max = nFD;
880 #else
881  int fd_max = FD_SETSIZE;
882 #endif
883  nMaxConnections = std::max(std::min<int>(nMaxConnections, fd_max - nBind - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE), 0);
884  if (nFD < MIN_CORE_FILEDESCRIPTORS)
885  return InitError(_("Not enough file descriptors available."));
886  nMaxConnections = std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE, nMaxConnections);
887 
888  if (nMaxConnections < nUserMaxConnections)
889  InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), nUserMaxConnections, nMaxConnections));
890 
891  // ********************************************************* Step 3: parameter-to-internal-flags
893 
894  fCheckBlockIndex = args.GetBoolArg("-checkblockindex", chainparams.DefaultConsistencyChecks());
896 
897  hashAssumeValid = uint256S(args.GetArg("-assumevalid", chainparams.GetConsensus().defaultAssumeValid.GetHex()));
898  if (!hashAssumeValid.IsNull())
899  LogPrintf("Assuming ancestors of block %s have valid signatures.\n", hashAssumeValid.GetHex());
900  else
901  LogPrintf("Validating signatures for all blocks.\n");
902 
903  if (args.IsArgSet("-minimumchainwork")) {
904  const std::string minChainWorkStr = args.GetArg("-minimumchainwork", "");
905  if (!IsHexNumber(minChainWorkStr)) {
906  return InitError(strprintf(Untranslated("Invalid non-hex (%s) minimum chain work value specified"), minChainWorkStr));
907  }
908  nMinimumChainWork = UintToArith256(uint256S(minChainWorkStr));
909  } else {
911  }
912  LogPrintf("Setting nMinimumChainWork=%s\n", nMinimumChainWork.GetHex());
914  LogPrintf("Warning: nMinimumChainWork set below default value of %s\n", chainparams.GetConsensus().nMinimumChainWork.GetHex());
915  }
916 
917  // mempool limits
918  int64_t nMempoolSizeMax = args.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
919  int64_t nMempoolSizeMin = args.GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) * 1000 * 40;
920  if (nMempoolSizeMax < 0 || nMempoolSizeMax < nMempoolSizeMin)
921  return InitError(strprintf(_("-maxmempool must be at least %d MB"), std::ceil(nMempoolSizeMin / 1000000.0)));
922  // incremental relay fee sets the minimum feerate increase necessary for BIP 125 replacement in the mempool
923  // and the amount the mempool min fee increases above the feerate of txs evicted due to mempool limiting.
924  if (args.IsArgSet("-incrementalrelayfee")) {
925  if (std::optional<CAmount> inc_relay_fee = ParseMoney(args.GetArg("-incrementalrelayfee", ""))) {
926  ::incrementalRelayFee = CFeeRate{inc_relay_fee.value()};
927  } else {
928  return InitError(AmountErrMsg("incrementalrelayfee", args.GetArg("-incrementalrelayfee", "")));
929  }
930  }
931 
932  // block pruning; get the amount of disk space (in MiB) to allot for block & undo files
933  int64_t nPruneArg = args.GetArg("-prune", 0);
934  if (nPruneArg < 0) {
935  return InitError(_("Prune cannot be configured with a negative value."));
936  }
937  nPruneTarget = (uint64_t) nPruneArg * 1024 * 1024;
938  if (nPruneArg == 1) { // manual pruning: -prune=1
939  LogPrintf("Block pruning enabled. Use RPC call pruneblockchain(height) to manually prune block and undo files.\n");
940  nPruneTarget = std::numeric_limits<uint64_t>::max();
941  fPruneMode = true;
942  } else if (nPruneTarget) {
944  return InitError(strprintf(_("Prune configured below the minimum of %d MiB. Please use a higher number."), MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
945  }
946  LogPrintf("Prune configured to target %u MiB on disk for block and undo files.\n", nPruneTarget / 1024 / 1024);
947  fPruneMode = true;
948  }
949 
950  nConnectTimeout = args.GetArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
951  if (nConnectTimeout <= 0) {
953  }
954 
955  peer_connect_timeout = args.GetArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
956  if (peer_connect_timeout <= 0) {
957  return InitError(Untranslated("peertimeout cannot be configured with a negative value."));
958  }
959 
960  if (args.IsArgSet("-minrelaytxfee")) {
961  if (std::optional<CAmount> min_relay_fee = ParseMoney(args.GetArg("-minrelaytxfee", ""))) {
962  // High fee check is done afterward in CWallet::Create()
963  ::minRelayTxFee = CFeeRate{min_relay_fee.value()};
964  } else {
965  return InitError(AmountErrMsg("minrelaytxfee", args.GetArg("-minrelaytxfee", "")));
966  }
967  } else if (incrementalRelayFee > ::minRelayTxFee) {
968  // Allow only setting incrementalRelayFee to control both
970  LogPrintf("Increasing minrelaytxfee to %s to match incrementalrelayfee\n",::minRelayTxFee.ToString());
971  }
972 
973  // Sanity check argument for min fee for including tx in block
974  // TODO: Harmonize which arguments need sanity checking and where that happens
975  if (args.IsArgSet("-blockmintxfee")) {
976  if (!ParseMoney(args.GetArg("-blockmintxfee", ""))) {
977  return InitError(AmountErrMsg("blockmintxfee", args.GetArg("-blockmintxfee", "")));
978  }
979  }
980 
981  // Feerate used to define dust. Shouldn't be changed lightly as old
982  // implementations may inadvertently create non-standard transactions
983  if (args.IsArgSet("-dustrelayfee")) {
984  if (std::optional<CAmount> parsed = ParseMoney(args.GetArg("-dustrelayfee", ""))) {
985  dustRelayFee = CFeeRate{parsed.value()};
986  } else {
987  return InitError(AmountErrMsg("dustrelayfee", args.GetArg("-dustrelayfee", "")));
988  }
989  }
990 
991  fRequireStandard = !args.GetBoolArg("-acceptnonstdtxn", !chainparams.RequireStandard());
992  if (!chainparams.IsTestChain() && !fRequireStandard) {
993  return InitError(strprintf(Untranslated("acceptnonstdtxn is not currently supported for %s chain"), chainparams.NetworkIDString()));
994  }
995  nBytesPerSigOp = args.GetArg("-bytespersigop", nBytesPerSigOp);
996 
997  if (!g_wallet_init_interface.ParameterInteraction()) return false;
998 
999  fIsBareMultisigStd = args.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
1001  nMaxDatacarrierBytes = args.GetArg("-datacarriersize", nMaxDatacarrierBytes);
1002 
1003  // Option to startup with mocktime set (used for regression testing):
1004  SetMockTime(args.GetArg("-mocktime", 0)); // SetMockTime(0) is a no-op
1005 
1006  if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
1007  nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
1008 
1009  if (args.GetArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) < 0)
1010  return InitError(Untranslated("rpcserialversion must be non-negative."));
1011 
1012  if (args.GetArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) > 1)
1013  return InitError(Untranslated("Unknown rpcserialversion requested."));
1014 
1015  nMaxTipAge = args.GetArg("-maxtipage", DEFAULT_MAX_TIP_AGE);
1016 
1017  if (args.IsArgSet("-proxy") && args.GetArg("-proxy", "").empty()) {
1018  return InitError(_("No proxy server specified. Use -proxy=<ip> or -proxy=<ip:port>."));
1019  }
1020 
1021  return true;
1022 }
1023 
1024 static bool LockDataDirectory(bool probeOnly)
1025 {
1026  // Make sure only a single Bitcoin process is using the data directory.
1027  fs::path datadir = gArgs.GetDataDirNet();
1028  if (!DirIsWritable(datadir)) {
1029  return InitError(strprintf(_("Cannot write to data directory '%s'; check permissions."), datadir.string()));
1030  }
1031  if (!LockDirectory(datadir, ".lock", probeOnly)) {
1032  return InitError(strprintf(_("Cannot obtain a lock on data directory %s. %s is probably already running."), datadir.string(), PACKAGE_NAME));
1033  }
1034  return true;
1035 }
1036 
1038 {
1039  // ********************************************************* Step 4: sanity checks
1040 
1041  init::SetGlobals();
1042 
1043  if (!init::SanityChecks()) {
1044  return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), PACKAGE_NAME));
1045  }
1046 
1047  // Probe the data directory lock to give an early error message, if possible
1048  // We cannot hold the data directory lock here, as the forking for daemon() hasn't yet happened,
1049  // and a fork will cause weird behavior to it.
1050  return LockDataDirectory(true);
1051 }
1052 
1054 {
1055  // After daemonization get the data directory lock again and hold on to it until exit
1056  // This creates a slight window for a race condition to happen, however this condition is harmless: it
1057  // will at most make us exit without printing a message to console.
1058  if (!LockDataDirectory(false)) {
1059  // Detailed error printed inside LockDataDirectory
1060  return false;
1061  }
1062  return true;
1063 }
1064 
1066 {
1067  node.chain = node.init->makeChain();
1068  // Create client interfaces for wallets that are supposed to be loaded
1069  // according to -wallet and -disablewallet options. This only constructs
1070  // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1071  // when load() and start() interface methods are called below.
1073  return true;
1074 }
1075 
1077 {
1078  const ArgsManager& args = *Assert(node.args);
1079  const CChainParams& chainparams = Params();
1080  // ********************************************************* Step 4a: application initialization
1081  if (!CreatePidFile(args)) {
1082  // Detailed error printed inside CreatePidFile().
1083  return false;
1084  }
1085  if (!init::StartLogging(args)) {
1086  // Detailed error printed inside StartLogging().
1087  return false;
1088  }
1089 
1090  LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, nFD);
1091 
1092  // Warn about relative -datadir path.
1093  if (args.IsArgSet("-datadir") && !fs::path(args.GetArg("-datadir", "")).is_absolute()) {
1094  LogPrintf("Warning: relative datadir option '%s' specified, which will be interpreted relative to the " /* Continued */
1095  "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1096  "from a different location, it will be unable to locate the current data files. There could "
1097  "also be data loss if bitcoin is started while in a temporary directory.\n",
1098  args.GetArg("-datadir", ""), fs::current_path().string());
1099  }
1100 
1103 
1104  int script_threads = args.GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
1105  if (script_threads <= 0) {
1106  // -par=0 means autodetect (number of cores - 1 script threads)
1107  // -par=-n means "leave n cores free" (number of cores - n - 1 script threads)
1108  script_threads += GetNumCores();
1109  }
1110 
1111  // Subtract 1 because the main thread counts towards the par threads
1112  script_threads = std::max(script_threads - 1, 0);
1113 
1114  // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
1115  script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
1116 
1117  LogPrintf("Script verification uses %d additional threads\n", script_threads);
1118  if (script_threads >= 1) {
1119  g_parallel_script_checks = true;
1120  StartScriptCheckWorkerThreads(script_threads);
1121  }
1122 
1123  assert(!node.scheduler);
1124  node.scheduler = std::make_unique<CScheduler>();
1125 
1126  // Start the lightweight task scheduler thread
1127  node.scheduler->m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { node.scheduler->serviceQueue(); });
1128 
1129  // Gather some entropy once per minute.
1130  node.scheduler->scheduleEvery([]{
1131  RandAddPeriodic();
1132  }, std::chrono::minutes{1});
1133 
1135 
1136  /* Register RPC commands regardless of -server setting so they will be
1137  * available in the GUI RPC console even if external calls are disabled.
1138  */
1140  for (const auto& client : node.chain_clients) {
1141  client->registerRpcs();
1142  }
1143 #if ENABLE_ZMQ
1145 #endif
1146 
1147  /* Start the RPC server already. It will be started in "warmup" mode
1148  * and not really process calls already (but it will signify connections
1149  * that the server is there and will be ready later). Warmup mode will
1150  * be disabled when initialisation is finished.
1151  */
1152  if (args.GetBoolArg("-server", false)) {
1153  uiInterface.InitMessage_connect(SetRPCWarmupStatus);
1154  if (!AppInitServers(node))
1155  return InitError(_("Unable to start HTTP server. See debug log for details."));
1156  }
1157 
1158  // ********************************************************* Step 5: verify wallet database integrity
1159  for (const auto& client : node.chain_clients) {
1160  if (!client->verify()) {
1161  return false;
1162  }
1163  }
1164 
1165  // ********************************************************* Step 6: network initialization
1166  // Note that we absolutely cannot open any actual connections
1167  // until the very end ("start node") as the UTXO/block state
1168  // is not yet setup and may end up being set up twice if we
1169  // need to reindex later.
1170 
1171  fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1172  fDiscover = args.GetBoolArg("-discover", true);
1173  const bool ignores_incoming_txs{args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)};
1174 
1175  {
1176  // Initialize addrman
1177  assert(!node.addrman);
1178 
1179  // Read asmap file if configured
1180  std::vector<bool> asmap;
1181  if (args.IsArgSet("-asmap")) {
1182  fs::path asmap_path = fs::path(args.GetArg("-asmap", ""));
1183  if (asmap_path.empty()) {
1184  asmap_path = DEFAULT_ASMAP_FILENAME;
1185  }
1186  if (!asmap_path.is_absolute()) {
1187  asmap_path = gArgs.GetDataDirNet() / asmap_path;
1188  }
1189  if (!fs::exists(asmap_path)) {
1190  InitError(strprintf(_("Could not find asmap file %s"), asmap_path));
1191  return false;
1192  }
1193  asmap = DecodeAsmap(asmap_path);
1194  if (asmap.size() == 0) {
1195  InitError(strprintf(_("Could not parse asmap file %s"), asmap_path));
1196  return false;
1197  }
1198  const uint256 asmap_version = SerializeHash(asmap);
1199  LogPrintf("Using asmap version %s for IP bucketing\n", asmap_version.ToString());
1200  } else {
1201  LogPrintf("Using /16 prefix for IP bucketing\n");
1202  }
1203 
1204  uiInterface.InitMessage(_("Loading P2P addresses…").translated);
1205  if (const auto error{LoadAddrman(asmap, args, node.addrman)}) {
1206  return InitError(*error);
1207  }
1208  }
1209 
1210  assert(!node.banman);
1211  node.banman = std::make_unique<BanMan>(gArgs.GetDataDirNet() / "banlist", &uiInterface, args.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1212  assert(!node.connman);
1213  node.connman = std::make_unique<CConnman>(GetRand(std::numeric_limits<uint64_t>::max()), GetRand(std::numeric_limits<uint64_t>::max()), *node.addrman, args.GetBoolArg("-networkactive", true));
1214 
1215  assert(!node.fee_estimator);
1216  // Don't initialize fee estimation with old data if we don't relay transactions,
1217  // as they would never get updated.
1218  if (!ignores_incoming_txs) node.fee_estimator = std::make_unique<CBlockPolicyEstimator>();
1219 
1220  assert(!node.mempool);
1221  int check_ratio = std::min<int>(std::max<int>(args.GetArg("-checkmempool", chainparams.DefaultConsistencyChecks() ? 1 : 0), 0), 1000000);
1222  node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get(), check_ratio);
1223 
1224  assert(!node.chainman);
1225  node.chainman = std::make_unique<ChainstateManager>();
1226  ChainstateManager& chainman = *node.chainman;
1227 
1228  assert(!node.peerman);
1229  node.peerman = PeerManager::make(chainparams, *node.connman, *node.addrman, node.banman.get(),
1230  chainman, *node.mempool, ignores_incoming_txs);
1231  RegisterValidationInterface(node.peerman.get());
1232 
1233  // sanitize comments per BIP-0014, format user agent and check total size
1234  std::vector<std::string> uacomments;
1235  for (const std::string& cmt : args.GetArgs("-uacomment")) {
1236  if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1237  return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1238  uacomments.push_back(cmt);
1239  }
1241  if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1242  return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1244  }
1245 
1246  if (args.IsArgSet("-onlynet")) {
1247  std::set<enum Network> nets;
1248  for (const std::string& snet : args.GetArgs("-onlynet")) {
1249  enum Network net = ParseNetwork(snet);
1250  if (net == NET_UNROUTABLE)
1251  return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1252  nets.insert(net);
1253  }
1254  for (int n = 0; n < NET_MAX; n++) {
1255  enum Network net = (enum Network)n;
1256  if (!nets.count(net))
1257  SetReachable(net, false);
1258  }
1259  }
1260 
1261  // Check for host lookup allowed before parsing any network related parameters
1262  fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
1263 
1264  bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1265  // -proxy sets a proxy for all outgoing network traffic
1266  // -noproxy (or -proxy=0) as well as the empty string can be used to not set a proxy, this is the default
1267  std::string proxyArg = args.GetArg("-proxy", "");
1268  SetReachable(NET_ONION, false);
1269  if (proxyArg != "" && proxyArg != "0") {
1270  CService proxyAddr;
1271  if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
1272  return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg));
1273  }
1274 
1275  proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
1276  if (!addrProxy.IsValid())
1277  return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg));
1278 
1279  SetProxy(NET_IPV4, addrProxy);
1280  SetProxy(NET_IPV6, addrProxy);
1281  SetProxy(NET_ONION, addrProxy);
1282  SetNameProxy(addrProxy);
1283  SetReachable(NET_ONION, true); // by default, -proxy sets onion as reachable, unless -noonion later
1284  }
1285 
1286  // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1287  // -noonion (or -onion=0) disables connecting to .onion entirely
1288  // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1289  std::string onionArg = args.GetArg("-onion", "");
1290  if (onionArg != "") {
1291  if (onionArg == "0") { // Handle -noonion/-onion=0
1292  SetReachable(NET_ONION, false);
1293  } else {
1294  CService onionProxy;
1295  if (!Lookup(onionArg, onionProxy, 9050, fNameLookup)) {
1296  return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1297  }
1298  proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
1299  if (!addrOnion.IsValid())
1300  return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1301  SetProxy(NET_ONION, addrOnion);
1302  SetReachable(NET_ONION, true);
1303  }
1304  }
1305 
1306  for (const std::string& strAddr : args.GetArgs("-externalip")) {
1307  CService addrLocal;
1308  if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) && addrLocal.IsValid())
1309  AddLocal(addrLocal, LOCAL_MANUAL);
1310  else
1311  return InitError(ResolveErrMsg("externalip", strAddr));
1312  }
1313 
1314 #if ENABLE_ZMQ
1316 
1319  }
1320 #endif
1321 
1322  // ********************************************************* Step 7: load block chain
1323 
1324  fReindex = args.GetBoolArg("-reindex", false);
1325  bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
1326 
1327  // cache size calculations
1328  int64_t nTotalCache = (args.GetArg("-dbcache", nDefaultDbCache) << 20);
1329  nTotalCache = std::max(nTotalCache, nMinDbCache << 20); // total cache cannot be less than nMinDbCache
1330  nTotalCache = std::min(nTotalCache, nMaxDbCache << 20); // total cache cannot be greater than nMaxDbcache
1331  int64_t nBlockTreeDBCache = std::min(nTotalCache / 8, nMaxBlockDBCache << 20);
1332  nTotalCache -= nBlockTreeDBCache;
1333  int64_t nTxIndexCache = std::min(nTotalCache / 8, args.GetBoolArg("-txindex", DEFAULT_TXINDEX) ? nMaxTxIndexCache << 20 : 0);
1334  nTotalCache -= nTxIndexCache;
1335  int64_t filter_index_cache = 0;
1336  if (!g_enabled_filter_types.empty()) {
1337  size_t n_indexes = g_enabled_filter_types.size();
1338  int64_t max_cache = std::min(nTotalCache / 8, max_filter_index_cache << 20);
1339  filter_index_cache = max_cache / n_indexes;
1340  nTotalCache -= filter_index_cache * n_indexes;
1341  }
1342  int64_t nCoinDBCache = std::min(nTotalCache / 2, (nTotalCache / 4) + (1 << 23)); // use 25%-50% of the remainder for disk cache
1343  nCoinDBCache = std::min(nCoinDBCache, nMaxCoinsDBCache << 20); // cap total coins db cache
1344  nTotalCache -= nCoinDBCache;
1345  int64_t nCoinCacheUsage = nTotalCache; // the rest goes to in-memory cache
1346  int64_t nMempoolSizeMax = args.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
1347  LogPrintf("Cache configuration:\n");
1348  LogPrintf("* Using %.1f MiB for block index database\n", nBlockTreeDBCache * (1.0 / 1024 / 1024));
1349  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1350  LogPrintf("* Using %.1f MiB for transaction index database\n", nTxIndexCache * (1.0 / 1024 / 1024));
1351  }
1352  for (BlockFilterType filter_type : g_enabled_filter_types) {
1353  LogPrintf("* Using %.1f MiB for %s block filter index database\n",
1354  filter_index_cache * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type));
1355  }
1356  LogPrintf("* Using %.1f MiB for chain state database\n", nCoinDBCache * (1.0 / 1024 / 1024));
1357  LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)\n", nCoinCacheUsage * (1.0 / 1024 / 1024), nMempoolSizeMax * (1.0 / 1024 / 1024));
1358 
1359  bool fLoaded = false;
1360  while (!fLoaded && !ShutdownRequested()) {
1361  const bool fReset = fReindex;
1362  auto is_coinsview_empty = [&](CChainState* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
1363  return fReset || fReindexChainState || chainstate->CoinsTip().GetBestBlock().IsNull();
1364  };
1365  bilingual_str strLoadError;
1366 
1367  uiInterface.InitMessage(_("Loading block index…").translated);
1368 
1369  do {
1370  const int64_t load_block_index_start_time = GetTimeMillis();
1371  try {
1372  LOCK(cs_main);
1373  chainman.InitializeChainstate(Assert(node.mempool.get()));
1374  chainman.m_total_coinstip_cache = nCoinCacheUsage;
1375  chainman.m_total_coinsdb_cache = nCoinDBCache;
1376 
1377  UnloadBlockIndex(node.mempool.get(), chainman);
1378 
1379  auto& pblocktree{chainman.m_blockman.m_block_tree_db};
1380  // new CBlockTreeDB tries to delete the existing file, which
1381  // fails if it's still open from the previous loop. Close it first:
1382  pblocktree.reset();
1383  pblocktree.reset(new CBlockTreeDB(nBlockTreeDBCache, false, fReset));
1384 
1385  if (fReset) {
1386  pblocktree->WriteReindexing(true);
1387  //If we're reindexing in prune mode, wipe away unusable block files and all undo data files
1388  if (fPruneMode)
1390  }
1391 
1392  if (ShutdownRequested()) break;
1393 
1394  // LoadBlockIndex will load fHavePruned if we've ever removed a
1395  // block file from disk.
1396  // Note that it also sets fReindex based on the disk flag!
1397  // From here on out fReindex and fReset mean something different!
1398  if (!chainman.LoadBlockIndex()) {
1399  if (ShutdownRequested()) break;
1400  strLoadError = _("Error loading block database");
1401  break;
1402  }
1403 
1404  // If the loaded chain has a wrong genesis, bail out immediately
1405  // (we're likely using a testnet datadir, or the other way around).
1406  if (!chainman.BlockIndex().empty() &&
1407  !chainman.m_blockman.LookupBlockIndex(chainparams.GetConsensus().hashGenesisBlock)) {
1408  return InitError(_("Incorrect or no genesis block found. Wrong datadir for network?"));
1409  }
1410 
1411  // Check for changed -prune state. What we are concerned about is a user who has pruned blocks
1412  // in the past, but is now trying to run unpruned.
1413  if (fHavePruned && !fPruneMode) {
1414  strLoadError = _("You need to rebuild the database using -reindex to go back to unpruned mode. This will redownload the entire blockchain");
1415  break;
1416  }
1417 
1418  // At this point blocktree args are consistent with what's on disk.
1419  // If we're not mid-reindex (based on disk + args), add a genesis block on disk
1420  // (otherwise we use the one already on disk).
1421  // This is called again in ThreadImport after the reindex completes.
1422  if (!fReindex && !chainman.ActiveChainstate().LoadGenesisBlock()) {
1423  strLoadError = _("Error initializing block database");
1424  break;
1425  }
1426 
1427  // At this point we're either in reindex or we've loaded a useful
1428  // block tree into BlockIndex()!
1429 
1430  bool failed_chainstate_init = false;
1431 
1432  for (CChainState* chainstate : chainman.GetAll()) {
1433  chainstate->InitCoinsDB(
1434  /* cache_size_bytes */ nCoinDBCache,
1435  /* in_memory */ false,
1436  /* should_wipe */ fReset || fReindexChainState);
1437 
1438  chainstate->CoinsErrorCatcher().AddReadErrCallback([]() {
1439  uiInterface.ThreadSafeMessageBox(
1440  _("Error reading from database, shutting down."),
1442  });
1443 
1444  // If necessary, upgrade from older database format.
1445  // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
1446  if (!chainstate->CoinsDB().Upgrade()) {
1447  strLoadError = _("Error upgrading chainstate database");
1448  failed_chainstate_init = true;
1449  break;
1450  }
1451 
1452  // ReplayBlocks is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
1453  if (!chainstate->ReplayBlocks()) {
1454  strLoadError = _("Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.");
1455  failed_chainstate_init = true;
1456  break;
1457  }
1458 
1459  // The on-disk coinsdb is now in a good state, create the cache
1460  chainstate->InitCoinsCache(nCoinCacheUsage);
1461  assert(chainstate->CanFlushToDisk());
1462 
1463  if (!is_coinsview_empty(chainstate)) {
1464  // LoadChainTip initializes the chain based on CoinsTip()'s best block
1465  if (!chainstate->LoadChainTip()) {
1466  strLoadError = _("Error initializing block database");
1467  failed_chainstate_init = true;
1468  break; // out of the per-chainstate loop
1469  }
1470  assert(chainstate->m_chain.Tip() != nullptr);
1471  }
1472  }
1473 
1474  if (failed_chainstate_init) {
1475  break; // out of the chainstate activation do-while
1476  }
1477  } catch (const std::exception& e) {
1478  LogPrintf("%s\n", e.what());
1479  strLoadError = _("Error opening block database");
1480  break;
1481  }
1482 
1483  if (!fReset) {
1484  LOCK(cs_main);
1485  auto chainstates{chainman.GetAll()};
1486  if (std::any_of(chainstates.begin(), chainstates.end(),
1487  [](const CChainState* cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
1488  strLoadError = strprintf(_("Witness data for blocks after height %d requires validation. Please restart with -reindex."),
1489  chainparams.GetConsensus().SegwitHeight);
1490  break;
1491  }
1492  }
1493 
1494  bool failed_verification = false;
1495 
1496  try {
1497  LOCK(cs_main);
1498 
1499  for (CChainState* chainstate : chainman.GetAll()) {
1500  if (!is_coinsview_empty(chainstate)) {
1501  uiInterface.InitMessage(_("Verifying blocks…").translated);
1502  if (fHavePruned && args.GetArg("-checkblocks", DEFAULT_CHECKBLOCKS) > MIN_BLOCKS_TO_KEEP) {
1503  LogPrintf("Prune: pruned datadir may not have more than %d blocks; only checking available blocks\n",
1505  }
1506 
1507  const CBlockIndex* tip = chainstate->m_chain.Tip();
1508  RPCNotifyBlockChange(tip);
1509  if (tip && tip->nTime > GetAdjustedTime() + 2 * 60 * 60) {
1510  strLoadError = _("The block database contains a block which appears to be from the future. "
1511  "This may be due to your computer's date and time being set incorrectly. "
1512  "Only rebuild the block database if you are sure that your computer's date and time are correct");
1513  failed_verification = true;
1514  break;
1515  }
1516 
1517  if (!CVerifyDB().VerifyDB(
1518  *chainstate, chainparams, chainstate->CoinsDB(),
1519  args.GetArg("-checklevel", DEFAULT_CHECKLEVEL),
1520  args.GetArg("-checkblocks", DEFAULT_CHECKBLOCKS))) {
1521  strLoadError = _("Corrupted block database detected");
1522  failed_verification = true;
1523  break;
1524  }
1525  }
1526  }
1527  } catch (const std::exception& e) {
1528  LogPrintf("%s\n", e.what());
1529  strLoadError = _("Error opening block database");
1530  failed_verification = true;
1531  break;
1532  }
1533 
1534  if (!failed_verification) {
1535  fLoaded = true;
1536  LogPrintf(" block index %15dms\n", GetTimeMillis() - load_block_index_start_time);
1537  }
1538  } while(false);
1539 
1540  if (!fLoaded && !ShutdownRequested()) {
1541  // first suggest a reindex
1542  if (!fReset) {
1543  bool fRet = uiInterface.ThreadSafeQuestion(
1544  strLoadError + Untranslated(".\n\n") + _("Do you want to rebuild the block database now?"),
1545  strLoadError.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(strLoadError);
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  // ********************************************************* Step 8: start indexers
1569  if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1570  if (const auto error{CheckLegacyTxindex(*Assert(chainman.m_blockman.m_block_tree_db))}) {
1571  return InitError(*error);
1572  }
1573 
1574  g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);
1575  if (!g_txindex->Start(chainman.ActiveChainstate())) {
1576  return false;
1577  }
1578  }
1579 
1580  for (const auto& filter_type : g_enabled_filter_types) {
1581  InitBlockFilterIndex(filter_type, filter_index_cache, false, fReindex);
1582  if (!GetBlockFilterIndex(filter_type)->Start(chainman.ActiveChainstate())) {
1583  return false;
1584  }
1585  }
1586 
1587  if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1588  g_coin_stats_index = std::make_unique<CoinStatsIndex>(/* cache size */ 0, false, fReindex);
1589  if (!g_coin_stats_index->Start(chainman.ActiveChainstate())) {
1590  return false;
1591  }
1592  }
1593 
1594  // ********************************************************* Step 9: load wallet
1595  for (const auto& client : node.chain_clients) {
1596  if (!client->load()) {
1597  return false;
1598  }
1599  }
1600 
1601  // ********************************************************* Step 10: data directory maintenance
1602 
1603  // if pruning, unset the service bit and perform the initial blockstore prune
1604  // after any wallet rescanning has taken place.
1605  if (fPruneMode) {
1606  LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
1607  nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
1608  if (!fReindex) {
1609  LOCK(cs_main);
1610  for (CChainState* chainstate : chainman.GetAll()) {
1611  uiInterface.InitMessage(_("Pruning blockstore…").translated);
1612  chainstate->PruneAndFlush();
1613  }
1614  }
1615  }
1616 
1617  // ********************************************************* Step 11: import blocks
1618 
1620  InitError(strprintf(_("Error: Disk space is low for %s"), gArgs.GetDataDirNet()));
1621  return false;
1622  }
1624  InitError(strprintf(_("Error: Disk space is low for %s"), gArgs.GetBlocksDirPath()));
1625  return false;
1626  }
1627 
1628  // Either install a handler to notify us when genesis activates, or set fHaveGenesis directly.
1629  // No locking, as this happens before any background thread is started.
1630  boost::signals2::connection block_notify_genesis_wait_connection;
1631  if (chainman.ActiveChain().Tip() == nullptr) {
1632  block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
1633  } else {
1634  fHaveGenesis = true;
1635  }
1636 
1637 #if HAVE_SYSTEM
1638  const std::string block_notify = args.GetArg("-blocknotify", "");
1639  if (!block_notify.empty()) {
1640  uiInterface.NotifyBlockTip_connect([block_notify](SynchronizationState sync_state, const CBlockIndex* pBlockIndex) {
1641  if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) return;
1642  std::string command = block_notify;
1643  boost::replace_all(command, "%s", pBlockIndex->GetBlockHash().GetHex());
1644  std::thread t(runCommand, command);
1645  t.detach(); // thread runs free
1646  });
1647  }
1648 #endif
1649 
1650  std::vector<fs::path> vImportFiles;
1651  for (const std::string& strFile : args.GetArgs("-loadblock")) {
1652  vImportFiles.push_back(strFile);
1653  }
1654 
1655  chainman.m_load_block = std::thread(&util::TraceThread, "loadblk", [=, &chainman, &args] {
1656  ThreadImport(chainman, vImportFiles, args);
1657  });
1658 
1659  // Wait for genesis block to be processed
1660  {
1662  // We previously could hang here if StartShutdown() is called prior to
1663  // ThreadImport getting started, so instead we just wait on a timer to
1664  // check ShutdownRequested() regularly.
1665  while (!fHaveGenesis && !ShutdownRequested()) {
1666  g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
1667  }
1668  block_notify_genesis_wait_connection.disconnect();
1669  }
1670 
1671  if (ShutdownRequested()) {
1672  return false;
1673  }
1674 
1675  // ********************************************************* Step 12: start node
1676 
1677  int chain_active_height;
1678 
1680  {
1681  LOCK(cs_main);
1682  LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
1683  chain_active_height = chainman.ActiveChain().Height();
1684  if (tip_info) {
1685  tip_info->block_height = chain_active_height;
1686  tip_info->block_time = chainman.ActiveChain().Tip() ? chainman.ActiveChain().Tip()->GetBlockTime() : Params().GenesisBlock().GetBlockTime();
1687  tip_info->verification_progress = GuessVerificationProgress(Params().TxData(), chainman.ActiveChain().Tip());
1688  }
1689  if (tip_info && ::pindexBestHeader) {
1692  }
1693  }
1694  LogPrintf("nBestHeight = %d\n", chain_active_height);
1695  if (node.peerman) node.peerman->SetBestHeight(chain_active_height);
1696 
1697  Discover();
1698 
1699  // Map ports with UPnP or NAT-PMP.
1700  StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP), gArgs.GetBoolArg("-natpmp", DEFAULT_NATPMP));
1701 
1702  CConnman::Options connOptions;
1703  connOptions.nLocalServices = nLocalServices;
1704  connOptions.nMaxConnections = nMaxConnections;
1707  connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
1708  connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
1709  connOptions.uiInterface = &uiInterface;
1710  connOptions.m_banman = node.banman.get();
1711  connOptions.m_msgproc = node.peerman.get();
1712  connOptions.nSendBufferMaxSize = 1000 * args.GetArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
1713  connOptions.nReceiveFloodSize = 1000 * args.GetArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
1714  connOptions.m_added_nodes = args.GetArgs("-addnode");
1715 
1716  connOptions.nMaxOutboundLimit = 1024 * 1024 * args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
1717  connOptions.m_peer_connect_timeout = peer_connect_timeout;
1718 
1719  for (const std::string& bind_arg : args.GetArgs("-bind")) {
1720  CService bind_addr;
1721  const size_t index = bind_arg.rfind('=');
1722  if (index == std::string::npos) {
1723  if (Lookup(bind_arg, bind_addr, GetListenPort(), false)) {
1724  connOptions.vBinds.push_back(bind_addr);
1725  continue;
1726  }
1727  } else {
1728  const std::string network_type = bind_arg.substr(index + 1);
1729  if (network_type == "onion") {
1730  const std::string truncated_bind_arg = bind_arg.substr(0, index);
1731  if (Lookup(truncated_bind_arg, bind_addr, BaseParams().OnionServiceTargetPort(), false)) {
1732  connOptions.onion_binds.push_back(bind_addr);
1733  continue;
1734  }
1735  }
1736  }
1737  return InitError(ResolveErrMsg("bind", bind_arg));
1738  }
1739 
1740  for (const std::string& strBind : args.GetArgs("-whitebind")) {
1741  NetWhitebindPermissions whitebind;
1743  if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
1744  connOptions.vWhiteBinds.push_back(whitebind);
1745  }
1746 
1747  // If the user did not specify -bind= or -whitebind= then we bind
1748  // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
1749  connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
1750 
1751  CService onion_service_target;
1752  if (!connOptions.onion_binds.empty()) {
1753  onion_service_target = connOptions.onion_binds.front();
1754  } else {
1755  onion_service_target = DefaultOnionServiceTarget();
1756  connOptions.onion_binds.push_back(onion_service_target);
1757  }
1758 
1759  if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
1760  if (connOptions.onion_binds.size() > 1) {
1761  InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
1762  "for the automatically created Tor onion service."),
1763  onion_service_target.ToStringIPPort()));
1764  }
1765  StartTorControl(onion_service_target);
1766  }
1767 
1768  for (const auto& net : args.GetArgs("-whitelist")) {
1769  NetWhitelistPermissions subnet;
1771  if (!NetWhitelistPermissions::TryParse(net, subnet, error)) return InitError(error);
1772  connOptions.vWhitelistedRange.push_back(subnet);
1773  }
1774 
1775  connOptions.vSeedNodes = args.GetArgs("-seednode");
1776 
1777  // Initiate outbound connections unless connect=0
1778  connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
1779  if (!connOptions.m_use_addrman_outgoing) {
1780  const auto connect = args.GetArgs("-connect");
1781  if (connect.size() != 1 || connect[0] != "0") {
1782  connOptions.m_specified_outgoing = connect;
1783  }
1784  }
1785 
1786  const std::string& i2psam_arg = args.GetArg("-i2psam", "");
1787  if (!i2psam_arg.empty()) {
1788  CService addr;
1789  if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) || !addr.IsValid()) {
1790  return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
1791  }
1792  SetReachable(NET_I2P, true);
1793  SetProxy(NET_I2P, proxyType{addr});
1794  } else {
1795  SetReachable(NET_I2P, false);
1796  }
1797 
1798  connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", true);
1799 
1800  if (!node.connman->Start(*node.scheduler, connOptions)) {
1801  return false;
1802  }
1803 
1804  // ********************************************************* Step 13: finished
1805 
1807  uiInterface.InitMessage(_("Done loading").translated);
1808 
1809  for (const auto& client : node.chain_clients) {
1810  client->start(*node.scheduler);
1811  }
1812 
1813  BanMan* banman = node.banman.get();
1814  node.scheduler->scheduleEvery([banman]{
1815  banman->DumpBanlist();
1816  }, DUMP_BANS_INTERVAL);
1817 
1818  if (node.peerman) node.peerman->StartScheduledTasks(*node.scheduler);
1819 
1820 #if HAVE_SYSTEM
1821  StartupNotify(args);
1822 #endif
1823 
1824  return true;
1825 }
CBlockIndex::GetBlockTime
int64_t GetBlockTime() const
Definition: chain.h:260
InitShutdownState
bool InitShutdownState()
Initialize shutdown state.
Definition: shutdown.cpp:45
CreatePidFile
static bool CreatePidFile(const ArgsManager &args)
Definition: init.cpp:118
AppInitInterfaces
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1065
AbsPathForConfigVal
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:1367
ShutdownRequested
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
Definition: shutdown.cpp:87
CService
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:539
policy.h
StartREST
void StartREST(const std::any &context)
Start HTTP REST subsystem.
Definition: rest.cpp:726
common.h
Common init functions shared by bitcoin-node, bitcoin-wallet, etc.
zmqabstractnotifier.h
g_wallet_init_interface
const WalletInitInterface & g_wallet_init_interface
Definition: init.cpp:42
BITCOIN_PID_FILENAME
static const char * BITCOIN_PID_FILENAME
The PID file facilities.
Definition: init.cpp:111
feerate.h
BlockFilterTypeName
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
Definition: blockfilter.cpp:178
CConnman::Options::vSeedNodes
std::vector< std::string > vSeedNodes
Definition: net.h:759
ArgsManager::GetBoolArg
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:600
SerializeHash
uint256 SerializeHash(const T &obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
Compute the 256-bit hash of an object's serialization.
Definition: hash.h:192
StartMapPort
void StartMapPort(bool use_upnp, bool use_natpmp)
Definition: mapport.cpp:325
ArgsManager::AddHiddenArgs
void AddHiddenArgs(const std::vector< std::string > &args)
Add many hidden arguments.
Definition: system.cpp:661
ChainstateManager::BlockIndex
BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:961
_
bilingual_str _(const char *psz)
Translation function.
Definition: translation.h:63
init::SanityChecks
bool SanityChecks()
Ensure a usable environment with all necessary library support.
Definition: common.cpp:41
CClientUIInterface::BTN_ABORT
@ BTN_ABORT
Definition: ui_interface.h:43
DEFAULT_CHECKLEVEL
static const unsigned int DEFAULT_CHECKLEVEL
Definition: validation.h:92
proxyType::IsValid
bool IsValid() const
Definition: netbase.h:54
NET_UNROUTABLE
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:47
init::SetLoggingCategories
void SetLoggingCategories(const ArgsManager &args)
Definition: common.cpp:96
assert
assert(!tx.IsCoinBase())
ParseNetwork
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:87
CHECKLEVEL_DOC
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
Definition: validation.cpp:79
CConnman::Options::nMaxAddnode
int nMaxAddnode
Definition: net.h:750
tinyformat::format
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:1062
InterruptMapPort
void InterruptMapPort()
Definition: mapport.cpp:329
DEFAULT_PERSIST_MEMPOOL
static const bool DEFAULT_PERSIST_MEMPOOL
Default for -persistmempool.
Definition: validation.h:86
check.h
fPruneMode
bool fPruneMode
True if we're running in -prune mode.
Definition: blockstorage.cpp:25
g_txindex
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
Definition: txindex.cpp:14
NET_IPV4
@ NET_IPV4
IPv4.
Definition: netaddress.h:50
CBlockIndex::nTime
uint32_t nTime
Definition: chain.h:192
mapport.h
ChainstateManager::m_total_coinstip_cache
int64_t m_total_coinstip_cache
The total number of bytes available for us to use across all in-memory coins caches.
Definition: validation.h:918
settings.h
DirIsWritable
bool DirIsWritable(const fs::path &directory)
Definition: system.cpp:131
fs.h
util::TraceThread
void TraceThread(const char *thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
Definition: thread.cpp:13
DEFAULT_BLOCK_MAX_WEIGHT
static const unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create.
Definition: policy.h:20
BITCOIN_SETTINGS_FILENAME
const char *const BITCOIN_SETTINGS_FILENAME
Definition: system.cpp:82
IsHexNumber
bool IsHexNumber(const std::string &str)
Return true if the string is a hex number, optionally prefixed with "0x".
Definition: strencodings.cpp:71
InitParameterInteraction
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:631
DEFAULT_ANCESTOR_SIZE_LIMIT
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
Definition: validation.h:69
OptionsCategory::RPC
@ RPC
asmap.h
ArgsManager::GetDataDirNet
const fs::path & GetDataDirNet() const
Get data directory path with appended network identifier.
Definition: system.h:282
init::SetGlobals
void SetGlobals()
Definition: common.cpp:26
DEFAULT_HTTP_WORKQUEUE
static const int DEFAULT_HTTP_WORKQUEUE
Definition: httpserver.h:12
CConnman::Options::vBinds
std::vector< CService > vBinds
Definition: net.h:762
base_uint::GetHex
std::string GetHex() const
Definition: arith_uint256.cpp:147
CZMQNotificationInterface::Create
static CZMQNotificationInterface * Create()
Definition: zmqnotificationinterface.cpp:32
NET_PERMISSIONS_DOC
const std::vector< std::string > NET_PERMISSIONS_DOC
Definition: net_permissions.cpp:11
DEFAULT_MAX_TIME_ADJUSTMENT
static const int64_t DEFAULT_MAX_TIME_ADJUSTMENT
Definition: timedata.h:13
ArgsManager::SoftSetBoolArg
bool SoftSetBoolArg(const std::string &strArg, bool fValue)
Set a boolean argument if it doesn't already have a value.
Definition: system.cpp:614
uiInterface
CClientUIInterface uiInterface
Definition: ui_interface.cpp:12
InitLogging
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:709
ArgsManager::GetBlocksDirPath
const fs::path & GetBlocksDirPath() const
Get blocks directory path.
Definition: system.cpp:397
CConnman::Options::m_i2p_accept_incoming
bool m_i2p_accept_incoming
Definition: net.h:770
moneystr.h
sync.h
handler
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:713
blockfilterindex.h
zmqrpc.h
nBytesPerSigOp
unsigned int nBytesPerSigOp
Definition: settings.cpp:14
timedata.h
CConnman::Options::nMaxOutboundLimit
uint64_t nMaxOutboundLimit
Definition: net.h:757
CChainParams::IsTestChain
bool IsTestChain() const
If this chain is exclusively used for testing.
Definition: chainparams.h:101
fsbridge::get_filesystem_error_message
std::string get_filesystem_error_message(const fs::filesystem_error &e)
Definition: fs.cpp:137
string.h
CleanupBlockRevFiles
void CleanupBlockRevFiles()
Definition: blockstorage.cpp:60
InterruptRPC
void InterruptRPC()
Definition: server.cpp:297
bilingual_str
Bilingual messages:
Definition: translation.h:16
nMaxDbCache
static const int64_t nMaxDbCache
max. -dbcache (MiB)
Definition: txdb.h:31
NET_MAX
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:69
MAX_SCRIPTCHECK_THREADS
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
Definition: validation.h:77
DEFAULT_MAX_PEER_CONNECTIONS
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:71
ArgsManager::ALLOW_ANY
@ ALLOW_ANY
Definition: system.h:166
SetupChainParamsBaseOptions
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
Definition: chainparamsbase.cpp:18
ArgsManager::GetChainName
std::string GetChainName() const
Returns the appropriate chain name from the program arguments.
Definition: system.cpp:988
WalletInitInterface::ParameterInteraction
virtual bool ParameterInteraction() const =0
Check wallet parameter interaction.
BlockFilterTypeByName
bool BlockFilterTypeByName(const std::string &name, BlockFilterType &filter_type)
Find a filter type by its human-readable name.
Definition: blockfilter.cpp:185
FormatSubVersion
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...
Definition: clientversion.cpp:59
ArgsManager::IsArgSet
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: system.cpp:492
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:150
AllBlockFilterTypes
const std::set< BlockFilterType > & AllBlockFilterTypes()
Get a list of known filter types.
Definition: blockfilter.cpp:195
WalletInitInterface::AddWalletOptions
virtual void AddWalletOptions(ArgsManager &argsman) const =0
Get wallet help string.
StartTorControl
void StartTorControl(CService onion_service_target)
Definition: torcontrol.cpp:593
CConnman::Options::bind_on_any
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:766
validationinterface.h
nConnectTimeout
int nConnectTimeout
Definition: netbase.cpp:36
DEFAULT_MAXRECEIVEBUFFER
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:84
BlockFilterIndex
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
Definition: blockfilterindex.h:24
DEFAULT_MEMPOOL_EXPIRY
static const unsigned int DEFAULT_MEMPOOL_EXPIRY
Default for -mempoolexpiry, expiration time for mempool transactions in hours.
Definition: validation.h:75
CConnman::Options::nLocalServices
ServiceFlags nLocalServices
Definition: net.h:746
CBaseChainParams::TESTNET
static const std::string TESTNET
Definition: chainparamsbase.h:23
ResolveErrMsg
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
Definition: error.cpp:43
InterruptTorControl
void InterruptTorControl()
Definition: torcontrol.cpp:612
DEFAULT_STOPATHEIGHT
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
Definition: validation.h:88
CChainParams
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:69
CopyrightHolders
std::string CopyrightHolders(const std::string &strPrefix)
Definition: system.cpp:1349
RegisterAllCoreRPCCommands
static void RegisterAllCoreRPCCommands(CRPCTable &t)
Definition: register.h:25
minRelayTxFee
CFeeRate minRelayTxFee
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)
Definition: validation.cpp:131
OnRPCStarted
static void OnRPCStarted()
Definition: init.cpp:338
CConnman::Options::m_added_nodes
std::vector< std::string > m_added_nodes
Definition: net.h:769
HandleSIGHUP
static void HandleSIGHUP(int)
Definition: init.cpp:313
CChainParams::GetConsensus
const Consensus::Params & GetConsensus() const
Definition: chainparams.h:82
AnnotatedMixin< std::mutex >
SAFE_CHARS_UA_COMMENT
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
Definition: strencodings.h:24
LicenseInfo
std::string LicenseInfo()
Returns licensing information (for -version)
Definition: init.cpp:569
interfaces::BlockAndHeaderTipInfo
Block and header tip information.
Definition: node.h:44
HandleSIGTERM
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
Definition: init.cpp:308
ServiceFlags
ServiceFlags
nServices flags
Definition: protocol.h:271
OptionsCategory::CONNECTION
@ CONNECTION
nMaxTxIndexCache
static const int64_t nMaxTxIndexCache
Max memory allocated to block tree DB specific cache, if -txindex (MiB)
Definition: txdb.h:39
NODE_NETWORK_LIMITED
@ NODE_NETWORK_LIMITED
Definition: protocol.h:291
StopREST
void StopREST()
Stop HTTP REST subsystem.
Definition: rest.cpp:738
InterruptHTTPRPC
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
Definition: httprpc.cpp:310
TRY_LOCK
#define TRY_LOCK(cs, name)
Definition: sync.h:230
CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM
static const int DEFAULT_ZMQ_SNDHWM
Definition: zmqabstractnotifier.h:21
fDiscover
bool fDiscover
Definition: net.cpp:111
Consensus::Params::defaultAssumeValid
uint256 defaultAssumeValid
By default assume that the signatures in ancestors of this block are valid.
Definition: params.h:109
DEFAULT_STOPAFTERBLOCKIMPORT
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
Definition: blockstorage.h:29
NODE_NETWORK
@ NODE_NETWORK
Definition: protocol.h:277
MIN_BLOCKS_TO_KEEP
static const unsigned int MIN_BLOCKS_TO_KEEP
Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ::ChainActive()....
Definition: validation.h:90
NetWhitelistPermissions::TryParse
static bool TryParse(const std::string &str, NetWhitelistPermissions &output, bilingual_str &error)
Definition: net_permissions.cpp:107
bitcoin-config.h
coinstatsindex.h
chainparams.h
AppInitBasicSetup
bool AppInitBasicSetup(const ArgsManager &args)
Initialize bitcoin core: Basic context setup.
Definition: init.cpp:739
chain.h
ChainstateManager::ActiveChainstate
CChainState & ActiveChainstate() const
The most-work chain.
Definition: validation.cpp:4872
RPCServer::OnStopped
void OnStopped(std::function< void()> slot)
Definition: server.cpp:74
OnRPCStopped
static void OnRPCStopped()
Definition: init.cpp:343
sanity.h
Network
Network
A network type.
Definition: netaddress.h:45
DEFAULT_MAX_SIG_CACHE_SIZE
static const unsigned int DEFAULT_MAX_SIG_CACHE_SIZE
Definition: sigcache.h:18
SetupHelpOptions
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
Definition: system.cpp:742
DEFAULT_DESCENDANT_LIMIT
static const unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
Definition: validation.h:71
CChain::Tip
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:403
NODE_COMPACT_FILTERS
@ NODE_COMPACT_FILTERS
Definition: protocol.h:287
StartHTTPServer
void StartHTTPServer()
Start HTTP server.
Definition: httpserver.cpp:415
context.h
DEFAULT_FORCEDNSSEED
static constexpr bool DEFAULT_FORCEDNSSEED
Definition: net.h:81
g_genesis_wait_cv
static std::condition_variable g_genesis_wait_cv
Definition: init.cpp:590
PeerManager::make
static std::unique_ptr< PeerManager > make(const CChainParams &chainparams, CConnman &connman, CAddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, bool ignore_incoming_txs)
Definition: net_processing.cpp:1422
nDefaultDbCache
static const int64_t nDefaultDbCache
-dbcache default (MiB)
Definition: txdb.h:27
proxyType
Definition: netbase.h:48
GetRand
uint64_t GetRand(uint64_t nMax) noexcept
Generate a uniform random integer in the range [0..range).
Definition: random.cpp:591
Assert
#define Assert(val)
Identity function.
Definition: check.h:57
rpc_notify_block_change_connection
static boost::signals2::connection rpc_notify_block_change_connection
Definition: init.cpp:337
CService::ToStringIPPort
std::string ToStringIPPort() const
Definition: netaddress.cpp:1028
CFeeRate
Fee rate in satoshis per kilobyte: CAmount / kB.
Definition: feerate.h:29
ArgsManager::DEBUG_ONLY
@ DEBUG_ONLY
Definition: system.h:167
scheduler.h
BITCOIN_CONF_FILENAME
const char *const BITCOIN_CONF_FILENAME
Definition: system.cpp:81
bilingual_str::empty
bool empty() const
Definition: translation.h:27
validation.h
LockDirectory
bool LockDirectory(const fs::path &directory, const std::string lockfile_name, bool probe_only)
Definition: system.cpp:95
DEFAULT_BLOCK_MIN_TX_FEE
static const 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:22
interfaces::BlockAndHeaderTipInfo::block_time
int64_t block_time
Definition: node.h:47
fReindex
std::atomic_bool fReindex
DEFAULT_MAX_ORPHAN_TRANSACTIONS
static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS
Default for -maxorphantx, maximum number of orphan transactions kept in memory.
Definition: net_processing.h:18
nDefaultDbBatchSize
static const int64_t nDefaultDbBatchSize
-dbbatchsize default (bytes)
Definition: txdb.h:29
cs
static void pool cs
Definition: mempool_eviction.cpp:12
g_coin_stats_index
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
Definition: coinstatsindex.cpp:94
BanMan::DumpBanlist
void DumpBanlist()
Definition: banman.cpp:40
GetMainSignals
CMainSignals & GetMainSignals()
Definition: validationinterface.cpp:116
ChainstateManager::ActiveChain
CChain & ActiveChain() const
Definition: validation.h:957
AmountErrMsg
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
Definition: error.cpp:53
txmempool.h
DEFAULT_LISTEN_ONION
static const bool DEFAULT_LISTEN_ONION
Definition: torcontrol.h:28
shutdown.h
txindex.h
deploymentstatus.h
BCLog::RPC
@ RPC
Definition: logging.h:45
DEFAULT_UPNP
static constexpr bool DEFAULT_UPNP
Definition: mapport.h:11
NetWhitelistPermissions
Definition: net_permissions.h:82
fsbridge::ofstream
fs::ofstream ofstream
Definition: fs.h:102
init::SetLoggingOptions
void SetLoggingOptions(const ArgsManager &args)
Definition: common.cpp:81
SetRPCWarmupFinished
void SetRPCWarmupFinished()
Definition: server.cpp:337
NET_I2P
@ NET_I2P
I2P.
Definition: netaddress.h:59
SetRPCWarmupStatus
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:331
protocol.h
StartScriptCheckWorkerThreads
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
Definition: validation.cpp:1481
MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
Definition: net.h:61
nMinimumChainWork
arith_uint256 nMinimumChainWork
Minimum work we will assume exists on some valid chain.
Definition: validation.cpp:129
DEFAULT_INCREMENTAL_RELAY_FEE
static const unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or BIP...
Definition: policy.h:34
BaseIndex::Stop
void Stop()
Stops the instance from staying in sync with blockchain updates.
Definition: base.cpp:355
banman.h
Consensus::Params::SegwitHeight
int SegwitHeight
Block height at which Segwit (BIP141, BIP143 and BIP147) becomes active.
Definition: params.h:87
CURRENCY_UNIT
const std::string CURRENCY_UNIT
Definition: feerate.h:14
DEFAULT_PEERBLOCKFILTERS
static const bool DEFAULT_PEERBLOCKFILTERS
Definition: net_processing.h:22
OptionsCategory::NODE_RELAY
@ NODE_RELAY
DEFAULT_ANCESTOR_LIMIT
static const unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
Definition: validation.h:67
Untranslated
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:46
DEFAULT_MAXSENDBUFFER
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:85
blockfilter.h
LOCAL_MANUAL
@ LOCAL_MANUAL
Definition: net.h:193
DEFAULT_TOR_CONTROL
const std::string DEFAULT_TOR_CONTROL
Default control port.
Definition: torcontrol.cpp:39
DecodeAsmap
std::vector< bool > DecodeAsmap(fs::path path)
Read asmap from provided binary file.
Definition: asmap.cpp:193
nMinDbCache
static const int64_t nMinDbCache
min. -dbcache (MiB)
Definition: txdb.h:33
CBlockHeader::GetBlockTime
int64_t GetBlockTime() const
Definition: block.h:55
CConnman::Options::vWhitelistedRange
std::vector< NetWhitelistPermissions > vWhitelistedRange
Definition: net.h:760
interfaces::BlockAndHeaderTipInfo::block_height
int block_height
Definition: node.h:46
DEFAULT_COINSTATSINDEX
static constexpr bool DEFAULT_COINSTATSINDEX
Definition: validation.h:83
CLIENT_NAME
const std::string CLIENT_NAME
max_filter_index_cache
static const int64_t max_filter_index_cache
Max memory allocated to all block filter index caches combined in MiB.
Definition: txdb.h:41
PACKAGE_NAME
#define PACKAGE_NAME
Definition: bitcoin-config.h:362
DEFAULT_PRINTPRIORITY
static const bool DEFAULT_PRINTPRIORITY
Definition: miner.h:26
init::LogPackageVersion
void LogPackageVersion()
Definition: common.cpp:157
init.h
CheckDiskSpace
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
Definition: system.cpp:144
DefaultOnionServiceTarget
CService DefaultOnionServiceTarget()
Definition: torcontrol.cpp:631
SetMockTime
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:101
DEFAULT_PEERBLOOMFILTERS
static const bool DEFAULT_PEERBLOOMFILTERS
Definition: net_processing.h:21
node.h
InitError
bool InitError(const bilingual_str &str)
Show error message.
Definition: ui_interface.cpp:56
DEFAULT_CHECKPOINTS_ENABLED
static const bool DEFAULT_CHECKPOINTS_ENABLED
Definition: validation.h:81
g_zmq_notification_interface
CZMQNotificationInterface * g_zmq_notification_interface
Definition: zmqnotificationinterface.cpp:191
fRequireStandard
bool fRequireStandard
Definition: validation.cpp:123
PACKAGE_URL
#define PACKAGE_URL
Definition: bitcoin-config.h:371
ArgsManager::AddArg
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
Definition: system.cpp:640
AppInitMain
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
Definition: init.cpp:1076
util::ThreadRename
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:57
CMainSignals::FlushBackgroundCallbacks
void FlushBackgroundCallbacks()
Call any remaining callbacks on the calling thread.
Definition: validationinterface.cpp:103
RegisterZMQRPCCommands
void RegisterZMQRPCCommands(CRPCTable &t)
Definition: zmqrpc.cpp:62
miner.h
CBaseChainParams::REGTEST
static const std::string REGTEST
Definition: chainparamsbase.h:25
StopHTTPRPC
void StopHTTPRPC()
Stop HTTP RPC subsystem.
Definition: httprpc.cpp:315
tableRPC
CRPCTable tableRPC
Definition: server.cpp:548
DEFAULT_MAX_TIP_AGE
static const int64_t DEFAULT_MAX_TIP_AGE
Definition: validation.h:80
CConnman::Options::onion_binds
std::vector< CService > onion_binds
Definition: net.h:763
pindexBestHeader
CBlockIndex * pindexBestHeader
Best header we've seen so far (used for getheaders queries' starting points).
Definition: validation.cpp:118
nMaxCoinsDBCache
static const int64_t nMaxCoinsDBCache
Max memory allocated to coin DB specific cache (MiB)
Definition: txdb.h:43
SetReachable
void SetReachable(enum Network net, bool reachable)
Mark a network as reachable or unreachable (no automatic connects to it)
Definition: net.cpp:271
StartHTTPRPC
bool StartHTTPRPC(const std::any &context)
Start HTTP RPC subsystem.
Definition: httprpc.cpp:292
ArgsManager::GetUnsuitableSectionOnlyArgs
const std::set< std::string > GetUnsuitableSectionOnlyArgs() const
Log warnings for options in m_section_only_args when they are specified in the default section but no...
Definition: system.cpp:262
CBlockTreeDB
Access to the block database (blocks/index/)
Definition: txdb.h:77
CConnman::Options::m_peer_connect_timeout
int64_t m_peer_connect_timeout
Definition: net.h:758
fHavePruned
bool fHavePruned
Pruning-related variables and constants.
Definition: blockstorage.cpp:24
ArgsManager::GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:588
NODE_BLOOM
@ NODE_BLOOM
Definition: protocol.h:281
LogPrintf
#define LogPrintf(...)
Definition: logging.h:185
OptionsCategory::OPTIONS
@ OPTIONS
base_blob::GetHex
std::string GetHex() const
Definition: uint256.cpp:20
DEFAULT_DAEMONWAIT
static constexpr bool DEFAULT_DAEMONWAIT
Default value for -daemonwait option.
Definition: init.h:16
standard.h
init.h
CChainParams::NetworkIDString
std::string NetworkIDString() const
Return the network string.
Definition: chainparams.h:112
CConnman::Options::m_use_addrman_outgoing
bool m_use_addrman_outgoing
Definition: net.h:767
DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN
static const unsigned int DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN
Default number of orphan+recently-replaced txn to keep around for block reconstruction.
Definition: net_processing.h:20
DEFAULT_FIXEDSEEDS
static constexpr bool DEFAULT_FIXEDSEEDS
Definition: net.h:83
Interrupt
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:158
LoadAddrman
std::optional< bilingual_str > LoadAddrman(const std::vector< bool > &asmap, const ArgsManager &args, std::unique_ptr< CAddrMan > &addrman)
Returns an error string on failure.
Definition: addrdb.cpp:184
CNetAddr::IsValid
bool IsValid() const
Definition: netaddress.cpp:451
CConnman::Options::m_max_outbound_block_relay
int m_max_outbound_block_relay
Definition: net.h:749
fNameLookup
bool fNameLookup
Definition: netbase.cpp:37
CreateBaseChainParams
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const std::string &chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 18445) have been chosen arbitrarily to...
Definition: chainparamsbase.cpp:43
BCLog::Logger::m_reopen_file
std::atomic< bool > m_reopen_file
Definition: logging.h:100
CheckLegacyTxindex
std::optional< bilingual_str > CheckLegacyTxindex(CBlockTreeDB &block_tree_db)
Definition: txdb.cpp:35
Discover
void Discover()
Definition: net.cpp:2374
bilingual_str::translated
std::string translated
Definition: translation.h:18
DEFAULT_ASMAP_FILENAME
static const char * DEFAULT_ASMAP_FILENAME
Definition: init.cpp:106
CMainSignals::RegisterBackgroundSignalScheduler
void RegisterBackgroundSignalScheduler(CScheduler &scheduler)
Register a CScheduler to give callbacks which should run in the background (may only be called once)
Definition: validationinterface.cpp:92
DEFAULT_PROXYRANDOMIZE
static const bool DEFAULT_PROXYRANDOMIZE
Definition: init.cpp:94
AppInitParameterInteraction
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:784
GetNumCores
int GetNumCores()
Return the number of cores available on the current system.
Definition: system.cpp:1344
DEFAULT_PERMIT_BAREMULTISIG
static const bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
Definition: policy.h:38
hashAssumeValid
uint256 hashAssumeValid
Block hash whose ancestors we will assume to have valid scripts without checking them.
Definition: validation.cpp:128
DUMP_BANS_INTERVAL
static constexpr std::chrono::minutes DUMP_BANS_INTERVAL
How often to dump banned addresses/subnets to disk.
Definition: banman.h:22
base_blob::ToString
std::string ToString() const
Definition: uint256.cpp:64
CChainParams::GenesisBlock
const CBlock & GenesisBlock() const
Definition: chainparams.h:95
DEFAULT_RPC_SERIALIZE_VERSION
static const unsigned int DEFAULT_RPC_SERIALIZE_VERSION
Definition: server.h:20
ChainstateManager::GetAll
CChainState &InitializeChainstate(CTxMemPool *mempool, const std::optional< uint256 > &snapshot_blockhash=std::nullopt) LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(std::vector< CChainState * GetAll)()
Instantiate a new chainstate and assign it based upon whether it is from a snapshot.
Definition: validation.h:937
uint256
256-bit opaque blob.
Definition: uint256.h:124
nMaxDatacarrierBytes
unsigned nMaxDatacarrierBytes
Maximum size of TxoutType::NULL_DATA scripts that this node considers standard.
Definition: standard.cpp:20
uint256S
uint256 uint256S(const char *str)
Definition: uint256.h:137
new_handler_terminate
static void new_handler_terminate()
Definition: init.cpp:726
CFeeRate::ToString
std::string ToString(const FeeEstimateMode &fee_estimate_mode=FeeEstimateMode::BTC_KVB) const
Definition: feerate.cpp:35
CChainState
CChainState stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:556
MAX_FEELER_CONNECTIONS
static const int MAX_FEELER_CONNECTIONS
Maximum number of feeler connections.
Definition: net.h:67
walletinitinterface.h
init::UnsetGlobals
void UnsetGlobals()
Definition: common.cpp:35
AppInitSanityChecks
bool AppInitSanityChecks()
Initialization sanity checks: ecc init, sanity checks, dir lock.
Definition: init.cpp:1037
LogPrint
#define LogPrint(category,...)
Definition: logging.h:189
CConnman::Options::nReceiveFloodSize
unsigned int nReceiveFloodSize
Definition: net.h:756
CMainSignals::UnregisterBackgroundSignalScheduler
void UnregisterBackgroundSignalScheduler()
Unregister a CScheduler to give callbacks which should run in the background - these callbacks will n...
Definition: validationinterface.cpp:98
zmqnotificationinterface.h
ListBlockFilterTypes
const std::string & ListBlockFilterTypes()
Get a comma-separated list of known filter type names.
Definition: blockfilter.cpp:209
GetNetworkNames
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:118
chain.h
DEFAULT_CONNECT_TIMEOUT
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
Definition: netbase.h:28
net_processing.h
CConnman::Options
Definition: net.h:744
CBlockIndex::GetBlockHash
uint256 GetBlockHash() const
Definition: chain.h:246
gArgs
ArgsManager gArgs
Definition: system.cpp:84
UnregisterValidationInterface
void UnregisterValidationInterface(CValidationInterface *callbacks)
Unregister subscriber.
Definition: validationinterface.cpp:140
DEFAULT_MIN_RELAY_TX_FEE
static const unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: validation.h:65
RaiseFileDescriptorLimit
int RaiseFileDescriptorLimit(int nMinFD)
this function tries to raise the file descriptor limit to the requested number.
Definition: system.cpp:1148
BlockFilterType::BASIC
@ BASIC
ArgsManager::SENSITIVE
@ SENSITIVE
Definition: system.h:175
CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:428
interfaces::BlockAndHeaderTipInfo::header_time
int64_t header_time
Definition: node.h:49
CConnman::Options::nMaxConnections
int nMaxConnections
Definition: net.h:747
DEFAULT_MAX_UPLOAD_TARGET
static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:73
bilingual_str::original
std::string original
Definition: translation.h:17
CBaseChainParams::MAIN
static const std::string MAIN
Chain name strings.
Definition: chainparamsbase.h:22
BanMan
Definition: banman.h:58
CChainParams::MessageStart
const CMessageHeader::MessageStartChars & MessageStart() const
Definition: chainparams.h:83
CConnman::Options::nSendBufferMaxSize
unsigned int nSendBufferMaxSize
Definition: net.h:755
ChainstateManager
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:858
OptionsCategory::ZMQ
@ ZMQ
attributes.h
g_genesis_wait_mutex
static Mutex g_genesis_wait_mutex
Definition: init.cpp:589
CVerifyDB
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
Definition: validation.h:346
interfaces::BlockAndHeaderTipInfo::verification_progress
double verification_progress
Definition: node.h:50
name
const char * name
Definition: rest.cpp:43
ui_interface.h
OptionsCategory::BLOCK_CREATION
@ BLOCK_CREATION
CConnman::Options::uiInterface
CClientUIInterface * uiInterface
Definition: net.h:752
UnregisterAllValidationInterfaces
void UnregisterAllValidationInterfaces()
Unregister all subscribers.
Definition: validationinterface.cpp:147
DEFAULT_NAME_LOOKUP
static const int DEFAULT_NAME_LOOKUP
-dns default
Definition: netbase.h:30
InitSignatureCache
void InitSignatureCache()
Definition: sigcache.cpp:95
NODE_WITNESS
@ NODE_WITNESS
Definition: protocol.h:284
InitWarning
void InitWarning(const bilingual_str &str)
Show warning message.
Definition: ui_interface.cpp:62
system.h
SetProxy
bool SetProxy(enum Network net, const proxyType &addrProxy)
Definition: netbase.cpp:605
StopScriptCheckWorkerThreads
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
Definition: validation.cpp:1486
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1164
CClientUIInterface::MSG_ERROR
@ MSG_ERROR
Definition: ui_interface.h:68
Join
auto Join(const std::vector< T > &list, const BaseType &separator, UnaryOp unary_op) -> decltype(unary_op(list.at(0)))
Join a list of items.
Definition: string.h:44
fCheckpointsEnabled
bool fCheckpointsEnabled
Definition: validation.cpp:125
httprpc.h
RPCNotifyBlockChange
void RPCNotifyBlockChange(const CBlockIndex *pindex)
Callback for when block tip changed.
Definition: blockchain.cpp:273
incrementalRelayFee
CFeeRate incrementalRelayFee
Definition: settings.cpp:12
strSubVersion
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:116
CConnman::Options::nMaxFeeler
int nMaxFeeler
Definition: net.h:751
GetAdjustedTime
int64_t GetAdjustedTime()
Definition: timedata.cpp:34
SanitizeString
std::string SanitizeString(const std::string &str, int rule)
Remove unsafe chars.
Definition: strencodings.cpp:27
MAX_OP_RETURN_RELAY
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for nMaxDatacarrierBytes.
Definition: standard.h:38
interfaces::BlockAndHeaderTipInfo::header_height
int header_height
Definition: node.h:48
NetWhitebindPermissions::TryParse
static bool TryParse(const std::string &str, NetWhitebindPermissions &output, bilingual_str &error)
Definition: net_permissions.cpp:84
MIN_DISK_SPACE_FOR_BLOCK_FILES
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Definition: validation.h:101
base_blob::IsNull
bool IsNull() const
Definition: uint256.h:31
MAX_BLOCK_RELAY_ONLY_CONNECTIONS
static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS
Maximum number of block-relay-only outgoing connections.
Definition: net.h:65
Consensus::Params::hashGenesisBlock
uint256 hashGenesisBlock
Definition: params.h:71
AppInitLockDataDirectory
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
Definition: init.cpp:1053
SetNameProxy
bool SetNameProxy(const proxyType &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
Definition: netbase.cpp:623
StopMapPort
void StopMapPort()
Definition: mapport.cpp:333
DEFAULT_WHITELISTRELAY
static const bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
Definition: net.h:46
fees.h
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:116
ArgsManager
Definition: system.h:158
torcontrol.h
translation.h
CConnman::Options::m_msgproc
NetEventsInterface * m_msgproc
Definition: net.h:753
BaseParams
const CBaseChainParams & BaseParams()
Return the currently selected parameters.
Definition: chainparamsbase.cpp:33
MAX_ADDNODE_CONNECTIONS
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:63
GetBlockFilterIndex
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
Definition: blockfilterindex.cpp:452
UintToArith256
arith_uint256 UintToArith256(const uint256 &a)
Definition: arith_uint256.cpp:253
EXCLUSIVE_LOCKS_REQUIRED
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
ForEachBlockFilterIndex
void ForEachBlockFilterIndex(std::function< void(BlockFilterIndex &)> fn)
Iterate over all running block filter indexes, invoking fn on each.
Definition: blockfilterindex.cpp:458
LOCK
#define LOCK(cs)
Definition: sync.h:226
WalletInitInterface::Construct
virtual void Construct(NodeContext &node) const =0
Add wallets that should be opened to list of chain clients.
DEFAULT_MISBEHAVING_BANTIME
static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME
Definition: banman.h:19
fCheckBlockIndex
bool fCheckBlockIndex
Definition: validation.cpp:124
GetPidFile
static fs::path GetPidFile(const ArgsManager &args)
Definition: init.cpp:113
RegisterValidationInterface
void RegisterValidationInterface(CValidationInterface *callbacks)
Register subscriber.
Definition: validationinterface.cpp:128
ChainstateManager::LoadBlockIndex
bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the block tree and coins database from disk, initializing state if we're running with -reindex.
Definition: validation.cpp:3992
MIN_CORE_FILEDESCRIPTORS
#define MIN_CORE_FILEDESCRIPTORS
Definition: init.cpp:103
blockstorage.h
ParseMoney
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
Definition: moneystr.cpp:41
InterruptHTTPServer
void InterruptHTTPServer()
Interrupt HTTP server threads.
Definition: httpserver.cpp:427
NET_ONION
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:56
init::StartLogging
bool StartLogging(const ArgsManager &args)
Definition: common.cpp:120
CChainParams::RequireStandard
bool RequireStandard() const
Policy: Filter transactions that do not match well-defined patterns.
Definition: chainparams.h:99
CLIENT_VERSION
static const int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
Definition: clientversion.h:33
nMaxTipAge
int64_t nMaxTipAge
If the tip is older than this (in seconds), the node is considered to be in initial block download.
Definition: validation.cpp:126
AppInitServers
static bool AppInitServers(NodeContext &node)
Definition: init.cpp:614
InitScriptExecutionCache
void InitScriptExecutionCache()
Initializes the script-execution cache.
Definition: validation.cpp:1256
ArgsManager::GetUnrecognizedSections
const std::list< SectionInfo > GetUnrecognizedSections() const
Log warnings for unrecognized section names in the config file.
Definition: system.cpp:282
LogInstance
BCLog::Logger & LogInstance()
Definition: logging.cpp:17
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:536
fIsBareMultisigStd
bool fIsBareMultisigStd
Definition: settings.cpp:11
DumpMempool
bool DumpMempool(const CTxMemPool &pool, FopenFn mockable_fopen_function, bool skip_file_commit)
Dump the mempool to disk.
Definition: validation.cpp:4467
OptionsCategory::DEBUG_TEST
@ DEBUG_TEST
SetupNetworking
bool SetupNetworking()
Definition: system.cpp:1332
DEFAULT_BLOCKFILTERINDEX
static const char *const DEFAULT_BLOCKFILTERINDEX
Definition: validation.h:84
hash.h
CConnman::Options::m_specified_outgoing
std::vector< std::string > m_specified_outgoing
Definition: net.h:768
DEFAULT_PEER_CONNECT_TIMEOUT
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:77
node
Definition: interfaces.cpp:68
NUM_FDS_MESSAGE_CAPTURE
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:79
InterruptREST
void InterruptREST()
Interrupt RPC REST subsystem.
Definition: rest.cpp:734
register.h
RpcInterruptionPoint
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:326
InitBlockFilterIndex
bool InitBlockFilterIndex(BlockFilterType filter_type, size_t n_cache_size, bool f_memory, bool f_wipe)
Initialize a block filter index for the given type if one does not already exist.
Definition: blockfilterindex.cpp:463
BlockFilterType
BlockFilterType
Definition: blockfilter.h:88
RPCServer::OnStarted
void OnStarted(std::function< void()> slot)
Definition: server.cpp:69
NET_IPV6
@ NET_IPV6
IPv6.
Definition: netaddress.h:53
addrman.h
LockDataDirectory
static bool LockDataDirectory(bool probeOnly)
Definition: init.cpp:1024
DEFAULT_SCRIPTCHECK_THREADS
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
Definition: validation.h:79
fHaveGenesis
static bool fHaveGenesis
Definition: init.cpp:588
DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
Definition: addrman.h:23
DUST_RELAY_TX_FEE
static const unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
Definition: policy.h:54
DEFAULT_BYTES_PER_SIGOP
static const unsigned int DEFAULT_BYTES_PER_SIGOP
Default for -bytespersigop.
Definition: policy.h:36
StartRPC
void StartRPC()
Definition: server.cpp:290
SynchronizationState
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:104
StopTorControl
void StopTorControl()
Definition: torcontrol.cpp:622
util.h
ChainstateManager::m_total_coinsdb_cache
int64_t m_total_coinsdb_cache
The total number of bytes available for us to use across all leveldb coins databases.
Definition: validation.h:922
CConnman::Options::m_max_outbound_full_relay
int m_max_outbound_full_relay
Definition: net.h:748
netbase.h
DEFAULT_TXINDEX
static const bool DEFAULT_TXINDEX
Definition: validation.h:82
ArgsManager::ALLOW_BOOL
@ ALLOW_BOOL
Definition: system.h:163
DEFAULT_NATPMP
static constexpr bool DEFAULT_NATPMP
Definition: mapport.h:17
Consensus::Params::nMinimumChainWork
uint256 nMinimumChainWork
The best chain should have at least this much work.
Definition: params.h:107
blockchain.h
httpserver.h
sigcache.h
ArgsManager::GetArgs
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: system.cpp:483
nPruneTarget
uint64_t nPruneTarget
Number of MiB of block files that we're trying to stay below.
Definition: blockstorage.cpp:26
DEFAULT_DESCENDANT_SIZE_LIMIT
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
Definition: validation.h:73
DEFAULT_WHITELISTFORCERELAY
static const bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
Definition: net.h:48
DEFAULT_REST_ENABLE
static const bool DEFAULT_REST_ENABLE
Definition: init.cpp:95
error
bool error(const char *fmt, const Args &... args)
Definition: system.h:49
Lookup
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:195
NodeContext
NodeContext struct containing references to chain state and connection state.
Definition: context.h:39
nMaxBlockDBCache
static const int64_t nMaxBlockDBCache
Max memory allocated to block tree DB specific cache, if no -txindex (MiB)
Definition: txdb.h:35
fListen
bool fListen
Definition: net.cpp:112
DEFAULT_BLOCKSONLY
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:75
server.h
ThreadImport
void ThreadImport(ChainstateManager &chainman, std::vector< fs::path > vImportFiles, const ArgsManager &args)
Definition: blockstorage.cpp:490
DEFAULT_DNSSEED
static constexpr bool DEFAULT_DNSSEED
Definition: net.h:82
UnloadBlockIndex
void UnloadBlockIndex(CTxMemPool *mempool, ChainstateManager &chainman)
Unload database information.
Definition: validation.cpp:3974
net.h
txorphanage.h
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:137
GetListenPort
uint16_t GetListenPort()
Definition: net.cpp:124
RandAddPeriodic
void RandAddPeriodic() noexcept
Gather entropy from various expensive sources, and feed them to the PRNG state.
Definition: random.cpp:586
StopHTTPServer
void StopHTTPServer()
Stop HTTP server.
Definition: httpserver.cpp:439
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: strencodings.cpp:594
CChainState::LoadGenesisBlock
bool LoadGenesisBlock()
Ensures we have a genesis block in the block tree, possibly writing one to disk.
Definition: validation.cpp:4015
NetWhitebindPermissions
Definition: net_permissions.h:75
fAcceptDatacarrier
bool fAcceptDatacarrier
A data carrying output is an unspendable output containing data.
Definition: standard.cpp:19
StopRPC
void StopRPC()
Definition: server.cpp:308
COPYRIGHT_YEAR
#define COPYRIGHT_YEAR
Definition: bitcoin-config.h:36
threadnames.h
amount.h
thread.h
GuessVerificationProgress
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...
Definition: validation.cpp:4530
DEFAULT_HTTP_THREADS
static const int DEFAULT_HTTP_THREADS
Definition: httpserver.h:11
SetupServerArgs
void SetupServerArgs(ArgsManager &argsman)
Register all arguments with the ArgsManager.
Definition: init.cpp:351
DEFAULT_DAEMON
static constexpr bool DEFAULT_DAEMON
Default value for -daemon option.
Definition: init.h:14
MAX_SUBVERSION_LENGTH
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:59
StartShutdown
void StartShutdown()
Request shutdown of the application.
Definition: shutdown.cpp:56
g_parallel_script_checks
bool g_parallel_script_checks
Whether there are dedicated script-checking threads running.
Definition: validation.cpp:122
CConnman::Options::vWhiteBinds
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:761
CreateChainParams
std::unique_ptr< const CChainParams > CreateChainParams(const ArgsManager &args, const std::string &chain)
Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
Definition: chainparams.cpp:541
AbortShutdown
void AbortShutdown()
Clear shutdown flag.
Definition: shutdown.cpp:77
init::AddLoggingArgs
void AddLoggingArgs(ArgsManager &argsman)
Definition: common.cpp:61
registerSignalHandler
static void registerSignalHandler(int signal, void(*handler)(int))
Definition: init.cpp:327
txdb.h
BlockNotifyGenesisWait
static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex)
Definition: init.cpp:592
Shutdown
void Shutdown(NodeContext &node)
Definition: init.cpp:177
DestroyAllBlockFilterIndexes
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
Definition: blockfilterindex.cpp:478
GetTimeMillis
int64_t GetTimeMillis()
Returns the system time (not mockable)
Definition: time.cpp:117
UNIX_EPOCH_TIME
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
Definition: util.cpp:20
ChainstateManager::m_load_block
std::thread m_load_block
Definition: validation.h:911
SynchronizationState::POST_INIT
@ POST_INIT
dustRelayFee
CFeeRate dustRelayFee
Definition: settings.cpp:13
WAIT_LOCK
#define WAIT_LOCK(cs, name)
Definition: sync.h:231
DEFAULT_MAX_MEMPOOL_SIZE
static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE
Default for -maxmempool, maximum megabytes of mempool memory usage.
Definition: policy.h:32
InitHTTPServer
bool InitHTTPServer()
Initialize HTTP server.
Definition: httpserver.cpp:347
CConnman::Options::m_banman
BanMan * m_banman
Definition: net.h:754
ArgsManager::NETWORK_ONLY
@ NETWORK_ONLY
Definition: system.h:173
CBaseChainParams::SIGNET
static const std::string SIGNET
Definition: chainparamsbase.h:24
DEFAULT_HTTP_SERVER_TIMEOUT
static const int DEFAULT_HTTP_SERVER_TIMEOUT
Definition: httpserver.h:13
DEFAULT_CHECKBLOCKS
static const signed int DEFAULT_CHECKBLOCKS
Definition: validation.h:91
net_permissions.h
DEFAULT_LISTEN
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:69
CChainParams::DefaultConsistencyChecks
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
Definition: chainparams.h:97
FormatMoney
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:15
DEFAULT_ACCEPT_DATACARRIER
static const bool DEFAULT_ACCEPT_DATACARRIER
Definition: standard.h:18
g_best_block_cv
std::condition_variable g_best_block_cv
Definition: validation.cpp:120
AddLocal
bool AddLocal(const CService &addr, int nScore)
Definition: net.cpp:233