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