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