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