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