Bitcoin Core 31.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-present 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#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <init.h>
9
10#include <addrdb.h>
11#include <addrman.h>
12#include <banman.h>
13#include <blockfilter.h>
14#include <chain.h>
15#include <chainparams.h>
16#include <chainparamsbase.h>
17#include <clientversion.h>
18#include <common/args.h>
19#include <common/messages.h>
20#include <common/system.h>
21#include <compat/compat.h>
22#include <consensus/params.h>
23#include <crypto/hex_base.h>
24#include <dbwrapper.h>
25#include <httprpc.h>
26#include <httpserver.h>
27#include <index/base.h>
30#include <index/txindex.h>
32#include <init/common.h>
33#include <interfaces/chain.h>
34#include <interfaces/init.h>
35#include <interfaces/ipc.h>
36#include <interfaces/mining.h>
37#include <interfaces/node.h>
38#include <ipc/exception.h>
40#include <kernel/caches.h>
42#include <kernel/checks.h>
43#include <kernel/context.h>
45#include <key.h>
46#include <logging.h>
47#include <mapport.h>
48#include <net.h>
49#include <net_permissions.h>
50#include <net_processing.h>
51#include <netaddress.h>
52#include <netbase.h>
53#include <netgroup.h>
55#include <node/blockstorage.h>
56#include <node/caches.h>
57#include <node/chainstate.h>
59#include <node/context.h>
60#include <node/interface_ui.h>
62#include <node/mempool_args.h>
65#include <node/mining_args.h>
66#include <node/mining_types.h>
67#include <node/peerman_args.h>
68#include <policy/feerate.h>
71#include <policy/policy.h>
72#include <policy/settings.h>
73#include <protocol.h>
74#include <random.h>
75#include <rpc/register.h>
76#include <rpc/server.h>
77#include <rpc/util.h>
78#include <scheduler.h>
79#include <script/sigcache.h>
80#include <sync.h>
81#include <tinyformat.h>
82#include <torcontrol.h>
83#include <txgraph.h>
84#include <txmempool.h>
85#include <uint256.h>
86#include <util/asmap.h>
87#include <util/batchpriority.h>
88#include <util/btcsignals.h>
89#include <util/chaintype.h>
90#include <util/check.h>
91#include <util/fs.h>
92#include <util/fs_helpers.h>
93#include <util/moneystr.h>
94#include <util/result.h>
96#include <util/strencodings.h>
97#include <util/string.h>
98#include <util/syserror.h>
99#include <util/thread.h>
100#include <util/threadnames.h>
101#include <util/time.h>
102#include <util/translation.h>
103#include <validation.h>
104#include <validationinterface.h>
105#include <walletinitinterface.h>
106
107#include <algorithm>
108#include <any>
109#include <cerrno>
110#include <condition_variable>
111#include <cstddef>
112#include <cstdint>
113#include <exception>
114#include <fstream>
115#include <functional>
116#include <initializer_list>
117#include <list>
118#include <memory>
119#include <new>
120#include <optional>
121#include <set>
122#include <span>
123#include <string>
124#include <system_error>
125#include <thread>
126#include <tuple>
127#include <utility>
128#include <variant>
129#include <vector>
130
131#ifndef WIN32
132#include <csignal>
133#endif
134
135#ifdef ENABLE_ZMQ
138#include <zmq/zmqrpc.h>
139#endif
140
141#ifdef ENABLE_EMBEDDED_ASMAP
142#include <node/data/ip_asn.dat.h>
143#endif
144
147
165using util::Join;
166using util::ReplaceAll;
167using util::ToString;
168
169static constexpr bool DEFAULT_PROXYRANDOMIZE{true};
170static constexpr bool DEFAULT_REST_ENABLE{false};
171static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING{true};
172static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false};
173
174#ifdef WIN32
175// Win32 LevelDB doesn't use filedescriptors, and the ones used for
176// accessing block files don't count towards the fd_set size limit
177// anyway.
178#define MIN_LEVELDB_FDS 0
179#else
180#define MIN_LEVELDB_FDS 150
181#endif
182
184
188static const char* BITCOIN_PID_FILENAME = "bitcoind.pid";
193static bool g_generated_pid{false};
194
195static fs::path GetPidFile(const ArgsManager& args)
196{
198}
199
200[[nodiscard]] static bool CreatePidFile(const ArgsManager& args)
201{
202 if (args.IsArgNegated("-pid")) return true;
203
204 std::ofstream file{GetPidFile(args).std_path()};
205 if (file) {
206#ifdef WIN32
207 tfm::format(file, "%d\n", GetCurrentProcessId());
208#else
209 tfm::format(file, "%d\n", getpid());
210#endif
211 g_generated_pid = true;
212 return true;
213 } else {
214 return InitError(strprintf(_("Unable to create the PID file '%s': %s"), fs::PathToString(GetPidFile(args)), SysErrorString(errno)));
215 }
216}
217
218static void RemovePidFile(const ArgsManager& args)
219{
220 if (!g_generated_pid) return;
221 const auto pid_path{GetPidFile(args)};
222 if (std::error_code error; !fs::remove(pid_path, error)) {
223 std::string msg{error ? error.message() : "File does not exist"};
224 LogWarning("Unable to remove PID file (%s): %s", fs::PathToString(pid_path), msg);
225 }
226}
227
228static std::optional<util::SignalInterrupt> g_shutdown;
229
231{
233 g_shutdown.emplace();
234
235 node.args = &gArgs;
236 node.shutdown_signal = &*g_shutdown;
237 node.shutdown_request = [&node] {
238 assert(node.shutdown_signal);
239 if (!(*node.shutdown_signal)()) return false;
240 return true;
241 };
242}
243
245//
246// Shutdown
247//
248
249//
250// Thread management and startup/shutdown:
251//
252// The network-processing threads are all part of a thread group
253// created by AppInit() or the Qt main() function.
254//
255// A clean exit happens when the SignalInterrupt object is triggered, which
256// makes the main thread's SignalInterrupt::wait() call return, and join all
257// other ongoing threads in the thread group to the main thread.
258// Shutdown() is then called to clean up database connections, and stop other
259// threads that should only be stopped after the main network-processing
260// threads have exited.
261//
262// Shutdown for Qt is very similar, only it uses a QTimer to detect
263// ShutdownRequested() getting set, and then does the normal Qt
264// shutdown thing.
265//
266
268{
269 return bool{*Assert(node.shutdown_signal)};
270}
271
272#if HAVE_SYSTEM
273static void ShutdownNotify(const ArgsManager& args)
274{
275 std::vector<std::thread> threads;
276 for (const auto& cmd : args.GetArgs("-shutdownnotify")) {
277 threads.emplace_back(runCommand, cmd);
278 }
279 for (auto& t : threads) {
280 t.join();
281 }
282}
283#endif
284
286{
287#if HAVE_SYSTEM
288 ShutdownNotify(*node.args);
289#endif
290 // Wake any threads that may be waiting for the tip to change.
291 if (node.notifications) WITH_LOCK(node.notifications->m_tip_block_mutex, node.notifications->m_tip_block_cv.notify_all());
294 InterruptRPC();
296 if (node.tor_controller) {
297 node.tor_controller->Interrupt();
298 }
300 if (node.connman)
301 node.connman->Interrupt();
302 for (auto* index : node.indexes) {
303 index->Interrupt();
304 }
305}
306
308{
309 static Mutex g_shutdown_mutex;
310 TRY_LOCK(g_shutdown_mutex, lock_shutdown);
311 if (!lock_shutdown) return;
312 LogInfo("Shutdown in progress...");
313 Assert(node.args);
314
319 util::ThreadRename("shutoff");
320 if (node.mempool) node.mempool->AddTransactionsUpdated(1);
321
322 StopHTTPRPC();
323 StopREST();
324 StopRPC();
326 for (auto& client : node.chain_clients) {
327 try {
328 client->stop();
329 } catch (const ipc::Exception& e) {
330 LogDebug(BCLog::IPC, "Chain client did not disconnect cleanly: %s", e.what());
331 client.reset();
332 }
333 }
334 StopMapPort();
335
336 // Because these depend on each-other, we make sure that neither can be
337 // using the other before destroying them.
338 if (node.peerman && node.validation_signals) node.validation_signals->UnregisterValidationInterface(node.peerman.get());
339 if (node.connman) node.connman->Stop();
340
341 if (node.tor_controller) {
342 node.tor_controller->Join();
343 node.tor_controller.reset();
344 }
345
346 if (node.background_init_thread.joinable()) node.background_init_thread.join();
347 // After everything has been shut down, but before things get flushed, stop the
348 // the scheduler. After this point, SyncWithValidationInterfaceQueue() should not be called anymore
349 // as this would prevent the shutdown from completing.
350 if (node.scheduler) node.scheduler->stop();
351
352 // After the threads that potentially access these pointers have been stopped,
353 // destruct and reset all to nullptr.
354 node.peerman.reset();
355 node.connman.reset();
356 node.banman.reset();
357 node.addrman.reset();
358 node.netgroupman.reset();
359
360 if (node.mempool && node.mempool->GetLoadTried() && ShouldPersistMempool(*node.args)) {
361 DumpMempool(*node.mempool, MempoolPath(*node.args));
362 }
363
364 // Drop transactions we were still watching, record fee estimations and unregister
365 // fee estimator from validation interface.
366 if (node.fee_estimator) {
367 node.fee_estimator->Flush();
368 if (node.validation_signals) {
369 node.validation_signals->UnregisterValidationInterface(node.fee_estimator.get());
370 }
371 }
372
373 // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
374 if (node.chainman) {
375 LOCK(cs_main);
376 for (const auto& chainstate : node.chainman->m_chainstates) {
377 if (chainstate->CanFlushToDisk()) {
378 chainstate->ForceFlushStateToDisk();
379 }
380 }
381 }
382
383 // After there are no more peers/RPC left to give us new data which may generate
384 // CValidationInterface callbacks, flush them...
385 if (node.validation_signals) node.validation_signals->FlushBackgroundCallbacks();
386
387 // Stop and delete all indexes only after flushing background callbacks.
388 for (auto* index : node.indexes) index->Stop();
389 if (g_txindex) g_txindex.reset();
393 node.indexes.clear(); // all instances are nullptr now
394
395 // Any future callbacks will be dropped. This should absolutely be safe - if
396 // missing a callback results in an unrecoverable situation, unclean shutdown
397 // would too. The only reason to do the above flushes is to let the wallet catch
398 // up with our current chain to avoid any strange pruning edge cases and make
399 // next startup faster by avoiding rescan.
400
401 if (node.chainman) {
402 LOCK(cs_main);
403 for (const auto& chainstate : node.chainman->m_chainstates) {
404 if (chainstate->CanFlushToDisk()) {
405 chainstate->ForceFlushStateToDisk();
406 chainstate->ResetCoinsViews();
407 }
408 }
409 }
410
411 // If any -ipcbind clients are still connected, disconnect them now so they
412 // do not block shutdown.
413 if (interfaces::Ipc* ipc = node.init->ipc()) {
414 ipc->disconnectIncoming();
415 }
416
417#ifdef ENABLE_ZMQ
419 if (node.validation_signals) node.validation_signals->UnregisterValidationInterface(g_zmq_notification_interface.get());
421 }
422#endif
423
424 node.chain_clients.clear();
425 if (node.validation_signals) {
426 node.validation_signals->UnregisterAllValidationInterfaces();
427 }
428 node.mempool.reset();
429 node.fee_estimator.reset();
430 node.chainman.reset();
431 node.validation_signals.reset();
432 node.scheduler.reset();
433 node.ecc_context.reset();
434 node.kernel.reset();
435
436 RemovePidFile(*node.args);
437
438 LogInfo("Shutdown done");
439}
440
446#ifndef WIN32
447static void HandleSIGTERM(int)
448{
449 // Return value is intentionally ignored because there is not a better way
450 // of handling this failure in a signal handler.
451 (void)(*Assert(g_shutdown))();
452}
453
454static void HandleSIGHUP(int)
455{
456 LogInstance().m_reopen_file = true;
457}
458#else
459static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
460{
461 if (!(*Assert(g_shutdown))()) {
462 LogError("Failed to send shutdown signal on Ctrl-C\n");
463 return false;
464 }
465 Sleep(INFINITE);
466 return true;
467}
468#endif
469
470#ifndef WIN32
471static void registerSignalHandler(int signal, void(*handler)(int))
472{
473 struct sigaction sa;
474 sa.sa_handler = handler;
475 sigemptyset(&sa.sa_mask);
476 sa.sa_flags = 0;
477 sigaction(signal, &sa, nullptr);
478}
479#endif
480
481void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
482{
483 SetupHelpOptions(argsman);
484 argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now
485
486 init::AddLoggingArgs(argsman);
487
488 const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
489 const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
490 const auto testnet4BaseParams = CreateBaseChainParams(ChainType::TESTNET4);
491 const auto signetBaseParams = CreateBaseChainParams(ChainType::SIGNET);
492 const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
493 const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
494 const auto testnetChainParams = CreateChainParams(argsman, ChainType::TESTNET);
495 const auto testnet4ChainParams = CreateChainParams(argsman, ChainType::TESTNET4);
496 const auto signetChainParams = CreateChainParams(argsman, ChainType::SIGNET);
497 const auto regtestChainParams = CreateChainParams(argsman, ChainType::REGTEST);
498
499 // Hidden Options
500 std::vector<std::string> hidden_args = {
501 "-dbcrashratio", "-forcecompactdb",
502 // GUI args. These will be overwritten by SetupUIArgs for the GUI
503 "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"};
504
505 argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
506#if HAVE_SYSTEM
507 argsman.AddArg("-alertnotify=<cmd>", "Execute command when an alert is raised (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
508#endif
509 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, testnet3: %s, testnet4: %s, signet: %s)", defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnetChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnet4ChainParams->GetConsensus().defaultAssumeValid.GetHex(), signetChainParams->GetConsensus().defaultAssumeValid.GetHex()), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
510 argsman.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
511 argsman.AddArg("-blocksxor",
512 strprintf("Whether an XOR-key applies to blocksdir *.dat files. "
513 "The created XOR-key will be zeros for an existing blocksdir or when `-blocksxor=0` is "
514 "set, and random for a freshly initialized blocksdir. "
515 "(default: %u)",
518 argsman.AddArg("-fastprune", "Use smaller block files and lower minimum prune height for testing purposes", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
519#if HAVE_SYSTEM
520 argsman.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
521#endif
522 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);
523 argsman.AddArg("-blocksonly", strprintf("Whether to reject transactions from network peers. Disables automatic broadcast and rebroadcast of transactions, unless the source peer has the 'forcerelay' permission. RPC transactions are not affected. (default: %u)", DEFAULT_BLOCKSONLY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
524 argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
525 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);
526 argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
527 argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", DEFAULT_DB_CACHE_BATCH), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
528 argsman.AddArg("-dbcache=<n>", strprintf("Maximum database cache size <n> MiB (minimum %d, default: %d). Make sure you have enough RAM. In addition, unused memory allocated to the mempool is shared with this cache (see -maxmempool).", MIN_DB_CACHE >> 20, node::GetDefaultDBCache() >> 20), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
529 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);
530 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);
531 argsman.AddArg("-loadblock=<file>", "Imports blocks from an external file on startup. Obfuscated blocks are not supported.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
532 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);
533 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);
534 argsman.AddArg("-minimumchainwork=<hex>", strprintf("Minimum work assumed to exist on a valid chain in hex (default: %s, testnet3: %s, testnet4: %s, signet: %s)", defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnetChainParams->GetConsensus().nMinimumChainWork.GetHex(), testnet4ChainParams->GetConsensus().nMinimumChainWork.GetHex(), signetChainParams->GetConsensus().nMinimumChainWork.GetHex()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
535 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)",
537 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);
538 argsman.AddArg("-persistmempoolv1",
539 strprintf("Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format "
540 "(version 1) or the current format (version 2). This temporary option will be removed in the future. (default: %u)",
543 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);
544 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. "
545 "Warning: Reverting this setting requires re-downloading the entire blockchain. "
546 "(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 / 1_MiB), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
547 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);
548 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);
549 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);
550#if HAVE_SYSTEM
551 argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
552 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);
553#endif
554 argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
555 argsman.AddArg("-txospenderindex", strprintf("Maintain a transaction output spender index, used by the gettxspendingprevout rpc call (default: %u)", DEFAULT_TXOSPENDERINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
556 argsman.AddArg("-blockfilterindex=<type>",
557 strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
558 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
560
561 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);
562 argsman.AddArg("-asmap=<file>", strprintf("Specify asn mapping used for bucketing of the peers. Relative paths will be prefixed by the net-specific datadir location.%s",
563 #ifdef ENABLE_EMBEDDED_ASMAP
564 " If a bool arg is given (-asmap or -asmap=1), the embedded mapping data in the binary will be used."
565 #else
566 ""
567 #endif
569 argsman.AddArg("-bantime=<n>", strprintf("Default duration (in seconds) of manually configured bans (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
570 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, testnet3: 127.0.0.1:%u=onion, testnet4: 127.0.0.1:%u=onion, signet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)", defaultChainParams->GetDefaultPort() + 1, testnetChainParams->GetDefaultPort() + 1, testnet4ChainParams->GetDefaultPort() + 1, signetChainParams->GetDefaultPort() + 1, regtestChainParams->GetDefaultPort() + 1), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
571 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);
572 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);
573 argsman.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
574 argsman.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
575 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);
576 argsman.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
577 argsman.AddArg("-fixedseeds", strprintf("Allow fixed seeds if DNS seeds don't provide peers (default: %u)", DEFAULT_FIXEDSEEDS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
578 argsman.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
579 argsman.AddArg("-listen", strprintf("Accept connections from outside (default: %u if no -proxy, -connect or -maxconnections=0)", DEFAULT_LISTEN), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
580 argsman.AddArg("-listenonion", strprintf("Automatically create Tor onion service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
581 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. It does not apply to short-lived private broadcast connections either, which have a separate limit of %u.", DEFAULT_MAX_PEER_CONNECTIONS, MAX_ADDNODE_CONNECTIONS, MAX_PRIVATE_BROADCAST_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
582 argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
583 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);
584 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);
585#ifdef HAVE_SOCKADDR_UN
586 argsman.AddArg("-onion=<ip:port|path>", "Use separate SOCKS5 proxy to reach peers via Tor onion services, set -noonion to disable (default: -proxy). May be a local file path prefixed with 'unix:'.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
587#else
588 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);
589#endif
590 argsman.AddArg("-i2psam=<ip:port>", "I2P SAM proxy to reach I2P peers and accept I2P connections", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
591 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);
592 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);
593 argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
594 argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
595 argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
596 argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
597 argsman.AddArg("-port=<port>", strprintf("Listen for connections on <port> (default: %u, testnet3: %u, testnet4: %u, signet: %u, regtest: %u). Not relevant for I2P (see doc/i2p.md). If set to a value x, the default onion listening port will be set to x+1.", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), testnet4ChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
598 const std::string proxy_doc_for_value =
599#ifdef HAVE_SOCKADDR_UN
600 "<ip>[:<port>]|unix:<path>";
601#else
602 "<ip>[:<port>]";
603#endif
604 const std::string proxy_doc_for_unix_socket =
605#ifdef HAVE_SOCKADDR_UN
606 "May be a local file path prefixed with 'unix:' if the proxy supports it. ";
607#else
608 "";
609#endif
610 argsman.AddArg("-proxy=" + proxy_doc_for_value + "[=<network>]",
611 "Connect through SOCKS5 proxy, set -noproxy to disable. " +
612 proxy_doc_for_unix_socket +
613 "Could end in =network to set the proxy only for that network. " +
614 "The network can be any of ipv4, ipv6, tor or cjdns. " +
615 "(default: disabled)",
618 argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
619 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. During startup, seednodes will be tried before dnsseeds.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
620 argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
621 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);
622 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);
623 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);
624 argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION);
625 argsman.AddArg("-natpmp", strprintf("Use PCP or NAT-PMP to map the listening port (default: %u)", DEFAULT_NATPMP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
626 argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. "
627 "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". "
628 "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
629
630 argsman.AddArg("-whitelist=<[permissions@]IP address or network>", "Add permission flags to the peers using the given IP address (e.g. 1.2.3.4) or "
631 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
632 "-whitebind. "
633 "Additional flags \"in\" and \"out\" control whether permissions apply to incoming connections and/or manual (default: incoming only). "
634 "Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
635
637
638#ifdef ENABLE_ZMQ
639 argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
640 argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
641 argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
642 argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
643 argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
644 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);
645 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);
646 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);
647 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);
648 argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
649#else
650 hidden_args.emplace_back("-zmqpubhashblock=<address>");
651 hidden_args.emplace_back("-zmqpubhashtx=<address>");
652 hidden_args.emplace_back("-zmqpubrawblock=<address>");
653 hidden_args.emplace_back("-zmqpubrawtx=<address>");
654 hidden_args.emplace_back("-zmqpubsequence=<n>");
655 hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
656 hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
657 hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
658 hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
659 hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
660#endif
661
662 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);
663 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);
664 argsman.AddArg("-checkblockindex", strprintf("Do a consistency check for the block tree, chainstate, and other validation data structures every <n> operations. Use 0 to disable. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
665 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);
666 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);
667 // Checkpoints were removed. We keep `-checkpoints` as a hidden arg to display a more user friendly error when set.
668 argsman.AddArg("-checkpoints", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
669 argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
670 argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
671 argsman.AddArg("-stopatheight", strprintf("Stop running after reaching the given height in the main chain (default: %u). Blocks after target height may be processed during shutdown.", DEFAULT_STOPATHEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
672 argsman.AddArg("-limitancestorcount=<n>", strprintf("Deprecated setting to not accept transactions if number of in-mempool ancestors is <n> or more (default: %u); replaced by cluster limits (see -limitclustercount) and only used by wallet for coin selection", DEFAULT_ANCESTOR_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
673 // Ancestor and descendant size limits were removed. We keep
674 // -limitancestorsize/-limitdescendantsize as hidden args to display a more
675 // user friendly error when set.
676 argsman.AddArg("-limitancestorsize", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
677 argsman.AddArg("-limitdescendantsize", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
678 argsman.AddArg("-limitdescendantcount=<n>", strprintf("Deprecated setting to not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u); replaced by cluster limits (see -limitclustercount) and only used by wallet for coin selection", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
679 argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
680 argsman.AddArg("-limitclustercount=<n>", strprintf("Do not accept transactions into mempool which are directly or indirectly connected to <n> or more other unconfirmed transactions (default: %u, maximum: %u)", DEFAULT_CLUSTER_LIMIT, MAX_CLUSTER_COUNT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
681 argsman.AddArg("-limitclustersize=<n>", strprintf("Do not accept transactions whose virtual size with all in-mempool connected transactions exceeds <n> kilobytes (default: %u)", DEFAULT_CLUSTER_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
682 argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
683 argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
684 argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_VALIDATION_CACHE_BYTES >> 20), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
685 argsman.AddArg("-maxtipage=<n>",
686 strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)",
687 Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
689 argsman.AddArg("-printpriority", strprintf("Log transaction fee rate in %s/kvB when mining blocks (default: %u)", CURRENCY_UNIT, DEFAULT_PRINT_MODIFIED_FEE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
690 argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
691
693
694 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);
695 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);
696 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);
697 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);
698 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);
699 argsman.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
700 argsman.AddArg("-datacarriersize",
701 strprintf("Relay and mine transactions whose data-carrying raw scriptPubKeys in aggregate "
702 "are of this size or less, allowing multiple outputs (default: %u)",
705 argsman.AddArg("-permitbaremultisig", strprintf("Relay transactions creating non-P2SH multisig outputs (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
707 argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
709 argsman.AddArg("-privatebroadcast",
710 strprintf(
711 "Broadcast transactions submitted via sendrawtransaction RPC using short-lived "
712 "connections through the Tor or I2P networks, without putting them in the mempool first. "
713 "Transactions submitted through the wallet are not affected by this option "
714 "(default: %u)",
718 argsman.AddArg("-whitelistforcerelay", strprintf("Add 'forcerelay' permission to whitelisted 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);
719 argsman.AddArg("-whitelistrelay", strprintf("Add 'relay' permission to whitelisted peers with default permissions. This will accept relayed transactions even when not relaying transactions (default: %d)", DEFAULT_WHITELISTRELAY), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
720
721
722 argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
723 argsman.AddArg("-blockreservedweight=<n>", strprintf("Reserve space for the fixed-size block header plus the largest coinbase transaction the mining software may add to the block. Only affects mining RPC clients, not IPC clients. (default: %d).", DEFAULT_BLOCK_RESERVED_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
724 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);
725 argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
726
727 argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
728 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). RFC4193 is allowed only if -cjdnsreachable=0. This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
729 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);
730 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);
731 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);
732 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);
733 argsman.AddArg("-rpccookieperms=<readable-by>", strprintf("Set permissions on the RPC auth cookie file so that it is readable by [owner|group|all] (default: owner [via umask 0077])"), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
734 argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
735 argsman.AddArg("-rpcport=<port>", strprintf("Listen for JSON-RPC connections on <port> (default: %u, testnet3: %u, testnet4: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), testnet4BaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::RPC);
736 argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
737 argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
738 argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
739 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);
740 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);
741 argsman.AddArg("-rpcworkqueue=<n>", strprintf("Set the maximum depth of the work queue to service RPC calls (default: %d)", DEFAULT_HTTP_WORKQUEUE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
742 argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
743 if (can_listen_ipc) {
744 argsman.AddArg("-ipcbind=<address>", "Bind to Unix socket address and listen for incoming connections. Valid address values are \"unix\" to listen on the default path, <datadir>/node.sock, or \"unix:/custom/path\" to specify a custom path. Can be specified multiple times to listen on multiple paths. Default behavior is not to listen on any path. If relative paths are specified, they are interpreted relative to the network data directory. If paths include any parent directory components and the parent directories do not exist, they will be created. Enabling this gives local processes that can access the socket unauthenticated RPC access, so it's important to choose a path with secure permissions if customizing this.", ArgsManager::ALLOW_ANY, OptionsCategory::IPC);
745 }
746
747#if HAVE_DECL_FORK
748 argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
749 argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
750#else
751 hidden_args.emplace_back("-daemon");
752 hidden_args.emplace_back("-daemonwait");
753#endif
754
755 // Add the hidden options
756 argsman.AddHiddenArgs(hidden_args);
757}
758
759#if HAVE_SYSTEM
760static void StartupNotify(const ArgsManager& args)
761{
762 std::string cmd = args.GetArg("-startupnotify", "");
763 if (!cmd.empty()) {
764 std::thread t(runCommand, cmd);
765 t.detach(); // thread runs free
766 }
767}
768#endif
769
771{
772 const ArgsManager& args = *Assert(node.args);
773 if (!InitHTTPServer(*Assert(node.shutdown_signal))) {
774 return false;
775 }
776 StartRPC();
777 node.rpc_interruption_point = RpcInterruptionPoint;
778 if (!StartHTTPRPC(&node))
779 return false;
782 return true;
783}
784
785// Parameter interaction based on rules
787{
788 // when specifying an explicit binding address, you want to listen on it
789 // even when -connect or -proxy is specified
790 if (!args.GetArgs("-bind").empty()) {
791 if (args.SoftSetBoolArg("-listen", true))
792 LogInfo("parameter interaction: -bind set -> setting -listen=1\n");
793 }
794 if (!args.GetArgs("-whitebind").empty()) {
795 if (args.SoftSetBoolArg("-listen", true))
796 LogInfo("parameter interaction: -whitebind set -> setting -listen=1\n");
797 }
798
799 if (!args.GetArgs("-connect").empty() || args.IsArgNegated("-connect") || args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS) <= 0) {
800 // when only connecting to trusted nodes, do not seed via DNS, or listen by default
801 // do the same when connections are disabled
802 if (args.SoftSetBoolArg("-dnsseed", false))
803 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n");
804 if (args.SoftSetBoolArg("-listen", false))
805 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n");
806 }
807
808 std::string proxy_arg = args.GetArg("-proxy", "");
809 if (proxy_arg != "" && proxy_arg != "0") {
810 // to protect privacy, do not listen by default if a default proxy server is specified
811 if (args.SoftSetBoolArg("-listen", false))
812 LogInfo("parameter interaction: -proxy set -> setting -listen=0\n");
813 // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1
814 // to listen locally, so don't rely on this happening through -listen below.
815 if (args.SoftSetBoolArg("-natpmp", false)) {
816 LogInfo("parameter interaction: -proxy set -> setting -natpmp=0\n");
817 }
818 // to protect privacy, do not discover addresses by default
819 if (args.SoftSetBoolArg("-discover", false))
820 LogInfo("parameter interaction: -proxy set -> setting -discover=0\n");
821 }
822
823 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
824 // do not map ports or try to retrieve public IP when not listening (pointless)
825 if (args.SoftSetBoolArg("-natpmp", false)) {
826 LogInfo("parameter interaction: -listen=0 -> setting -natpmp=0\n");
827 }
828 if (args.SoftSetBoolArg("-discover", false))
829 LogInfo("parameter interaction: -listen=0 -> setting -discover=0\n");
830 if (args.SoftSetBoolArg("-listenonion", false))
831 LogInfo("parameter interaction: -listen=0 -> setting -listenonion=0\n");
832 if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
833 LogInfo("parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n");
834 }
835 }
836
837 if (!args.GetArgs("-externalip").empty()) {
838 // if an explicit public IP is specified, do not try to find others
839 if (args.SoftSetBoolArg("-discover", false))
840 LogInfo("parameter interaction: -externalip set -> setting -discover=0\n");
841 }
842
843 if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
844 // disable whitelistrelay in blocksonly mode
845 if (args.SoftSetBoolArg("-whitelistrelay", false))
846 LogInfo("parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n");
847 // Reduce default mempool size in blocksonly mode to avoid unexpected resource usage
849 LogInfo("parameter interaction: -blocksonly=1 -> setting -maxmempool=%d\n", DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB);
850 }
851
852 // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.
853 if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
854 if (args.SoftSetBoolArg("-whitelistrelay", true))
855 LogInfo("parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n");
856 }
857 const auto onlynets = args.GetArgs("-onlynet");
858 if (!onlynets.empty()) {
859 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](const auto& net) {
860 const auto n = ParseNetwork(net);
861 return n == NET_IPV4 || n == NET_IPV6;
862 });
863 if (!clearnet_reachable && args.SoftSetBoolArg("-dnsseed", false)) {
864 LogInfo("parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n");
865 }
866 }
867}
868
876{
879}
880
881namespace { // Variables internal to initialization process only
882
883int nMaxConnections;
884int available_fds;
886int64_t peer_connect_timeout;
887std::set<BlockFilterType> g_enabled_filter_types;
888
889} // namespace
890
891[[noreturn]] static void new_handler_terminate()
892{
893 // Rather than throwing std::bad-alloc if allocation fails, terminate
894 // immediately to (try to) avoid chain corruption.
895 // Since logging may itself allocate memory, set the handler directly
896 // to terminate first.
897 std::set_new_handler(std::terminate);
898 LogError("Out of memory. Terminating.\n");
899
900 // The log was successful, terminate now.
901 std::terminate();
902};
903
904bool AppInitBasicSetup(const ArgsManager& args, std::atomic<int>& exit_status)
905{
906 // ********************************************************* Step 1: setup
907#ifdef _MSC_VER
908 // Turn off Microsoft heap dump noise
909 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
910 _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0));
911 // Disable confusing "helpful" text message on abort, Ctrl-C
912 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
913#endif
914#ifdef WIN32
915 // Enable heap terminate-on-corruption
916 HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0);
917#endif
918 if (!SetupNetworking()) {
919 return InitError(Untranslated("Initializing networking failed."));
920 }
921
922#ifndef WIN32
923 // Clean shutdown on SIGTERM
926
927 // Reopen debug.log on SIGHUP
929
930 // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly
931 signal(SIGPIPE, SIG_IGN);
932#else
933 SetConsoleCtrlHandler(consoleCtrlHandler, true);
934#endif
935
936 std::set_new_handler(new_handler_terminate);
937
938 return true;
939}
940
942{
943 const CChainParams& chainparams = Params();
944 // ********************************************************* Step 2: parameter interactions
945
946 // also see: InitParameterInteraction()
947
948 // We removed checkpoints but keep the option to warn users who still have it in their config.
949 if (args.IsArgSet("-checkpoints")) {
950 InitWarning(_("Option '-checkpoints' is set but checkpoints were removed. This option has no effect."));
951 }
952 if (args.IsArgSet("-limitancestorsize")) {
953 InitWarning(_("Option '-limitancestorsize' is given but ancestor size limits have been replaced with cluster size limits (see -limitclustersize). This option has no effect."));
954 }
955 if (args.IsArgSet("-limitdescendantsize")) {
956 InitWarning(_("Option '-limitdescendantsize' is given but descendant size limits have been replaced with cluster size limits (see -limitclustersize). This option has no effect."));
957 }
958
959 // Error if network-specific options (-addnode, -connect, etc) are
960 // specified in default section of config file, but not overridden
961 // on the command line or in this chain's section of the config file.
962 ChainType chain = args.GetChainType();
963 if (chain == ChainType::SIGNET) {
964 LogInfo("Signet derived magic (message start): %s", HexStr(chainparams.MessageStart()));
965 }
966 bilingual_str errors;
967 for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
968 errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section."), arg, ChainTypeToString(chain), ChainTypeToString(chain)) + Untranslated("\n");
969 }
970
971 if (!errors.empty()) {
972 return InitError(errors);
973 }
974
975 // Testnet3 deprecation warning
976 if (chain == ChainType::TESTNET) {
977 LogInfo("Warning: Support for testnet3 is deprecated and will be removed in an upcoming release. Consider switching to testnet4.\n");
978 }
979
980 // Warn if unrecognized section name are present in the config file.
981 bilingual_str warnings;
982 for (const auto& section : args.GetUnrecognizedSections()) {
983 warnings += Untranslated(strprintf("%s:%i ", section.m_file, section.m_line)) + strprintf(_("Section [%s] is not recognized."), section.m_name) + Untranslated("\n");
984 }
985
986 if (!warnings.empty()) {
987 InitWarning(warnings);
988 }
989
990 if (!fs::is_directory(args.GetBlocksDirPath())) {
991 return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
992 }
993
994 // parse and validate enabled filter types
995 std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
996 if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
997 g_enabled_filter_types = AllBlockFilterTypes();
998 } else if (blockfilterindex_value != "0") {
999 const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
1000 for (const auto& name : names) {
1001 BlockFilterType filter_type;
1002 if (!BlockFilterTypeByName(name, filter_type)) {
1003 return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
1004 }
1005 g_enabled_filter_types.insert(filter_type);
1006 }
1007 }
1008
1009 // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.
1010 if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {
1011 g_local_services = ServiceFlags(g_local_services | NODE_P2P_V2);
1012 }
1013
1014 // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
1015 if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
1016 if (!g_enabled_filter_types.contains(BlockFilterType::BASIC)) {
1017 return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
1018 }
1019
1020 g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
1021 }
1022
1023 if (args.GetIntArg("-prune", 0)) {
1024 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
1025 return InitError(_("Prune mode is incompatible with -txindex."));
1026 if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX))
1027 return InitError(_("Prune mode is incompatible with -txospenderindex."));
1028 if (args.GetBoolArg("-reindex-chainstate", false)) {
1029 return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
1030 }
1031 }
1032
1033 // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
1034 if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
1035 return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
1036 }
1037
1038 // -bind and -whitebind can't be set when not listening
1039 size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
1040 if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
1041 return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0"));
1042 }
1043
1044 // if listen=0, then disallow listenonion=1
1045 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
1046 return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1"));
1047 }
1048
1049 // Make sure enough file descriptors are available. We need to reserve enough FDs to account for the bare minimum,
1050 // plus all manual connections and all bound interfaces. Any remainder will be available for connection sockets
1051
1052 // Number of bound interfaces (we have at least one)
1053 int nBind = std::max(nUserBind, size_t(1));
1054 // Maximum number of connections with other nodes, this accounts for all types of outbounds and inbounds except for manual
1055 int user_max_connection = args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
1056 if (user_max_connection < 0) {
1057 return InitError(Untranslated("-maxconnections must be greater or equal than zero"));
1058 }
1059 const size_t max_private{args.GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)
1061 : 0};
1062 // Reserve enough FDs to account for the bare minimum, plus any manual connections, plus the bound interfaces
1063 int min_required_fds = MIN_CORE_FDS + MAX_ADDNODE_CONNECTIONS + nBind;
1064
1065 // Try raising the FD limit to what we need (available_fds may be smaller than the requested amount if this fails)
1066 available_fds = RaiseFileDescriptorLimit(user_max_connection + max_private + min_required_fds);
1067 // If we are using select instead of poll, our actual limit may be even smaller
1068#ifndef USE_POLL
1069 available_fds = std::min(FD_SETSIZE, available_fds);
1070#endif
1071 if (available_fds < min_required_fds)
1072 return InitError(strprintf(_("Not enough file descriptors available. %d available, %d required."), available_fds, min_required_fds));
1073
1074 // Trim requested connection counts, to fit into system limitations
1075 nMaxConnections = std::min(available_fds - min_required_fds, user_max_connection);
1076
1077 if (nMaxConnections < user_max_connection)
1078 InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), user_max_connection, nMaxConnections));
1079
1080 // ********************************************************* Step 3: parameter-to-internal-flags
1081 if (auto result{init::SetLoggingCategories(args)}; !result) return InitError(util::ErrorString(result));
1082 if (auto result{init::SetLoggingLevel(args)}; !result) return InitError(util::ErrorString(result));
1083
1085 if (nConnectTimeout <= 0) {
1087 }
1088
1089 peer_connect_timeout = args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
1090 if (peer_connect_timeout <= 0) {
1091 return InitError(Untranslated("peertimeout must be a positive integer."));
1092 }
1093
1094 auto mining_result{node::ReadMiningArgs(args)};
1095 if (!mining_result) {
1096 return InitError(util::ErrorString(mining_result));
1097 }
1098
1099 nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);
1100
1101 if (!g_wallet_init_interface.ParameterInteraction()) return false;
1102
1103 // Option to startup with mocktime set (used for regression testing):
1104 if (const auto mocktime{args.GetIntArg("-mocktime")}) {
1105 SetMockTime(std::chrono::seconds{*mocktime});
1106 }
1107
1108 if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
1109 g_local_services = ServiceFlags(g_local_services | NODE_BLOOM);
1110
1111 const std::vector<std::string> test_options = args.GetArgs("-test");
1112 if (!test_options.empty()) {
1113 if (chainparams.GetChainType() != ChainType::REGTEST) {
1114 return InitError(Untranslated("-test=<option> can only be used with regtest"));
1115 }
1116 for (const std::string& option : test_options) {
1117 auto it = std::find_if(TEST_OPTIONS_DOC.begin(), TEST_OPTIONS_DOC.end(), [&option](const std::string& doc_option) {
1118 size_t pos = doc_option.find(" (");
1119 return (pos != std::string::npos) && (doc_option.substr(0, pos) == option);
1120 });
1121 if (it == TEST_OPTIONS_DOC.end()) {
1122 InitWarning(strprintf(_("Unrecognised option \"%s\" provided in -test=<option>."), option));
1123 }
1124 }
1125 }
1126
1127 // Prevent setting deployment parameters on mainnet.
1128 if (chainparams.GetChainType() == ChainType::MAIN) {
1129 if (args.IsArgSet("-testactivationheight")) {
1130 return InitError(_("The -testactivationheight option may not be used on mainnet."));
1131 }
1132 if (args.IsArgSet("-vbparams")) {
1133 return InitError(_("The -vbparams option may not be used on mainnet."));
1134 }
1135 }
1136
1137 // Also report errors from parsing before daemonization
1138 {
1139 kernel::Notifications notifications{};
1140 ChainstateManager::Options chainman_opts_dummy{
1141 .chainparams = chainparams,
1142 .datadir = args.GetDataDirNet(),
1143 .notifications = notifications,
1144 };
1145 auto chainman_result{ApplyArgsManOptions(args, chainman_opts_dummy)};
1146 if (!chainman_result) {
1147 return InitError(util::ErrorString(chainman_result));
1148 }
1149 BlockManager::Options blockman_opts_dummy{
1150 .chainparams = chainman_opts_dummy.chainparams,
1151 .blocks_dir = args.GetBlocksDirPath(),
1152 .notifications = chainman_opts_dummy.notifications,
1153 .block_tree_db_params = DBParams{
1154 .path = args.GetDataDirNet() / "blocks" / "index",
1155 .cache_bytes = 0,
1156 },
1157 };
1158 auto blockman_result{ApplyArgsManOptions(args, blockman_opts_dummy)};
1159 if (!blockman_result) {
1160 return InitError(util::ErrorString(blockman_result));
1161 }
1162 CTxMemPool::Options mempool_opts{};
1163 auto mempool_result{ApplyArgsManOptions(args, chainparams, mempool_opts)};
1164 if (!mempool_result) {
1165 return InitError(util::ErrorString(mempool_result));
1166 }
1167 }
1168
1169 return true;
1170}
1171
1172static bool LockDirectory(const fs::path& dir, bool probeOnly)
1173{
1174 // Make sure only a single process is using the directory.
1175 switch (util::LockDirectory(dir, ".lock", probeOnly)) {
1177 return InitError(strprintf(_("Cannot write to directory '%s'; check permissions."), fs::PathToString(dir)));
1179 return InitError(strprintf(_("Cannot obtain a lock on directory %s. %s is probably already running."), fs::PathToString(dir), CLIENT_NAME));
1180 case util::LockResult::Success: return true;
1181 } // no default case, so the compiler can warn about missing cases
1182 assert(false);
1183}
1184static bool LockDirectories(bool probeOnly)
1185{
1186 return LockDirectory(gArgs.GetDataDirNet(), probeOnly) && \
1187 LockDirectory(gArgs.GetBlocksDirPath(), probeOnly);
1188}
1189
1191{
1192 // ********************************************************* Step 4: sanity checks
1193 auto result{kernel::SanityChecks(kernel)};
1194 if (!result) {
1196 return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), CLIENT_NAME));
1197 }
1198
1199 if (!ECC_InitSanityCheck()) {
1200 return InitError(strprintf(_("Elliptic curve cryptography sanity check failure. %s is shutting down."), CLIENT_NAME));
1201 }
1202
1203 // Probe the directory locks to give an early error message, if possible
1204 // We cannot hold the directory locks here, as the forking for daemon() hasn't yet happened,
1205 // and a fork will cause weird behavior to them.
1206 return LockDirectories(true);
1207}
1208
1210{
1211 // After daemonization get the directory locks again and hold on to them until exit
1212 // This creates a slight window for a race condition to happen, however this condition is harmless: it
1213 // will at most make us exit without printing a message to console.
1214 if (!LockDirectories(false)) {
1215 // Detailed error printed inside LockDirectory
1216 return false;
1217 }
1218 return true;
1219}
1220
1222{
1224 // Specify wait_loaded=false so internal mining interface can be initialized
1225 // on early startup and does not need to be tied to chainstate loading.
1226 node.mining = interfaces::MakeMining(node, /*wait_loaded=*/false);
1227 return true;
1228}
1229
1231 for (const std::string port_option : {
1232 "-port",
1233 "-rpcport",
1234 }) {
1235 if (const auto port{args.GetArg(port_option)}) {
1236 const auto n{ToIntegral<uint16_t>(*port)};
1237 if (!n || *n == 0) {
1238 return InitError(InvalidPortErrMsg(port_option, *port));
1239 }
1240 }
1241 }
1242
1243 for ([[maybe_unused]] const auto& [param_name, unix, suffix_allowed] : std::vector<std::tuple<std::string, bool, bool>>{
1244 // arg name UNIX socket support =suffix allowed
1245 {"-i2psam", false, false},
1246 {"-onion", true, false},
1247 {"-proxy", true, true},
1248 {"-bind", false, true},
1249 {"-rpcbind", false, false},
1250 {"-torcontrol", false, false},
1251 {"-whitebind", false, false},
1252 {"-zmqpubhashblock", true, false},
1253 {"-zmqpubhashtx", true, false},
1254 {"-zmqpubrawblock", true, false},
1255 {"-zmqpubrawtx", true, false},
1256 {"-zmqpubsequence", true, false},
1257 }) {
1258 for (const std::string& param_value : args.GetArgs(param_name)) {
1259 const std::string param_value_hostport{
1260 suffix_allowed ? param_value.substr(0, param_value.rfind('=')) : param_value};
1261 std::string host_out;
1262 uint16_t port_out{0};
1263 if (!SplitHostPort(param_value_hostport, port_out, host_out)) {
1264#ifdef HAVE_SOCKADDR_UN
1265 // Allow unix domain sockets for some options e.g. unix:/some/file/path
1266 if (!unix || !param_value.starts_with(ADDR_PREFIX_UNIX)) {
1267 return InitError(InvalidPortErrMsg(param_name, param_value));
1268 }
1269#else
1270 return InitError(InvalidPortErrMsg(param_name, param_value));
1271#endif
1272 }
1273 }
1274 }
1275
1276 return true;
1277}
1278
1285static std::optional<CService> CheckBindingConflicts(const CConnman::Options& conn_options)
1286{
1287 std::set<CService> seen;
1288
1289 // Check all whitelisted bindings
1290 for (const auto& wb : conn_options.vWhiteBinds) {
1291 if (!seen.insert(wb.m_service).second) {
1292 return wb.m_service;
1293 }
1294 }
1295
1296 // Check regular bindings
1297 for (const auto& bind : conn_options.vBinds) {
1298 if (!seen.insert(bind).second) {
1299 return bind;
1300 }
1301 }
1302
1303 // Check onion bindings
1304 for (const auto& onion_bind : conn_options.onion_binds) {
1305 if (!seen.insert(onion_bind).second) {
1306 return onion_bind;
1307 }
1308 }
1309
1310 return std::nullopt;
1311}
1312
1313// A GUI user may opt to retry once with do_reindex set if there is a failure during chainstate initialization.
1314// The function therefore has to support re-entry.
1317 bool do_reindex,
1318 const bool do_reindex_chainstate,
1319 const kernel::CacheSizes& cache_sizes,
1320 const ArgsManager& args)
1321{
1322 // This function may be called twice, so any dirty state must be reset.
1323 node.notifications->setChainstateLoaded(false); // Drop state, such as a cached tip block
1324 node.mempool.reset();
1325 node.chainman.reset(); // Drop state, such as an initialized m_block_tree_db
1326
1327 const CChainParams& chainparams = Params();
1328
1329 CTxMemPool::Options mempool_opts{
1330 .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
1331 .signals = node.validation_signals.get(),
1332 };
1333 Assert(ApplyArgsManOptions(args, chainparams, mempool_opts)); // no error can happen, already checked in AppInitParameterInteraction
1334 bilingual_str mempool_error;
1335 Assert(!node.mempool); // Was reset above
1336 node.mempool = std::make_unique<CTxMemPool>(mempool_opts, mempool_error);
1337 if (!mempool_error.empty()) {
1338 return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
1339 }
1340 auto mining_args{node::ReadMiningArgs(args)};
1341 Assert(mining_args); // no error can happen, already checked in AppInitParameterInteraction
1342 node.mining_args = std::move(*mining_args);
1343 LogInfo("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)",
1344 cache_sizes.coins / double(1_MiB),
1345 mempool_opts.max_size_bytes / double(1_MiB));
1346 ChainstateManager::Options chainman_opts{
1347 .chainparams = chainparams,
1348 .datadir = args.GetDataDirNet(),
1349 .notifications = *node.notifications,
1350 .signals = node.validation_signals.get(),
1351 };
1352 Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1353
1354 BlockManager::Options blockman_opts{
1355 .chainparams = chainman_opts.chainparams,
1356 .blocks_dir = args.GetBlocksDirPath(),
1357 .notifications = chainman_opts.notifications,
1358 .block_tree_db_params = DBParams{
1359 .path = args.GetDataDirNet() / "blocks" / "index",
1360 .cache_bytes = cache_sizes.block_tree_db,
1361 .wipe_data = do_reindex,
1362 },
1363 };
1364 Assert(ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1365
1366 // Creating the chainstate manager internally creates a BlockManager, opens
1367 // the blocks tree db, and wipes existing block files in case of a reindex.
1368 // The coinsdb is opened at a later point on LoadChainstate.
1369 Assert(!node.chainman); // Was reset above
1370 try {
1371 node.chainman = std::make_unique<ChainstateManager>(*Assert(node.shutdown_signal), chainman_opts, blockman_opts);
1372 } catch (dbwrapper_error& e) {
1373 LogError("%s", e.what());
1374 return {ChainstateLoadStatus::FAILURE, _("Error opening block database")};
1375 } catch (std::exception& e) {
1376 return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated(strprintf("Failed to initialize ChainstateManager: %s", e.what()))};
1377 }
1378 ChainstateManager& chainman = *node.chainman;
1379 if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
1380
1381 // This is defined and set here instead of inline in validation.h to avoid a hard
1382 // dependency between validation and index/base, since the latter is not in
1383 // libbitcoinkernel.
1384 chainman.snapshot_download_completed = [&node]() {
1385 if (!node.chainman->m_blockman.IsPruneMode()) {
1386 LogInfo("[snapshot] re-enabling NODE_NETWORK services");
1387 node.connman->AddLocalServices(NODE_NETWORK);
1388 }
1389 LogInfo("[snapshot] restarting indexes");
1390 // Drain the validation interface queue to ensure that the old indexes
1391 // don't have any pending work.
1392 Assert(node.validation_signals)->SyncWithValidationInterfaceQueue();
1393 for (auto* index : node.indexes) {
1394 index->Interrupt();
1395 index->Stop();
1396 if (!(index->Init() && index->StartBackgroundSync())) {
1397 LogWarning("[snapshot] Failed to restart index %s on snapshot chain", index->GetName());
1398 }
1399 }
1400 };
1402 options.mempool = Assert(node.mempool.get());
1403 options.wipe_chainstate_db = do_reindex || do_reindex_chainstate;
1404 options.prune = chainman.m_blockman.IsPruneMode();
1405 options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
1406 options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
1407 options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
1408 options.coins_error_cb = [] {
1410 _("Error reading from database, shutting down."),
1412 };
1413 uiInterface.InitMessage(_("Loading block index…"));
1414 auto catch_exceptions = [](auto&& f) -> ChainstateLoadResult {
1415 try {
1416 return f();
1417 } catch (const std::exception& e) {
1418 LogError("%s\n", e.what());
1419 return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error loading databases"));
1420 }
1421 };
1422 auto [status, error] = catch_exceptions([&] { return LoadChainstate(chainman, cache_sizes, options); });
1424 uiInterface.InitMessage(_("Verifying blocks…"));
1425 if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) {
1426 LogWarning("pruned datadir may not have more than %d blocks; only checking available blocks\n",
1428 }
1429 std::tie(status, error) = catch_exceptions([&] { return VerifyLoadedChainstate(chainman, options); });
1431 LogInfo("Block index and chainstate loaded");
1432 node.notifications->setChainstateLoaded(true);
1433 }
1434 }
1435 return {status, error};
1436};
1437
1439{
1440 const ArgsManager& args = *Assert(node.args);
1441 const CChainParams& chainparams = Params();
1442
1443 auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
1444 if (!opt_max_upload) {
1445 return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
1446 }
1447
1448 // ********************************************************* Step 4a: application initialization
1449 if (!CreatePidFile(args)) {
1450 // Detailed error printed inside CreatePidFile().
1451 return false;
1452 }
1453 if (!init::StartLogging(args)) {
1454 // Detailed error printed inside StartLogging().
1455 return false;
1456 }
1457
1458 LogInfo("Using at most %i automatic connections (%i file descriptors available)", nMaxConnections, available_fds);
1459
1460 // Warn about relative -datadir path.
1461 if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) {
1462 LogWarning("Relative datadir option '%s' specified, which will be interpreted relative to the "
1463 "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1464 "from a different location, it will be unable to locate the current data files. There could "
1465 "also be data loss if bitcoin is started while in a temporary directory.",
1466 args.GetArg("-datadir", ""), fs::PathToString(fs::current_path()));
1467 }
1468
1469 assert(!node.scheduler);
1470 node.scheduler = std::make_unique<CScheduler>();
1471 auto& scheduler = *node.scheduler;
1472
1473 // Start the lightweight task scheduler thread
1474 scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); });
1475
1476 // Gather some entropy once per minute.
1477 scheduler.scheduleEvery([]{
1479 }, std::chrono::minutes{1});
1480
1481 // Check disk space every 5 minutes to avoid db corruption.
1482 scheduler.scheduleEvery([&args, &node]{
1483 constexpr uint64_t min_disk_space{50_MiB};
1484 if (!CheckDiskSpace(args.GetBlocksDirPath(), min_disk_space)) {
1485 LogError("Shutting down due to lack of disk space!\n");
1486 if (!(Assert(node.shutdown_request))()) {
1487 LogError("Failed to send shutdown signal after disk space check\n");
1488 }
1489 }
1490 }, std::chrono::minutes{5});
1491
1492 if (args.GetBoolArg("-logratelimit", BCLog::DEFAULT_LOGRATELIMIT)) {
1494 [&scheduler](auto func, auto window) { scheduler.scheduleEvery(std::move(func), window); },
1497 } else {
1498 LogInfo("Log rate limiting disabled");
1499 }
1500
1501 assert(!node.validation_signals);
1502 node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler));
1503 auto& validation_signals = *node.validation_signals;
1504
1505 // Create KernelNotifications object. Important to do this early before
1506 // calling ipc->listenAddress() below so makeMining and other IPC methods
1507 // can use this.
1508 assert(!node.notifications);
1509 node.notifications = std::make_unique<KernelNotifications>(Assert(node.shutdown_request), node.exit_status, *Assert(node.warnings));
1510 ReadNotificationArgs(args, *node.notifications);
1511
1512 // Create client interfaces for wallets that are supposed to be loaded
1513 // according to -wallet and -disablewallet options. This only constructs
1514 // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1515 // when load() and start() interface methods are called below.
1518
1519 if (interfaces::Ipc* ipc = node.init->ipc()) {
1520 for (std::string address : gArgs.GetArgs("-ipcbind")) {
1521 try {
1522 ipc->listenAddress(address);
1523 } catch (const std::exception& e) {
1524 return InitError(Untranslated(strprintf("Unable to bind to IPC address '%s'. %s", address, e.what())));
1525 }
1526 LogInfo("Listening for IPC requests on address %s", address);
1527 }
1528 }
1529
1530 /* Register RPC commands regardless of -server setting so they will be
1531 * available in the GUI RPC console even if external calls are disabled.
1532 */
1534 for (const auto& client : node.chain_clients) {
1535 client->registerRpcs();
1536 }
1537#ifdef ENABLE_ZMQ
1539#endif
1540
1541 // Check port numbers
1542 if (!CheckHostPortOptions(args)) return false;
1543
1544 // Configure reachable networks before we start the RPC server.
1545 // This is necessary for -rpcallowip to distinguish CJDNS from other RFC4193
1546 const auto onlynets = args.GetArgs("-onlynet");
1547 if (!onlynets.empty()) {
1549 for (const std::string& snet : onlynets) {
1550 enum Network net = ParseNetwork(snet);
1551 if (net == NET_UNROUTABLE)
1552 return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1553 g_reachable_nets.Add(net);
1554 }
1555 }
1556
1557 if (!args.IsArgSet("-cjdnsreachable")) {
1558 if (!onlynets.empty() && g_reachable_nets.Contains(NET_CJDNS)) {
1559 return InitError(
1560 _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1561 "-cjdnsreachable is not provided"));
1562 }
1564 }
1565 // Now g_reachable_nets.Contains(NET_CJDNS) is true if:
1566 // 1. -cjdnsreachable is given and
1567 // 2.1. -onlynet is not given or
1568 // 2.2. -onlynet=cjdns is given
1569
1570 /* Start the RPC server already. It will be started in "warmup" mode
1571 * and not really process calls already (but it will signify connections
1572 * that the server is there and will be ready later). Warmup mode will
1573 * be disabled when initialisation is finished.
1574 */
1575 if (args.GetBoolArg("-server", false)) {
1577 if (!AppInitServers(node))
1578 return InitError(_("Unable to start HTTP server. See debug log for details."));
1579 }
1580
1581 // ********************************************************* Step 5: verify wallet database integrity
1582 for (const auto& client : node.chain_clients) {
1583 if (!client->verify()) {
1584 return false;
1585 }
1586 }
1587
1588 // ********************************************************* Step 6: network initialization
1589 // Note that we absolutely cannot open any actual connections
1590 // until the very end ("start node") as the UTXO/block state
1591 // is not yet setup and may end up being set up twice if we
1592 // need to reindex later.
1593
1594 fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1595 fDiscover = args.GetBoolArg("-discover", true);
1596
1597 PeerManager::Options peerman_opts{};
1598 ApplyArgsManOptions(args, peerman_opts);
1599
1600 {
1601 // Read asmap file if configured or embedded asmap data and initialize
1602 // Netgroupman with or without it
1603 assert(!node.netgroupman);
1604 if (args.IsArgSet("-asmap") && !args.IsArgNegated("-asmap")) {
1605 uint256 asmap_version{};
1606 if (!args.GetBoolArg("-asmap", false)) {
1607 fs::path asmap_path = args.GetPathArg("-asmap");
1608 if (!asmap_path.is_absolute()) {
1609 asmap_path = args.GetDataDirNet() / asmap_path;
1610 }
1611
1612 // If a specific path was passed with the asmap argument check if
1613 // the file actually exists in that location
1614 if (!fs::exists(asmap_path)) {
1615 InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1616 return false;
1617 }
1618
1619 // If a file exists at the path, try to read the file
1620 std::vector<std::byte> asmap{DecodeAsmap(asmap_path)};
1621 if (asmap.empty()) {
1622 InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1623 return false;
1624 }
1625 asmap_version = AsmapVersion(asmap);
1626 node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::WithLoadedAsmap(std::move(asmap)));
1627 } else {
1628 #ifdef ENABLE_EMBEDDED_ASMAP
1629 // Use the embedded asmap data
1630 std::span<const std::byte> asmap{node::data::ip_asn};
1631 if (asmap.empty() || !CheckStandardAsmap(asmap)) {
1632 InitError(strprintf(_("Could not read embedded asmap data")));
1633 return false;
1634 }
1635 node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::WithEmbeddedAsmap(asmap));
1636 asmap_version = AsmapVersion(asmap);
1637 LogInfo("Opened asmap data (%zu bytes) from embedded byte array\n", asmap.size());
1638 #else
1639 // If there is no embedded data, fail and report it since
1640 // the user tried to use it
1641 InitError(strprintf(_("Embedded asmap data not available")));
1642 return false;
1643 #endif
1644 }
1645 LogInfo("Using asmap version %s for IP bucketing", asmap_version.ToString());
1646 } else {
1647 node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::NoAsmap());
1648 LogInfo("Using /16 prefix for IP bucketing");
1649 }
1650
1651 // Initialize addrman
1652 assert(!node.addrman);
1653 uiInterface.InitMessage(_("Loading P2P addresses…"));
1654 auto addrman{LoadAddrman(*node.netgroupman, args)};
1655 if (!addrman) return InitError(util::ErrorString(addrman));
1656 node.addrman = std::move(*addrman);
1657 }
1658
1660 assert(!node.banman);
1661 node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1662 assert(!node.connman);
1663 node.connman = std::make_unique<CConnman>(rng.rand64(),
1664 rng.rand64(),
1665 *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
1666
1667 assert(!node.fee_estimator);
1668 // Don't initialize fee estimation with old data if we don't relay transactions,
1669 // as they would never get updated.
1670 if (!peerman_opts.ignore_incoming_txs) {
1671 bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
1672 if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
1673 return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
1674 }
1675 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
1676
1677 // Flush estimates to disk periodically
1678 CBlockPolicyEstimator* fee_estimator = node.fee_estimator.get();
1679 scheduler.scheduleEvery([fee_estimator] { fee_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
1680 validation_signals.RegisterValidationInterface(fee_estimator);
1681 }
1682
1683 for (const std::string& socket_addr : args.GetArgs("-bind")) {
1684 std::string host_out;
1685 uint16_t port_out{0};
1686 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('='));
1687 if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
1688 return InitError(InvalidPortErrMsg("-bind", socket_addr));
1689 }
1690 }
1691
1692 // sanitize comments per BIP-0014, format user agent and check total size
1693 std::vector<std::string> uacomments;
1694 for (const std::string& cmt : args.GetArgs("-uacomment")) {
1695 if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1696 return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1697 uacomments.push_back(cmt);
1698 }
1700 if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1701 return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1703 }
1704
1705 // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit:
1706 // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip
1707 // the DNS seeds by adjusting -dnsseed in InitParameterInteraction.
1709 return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1710 };
1711
1712 // Check for host lookup allowed before parsing any network related parameters
1714
1715 bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1716 // -proxy sets a proxy for outgoing network traffic, possibly per network.
1717 // -noproxy, -proxy=0 or -proxy="" can be used to remove the proxy setting, this is the default
1718 Proxy ipv4_proxy;
1719 Proxy ipv6_proxy;
1720 Proxy onion_proxy;
1721 Proxy name_proxy;
1722 Proxy cjdns_proxy;
1723 for (const std::string& param_value : args.GetArgs("-proxy")) {
1724 const auto eq_pos{param_value.rfind('=')};
1725 const std::string proxy_str{param_value.substr(0, eq_pos)}; // e.g. 127.0.0.1:9050=ipv4 -> 127.0.0.1:9050
1726 std::string net_str;
1727 if (eq_pos != std::string::npos) {
1728 if (eq_pos + 1 == param_value.length()) {
1729 return InitError(strprintf(_("Invalid -proxy address or hostname, ends with '=': '%s'"), param_value));
1730 }
1731 net_str = ToLower(param_value.substr(eq_pos + 1)); // e.g. 127.0.0.1:9050=ipv4 -> ipv4
1732 }
1733
1734 Proxy proxy;
1735 if (!proxy_str.empty() && proxy_str != "0") {
1736 if (IsUnixSocketPath(proxy_str)) {
1737 proxy = Proxy{proxy_str, /*tor_stream_isolation=*/proxyRandomize};
1738 } else {
1739 const std::optional<CService> addr{Lookup(proxy_str, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1740 if (!addr.has_value()) {
1741 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1742 }
1743 proxy = Proxy{addr.value(), /*tor_stream_isolation=*/proxyRandomize};
1744 }
1745 if (!proxy.IsValid()) {
1746 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1747 }
1748 }
1749
1750 if (net_str.empty()) { // For all networks.
1751 ipv4_proxy = ipv6_proxy = name_proxy = cjdns_proxy = onion_proxy = proxy;
1752 } else if (net_str == "ipv4") {
1753 ipv4_proxy = name_proxy = proxy;
1754 } else if (net_str == "ipv6") {
1755 ipv6_proxy = name_proxy = proxy;
1756 } else if (net_str == "onion") {
1757 onion_proxy = proxy;
1758 } else if (net_str == "cjdns") {
1759 cjdns_proxy = proxy;
1760 } else {
1761 return InitError(strprintf(_("Unrecognized network in -proxy='%s': '%s'"), param_value, net_str));
1762 }
1763 }
1764 if (ipv4_proxy.IsValid()) {
1765 SetProxy(NET_IPV4, ipv4_proxy);
1766 }
1767 if (ipv6_proxy.IsValid()) {
1768 SetProxy(NET_IPV6, ipv6_proxy);
1769 }
1770 if (name_proxy.IsValid()) {
1771 SetNameProxy(name_proxy);
1772 }
1773 if (cjdns_proxy.IsValid()) {
1774 SetProxy(NET_CJDNS, cjdns_proxy);
1775 }
1776
1777 const bool onlynet_used_with_onion{!onlynets.empty() && g_reachable_nets.Contains(NET_ONION)};
1778
1779 // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1780 // -noonion (or -onion=0) disables connecting to .onion entirely
1781 // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1782 std::string onionArg = args.GetArg("-onion", "");
1783 if (onionArg != "") {
1784 if (onionArg == "0") { // Handle -noonion/-onion=0
1785 onion_proxy = Proxy{};
1786 if (onlynet_used_with_onion) {
1787 return InitError(
1788 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1789 "reaching the Tor network is explicitly forbidden: -onion=0"));
1790 }
1791 } else {
1792 if (IsUnixSocketPath(onionArg)) {
1793 onion_proxy = Proxy(onionArg, /*tor_stream_isolation=*/proxyRandomize);
1794 } else {
1795 const std::optional<CService> addr{Lookup(onionArg, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1796 if (!addr.has_value() || !addr->IsValid()) {
1797 return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1798 }
1799
1800 onion_proxy = Proxy(addr.value(), /*tor_stream_isolation=*/proxyRandomize);
1801 }
1802 }
1803 }
1804
1805 const bool listenonion{args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
1806 if (onion_proxy.IsValid()) {
1807 SetProxy(NET_ONION, onion_proxy);
1808 } else {
1809 // If -listenonion is set, then we will (try to) connect to the Tor control port
1810 // later from the torcontrol thread and may retrieve the onion proxy from there.
1811 if (onlynet_used_with_onion && !listenonion) {
1812 return InitError(
1813 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1814 "reaching the Tor network is not provided: none of -proxy, -onion or "
1815 "-listenonion is given"));
1816 }
1818 }
1819
1820 for (const std::string& strAddr : args.GetArgs("-externalip")) {
1821 const std::optional<CService> addrLocal{Lookup(strAddr, GetListenPort(), fNameLookup)};
1822 if (addrLocal.has_value() && addrLocal->IsValid())
1823 AddLocal(addrLocal.value(), LOCAL_MANUAL);
1824 else
1825 return InitError(ResolveErrMsg("externalip", strAddr));
1826 }
1827
1828#ifdef ENABLE_ZMQ
1830 [&chainman = node.chainman](std::vector<std::byte>& block, const CBlockIndex& index) {
1831 assert(chainman);
1832 if (auto ret{chainman->m_blockman.ReadRawBlock(WITH_LOCK(cs_main, return index.GetBlockPos()))}) {
1833 block = std::move(*ret);
1834 return true;
1835 }
1836 return false;
1837 });
1838
1840 validation_signals.RegisterValidationInterface(g_zmq_notification_interface.get());
1841 }
1842#endif
1843
1844 // ********************************************************* Step 7: load block chain
1845
1846 // cache size calculations
1848 const auto [index_cache_sizes, kernel_cache_sizes] = CalculateCacheSizes(args, g_enabled_filter_types.size());
1849
1850 LogInfo("Cache configuration:");
1851 LogInfo("* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db / double(1_MiB));
1852 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1853 LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index / double(1_MiB));
1854 }
1855 if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
1856 LogInfo("* Using %.1f MiB for transaction output spender index database", index_cache_sizes.txospender_index / double(1_MiB));
1857 }
1858 for (BlockFilterType filter_type : g_enabled_filter_types) {
1859 LogInfo("* Using %.1f MiB for %s block filter index database",
1860 index_cache_sizes.filter_index / double(1_MiB), BlockFilterTypeName(filter_type));
1861 }
1862 LogInfo("* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db / double(1_MiB));
1863
1864 assert(!node.mempool);
1865 assert(!node.chainman);
1866
1867 bool do_reindex{args.GetBoolArg("-reindex", false)};
1868 const bool do_reindex_chainstate{args.GetBoolArg("-reindex-chainstate", false)};
1869
1870 // Chainstate initialization and loading may be retried once with reindexing by GUI users
1871 auto [status, error] = InitAndLoadChainstate(
1872 node,
1873 do_reindex,
1874 do_reindex_chainstate,
1875 kernel_cache_sizes,
1876 args);
1877 if (status == ChainstateLoadStatus::FAILURE && !do_reindex && !ShutdownRequested(node)) {
1878 // suggest a reindex
1879 bool do_retry{HasTestOption(args, "reindex_after_failure_noninteractive_yes") ||
1881 error + Untranslated(".\n\n") + _("Do you want to rebuild the databases now?"),
1882 error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1884 if (!do_retry) {
1885 return false;
1886 }
1887 do_reindex = true;
1888 if (!Assert(node.shutdown_signal)->reset()) {
1889 LogError("Internal error: failed to reset shutdown signal.\n");
1890 }
1891 std::tie(status, error) = InitAndLoadChainstate(
1892 node,
1893 do_reindex,
1894 do_reindex_chainstate,
1895 kernel_cache_sizes,
1896 args);
1897 }
1898 if (status != ChainstateLoadStatus::SUCCESS && status != ChainstateLoadStatus::INTERRUPTED) {
1899 return InitError(error);
1900 }
1901
1902 // As LoadBlockIndex can take several minutes, it's possible the user
1903 // requested to kill the GUI during the last operation. If so, exit.
1904 if (ShutdownRequested(node)) {
1905 LogInfo("Shutdown requested. Exiting.");
1906 return true;
1907 }
1908
1909 ChainstateManager& chainman = *Assert(node.chainman);
1910 auto& kernel_notifications{*Assert(node.notifications)};
1911
1912 assert(!node.peerman);
1913 node.peerman = PeerManager::make(*node.connman, *node.addrman,
1914 node.banman.get(), chainman,
1915 *node.mempool, *node.warnings,
1916 peerman_opts);
1917 validation_signals.RegisterValidationInterface(node.peerman.get());
1918
1919 // ********************************************************* Step 8: start indexers
1920
1921 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1922 g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), index_cache_sizes.tx_index, false, do_reindex);
1923 node.indexes.emplace_back(g_txindex.get());
1924 }
1925
1926 if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
1927 g_txospenderindex = std::make_unique<TxoSpenderIndex>(interfaces::MakeChain(node), index_cache_sizes.txospender_index, false, do_reindex);
1928 node.indexes.emplace_back(g_txospenderindex.get());
1929 }
1930
1931 for (const auto& filter_type : g_enabled_filter_types) {
1932 InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, index_cache_sizes.filter_index, false, do_reindex);
1933 node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
1934 }
1935
1936 if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1937 g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, do_reindex);
1938 node.indexes.emplace_back(g_coin_stats_index.get());
1939 }
1940
1941 // Init indexes
1942 for (auto index : node.indexes) if (!index->Init()) return false;
1943
1944 // ********************************************************* Step 9: load wallet
1945 for (const auto& client : node.chain_clients) {
1946 if (!client->load()) {
1947 return false;
1948 }
1949 }
1950
1951 // ********************************************************* Step 10: data directory maintenance
1952
1953 // if pruning, perform the initial blockstore prune
1954 // after any wallet rescanning has taken place.
1955 if (chainman.m_blockman.IsPruneMode()) {
1956 if (chainman.m_blockman.m_blockfiles_indexed) {
1957 LOCK(cs_main);
1958 for (const auto& chainstate : chainman.m_chainstates) {
1959 uiInterface.InitMessage(_("Pruning blockstore…"));
1960 chainstate->PruneAndFlush();
1961 }
1962 }
1963 } else {
1964 // Prior to setting NODE_NETWORK, check if we can provide historical blocks.
1965 if (!WITH_LOCK(chainman.GetMutex(), return chainman.HistoricalChainstate())) {
1966 LogInfo("Setting NODE_NETWORK in non-prune mode");
1967 g_local_services = ServiceFlags(g_local_services | NODE_NETWORK);
1968 } else {
1969 LogInfo("Running node in NODE_NETWORK_LIMITED mode until snapshot background sync completes");
1970 }
1971 }
1972
1973 // ********************************************************* Step 11: import blocks
1974
1976 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetDataDirNet()))));
1977 return false;
1978 }
1980 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
1981 return false;
1982 }
1983
1984 int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height());
1985
1986 // On first startup, warn on low block storage space
1987 if (!do_reindex && !do_reindex_chainstate && chain_active_height <= 1) {
1988 uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1_GiB};
1989 uint64_t additional_bytes_needed{
1990 chainman.m_blockman.IsPruneMode() ?
1991 std::min(chainman.m_blockman.GetPruneTarget(), assumed_chain_bytes) :
1992 assumed_chain_bytes};
1993
1994 if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) {
1996 "Disk space for %s may not accommodate the block files. " \
1997 "Approximately %u GB of data will be stored in this directory."
1998 ),
1999 fs::quoted(fs::PathToString(args.GetBlocksDirPath())),
2000 chainparams.AssumedBlockchainSize()
2001 ));
2002 }
2003 }
2004
2005#ifdef __APPLE__
2006 auto check_and_warn_fs{[&](const fs::path& path, std::string_view desc) {
2007 const auto path_desc{strprintf("%s (\"%s\")", desc, fs::PathToString(path))};
2008 switch (GetFilesystemType(path)) {
2009 case FSType::EXFAT:
2010 InitWarning(strprintf(_("The %s path uses exFAT, which is known to have intermittent corruption problems on macOS. "
2011 "Move this directory to a different filesystem to avoid data loss."), path_desc));
2012 break;
2013 case FSType::ERROR:
2014 LogInfo("Failed to detect filesystem type for %s", path_desc);
2015 break;
2016 case FSType::OTHER:
2017 break;
2018 }
2019 }};
2020
2021 check_and_warn_fs(args.GetDataDirNet(), "data directory");
2022 check_and_warn_fs(args.GetBlocksDirPath(), "blocks directory");
2023#endif
2024
2025#if HAVE_SYSTEM
2026 const std::string block_notify = args.GetArg("-blocknotify", "");
2027 if (!block_notify.empty()) {
2028 uiInterface.NotifyBlockTip.connect([block_notify](SynchronizationState sync_state, const CBlockIndex& block, double /* verification_progress */) {
2029 if (sync_state != SynchronizationState::POST_INIT) return;
2030 std::string command = block_notify;
2031 ReplaceAll(command, "%s", block.GetBlockHash().GetHex());
2032 std::thread t(runCommand, command);
2033 t.detach(); // thread runs free
2034 });
2035 }
2036#endif
2037
2038 std::vector<fs::path> vImportFiles;
2039 for (const std::string& strFile : args.GetArgs("-loadblock")) {
2040 vImportFiles.push_back(fs::PathFromString(strFile));
2041 }
2042
2044 node.background_init_thread = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &node] {
2046 // Import blocks and ActivateBestChain()
2047 ImportBlocks(chainman, vImportFiles);
2048 WITH_LOCK(::cs_main, chainman.UpdateIBDStatus());
2049 if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {
2050 LogInfo("Stopping after block import");
2051 if (!(Assert(node.shutdown_request))()) {
2052 LogError("Failed to send shutdown signal after finishing block import\n");
2053 }
2054 return;
2055 }
2056
2057 // Start indexes initial sync
2059 bilingual_str err_str = _("Failed to start indexes, shutting down…");
2060 chainman.GetNotifications().fatalError(err_str);
2061 return;
2062 }
2063 // Load mempool from disk
2064 if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
2065 LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
2066 pool->SetLoadTried(!chainman.m_interrupt);
2067 }
2068 });
2069
2070 /*
2071 * Wait for genesis block to be processed. Typically kernel_notifications.m_tip_block
2072 * has already been set by a call to LoadChainTip() in CompleteChainstateInitialization().
2073 * But this is skipped if the chainstate doesn't exist yet or is being wiped:
2074 *
2075 * 1. first startup with an empty datadir
2076 * 2. reindex
2077 * 3. reindex-chainstate
2078 *
2079 * In these case it's connected by a call to ActivateBestChain() in the initload thread.
2080 */
2081 {
2082 WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
2083 kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
2084 return kernel_notifications.TipBlock() || ShutdownRequested(node);
2085 });
2086 }
2087
2088 if (ShutdownRequested(node)) {
2089 return true;
2090 }
2091
2092 // ********************************************************* Step 12: start node
2093
2094 int64_t best_block_time{};
2095 {
2096 LOCK(chainman.GetMutex());
2097 const auto& tip{*Assert(chainman.ActiveTip())};
2098 LogInfo("block tree size = %u", chainman.BlockIndex().size());
2099 chain_active_height = tip.nHeight;
2100 best_block_time = tip.GetBlockTime();
2101 if (tip_info) {
2102 tip_info->block_height = chain_active_height;
2103 tip_info->block_time = best_block_time;
2104 tip_info->verification_progress = chainman.GuessVerificationProgress(&tip);
2105 }
2106 if (tip_info && chainman.m_best_header) {
2107 tip_info->header_height = chainman.m_best_header->nHeight;
2108 tip_info->header_time = chainman.m_best_header->GetBlockTime();
2109 }
2110 }
2111 LogInfo("nBestHeight = %d", chain_active_height);
2112 if (node.peerman) node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time});
2113
2114 // Map ports with NAT-PMP
2116
2117 CConnman::Options connOptions;
2118 connOptions.m_local_services = g_local_services;
2119 connOptions.m_max_automatic_connections = nMaxConnections;
2120 connOptions.uiInterface = &uiInterface;
2121 connOptions.m_banman = node.banman.get();
2122 connOptions.m_msgproc = node.peerman.get();
2123 connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
2124 connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
2125 connOptions.m_added_nodes = args.GetArgs("-addnode");
2126 connOptions.nMaxOutboundLimit = *opt_max_upload;
2127 connOptions.m_peer_connect_timeout = peer_connect_timeout;
2128 connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
2129 connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
2130 connOptions.m_capture_messages = args.GetBoolArg("-capturemessages", false);
2131
2132 // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
2133 const uint16_t default_bind_port =
2134 static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));
2135
2136 const uint16_t default_bind_port_onion = default_bind_port + 1;
2137
2138 const auto BadPortWarning = [](const char* prefix, uint16_t port) {
2139 return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and "
2140 "thus it is unlikely that any peer will connect to it. See "
2141 "doc/p2p-bad-ports.md for details and a full list."),
2142 prefix,
2143 port);
2144 };
2145
2146 for (const std::string& bind_arg : args.GetArgs("-bind")) {
2147 std::optional<CService> bind_addr;
2148 const size_t index = bind_arg.rfind('=');
2149 if (index == std::string::npos) {
2150 bind_addr = Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false);
2151 if (bind_addr.has_value()) {
2152 connOptions.vBinds.push_back(bind_addr.value());
2153 if (IsBadPort(bind_addr.value().GetPort())) {
2154 InitWarning(BadPortWarning("-bind", bind_addr.value().GetPort()));
2155 }
2156 continue;
2157 }
2158 } else {
2159 const std::string network_type = bind_arg.substr(index + 1);
2160 if (network_type == "onion") {
2161 const std::string truncated_bind_arg = bind_arg.substr(0, index);
2162 bind_addr = Lookup(truncated_bind_arg, default_bind_port_onion, false);
2163 if (bind_addr.has_value()) {
2164 connOptions.onion_binds.push_back(bind_addr.value());
2165 continue;
2166 }
2167 }
2168 }
2169 return InitError(ResolveErrMsg("bind", bind_arg));
2170 }
2171
2172 for (const std::string& strBind : args.GetArgs("-whitebind")) {
2173 NetWhitebindPermissions whitebind;
2174 bilingual_str error;
2175 if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
2176 connOptions.vWhiteBinds.push_back(whitebind);
2177 }
2178
2179 // If the user did not specify -bind= or -whitebind= then we bind
2180 // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
2181 connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
2182
2183 // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not
2184 // given, because if they are, then -port= is ignored.
2185 if (connOptions.bind_on_any && args.IsArgSet("-port")) {
2186 const uint16_t port_arg = args.GetIntArg("-port", 0);
2187 if (IsBadPort(port_arg)) {
2188 InitWarning(BadPortWarning("-port", port_arg));
2189 }
2190 }
2191
2192 CService onion_service_target;
2193 if (!connOptions.onion_binds.empty()) {
2194 onion_service_target = connOptions.onion_binds.front();
2195 } else if (!connOptions.vBinds.empty()) {
2196 onion_service_target = connOptions.vBinds.front();
2197 } else {
2198 onion_service_target = DefaultOnionServiceTarget(default_bind_port_onion);
2199 connOptions.onion_binds.push_back(onion_service_target);
2200 }
2201
2202 if (listenonion) {
2203 if (connOptions.onion_binds.size() > 1) {
2204 InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
2205 "for the automatically created Tor onion service."),
2206 onion_service_target.ToStringAddrPort()));
2207 }
2208 node.tor_controller = std::make_unique<TorController>(gArgs.GetArg("-torcontrol", DEFAULT_TOR_CONTROL), onion_service_target);
2209 }
2210
2211 bool should_discover = connOptions.bind_on_any;
2212 if (!should_discover) {
2213 for (const auto& bind : connOptions.vBinds) {
2214 if (bind.IsBindAny()) {
2215 should_discover = true;
2216 break;
2217 }
2218 }
2219 }
2220
2221 if (!should_discover) {
2222 for (const auto& whitebind : connOptions.vWhiteBinds) {
2223 if (whitebind.m_service.IsBindAny()) {
2224 should_discover = true;
2225 break;
2226 }
2227 }
2228 }
2229
2230 if (should_discover) {
2231 // Only add all IP addresses of the machine if we would be listening on
2232 // any address - 0.0.0.0 (IPv4) and :: (IPv6).
2233 Discover();
2234 }
2235
2236 for (const auto& net : args.GetArgs("-whitelist")) {
2238 ConnectionDirection connection_direction;
2239 bilingual_str error;
2240 if (!NetWhitelistPermissions::TryParse(net, subnet, connection_direction, error)) return InitError(error);
2241 if (connection_direction & ConnectionDirection::In) {
2242 connOptions.vWhitelistedRangeIncoming.push_back(subnet);
2243 }
2244 if (connection_direction & ConnectionDirection::Out) {
2245 connOptions.vWhitelistedRangeOutgoing.push_back(subnet);
2246 }
2247 }
2248
2249 connOptions.vSeedNodes = args.GetArgs("-seednode");
2250
2251 const auto connect = args.GetArgs("-connect");
2252 if (!connect.empty() || args.IsArgNegated("-connect")) {
2253 // Do not initiate other outgoing connections when connecting to trusted
2254 // nodes, or when -noconnect is specified.
2255 connOptions.m_use_addrman_outgoing = false;
2256
2257 if (connect.size() != 1 || connect[0] != "0") {
2258 connOptions.m_specified_outgoing = connect;
2259 }
2260 if (!connOptions.m_specified_outgoing.empty() && !connOptions.vSeedNodes.empty()) {
2261 LogInfo("-seednode is ignored when -connect is used");
2262 }
2263
2264 if (args.IsArgSet("-dnsseed") && args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED) && args.IsArgSet("-proxy")) {
2265 LogInfo("-dnsseed is ignored when -connect is used and -proxy is specified");
2266 }
2267 }
2268
2269 const std::string& i2psam_arg = args.GetArg("-i2psam", "");
2270 if (!i2psam_arg.empty()) {
2271 const std::optional<CService> addr{Lookup(i2psam_arg, 7656, fNameLookup)};
2272 if (!addr.has_value() || !addr->IsValid()) {
2273 return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
2274 }
2275 SetProxy(NET_I2P, Proxy{addr.value()});
2276 } else {
2277 if (!onlynets.empty() && g_reachable_nets.Contains(NET_I2P)) {
2278 return InitError(
2279 _("Outbound connections restricted to i2p (-onlynet=i2p) but "
2280 "-i2psam is not provided"));
2281 }
2283 }
2284
2285 connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING);
2286
2287 if (auto conflict = CheckBindingConflicts(connOptions)) {
2288 return InitError(strprintf(
2289 _("Duplicate binding configuration for address %s. "
2290 "Please check your -bind, -bind=...=onion and -whitebind settings."),
2291 conflict->ToStringAddrPort()));
2292 }
2293
2294 if (args.GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)) {
2295 // If -listenonion is set, then NET_ONION may not be reachable now
2296 // but may become reachable later, thus only error here if it is not
2297 // reachable and will not become reachable for sure.
2298 const bool onion_may_become_reachable{listenonion && (!args.IsArgSet("-onlynet") || onlynet_used_with_onion)};
2301 !onion_may_become_reachable) {
2302 return InitError(_("Private broadcast of own transactions requested (-privatebroadcast), "
2303 "but none of Tor or I2P networks is reachable"));
2304 }
2305 if (!connOptions.m_use_addrman_outgoing) {
2306 return InitError(_("Private broadcast of own transactions requested (-privatebroadcast), "
2307 "but -connect is also configured. They are incompatible because the "
2308 "private broadcast needs to open new connections to randomly "
2309 "chosen Tor or I2P peers. Consider using -maxconnections=0 -addnode=... "
2310 "instead"));
2311 }
2312 if (!proxyRandomize && (g_reachable_nets.Contains(NET_ONION) || onion_may_become_reachable)) {
2313 InitWarning(_("Private broadcast of own transactions requested (-privatebroadcast) and "
2314 "-proxyrandomize is disabled. Tor circuits for private broadcast connections "
2315 "may be correlated to other connections over Tor. For maximum privacy set "
2316 "-proxyrandomize=1."));
2317 }
2318 }
2319
2320 if (!node.connman->Start(scheduler, connOptions)) {
2321 return false;
2322 }
2323
2324 // ********************************************************* Step 13: finished
2325
2326 // At this point, the RPC is "started", but still in warmup, which means it
2327 // cannot yet be called. Before we make it callable, we need to make sure
2328 // that the RPC's view of the best block is valid and consistent with
2329 // ChainstateManager's active tip.
2331
2332 uiInterface.InitMessage(_("Done loading"));
2333
2334 for (const auto& client : node.chain_clients) {
2335 client->start(scheduler);
2336 }
2337
2338 BanMan* banman = node.banman.get();
2339 scheduler.scheduleEvery([banman]{
2340 banman->DumpBanlist();
2342
2343 if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
2344
2345#if HAVE_SYSTEM
2346 StartupNotify(args);
2347#endif
2348
2349 return true;
2350}
2351
2353{
2354 ChainstateManager& chainman = *Assert(node.chainman);
2355 const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.ValidatedChainstate());
2356 const CChain& index_chain = chainstate.m_chain;
2357 const int current_height = WITH_LOCK(::cs_main, return index_chain.Height());
2358
2359 // Skip checking data availability if we have not synced any blocks yet
2360 if (current_height > 0) {
2361 // Before starting index sync, verify that all required block data is available
2362 // on disk from each index's current sync position up to the chain tip.
2363 //
2364 // This is done separately for undo and block data: First we verify block + undo
2365 // data existence from tip down to the lowest height required by any index that
2366 // needs undo data (e.g., coinstatsindex, blockfilterindex). Then, if any
2367 // block-only index needs to sync from a lower height than previously covered,
2368 // verify block data existence down to that lower height.
2369 //
2370 // This avoids checking undo data for blocks where no index requires it,
2371 // though currently block and undo data availability are synchronized on disk
2372 // under normal circumstances.
2373 std::optional<const CBlockIndex*> block_start;
2374 std::string block_start_name;
2375 std::optional<const CBlockIndex*> undo_start;
2376 std::string undo_start_name;
2377
2378 for (const auto& index : node.indexes) {
2379 const IndexSummary& summary = index->GetSummary();
2380 if (summary.synced) continue;
2381
2382 // Get the last common block between the index best block and the active chain
2383 const CBlockIndex* pindex = nullptr;
2384 {
2385 LOCK(::cs_main);
2386 pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash);
2387 if (!pindex) {
2388 LogWarning("Failed to find block manager entry for best block %s from %s, falling back to genesis for index sync",
2389 summary.best_block_hash.ToString(), summary.name);
2390 } else if (!index_chain.Contains(*pindex)) {
2391 pindex = index_chain.FindFork(*pindex);
2392 }
2393 }
2394 if (!pindex) {
2395 pindex = index_chain.Genesis();
2396 }
2397
2398 bool need_undo = index->CustomOptions().connect_undo_data;
2399 auto& op_start_index = need_undo ? undo_start : block_start;
2400 auto& name_index = need_undo ? undo_start_name : block_start_name;
2401
2402 if (op_start_index && pindex->nHeight >= op_start_index.value()->nHeight) continue;
2403 op_start_index = pindex;
2404 name_index = summary.name;
2405 }
2406
2407 // Verify all blocks needed to sync to current tip are present including undo data.
2408 if (undo_start) {
2409 LOCK(::cs_main);
2410 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(undo_start.value()), BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO})) {
2411 return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)", undo_start_name)));
2412 }
2413 }
2414
2415 // Verify all blocks needed to sync to current tip are present unless we already checked all of them above.
2416 if (block_start && !(undo_start && undo_start.value()->nHeight <= block_start.value()->nHeight)) {
2417 LOCK(::cs_main);
2418 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(block_start.value()), BlockStatus{BLOCK_HAVE_DATA})) {
2419 return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data. Please disable the index or reindex (which will download the whole blockchain again)", block_start_name)));
2420 }
2421 }
2422 }
2423
2424 // Start threads
2425 for (auto index : node.indexes) if (!index->StartBackgroundSync()) return false;
2426 return true;
2427}
util::Result< std::unique_ptr< AddrMan > > LoadAddrman(const NetGroupManager &netgroupman, const ArgsManager &args)
Returns an error string on failure.
Definition: addrdb.cpp:196
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
Definition: addrman.h:57
const std::vector< std::string > TEST_OPTIONS_DOC
Definition: args.cpp:839
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
Definition: args.cpp:811
const char *const BITCOIN_SETTINGS_FILENAME
Definition: args.cpp:38
ArgsManager gArgs
Definition: args.cpp:40
bool HasTestOption(const ArgsManager &args, const std::string &test_option)
Checks if a particular test option is present in -test command-line arg options.
Definition: args.cpp:845
const char *const BITCOIN_CONF_FILENAME
Definition: args.cpp:37
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:240
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
void ScheduleBatchPriority()
On platforms that support it, tell the kernel the calling thread is CPU-intensive and non-interactive...
int ret
const auto cmd
int exit_status
const auto command
ArgsManager & args
Definition: bitcoind.cpp:280
static constexpr bool DEFAULT_ACCEPT_STALE_FEE_ESTIMATES
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...
static constexpr std::chrono::hours FEE_FLUSH_INTERVAL
fs::path FeeestPath(const ArgsManager &argsman)
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
const std::set< BlockFilterType > & AllBlockFilterTypes()
Get a list of known filter types.
bool BlockFilterTypeByName(std::string_view name, BlockFilterType &filter_type)
Find a filter type by its human-readable name.
const std::string & ListBlockFilterTypes()
Get a comma-separated list of known filter type names.
BlockFilterType
Definition: blockfilter.h:94
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
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
BlockStatus
Definition: chain.h:42
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 CChainParams & Params()
Return the currently selected parameters.
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const ChainType chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 48334, 18445) have been chosen arbitra...
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
static constexpr int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
static constexpr auto DEFAULT_MAX_TIP_AGE
std::string ChainTypeToString(ChainType chain)
Definition: chaintype.cpp:12
ChainType
Definition: chaintype.h:12
#define Assert(val)
Identity function.
Definition: check.h:116
std::vector< std::string > GetArgs(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return a vector of strings of the given argument.
Definition: args.cpp:424
ChainType GetChainType() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Returns the appropriate chain type from the program arguments.
Definition: args.cpp:904
@ NETWORK_ONLY
Definition: args.h:129
@ ALLOW_ANY
disable validation
Definition: args.h:115
@ DISALLOW_NEGATION
disallow -nofoo syntax
Definition: args.h:120
@ DISALLOW_ELISION
disallow -foo syntax that doesn't assign any value
Definition: args.h:121
@ DEBUG_ONLY
Definition: args.h:123
@ SENSITIVE
Definition: args.h:131
std::list< SectionInfo > GetUnrecognizedSections() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Log warnings for unrecognized section names in the config file.
Definition: args.cpp:154
fs::path GetBlocksDirPath() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get blocks directory path.
Definition: args.cpp:300
bool SoftSetArg(const std::string &strArg, const std::string &strValue) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Set an argument if it doesn't already have a value.
Definition: args.cpp:613
std::set< std::string > GetUnsuitableSectionOnlyArgs() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Log warnings for options in m_section_only_args when they are specified in the default section but no...
Definition: args.cpp:134
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Add argument.
Definition: args.cpp:659
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return path argument or default value.
Definition: args.cpp:294
std::string GetArg(const std::string &strArg, const std::string &strDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return string argument or default value.
Definition: args.cpp:519
void AddHiddenArgs(const std::vector< std::string > &args) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Add many hidden arguments.
Definition: args.cpp:680
bool IsArgSet(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return true if the given argument has been manually set.
Definition: args.cpp:433
bool SoftSetBoolArg(const std::string &strArg, bool fValue) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Set a boolean argument if it doesn't already have a value.
Definition: args.cpp:621
fs::path GetDataDirNet() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get data directory path with appended network identifier.
Definition: args.cpp:330
bool IsArgNegated(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return true if the argument was originally passed as a negated option, i.e.
Definition: args.cpp:514
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: args.h:324
bool GetBoolArg(const std::string &strArg, bool fDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return boolean argument or default value.
Definition: args.cpp:573
static std::shared_ptr< LogRateLimiter > Create(SchedulerFunction &&scheduler_func, uint64_t max_bytes, std::chrono::seconds reset_window)
Definition: logging.cpp:384
void SetRateLimiting(std::shared_ptr< LogRateLimiter > limiter) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Definition: logging.h:216
std::atomic< bool > m_reopen_file
Definition: logging.h:178
Definition: banman.h:64
void DumpBanlist() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
Definition: banman.cpp:48
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:94
uint256 GetBlockHash() const
Definition: chain.h:198
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:106
The BlockPolicyEstimator is used for estimating the feerate needed for a transaction to be included i...
void FlushFeeEstimates() EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator)
Record current fee estimations.
An in-memory indexed chain of blocks.
Definition: chain.h:380
bool Contains(const CBlockIndex &index) const
Efficiently check whether a block is present in this chain.
Definition: chain.h:410
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:396
const CBlockIndex * FindFork(const CBlockIndex &index) const
Find the last common block between this chain and a block index entry.
Definition: chain.cpp:50
CBlockIndex * Genesis() const
Returns the index entry for the genesis block of this chain, or nullptr if none.
Definition: chain.h:390
int Height() const
Return the maximal height in the chain.
Definition: chain.h:425
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:77
std::string GetChainTypeString() const
Return the chain type string.
Definition: chainparams.h:109
const MessageStartChars & MessageStart() const
Definition: chainparams.h:90
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
Definition: chainparams.h:96
ChainType GetChainType() const
Return the chain type.
Definition: chainparams.h:111
btcsignals::signal< void(const std::string &message)> InitMessage
Progress message during initialization.
Definition: interface_ui.h:74
btcsignals::signal< bool(const bilingual_str &message, const std::string &noninteractive_message, unsigned int style), btcsignals::any_of > ThreadSafeQuestion
If possible, ask the user a question.
Definition: interface_ui.h:71
btcsignals::signal< void()> InitWallet
Wallet loader created.
Definition: interface_ui.h:77
btcsignals::signal< void(const bilingual_str &message, unsigned int style)> ThreadSafeMessageBox
Show message box.
Definition: interface_ui.h:68
btcsignals::signal< void(SynchronizationState, const CBlockIndex &block, double verification_progress)> NotifyBlockTip
New block has been accepted.
Definition: interface_ui.h:97
bool IsBindAny() const
Definition: netaddress.cpp:303
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:530
std::string ToStringAddrPort() const
Definition: netaddress.cpp:903
static const int DEFAULT_ZMQ_SNDHWM
static std::unique_ptr< CZMQNotificationInterface > Create(std::function< bool(std::vector< std::byte > &, 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:551
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:625
Interface for managing multiple Chainstate objects, where each chainstate is associated with chainsta...
Definition: validation.h:940
Chainstate * HistoricalChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Return historical chainstate targeting a specific block, if any.
Definition: validation.h:1128
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1183
double GuessVerificationProgress(const CBlockIndex *pindex) const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
kernel::Notifications & GetNotifications() const
Definition: validation.h:1012
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1032
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1167
Chainstate & ActiveChainstate() const
Alternatives to CurrentChainstate() used by older code to query latest chainstate information without...
const util::SignalInterrupt & m_interrupt
Definition: validation.h:1034
Chainstate & ValidatedChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Return fully validated chainstate that should be used for indexing, to support indexes that need to i...
Definition: validation.h:1139
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
Definition: validation.h:1005
void UpdateIBDStatus() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Update and possibly latch the IBD status.
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1165
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1038
Fast randomness source.
Definition: random.h:386
uint64_t rand64() noexcept
Generate a random 64-bit integer.
Definition: random.h:404
static NetGroupManager NoAsmap()
Definition: netgroup.h:32
static NetGroupManager WithEmbeddedAsmap(std::span< const std::byte > asmap)
Definition: netgroup.h:24
static NetGroupManager WithLoadedAsmap(std::vector< std::byte > &&asmap)
Definition: netgroup.h:28
static bool TryParse(const std::string &str, NetWhitebindPermissions &output, bilingual_str &error)
static bool TryParse(const std::string &str, NetWhitelistPermissions &output, ConnectionDirection &output_connection_direction, bilingual_str &error)
static std::unique_ptr< PeerManager > make(CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, node::Warnings &warnings, Options opts)
Definition: netbase.h:61
bool IsValid() const
Definition: netbase.h:73
void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:106
bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:134
void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:113
void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:120
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:21
std::string GetHex() const
Definition: uint256.cpp:11
connection connect(Callable &&func) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: btcsignals.h:236
Interface providing access to interprocess-communication (IPC) functionality.
Definition: ipc.h:51
Exception class thrown when a call to remote method fails due to an IPC error, like a socket getting ...
Definition: exception.h:14
A base class defining functions for notifying about certain kernel events.
virtual void fatalError(const bilingual_str &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:196
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CBlockFileInfo *GetBlockFileInfo(size_t n) EXCLUSIVE_LOCKS_REQUIRED(bool WriteBlockUndo(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos WriteBlock(const CBlock &block, int nHeight) EXCLUSIVE_LOCKS_REQUIRED(void UpdateBlockInfo(const CBlock &block, unsigned int nHeight, const FlatFilePos &pos) EXCLUSIVE_LOCKS_REQUIRED(bool IsPruneMode() const
Get block file info entry for one block file.
Definition: blockstorage.h:407
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
Definition: blockstorage.h:333
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
Definition: blockstorage.h:410
uint64_t CalculateCurrentUsage() EXCLUSIVE_LOCKS_REQUIRED(bool CheckBlockDataAvailability(const CBlockIndex &upper_block, const CBlockIndex &lower_block, BlockStatus block_status=BLOCK_HAVE_DATA) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex &GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block LIFETIMEBOUND=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Calculate the amount of disk space the block & undo files currently use.
Definition: blockstorage.h:453
256-bit opaque blob.
Definition: uint256.h:196
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...
const std::string UA_NAME
static const int CLIENT_VERSION
Definition: clientversion.h:26
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
static constexpr bool DEFAULT_COINSTATSINDEX
bool SetupNetworking()
Definition: system.cpp:97
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
const std::string CURRENCY_UNIT
Definition: feerate.h:19
static auto quoted(const std::string &s)
Definition: fs.h:106
static bool exists(const path &p)
Definition: fs.h:96
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition: fs.h:162
int RaiseFileDescriptorLimit(int nMinFD)
this function tries to raise the file descriptor limit to the requested number.
Definition: fs_helpers.cpp:161
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
Definition: fs_helpers.cpp:91
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:30
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
Definition: httprpc.cpp:355
void StopHTTPRPC()
Stop HTTP RPC subsystem.
Definition: httprpc.cpp:360
bool StartHTTPRPC(const std::any &context)
Start HTTP RPC subsystem.
Definition: httprpc.cpp:339
void StartREST(const std::any &context)
Start HTTP REST subsystem.
Definition: rest.cpp:1161
void StopREST()
Stop HTTP REST subsystem.
Definition: rest.cpp:1173
void InterruptREST()
Interrupt RPC REST subsystem.
Definition: rest.cpp:1169
void InterruptHTTPServer()
Interrupt HTTP server threads.
Definition: httpserver.cpp:448
void StartHTTPServer()
Start HTTP server.
Definition: httpserver.cpp:440
bool InitHTTPServer(const util::SignalInterrupt &interrupt)
Initialize HTTP server.
Definition: httpserver.cpp:384
void StopHTTPServer()
Stop HTTP server.
Definition: httpserver.cpp:459
static const int DEFAULT_HTTP_SERVER_TIMEOUT
Definition: httpserver.h:28
static const int DEFAULT_HTTP_WORKQUEUE
The default value for -rpcworkqueue.
Definition: httpserver.h:26
static const int DEFAULT_HTTP_THREADS
The default value for -rpcthreads.
Definition: httpserver.h:20
Common init functions shared by bitcoin-node, bitcoin-wallet, etc.
static bool LockDirectory(const fs::path &dir, bool probeOnly)
Definition: init.cpp:1172
static const char * BITCOIN_PID_FILENAME
The PID file facilities.
Definition: init.cpp:188
static bool CreatePidFile(const ArgsManager &args)
Definition: init.cpp:200
static bool g_generated_pid
True if this process has created a PID file.
Definition: init.cpp:193
static std::optional< util::SignalInterrupt > g_shutdown
Definition: init.cpp:228
static void RemovePidFile(const ArgsManager &args)
Definition: init.cpp:218
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:285
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:875
static bool AppInitServers(NodeContext &node)
Definition: init.cpp:770
static bool LockDirectories(bool probeOnly)
Definition: init.cpp:1184
static constexpr int MIN_CORE_FDS
Definition: init.cpp:183
void Shutdown(NodeContext &node)
Definition: init.cpp:307
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
Definition: init.cpp:447
static void HandleSIGHUP(int)
Definition: init.cpp:454
bool AppInitBasicSetup(const ArgsManager &args, std::atomic< int > &exit_status)
Initialize bitcoin core: Basic context setup.
Definition: init.cpp:904
static fs::path GetPidFile(const ArgsManager &args)
Definition: init.cpp:195
static constexpr bool DEFAULT_PROXYRANDOMIZE
Definition: init.cpp:169
bool CheckHostPortOptions(const ArgsManager &args)
Definition: init.cpp:1230
static std::optional< CService > CheckBindingConflicts(const CConnman::Options &conn_options)
Checks for duplicate bindings across all binding configurations.
Definition: init.cpp:1285
static ChainstateLoadResult InitAndLoadChainstate(NodeContext &node, bool do_reindex, const bool do_reindex_chainstate, const kernel::CacheSizes &cache_sizes, const ArgsManager &args)
Definition: init.cpp:1315
bool ShutdownRequested(node::NodeContext &node)
Return whether node shutdown was requested.
Definition: init.cpp:267
bool StartIndexBackgroundSync(NodeContext &node)
Validates requirements to run the indexes and spawns each index initial sync thread.
Definition: init.cpp:2352
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:941
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1221
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
Definition: init.cpp:172
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:786
static constexpr bool DEFAULT_REST_ENABLE
Definition: init.cpp:170
#define MIN_LEVELDB_FDS
Definition: init.cpp:180
static void registerSignalHandler(int signal, void(*handler)(int))
Definition: init.cpp:471
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
Definition: init.cpp:1438
static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING
Definition: init.cpp:171
bool AppInitLockDirectories()
Lock bitcoin core critical directories.
Definition: init.cpp:1209
void SetupServerArgs(ArgsManager &argsman, bool can_listen_ipc)
Register all arguments with the ArgsManager.
Definition: init.cpp:481
void InitContext(NodeContext &node)
Initialize node context shutdown and args variables.
Definition: init.cpp:230
static void new_handler_terminate()
Definition: init.cpp:891
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
Definition: init.cpp:1190
static constexpr bool DEFAULT_DAEMON
Default value for -daemon option.
Definition: init.h:12
static constexpr bool DEFAULT_DAEMONWAIT
Default value for -daemonwait option.
Definition: init.h:14
CClientUIInterface uiInterface
void InitWarning(const bilingual_str &str)
Show warning message.
bool InitError(const bilingual_str &str)
Show error message.
static constexpr size_t DEFAULT_DB_CACHE_BATCH
Default LevelDB write batch size.
Definition: caches.h:15
bool ECC_InitSanityCheck()
Check that required EC support is available at runtime.
Definition: key.cpp:442
#define LogWarning(...)
Definition: log.h:126
#define LogInfo(...)
Definition: log.h:125
#define LogError(...)
Definition: log.h:127
#define LogDebug(category,...)
Definition: log.h:143
BCLog::Logger & LogInstance()
Definition: logging.cpp:26
void StopMapPort()
Definition: mapport.cpp:155
void InterruptMapPort()
Definition: mapport.cpp:148
void StartMapPort(bool enable)
Definition: mapport.cpp:138
static constexpr bool DEFAULT_NATPMP
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 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.
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
is used externally by mining IPC clients, so it should only declare simple data definitions.
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:19
constexpr auto RATELIMIT_WINDOW
Definition: logging.h:67
constexpr bool DEFAULT_LOGRATELIMIT
Definition: logging.h:68
constexpr uint64_t RATELIMIT_MAX_BYTES
Definition: logging.h:66
@ IPC
Definition: categories.h:39
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
Definition: messages.cpp:150
bilingual_str InvalidPortErrMsg(const std::string &optname, const std::string &invalid_value)
Definition: messages.cpp:155
void AddLoggingArgs(ArgsManager &argsman)
Definition: common.cpp:27
util::Result< void > SetLoggingCategories(const ArgsManager &args)
Definition: common.cpp:79
bool StartLogging(const ArgsManager &args)
Definition: common.cpp:107
util::Result< void > SetLoggingLevel(const ArgsManager &args)
Definition: common.cpp:60
void SetLoggingOptions(const ArgsManager &args)
Definition: common.cpp:46
void LogPackageVersion()
Definition: common.cpp:148
std::unique_ptr< Mining > MakeMining(const node::NodeContext &node, bool wait_loaded=true)
Return implementation of Mining interface.
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
Definition: ipc.h:13
static constexpr bool DEFAULT_XOR_BLOCKSDIR
util::Result< void > SanityChecks(const Context &)
Ensure a usable environment with all necessary library support.
Definition: checks.cpp:15
Definition: messages.h:21
ChainstateLoadStatus
Chainstate load status.
Definition: chainstate.h:44
@ FAILURE
Generic failure which reindexing may fix.
std::tuple< ChainstateLoadStatus, bilingual_str > ChainstateLoadResult
Chainstate load status code and optional error string.
Definition: chainstate.h:54
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
Definition: caches.cpp:57
fs::path MempoolPath(const ArgsManager &argsman)
void LogOversizedDbCache(const ArgsManager &args) noexcept
Definition: caches.cpp:85
util::Result< void > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
Result< BlockCreateOptions > ReadMiningArgs(const ArgsManager &args)
Read the mining options set in args.
Definition: mining_args.cpp:63
static const bool DEFAULT_PRINT_MODIFIED_FEE
Definition: mining_args.h:15
bool ShouldPersistMempool(const ArgsManager &argsman)
void ReadNotificationArgs(const ArgsManager &args, KernelNotifications &notifications)
size_t GetDefaultDBCache()
Definition: caches.cpp:36
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:151
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:240
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.
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
void ImportBlocks(ChainstateManager &chainman, std::span< const fs::path > import_paths)
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
void format(std::ostream &out, FormatStringCheck< sizeof...(Args)> fmt, const Args &... args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1079
void ThreadRename(const std::string &)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
Definition: threadnames.cpp:54
bilingual_str ErrorString(const Result< T > &result)
Definition: result.h:93
void TraceThread(std::string_view thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
Definition: thread.cpp:15
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:247
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
Definition: string.h:206
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
Definition: string.cpp:14
LockResult LockDirectory(const fs::path &directory, const fs::path &lockfile_name, bool probe_only)
Definition: fs_helpers.cpp:51
uint16_t GetListenPort()
Definition: net.cpp:139
bool fDiscover
Definition: net.cpp:117
bool AddLocal(const CService &addr_, int nScore)
Definition: net.cpp:278
bool fListen
Definition: net.cpp:118
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:121
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:3417
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:81
static constexpr bool DEFAULT_PRIVATE_BROADCAST
Default for -privatebroadcast.
Definition: net.h:89
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:67
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:71
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:99
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:91
static constexpr bool DEFAULT_FIXEDSEEDS
Definition: net.h:97
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:85
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:98
static const std::string DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:83
static constexpr bool DEFAULT_FORCEDNSSEED
Definition: net.h:95
static constexpr size_t MAX_PRIVATE_BROADCAST_CONNECTIONS
Maximum number of private broadcast connections.
Definition: net.h:77
static constexpr bool DEFAULT_DNSSEED
Definition: net.h:96
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:79
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:87
@ LOCAL_MANUAL
Definition: net.h:158
static constexpr bool DEFAULT_V2_TRANSPORT
Definition: net.h:101
const std::vector< std::string > NET_PERMISSIONS_DOC
constexpr bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
constexpr bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN
Default number of non-mempool transactions to keep around for block reconstruction.
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:33
@ NET_I2P
I2P.
Definition: netaddress.h:47
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:50
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:44
@ NET_IPV6
IPv6.
Definition: netaddress.h:41
@ NET_IPV4
IPv4.
Definition: netaddress.h:38
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:35
bool SetNameProxy(const Proxy &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
Definition: netbase.cpp:736
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:100
bool SetProxy(enum Network net, const Proxy &addrProxy)
Definition: netbase.cpp:717
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:191
ReachableNets g_reachable_nets
Definition: netbase.cpp:43
bool fNameLookup
Definition: netbase.cpp:37
int nConnectTimeout
Definition: netbase.cpp:36
bool IsUnixSocketPath(const std::string &name)
Check if a string is a valid UNIX domain socket path.
Definition: netbase.cpp:226
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:866
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:130
ConnectionDirection
Definition: netbase.h:35
static const int DEFAULT_NAME_LOOKUP
-dns default
Definition: netbase.h:30
const std::string ADDR_PREFIX_UNIX
Prefix for unix domain socket addresses (which are local filesystem paths)
Definition: netbase.h:33
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
Definition: netbase.h:28
static constexpr size_t MIN_DB_CACHE
min. -dbcache (bytes)
Definition: caches.h:16
unsigned int nBytesPerSigOp
Definition: settings.cpp:10
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for -datacarriersize in vbytes.
Definition: policy.h:84
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:36
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:48
static constexpr bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
Definition: policy.h:52
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
Definition: policy.h:68
static constexpr unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
Definition: policy.h:78
static constexpr unsigned int DEFAULT_BYTES_PER_SIGOP
Default for -bytespersigop.
Definition: policy.h:50
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:25
static constexpr unsigned int DEFAULT_CLUSTER_SIZE_LIMIT_KVB
Maximum size of cluster in virtual kilobytes.
Definition: policy.h:74
static constexpr unsigned int DEFAULT_BLOCK_RESERVED_WEIGHT
Default for -blockreservedweight.
Definition: policy.h:27
static const bool DEFAULT_ACCEPT_DATACARRIER
Default for -datacarrier.
Definition: policy.h:80
static constexpr unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
Definition: policy.h:76
static constexpr unsigned int DEFAULT_CLUSTER_LIMIT
Maximum number of transactions per cluster (default)
Definition: policy.h:72
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: policy.h:70
ServiceFlags
nServices flags
Definition: protocol.h:321
@ NODE_P2P_V2
Definition: protocol.h:342
@ NODE_WITNESS
Definition: protocol.h:332
@ NODE_NETWORK_LIMITED
Definition: protocol.h:339
@ NODE_BLOOM
Definition: protocol.h:329
@ NODE_NETWORK
Definition: protocol.h:327
@ NODE_COMPACT_FILTERS
Definition: protocol.h:335
void RandAddPeriodic() noexcept
Gather entropy from various expensive sources, and feed them to the PRNG state.
Definition: random.cpp:612
static void RegisterAllCoreRPCCommands(CRPCTable &t)
Definition: register.h:26
const char * prefix
Definition: rest.cpp:1142
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:1143
const char * name
Definition: rest.cpp:49
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:43
static constexpr bool DEFAULT_RPC_DOC_CHECK
Definition: util.h:46
void SetRPCWarmupFinished()
Definition: server.cpp:324
void StartRPC()
Definition: server.cpp:273
void StopRPC()
Definition: server.cpp:290
void InterruptRPC()
Definition: server.cpp:279
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:312
CRPCTable tableRPC
Definition: server.cpp:544
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:307
static constexpr size_t DEFAULT_VALIDATION_CACHE_BYTES
Definition: sigcache.h:31
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
Definition: strencodings.h:33
unsigned int nReceiveFloodSize
Definition: net.h:1094
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:1100
uint64_t nMaxOutboundLimit
Definition: net.h:1095
CClientUIInterface * uiInterface
Definition: net.h:1090
std::vector< NetWhitelistPermissions > vWhitelistedRangeIncoming
Definition: net.h:1098
std::vector< CService > onion_binds
Definition: net.h:1102
std::vector< std::string > m_specified_outgoing
Definition: net.h:1107
bool whitelist_relay
Definition: net.h:1111
NetEventsInterface * m_msgproc
Definition: net.h:1091
std::vector< std::string > m_added_nodes
Definition: net.h:1108
int64_t m_peer_connect_timeout
Definition: net.h:1096
std::vector< CService > vBinds
Definition: net.h:1101
bool m_capture_messages
Definition: net.h:1112
unsigned int nSendBufferMaxSize
Definition: net.h:1093
int m_max_automatic_connections
Definition: net.h:1089
ServiceFlags m_local_services
Definition: net.h:1088
bool m_i2p_accept_incoming
Definition: net.h:1109
std::vector< std::string > vSeedNodes
Definition: net.h:1097
BanMan * m_banman
Definition: net.h:1092
bool m_use_addrman_outgoing
Definition: net.h:1106
bool whitelist_forcerelay
Definition: net.h:1110
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:1105
std::vector< NetWhitelistPermissions > vWhitelistedRangeOutgoing
Definition: net.h:1099
Application-specific storage settings.
Definition: dbwrapper.h:38
fs::path path
Location in the filesystem where leveldb data will be stored.
Definition: dbwrapper.h:40
std::string name
Definition: base.h:31
bool synced
Definition: base.h:32
uint256 best_block_hash
Definition: base.h:34
Bilingual messages:
Definition: translation.h:24
bool empty() const
Definition: translation.h:35
Block and header tip information.
Definition: node.h:51
size_t block_tree_db
Definition: caches.h:24
size_t coins
Definition: caches.h:26
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:16
Options struct containing options for constructing a CTxMemPool.
bool require_full_verification
Setting require_full_verification to true will require all checks at check_level (below) to succeed f...
Definition: chainstate.h:34
std::function< void()> coins_error_cb
Definition: chainstate.h:37
NodeContext struct containing references to chain state and connection state.
Definition: context.h:59
#define WAIT_LOCK(cs, name)
Definition: sync.h:274
#define LOCK(cs)
Definition: sync.h:268
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:299
#define TRY_LOCK(cs, name)
Definition: sync.h:273
std::string SysErrorString(int err)
Return system error string from errno value.
Definition: syserror.cpp:18
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
const std::string DEFAULT_TOR_CONTROL
Default control ip and port.
Definition: torcontrol.cpp:46
CService DefaultOnionServiceTarget(uint16_t port)
Definition: torcontrol.cpp:750
constexpr uint16_t DEFAULT_TOR_SOCKS_PORT
Functionality for communicating with Tor.
Definition: torcontrol.h:24
static const bool DEFAULT_LISTEN_ONION
Definition: torcontrol.h:27
constexpr int DEFAULT_TOR_CONTROL_PORT
Definition: torcontrol.h:25
consteval auto _(util::TranslatedLiteral str)
Definition: translation.h:79
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:82
static constexpr unsigned MAX_CLUSTER_COUNT_LIMIT
Definition: txgraph.h:18
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
Definition: txindex.cpp:33
static constexpr bool DEFAULT_TXINDEX
Definition: txindex.h:19
std::unique_ptr< TxoSpenderIndex > g_txospenderindex
The global txo spender index. May be null.
static constexpr bool DEFAULT_TXOSPENDERINDEX
bool CheckStandardAsmap(const std::span< const std::byte > data)
Provides a safe interface for validating ASMap data before use.
Definition: asmap.cpp:308
std::vector< std::byte > DecodeAsmap(fs::path path)
Loads an ASMap file from disk and validates it.
Definition: asmap.cpp:320
uint256 AsmapVersion(const std::span< const std::byte > data)
Computes SHA256 hash of ASMap data for versioning and consistency checks.
Definition: asmap.cpp:346
bool SplitHostPort(std::string_view in, uint16_t &portOut, std::string &hostOut)
Splits socket address string into host string and port value.
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].
std::string ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:52
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
Definition: validation.cpp:101
assert(!tx.IsCoinBase())
static constexpr int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
Definition: validation.h:90
static constexpr int DEFAULT_CHECKLEVEL
Definition: validation.h:78
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Definition: validation.h:87
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:76
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:93
static const signed int DEFAULT_CHECKBLOCKS
Definition: validation.h:77
const WalletInitInterface & g_wallet_init_interface
Definition: init.cpp:115
std::unique_ptr< CZMQNotificationInterface > g_zmq_notification_interface
void RegisterZMQRPCCommands(CRPCTable &t)
Definition: zmqrpc.cpp:68