Bitcoin Core 29.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 <kernel/checks.h>
11
12#include <addrman.h>
13#include <banman.h>
14#include <blockfilter.h>
15#include <chain.h>
16#include <chainparams.h>
17#include <chainparamsbase.h>
18#include <clientversion.h>
19#include <common/args.h>
20#include <common/system.h>
21#include <consensus/amount.h>
22#include <consensus/consensus.h>
23#include <deploymentstatus.h>
24#include <hash.h>
25#include <httprpc.h>
26#include <httpserver.h>
29#include <index/txindex.h>
30#include <init/common.h>
31#include <interfaces/chain.h>
32#include <interfaces/init.h>
33#include <interfaces/ipc.h>
34#include <interfaces/mining.h>
35#include <interfaces/node.h>
36#include <kernel/caches.h>
37#include <kernel/context.h>
38#include <key.h>
39#include <logging.h>
40#include <mapport.h>
41#include <net.h>
42#include <net_permissions.h>
43#include <net_processing.h>
44#include <netbase.h>
45#include <netgroup.h>
47#include <node/blockstorage.h>
48#include <node/caches.h>
49#include <node/chainstate.h>
51#include <node/context.h>
52#include <node/interface_ui.h>
54#include <node/mempool_args.h>
57#include <node/miner.h>
58#include <node/peerman_args.h>
59#include <policy/feerate.h>
60#include <policy/fees.h>
61#include <policy/fees_args.h>
62#include <policy/policy.h>
63#include <policy/settings.h>
64#include <protocol.h>
65#include <rpc/blockchain.h>
66#include <rpc/register.h>
67#include <rpc/server.h>
68#include <rpc/util.h>
69#include <scheduler.h>
70#include <script/sigcache.h>
71#include <sync.h>
72#include <torcontrol.h>
73#include <txdb.h>
74#include <txmempool.h>
75#include <util/asmap.h>
76#include <util/batchpriority.h>
77#include <util/chaintype.h>
78#include <util/check.h>
79#include <util/fs.h>
80#include <util/fs_helpers.h>
81#include <util/moneystr.h>
82#include <util/result.h>
84#include <util/strencodings.h>
85#include <util/string.h>
86#include <util/syserror.h>
87#include <util/thread.h>
88#include <util/threadnames.h>
89#include <util/time.h>
90#include <util/translation.h>
91#include <validation.h>
92#include <validationinterface.h>
93#include <walletinitinterface.h>
94
95#include <algorithm>
96#include <cerrno>
97#include <condition_variable>
98#include <cstdint>
99#include <cstdio>
100#include <fstream>
101#include <functional>
102#include <set>
103#include <string>
104#include <thread>
105#include <vector>
106
107#ifndef WIN32
108#include <signal.h>
109#include <sys/stat.h>
110#endif
111
112#include <boost/signals2/signal.hpp>
113
114#ifdef ENABLE_ZMQ
117#include <zmq/zmqrpc.h>
118#endif
119
123
141using util::Join;
142using util::ReplaceAll;
143using util::ToString;
144
145static constexpr bool DEFAULT_PROXYRANDOMIZE{true};
146static constexpr bool DEFAULT_REST_ENABLE{false};
147static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING{true};
148static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false};
149
150#ifdef WIN32
151// Win32 LevelDB doesn't use filedescriptors, and the ones used for
152// accessing block files don't count towards the fd_set size limit
153// anyway.
154#define MIN_LEVELDB_FDS 0
155#else
156#define MIN_LEVELDB_FDS 150
157#endif
158
160static const char* DEFAULT_ASMAP_FILENAME="ip_asn.map";
161
165static const char* BITCOIN_PID_FILENAME = "bitcoind.pid";
170static bool g_generated_pid{false};
171
172static fs::path GetPidFile(const ArgsManager& args)
173{
175}
176
177[[nodiscard]] static bool CreatePidFile(const ArgsManager& args)
178{
179 if (args.IsArgNegated("-pid")) return true;
180
181 std::ofstream file{GetPidFile(args)};
182 if (file) {
183#ifdef WIN32
184 tfm::format(file, "%d\n", GetCurrentProcessId());
185#else
186 tfm::format(file, "%d\n", getpid());
187#endif
188 g_generated_pid = true;
189 return true;
190 } else {
191 return InitError(strprintf(_("Unable to create the PID file '%s': %s"), fs::PathToString(GetPidFile(args)), SysErrorString(errno)));
192 }
193}
194
195static void RemovePidFile(const ArgsManager& args)
196{
197 if (!g_generated_pid) return;
198 const auto pid_path{GetPidFile(args)};
199 if (std::error_code error; !fs::remove(pid_path, error)) {
200 std::string msg{error ? error.message() : "File does not exist"};
201 LogPrintf("Unable to remove PID file (%s): %s\n", fs::PathToString(pid_path), msg);
202 }
203}
204
205static std::optional<util::SignalInterrupt> g_shutdown;
206
208{
210 g_shutdown.emplace();
211
212 node.args = &gArgs;
213 node.shutdown_signal = &*g_shutdown;
214 node.shutdown_request = [&node] {
215 assert(node.shutdown_signal);
216 if (!(*node.shutdown_signal)()) return false;
217 // Wake any threads that may be waiting for the tip to change.
218 if (node.notifications) WITH_LOCK(node.notifications->m_tip_block_mutex, node.notifications->m_tip_block_cv.notify_all());
219 return true;
220 };
221}
222
224//
225// Shutdown
226//
227
228//
229// Thread management and startup/shutdown:
230//
231// The network-processing threads are all part of a thread group
232// created by AppInit() or the Qt main() function.
233//
234// A clean exit happens when the SignalInterrupt object is triggered, which
235// makes the main thread's SignalInterrupt::wait() call return, and join all
236// other ongoing threads in the thread group to the main thread.
237// Shutdown() is then called to clean up database connections, and stop other
238// threads that should only be stopped after the main network-processing
239// threads have exited.
240//
241// Shutdown for Qt is very similar, only it uses a QTimer to detect
242// ShutdownRequested() getting set, and then does the normal Qt
243// shutdown thing.
244//
245
247{
248 return bool{*Assert(node.shutdown_signal)};
249}
250
251#if HAVE_SYSTEM
252static void ShutdownNotify(const ArgsManager& args)
253{
254 std::vector<std::thread> threads;
255 for (const auto& cmd : args.GetArgs("-shutdownnotify")) {
256 threads.emplace_back(runCommand, cmd);
257 }
258 for (auto& t : threads) {
259 t.join();
260 }
261}
262#endif
263
265{
266#if HAVE_SYSTEM
267 ShutdownNotify(*node.args);
268#endif
271 InterruptRPC();
275 if (node.connman)
276 node.connman->Interrupt();
277 for (auto* index : node.indexes) {
278 index->Interrupt();
279 }
280}
281
283{
284 static Mutex g_shutdown_mutex;
285 TRY_LOCK(g_shutdown_mutex, lock_shutdown);
286 if (!lock_shutdown) return;
287 LogPrintf("%s: In progress...\n", __func__);
288 Assert(node.args);
289
294 util::ThreadRename("shutoff");
295 if (node.mempool) node.mempool->AddTransactionsUpdated(1);
296
297 StopHTTPRPC();
298 StopREST();
299 StopRPC();
301 StopMapPort();
302
303 // Because these depend on each-other, we make sure that neither can be
304 // using the other before destroying them.
305 if (node.peerman && node.validation_signals) node.validation_signals->UnregisterValidationInterface(node.peerman.get());
306 if (node.connman) node.connman->Stop();
307
309
310 if (node.background_init_thread.joinable()) node.background_init_thread.join();
311 // After everything has been shut down, but before things get flushed, stop the
312 // the scheduler. After this point, SyncWithValidationInterfaceQueue() should not be called anymore
313 // as this would prevent the shutdown from completing.
314 if (node.scheduler) node.scheduler->stop();
315
316 // After the threads that potentially access these pointers have been stopped,
317 // destruct and reset all to nullptr.
318 node.peerman.reset();
319 node.connman.reset();
320 node.banman.reset();
321 node.addrman.reset();
322 node.netgroupman.reset();
323
324 if (node.mempool && node.mempool->GetLoadTried() && ShouldPersistMempool(*node.args)) {
325 DumpMempool(*node.mempool, MempoolPath(*node.args));
326 }
327
328 // Drop transactions we were still watching, record fee estimations and unregister
329 // fee estimator from validation interface.
330 if (node.fee_estimator) {
331 node.fee_estimator->Flush();
332 if (node.validation_signals) {
333 node.validation_signals->UnregisterValidationInterface(node.fee_estimator.get());
334 }
335 }
336
337 // FlushStateToDisk generates a ChainStateFlushed callback, which we should avoid missing
338 if (node.chainman) {
339 LOCK(cs_main);
340 for (Chainstate* chainstate : node.chainman->GetAll()) {
341 if (chainstate->CanFlushToDisk()) {
342 chainstate->ForceFlushStateToDisk();
343 }
344 }
345 }
346
347 // After there are no more peers/RPC left to give us new data which may generate
348 // CValidationInterface callbacks, flush them...
349 if (node.validation_signals) node.validation_signals->FlushBackgroundCallbacks();
350
351 // Stop and delete all indexes only after flushing background callbacks.
352 for (auto* index : node.indexes) index->Stop();
353 if (g_txindex) g_txindex.reset();
356 node.indexes.clear(); // all instances are nullptr now
357
358 // Any future callbacks will be dropped. This should absolutely be safe - if
359 // missing a callback results in an unrecoverable situation, unclean shutdown
360 // would too. The only reason to do the above flushes is to let the wallet catch
361 // up with our current chain to avoid any strange pruning edge cases and make
362 // next startup faster by avoiding rescan.
363
364 if (node.chainman) {
365 LOCK(cs_main);
366 for (Chainstate* chainstate : node.chainman->GetAll()) {
367 if (chainstate->CanFlushToDisk()) {
368 chainstate->ForceFlushStateToDisk();
369 chainstate->ResetCoinsViews();
370 }
371 }
372 }
373 for (const auto& client : node.chain_clients) {
374 client->stop();
375 }
376
377#ifdef ENABLE_ZMQ
379 if (node.validation_signals) node.validation_signals->UnregisterValidationInterface(g_zmq_notification_interface.get());
381 }
382#endif
383
384 node.chain_clients.clear();
385 if (node.validation_signals) {
386 node.validation_signals->UnregisterAllValidationInterfaces();
387 }
388 node.mempool.reset();
389 node.fee_estimator.reset();
390 node.chainman.reset();
391 node.validation_signals.reset();
392 node.scheduler.reset();
393 node.ecc_context.reset();
394 node.kernel.reset();
395
396 RemovePidFile(*node.args);
397
398 LogPrintf("%s: done\n", __func__);
399}
400
406#ifndef WIN32
407static void HandleSIGTERM(int)
408{
409 // Return value is intentionally ignored because there is not a better way
410 // of handling this failure in a signal handler.
411 (void)(*Assert(g_shutdown))();
412}
413
414static void HandleSIGHUP(int)
415{
416 LogInstance().m_reopen_file = true;
417}
418#else
419static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
420{
421 if (!(*Assert(g_shutdown))()) {
422 LogError("Failed to send shutdown signal on Ctrl-C\n");
423 return false;
424 }
425 Sleep(INFINITE);
426 return true;
427}
428#endif
429
430#ifndef WIN32
431static void registerSignalHandler(int signal, void(*handler)(int))
432{
433 struct sigaction sa;
434 sa.sa_handler = handler;
435 sigemptyset(&sa.sa_mask);
436 sa.sa_flags = 0;
437 sigaction(signal, &sa, nullptr);
438}
439#endif
440
441void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
442{
443 SetupHelpOptions(argsman);
444 argsman.AddArg("-help-debug", "Print help message with debugging options and exit", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST); // server-only for now
445
446 init::AddLoggingArgs(argsman);
447
448 const auto defaultBaseParams = CreateBaseChainParams(ChainType::MAIN);
449 const auto testnetBaseParams = CreateBaseChainParams(ChainType::TESTNET);
450 const auto testnet4BaseParams = CreateBaseChainParams(ChainType::TESTNET4);
451 const auto signetBaseParams = CreateBaseChainParams(ChainType::SIGNET);
452 const auto regtestBaseParams = CreateBaseChainParams(ChainType::REGTEST);
453 const auto defaultChainParams = CreateChainParams(argsman, ChainType::MAIN);
454 const auto testnetChainParams = CreateChainParams(argsman, ChainType::TESTNET);
455 const auto testnet4ChainParams = CreateChainParams(argsman, ChainType::TESTNET4);
456 const auto signetChainParams = CreateChainParams(argsman, ChainType::SIGNET);
457 const auto regtestChainParams = CreateChainParams(argsman, ChainType::REGTEST);
458
459 // Hidden Options
460 std::vector<std::string> hidden_args = {
461 "-dbcrashratio", "-forcecompactdb",
462 // GUI args. These will be overwritten by SetupUIArgs for the GUI
463 "-choosedatadir", "-lang=<lang>", "-min", "-resetguisettings", "-splash", "-uiplatform"};
464
465 argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
466#if HAVE_SYSTEM
467 argsman.AddArg("-alertnotify=<cmd>", "Execute command when an alert is raised (%s in cmd is replaced by message)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
468#endif
469 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);
470 argsman.AddArg("-blocksdir=<dir>", "Specify directory to hold blocks subdirectory for *.dat files (default: <datadir>)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
471 argsman.AddArg("-blocksxor",
472 strprintf("Whether an XOR-key applies to blocksdir *.dat files. "
473 "The created XOR-key will be zeros for an existing blocksdir or when `-blocksxor=0` is "
474 "set, and random for a freshly initialized blocksdir. "
475 "(default: %u)",
478 argsman.AddArg("-fastprune", "Use smaller block files and lower minimum prune height for testing purposes", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
479#if HAVE_SYSTEM
480 argsman.AddArg("-blocknotify=<cmd>", "Execute command when the best block changes (%s in cmd is replaced by block hash)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
481#endif
482 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);
483 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);
484 argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
485 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);
486 argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
487 argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", nDefaultDbBatchSize), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
488 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, DEFAULT_DB_CACHE >> 20), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
489 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);
490 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);
491 argsman.AddArg("-loadblock=<file>", "Imports blocks from external file on startup", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
492 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);
493 argsman.AddArg("-maxorphantx=<n>", strprintf("Keep at most <n> unconnectable transactions in memory (default: %u)", DEFAULT_MAX_ORPHAN_TRANSACTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
494 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);
495 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);
496 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)",
498 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);
499 argsman.AddArg("-persistmempoolv1",
500 strprintf("Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format "
501 "(version 1) or the current format (version 2). This temporary option will be removed in the future. (default: %u)",
504 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);
505 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. "
506 "Warning: Reverting this setting requires re-downloading the entire blockchain. "
507 "(default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, >=%u = automatically prune block files to stay under the specified target size in MiB)", MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
508 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);
509 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);
510 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);
511#if HAVE_SYSTEM
512 argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
513 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);
514#endif
515 argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
516 argsman.AddArg("-blockfilterindex=<type>",
517 strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
518 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
520
521 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);
522 argsman.AddArg("-asmap=<file>", strprintf("Specify asn mapping used for bucketing of the peers (default: %s). Relative paths will be prefixed by the net-specific datadir location.", DEFAULT_ASMAP_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
523 argsman.AddArg("-bantime=<n>", strprintf("Default duration (in seconds) of manually configured bans (default: %u)", DEFAULT_MISBEHAVING_BANTIME), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
524 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);
525 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);
526 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);
527 argsman.AddArg("-discover", "Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
528 argsman.AddArg("-dns", strprintf("Allow DNS lookups for -addnode, -seednode and -connect (default: %u)", DEFAULT_NAME_LOOKUP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
529 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);
530 argsman.AddArg("-externalip=<ip>", "Specify your own public address", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
531 argsman.AddArg("-fixedseeds", strprintf("Allow fixed seeds if DNS seeds don't provide peers (default: %u)", DEFAULT_FIXEDSEEDS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
532 argsman.AddArg("-forcednsseed", strprintf("Always query for peer addresses via DNS lookup (default: %u)", DEFAULT_FORCEDNSSEED), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
533 argsman.AddArg("-listen", strprintf("Accept connections from outside (default: %u if no -proxy, -connect or -maxconnections=0)", DEFAULT_LISTEN), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
534 argsman.AddArg("-listenonion", strprintf("Automatically create Tor onion service (default: %d)", DEFAULT_LISTEN_ONION), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
535 argsman.AddArg("-maxconnections=<n>", strprintf("Maintain at most <n> automatic connections to peers (default: %u). This limit does not apply to connections manually added via -addnode or the addnode RPC, which have a separate limit of %u.", DEFAULT_MAX_PEER_CONNECTIONS, MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
536 argsman.AddArg("-maxreceivebuffer=<n>", strprintf("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)", DEFAULT_MAXRECEIVEBUFFER), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
537 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);
538 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);
539#ifdef HAVE_SOCKADDR_UN
540 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);
541#else
542 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);
543#endif
544 argsman.AddArg("-i2psam=<ip:port>", "I2P SAM proxy to reach I2P peers and accept I2P connections (default: none)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
545 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);
546 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);
547 argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
548 argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
549 argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
550 argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
551 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);
552#ifdef HAVE_SOCKADDR_UN
553 argsman.AddArg("-proxy=<ip:port|path>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled). May be a local file path prefixed with 'unix:' if the proxy supports it.", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION, OptionsCategory::CONNECTION);
554#else
555 argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy, set -noproxy to disable (default: disabled)", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_ELISION, OptionsCategory::CONNECTION);
556#endif
557 argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
558 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);
559 argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
560 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);
561 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);
562 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);
563 argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION);
564 argsman.AddArg("-natpmp", strprintf("Use PCP or NAT-PMP to map the listening port (default: %u)", DEFAULT_NATPMP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
565 argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. "
566 "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". "
567 "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
568
569 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 "
570 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
571 "-whitebind. "
572 "Additional flags \"in\" and \"out\" control whether permissions apply to incoming connections and/or manual (default: incoming only). "
573 "Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
574
576
577#ifdef ENABLE_ZMQ
578 argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
579 argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
580 argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
581 argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
582 argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
583 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);
584 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);
585 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);
586 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);
587 argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
588#else
589 hidden_args.emplace_back("-zmqpubhashblock=<address>");
590 hidden_args.emplace_back("-zmqpubhashtx=<address>");
591 hidden_args.emplace_back("-zmqpubrawblock=<address>");
592 hidden_args.emplace_back("-zmqpubrawtx=<address>");
593 hidden_args.emplace_back("-zmqpubsequence=<n>");
594 hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
595 hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
596 hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
597 hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
598 hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
599#endif
600
601 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);
602 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);
603 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);
604 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);
605 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);
606 // Checkpoints were removed. We keep `-checkpoints` as a hidden arg to display a more user friendly error when set.
607 argsman.AddArg("-checkpoints", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
608 argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
609 argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
610 argsman.AddArg("-stopatheight", strprintf("Stop running after reaching the given height in the main chain (default: %u)", DEFAULT_STOPATHEIGHT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
611 argsman.AddArg("-limitancestorcount=<n>", strprintf("Do not accept transactions if number of in-mempool ancestors is <n> or more (default: %u)", DEFAULT_ANCESTOR_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
612 argsman.AddArg("-limitancestorsize=<n>", strprintf("Do not accept transactions whose size with all in-mempool ancestors exceeds <n> kilobytes (default: %u)", DEFAULT_ANCESTOR_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
613 argsman.AddArg("-limitdescendantcount=<n>", strprintf("Do not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u)", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
614 argsman.AddArg("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
615 argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
616 argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
617 argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
618 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);
619 argsman.AddArg("-maxtipage=<n>",
620 strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)",
621 Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
623 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);
624 argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
625
627
628 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);
629 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);
630 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);
631 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);
632 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);
633 argsman.AddArg("-datacarrier", strprintf("Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
634 argsman.AddArg("-datacarriersize",
635 strprintf("Relay and mine transactions whose data-carrying raw scriptPubKey "
636 "is of this size or less (default: %u)",
639 argsman.AddArg("-permitbaremultisig", strprintf("Relay transactions creating non-P2SH multisig outputs (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
641 argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
643 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);
644 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);
645
646
647 argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
648 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. (default: %d).", DEFAULT_BLOCK_RESERVED_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
649 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);
650 argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
651
652 argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
653 argsman.AddArg("-rpcallowip=<ip>", "Allow JSON-RPC connections from specified source. Valid values for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0), a network/CIDR (e.g. 1.2.3.4/24), all ipv4 (0.0.0.0/0), or all ipv6 (::/0). This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
654 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);
655 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);
656 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);
657 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);
658 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);
659 argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
660 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);
661 argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
662 argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
663 argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
664 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);
665 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);
666 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);
667 argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
668 if (can_listen_ipc) {
669 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.", ArgsManager::ALLOW_ANY, OptionsCategory::IPC);
670 }
671
672#if HAVE_DECL_FORK
673 argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
674 argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
675#else
676 hidden_args.emplace_back("-daemon");
677 hidden_args.emplace_back("-daemonwait");
678#endif
679
680 // Add the hidden options
681 argsman.AddHiddenArgs(hidden_args);
682}
683
684#if HAVE_SYSTEM
685static void StartupNotify(const ArgsManager& args)
686{
687 std::string cmd = args.GetArg("-startupnotify", "");
688 if (!cmd.empty()) {
689 std::thread t(runCommand, cmd);
690 t.detach(); // thread runs free
691 }
692}
693#endif
694
696{
697 const ArgsManager& args = *Assert(node.args);
698 if (!InitHTTPServer(*Assert(node.shutdown_signal))) {
699 return false;
700 }
701 StartRPC();
702 node.rpc_interruption_point = RpcInterruptionPoint;
703 if (!StartHTTPRPC(&node))
704 return false;
707 return true;
708}
709
710// Parameter interaction based on rules
712{
713 // when specifying an explicit binding address, you want to listen on it
714 // even when -connect or -proxy is specified
715 if (!args.GetArgs("-bind").empty()) {
716 if (args.SoftSetBoolArg("-listen", true))
717 LogInfo("parameter interaction: -bind set -> setting -listen=1\n");
718 }
719 if (!args.GetArgs("-whitebind").empty()) {
720 if (args.SoftSetBoolArg("-listen", true))
721 LogInfo("parameter interaction: -whitebind set -> setting -listen=1\n");
722 }
723
724 if (!args.GetArgs("-connect").empty() || args.IsArgNegated("-connect") || args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS) <= 0) {
725 // when only connecting to trusted nodes, do not seed via DNS, or listen by default
726 // do the same when connections are disabled
727 if (args.SoftSetBoolArg("-dnsseed", false))
728 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n");
729 if (args.SoftSetBoolArg("-listen", false))
730 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n");
731 }
732
733 std::string proxy_arg = args.GetArg("-proxy", "");
734 if (proxy_arg != "" && proxy_arg != "0") {
735 // to protect privacy, do not listen by default if a default proxy server is specified
736 if (args.SoftSetBoolArg("-listen", false))
737 LogInfo("parameter interaction: -proxy set -> setting -listen=0\n");
738 // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1
739 // to listen locally, so don't rely on this happening through -listen below.
740 if (args.SoftSetBoolArg("-natpmp", false)) {
741 LogInfo("parameter interaction: -proxy set -> setting -natpmp=0\n");
742 }
743 // to protect privacy, do not discover addresses by default
744 if (args.SoftSetBoolArg("-discover", false))
745 LogInfo("parameter interaction: -proxy set -> setting -discover=0\n");
746 }
747
748 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
749 // do not map ports or try to retrieve public IP when not listening (pointless)
750 if (args.SoftSetBoolArg("-natpmp", false)) {
751 LogInfo("parameter interaction: -listen=0 -> setting -natpmp=0\n");
752 }
753 if (args.SoftSetBoolArg("-discover", false))
754 LogInfo("parameter interaction: -listen=0 -> setting -discover=0\n");
755 if (args.SoftSetBoolArg("-listenonion", false))
756 LogInfo("parameter interaction: -listen=0 -> setting -listenonion=0\n");
757 if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
758 LogInfo("parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n");
759 }
760 }
761
762 if (!args.GetArgs("-externalip").empty()) {
763 // if an explicit public IP is specified, do not try to find others
764 if (args.SoftSetBoolArg("-discover", false))
765 LogInfo("parameter interaction: -externalip set -> setting -discover=0\n");
766 }
767
768 if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
769 // disable whitelistrelay in blocksonly mode
770 if (args.SoftSetBoolArg("-whitelistrelay", false))
771 LogInfo("parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n");
772 // Reduce default mempool size in blocksonly mode to avoid unexpected resource usage
774 LogInfo("parameter interaction: -blocksonly=1 -> setting -maxmempool=%d\n", DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB);
775 }
776
777 // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.
778 if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
779 if (args.SoftSetBoolArg("-whitelistrelay", true))
780 LogInfo("parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n");
781 }
782 const auto onlynets = args.GetArgs("-onlynet");
783 if (!onlynets.empty()) {
784 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](const auto& net) {
785 const auto n = ParseNetwork(net);
786 return n == NET_IPV4 || n == NET_IPV6;
787 });
788 if (!clearnet_reachable && args.SoftSetBoolArg("-dnsseed", false)) {
789 LogInfo("parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n");
790 }
791 }
792}
793
801{
804}
805
806namespace { // Variables internal to initialization process only
807
808int nMaxConnections;
809int available_fds;
811int64_t peer_connect_timeout;
812std::set<BlockFilterType> g_enabled_filter_types;
813
814} // namespace
815
816[[noreturn]] static void new_handler_terminate()
817{
818 // Rather than throwing std::bad-alloc if allocation fails, terminate
819 // immediately to (try to) avoid chain corruption.
820 // Since logging may itself allocate memory, set the handler directly
821 // to terminate first.
822 std::set_new_handler(std::terminate);
823 LogError("Out of memory. Terminating.\n");
824
825 // The log was successful, terminate now.
826 std::terminate();
827};
828
829bool AppInitBasicSetup(const ArgsManager& args, std::atomic<int>& exit_status)
830{
831 // ********************************************************* Step 1: setup
832#ifdef _MSC_VER
833 // Turn off Microsoft heap dump noise
834 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
835 _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0));
836 // Disable confusing "helpful" text message on abort, Ctrl-C
837 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
838#endif
839#ifdef WIN32
840 // Enable heap terminate-on-corruption
841 HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0);
842#endif
843 if (!SetupNetworking()) {
844 return InitError(Untranslated("Initializing networking failed."));
845 }
846
847#ifndef WIN32
848 // Clean shutdown on SIGTERM
851
852 // Reopen debug.log on SIGHUP
854
855 // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly
856 signal(SIGPIPE, SIG_IGN);
857#else
858 SetConsoleCtrlHandler(consoleCtrlHandler, true);
859#endif
860
861 std::set_new_handler(new_handler_terminate);
862
863 return true;
864}
865
867{
868 const CChainParams& chainparams = Params();
869 // ********************************************************* Step 2: parameter interactions
870
871 // also see: InitParameterInteraction()
872
873 // We removed checkpoints but keep the option to warn users who still have it in their config.
874 if (args.IsArgSet("-checkpoints")) {
875 InitWarning(_("Option '-checkpoints' is set but checkpoints were removed. This option has no effect."));
876 }
877
878 // Error if network-specific options (-addnode, -connect, etc) are
879 // specified in default section of config file, but not overridden
880 // on the command line or in this chain's section of the config file.
881 ChainType chain = args.GetChainType();
882 if (chain == ChainType::SIGNET) {
883 LogPrintf("Signet derived magic (message start): %s\n", HexStr(chainparams.MessageStart()));
884 }
885 bilingual_str errors;
886 for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
887 errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section."), arg, ChainTypeToString(chain), ChainTypeToString(chain)) + Untranslated("\n");
888 }
889
890 if (!errors.empty()) {
891 return InitError(errors);
892 }
893
894 // Testnet3 deprecation warning
895 if (chain == ChainType::TESTNET) {
896 LogInfo("Warning: Support for testnet3 is deprecated and will be removed in an upcoming release. Consider switching to testnet4.\n");
897 }
898
899 // Warn if unrecognized section name are present in the config file.
900 bilingual_str warnings;
901 for (const auto& section : args.GetUnrecognizedSections()) {
902 warnings += Untranslated(strprintf("%s:%i ", section.m_file, section.m_line)) + strprintf(_("Section [%s] is not recognized."), section.m_name) + Untranslated("\n");
903 }
904
905 if (!warnings.empty()) {
906 InitWarning(warnings);
907 }
908
909 if (!fs::is_directory(args.GetBlocksDirPath())) {
910 return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
911 }
912
913 // parse and validate enabled filter types
914 std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
915 if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
916 g_enabled_filter_types = AllBlockFilterTypes();
917 } else if (blockfilterindex_value != "0") {
918 const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
919 for (const auto& name : names) {
920 BlockFilterType filter_type;
921 if (!BlockFilterTypeByName(name, filter_type)) {
922 return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
923 }
924 g_enabled_filter_types.insert(filter_type);
925 }
926 }
927
928 // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.
929 if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {
930 g_local_services = ServiceFlags(g_local_services | NODE_P2P_V2);
931 }
932
933 // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
934 if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
935 if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
936 return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
937 }
938
939 g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
940 }
941
942 if (args.GetIntArg("-prune", 0)) {
943 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
944 return InitError(_("Prune mode is incompatible with -txindex."));
945 if (args.GetBoolArg("-reindex-chainstate", false)) {
946 return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
947 }
948 }
949
950 // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
951 if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
952 return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
953 }
954
955 // -bind and -whitebind can't be set when not listening
956 size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
957 if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
958 return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0"));
959 }
960
961 // if listen=0, then disallow listenonion=1
962 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
963 return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1"));
964 }
965
966 // Make sure enough file descriptors are available. We need to reserve enough FDs to account for the bare minimum,
967 // plus all manual connections and all bound interfaces. Any remainder will be available for connection sockets
968
969 // Number of bound interfaces (we have at least one)
970 int nBind = std::max(nUserBind, size_t(1));
971 // Maximum number of connections with other nodes, this accounts for all types of outbounds and inbounds except for manual
972 int user_max_connection = args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
973 if (user_max_connection < 0) {
974 return InitError(Untranslated("-maxconnections must be greater or equal than zero"));
975 }
976 // Reserve enough FDs to account for the bare minimum, plus any manual connections, plus the bound interfaces
977 int min_required_fds = MIN_CORE_FDS + MAX_ADDNODE_CONNECTIONS + nBind;
978
979 // Try raising the FD limit to what we need (available_fds may be smaller than the requested amount if this fails)
980 available_fds = RaiseFileDescriptorLimit(user_max_connection + min_required_fds);
981 // If we are using select instead of poll, our actual limit may be even smaller
982#ifndef USE_POLL
983 available_fds = std::min(FD_SETSIZE, available_fds);
984#endif
985 if (available_fds < min_required_fds)
986 return InitError(strprintf(_("Not enough file descriptors available. %d available, %d required."), available_fds, min_required_fds));
987
988 // Trim requested connection counts, to fit into system limitations
989 nMaxConnections = std::min(available_fds - min_required_fds, user_max_connection);
990
991 if (nMaxConnections < user_max_connection)
992 InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), user_max_connection, nMaxConnections));
993
994 // ********************************************************* Step 3: parameter-to-internal-flags
995 if (auto result{init::SetLoggingCategories(args)}; !result) return InitError(util::ErrorString(result));
996 if (auto result{init::SetLoggingLevel(args)}; !result) return InitError(util::ErrorString(result));
997
999 if (nConnectTimeout <= 0) {
1001 }
1002
1003 peer_connect_timeout = args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
1004 if (peer_connect_timeout <= 0) {
1005 return InitError(Untranslated("peertimeout must be a positive integer."));
1006 }
1007
1008 if (const auto arg{args.GetArg("-blockmintxfee")}) {
1009 if (!ParseMoney(*arg)) {
1010 return InitError(AmountErrMsg("blockmintxfee", *arg));
1011 }
1012 }
1013
1014 {
1015 const auto max_block_weight = args.GetIntArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT);
1016 if (max_block_weight > MAX_BLOCK_WEIGHT) {
1017 return InitError(strprintf(_("Specified -blockmaxweight (%d) exceeds consensus maximum block weight (%d)"), max_block_weight, MAX_BLOCK_WEIGHT));
1018 }
1019 }
1020
1021 {
1022 const auto block_reserved_weight = args.GetIntArg("-blockreservedweight", DEFAULT_BLOCK_RESERVED_WEIGHT);
1023 if (block_reserved_weight > MAX_BLOCK_WEIGHT) {
1024 return InitError(strprintf(_("Specified -blockreservedweight (%d) exceeds consensus maximum block weight (%d)"), block_reserved_weight, MAX_BLOCK_WEIGHT));
1025 }
1026 if (block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
1027 return InitError(strprintf(_("Specified -blockreservedweight (%d) is lower than minimum safety value of (%d)"), block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT));
1028 }
1029 }
1030
1031 nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);
1032
1033 if (!g_wallet_init_interface.ParameterInteraction()) return false;
1034
1035 // Option to startup with mocktime set (used for regression testing):
1036 SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
1037
1038 if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
1039 g_local_services = ServiceFlags(g_local_services | NODE_BLOOM);
1040
1041 const std::vector<std::string> test_options = args.GetArgs("-test");
1042 if (!test_options.empty()) {
1043 if (chainparams.GetChainType() != ChainType::REGTEST) {
1044 return InitError(Untranslated("-test=<option> can only be used with regtest"));
1045 }
1046 for (const std::string& option : test_options) {
1047 auto it = std::find_if(TEST_OPTIONS_DOC.begin(), TEST_OPTIONS_DOC.end(), [&option](const std::string& doc_option) {
1048 size_t pos = doc_option.find(" (");
1049 return (pos != std::string::npos) && (doc_option.substr(0, pos) == option);
1050 });
1051 if (it == TEST_OPTIONS_DOC.end()) {
1052 InitWarning(strprintf(_("Unrecognised option \"%s\" provided in -test=<option>."), option));
1053 }
1054 }
1055 }
1056
1057 // Also report errors from parsing before daemonization
1058 {
1059 kernel::Notifications notifications{};
1060 ChainstateManager::Options chainman_opts_dummy{
1061 .chainparams = chainparams,
1062 .datadir = args.GetDataDirNet(),
1063 .notifications = notifications,
1064 };
1065 auto chainman_result{ApplyArgsManOptions(args, chainman_opts_dummy)};
1066 if (!chainman_result) {
1067 return InitError(util::ErrorString(chainman_result));
1068 }
1069 BlockManager::Options blockman_opts_dummy{
1070 .chainparams = chainman_opts_dummy.chainparams,
1071 .blocks_dir = args.GetBlocksDirPath(),
1072 .notifications = chainman_opts_dummy.notifications,
1073 .block_tree_db_params = DBParams{
1074 .path = args.GetDataDirNet() / "blocks" / "index",
1075 .cache_bytes = 0,
1076 },
1077 };
1078 auto blockman_result{ApplyArgsManOptions(args, blockman_opts_dummy)};
1079 if (!blockman_result) {
1080 return InitError(util::ErrorString(blockman_result));
1081 }
1082 CTxMemPool::Options mempool_opts{};
1083 auto mempool_result{ApplyArgsManOptions(args, chainparams, mempool_opts)};
1084 if (!mempool_result) {
1085 return InitError(util::ErrorString(mempool_result));
1086 }
1087 }
1088
1089 return true;
1090}
1091
1092static bool LockDirectory(const fs::path& dir, bool probeOnly)
1093{
1094 // Make sure only a single process is using the directory.
1095 switch (util::LockDirectory(dir, ".lock", probeOnly)) {
1097 return InitError(strprintf(_("Cannot write to directory '%s'; check permissions."), fs::PathToString(dir)));
1099 return InitError(strprintf(_("Cannot obtain a lock on directory %s. %s is probably already running."), fs::PathToString(dir), CLIENT_NAME));
1100 case util::LockResult::Success: return true;
1101 } // no default case, so the compiler can warn about missing cases
1102 assert(false);
1103}
1104static bool LockDirectories(bool probeOnly)
1105{
1106 return LockDirectory(gArgs.GetDataDirNet(), probeOnly) && \
1107 LockDirectory(gArgs.GetBlocksDirPath(), probeOnly);
1108}
1109
1111{
1112 // ********************************************************* Step 4: sanity checks
1113 auto result{kernel::SanityChecks(kernel)};
1114 if (!result) {
1116 return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), CLIENT_NAME));
1117 }
1118
1119 if (!ECC_InitSanityCheck()) {
1120 return InitError(strprintf(_("Elliptic curve cryptography sanity check failure. %s is shutting down."), CLIENT_NAME));
1121 }
1122
1123 // Probe the directory locks to give an early error message, if possible
1124 // We cannot hold the directory locks here, as the forking for daemon() hasn't yet happened,
1125 // and a fork will cause weird behavior to them.
1126 return LockDirectories(true);
1127}
1128
1130{
1131 // After daemonization get the directory locks again and hold on to them until exit
1132 // This creates a slight window for a race condition to happen, however this condition is harmless: it
1133 // will at most make us exit without printing a message to console.
1134 if (!LockDirectories(false)) {
1135 // Detailed error printed inside LockDirectory
1136 return false;
1137 }
1138 return true;
1139}
1140
1142{
1143 node.chain = node.init->makeChain();
1144 node.mining = node.init->makeMining();
1145 return true;
1146}
1147
1149 for (const std::string port_option : {
1150 "-port",
1151 "-rpcport",
1152 }) {
1153 if (const auto port{args.GetArg(port_option)}) {
1154 const auto n{ToIntegral<uint16_t>(*port)};
1155 if (!n || *n == 0) {
1156 return InitError(InvalidPortErrMsg(port_option, *port));
1157 }
1158 }
1159 }
1160
1161 for ([[maybe_unused]] const auto& [arg, unix] : std::vector<std::pair<std::string, bool>>{
1162 // arg name UNIX socket support
1163 {"-i2psam", false},
1164 {"-onion", true},
1165 {"-proxy", true},
1166 {"-rpcbind", false},
1167 {"-torcontrol", false},
1168 {"-whitebind", false},
1169 {"-zmqpubhashblock", true},
1170 {"-zmqpubhashtx", true},
1171 {"-zmqpubrawblock", true},
1172 {"-zmqpubrawtx", true},
1173 {"-zmqpubsequence", true},
1174 }) {
1175 for (const std::string& socket_addr : args.GetArgs(arg)) {
1176 std::string host_out;
1177 uint16_t port_out{0};
1178 if (!SplitHostPort(socket_addr, port_out, host_out)) {
1179#ifdef HAVE_SOCKADDR_UN
1180 // Allow unix domain sockets for some options e.g. unix:/some/file/path
1181 if (!unix || !socket_addr.starts_with(ADDR_PREFIX_UNIX)) {
1182 return InitError(InvalidPortErrMsg(arg, socket_addr));
1183 }
1184#else
1185 return InitError(InvalidPortErrMsg(arg, socket_addr));
1186#endif
1187 }
1188 }
1189 }
1190
1191 return true;
1192}
1193
1194// A GUI user may opt to retry once with do_reindex set if there is a failure during chainstate initialization.
1195// The function therefore has to support re-entry.
1198 bool do_reindex,
1199 const bool do_reindex_chainstate,
1200 const kernel::CacheSizes& cache_sizes,
1201 const ArgsManager& args)
1202{
1203 const CChainParams& chainparams = Params();
1204 CTxMemPool::Options mempool_opts{
1205 .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
1206 .signals = node.validation_signals.get(),
1207 };
1208 Assert(ApplyArgsManOptions(args, chainparams, mempool_opts)); // no error can happen, already checked in AppInitParameterInteraction
1209 bilingual_str mempool_error;
1210 node.mempool = std::make_unique<CTxMemPool>(mempool_opts, mempool_error);
1211 if (!mempool_error.empty()) {
1212 return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
1213 }
1214 LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)\n", cache_sizes.coins * (1.0 / 1024 / 1024), mempool_opts.max_size_bytes * (1.0 / 1024 / 1024));
1215 ChainstateManager::Options chainman_opts{
1216 .chainparams = chainparams,
1217 .datadir = args.GetDataDirNet(),
1218 .notifications = *node.notifications,
1219 .signals = node.validation_signals.get(),
1220 };
1221 Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1222
1223 BlockManager::Options blockman_opts{
1224 .chainparams = chainman_opts.chainparams,
1225 .blocks_dir = args.GetBlocksDirPath(),
1226 .notifications = chainman_opts.notifications,
1227 .block_tree_db_params = DBParams{
1228 .path = args.GetDataDirNet() / "blocks" / "index",
1229 .cache_bytes = cache_sizes.block_tree_db,
1230 .wipe_data = do_reindex,
1231 },
1232 };
1233 Assert(ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1234
1235 // Creating the chainstate manager internally creates a BlockManager, opens
1236 // the blocks tree db, and wipes existing block files in case of a reindex.
1237 // The coinsdb is opened at a later point on LoadChainstate.
1238 try {
1239 node.chainman = std::make_unique<ChainstateManager>(*Assert(node.shutdown_signal), chainman_opts, blockman_opts);
1240 } catch (dbwrapper_error& e) {
1241 LogError("%s", e.what());
1242 return {ChainstateLoadStatus::FAILURE, _("Error opening block database")};
1243 } catch (std::exception& e) {
1244 return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated(strprintf("Failed to initialize ChainstateManager: %s", e.what()))};
1245 }
1246 ChainstateManager& chainman = *node.chainman;
1247 if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
1248
1249 // This is defined and set here instead of inline in validation.h to avoid a hard
1250 // dependency between validation and index/base, since the latter is not in
1251 // libbitcoinkernel.
1252 chainman.snapshot_download_completed = [&node]() {
1253 if (!node.chainman->m_blockman.IsPruneMode()) {
1254 LogPrintf("[snapshot] re-enabling NODE_NETWORK services\n");
1255 node.connman->AddLocalServices(NODE_NETWORK);
1256 }
1257 LogPrintf("[snapshot] restarting indexes\n");
1258 // Drain the validation interface queue to ensure that the old indexes
1259 // don't have any pending work.
1260 Assert(node.validation_signals)->SyncWithValidationInterfaceQueue();
1261 for (auto* index : node.indexes) {
1262 index->Interrupt();
1263 index->Stop();
1264 if (!(index->Init() && index->StartBackgroundSync())) {
1265 LogPrintf("[snapshot] WARNING failed to restart index %s on snapshot chain\n", index->GetName());
1266 }
1267 }
1268 };
1270 options.mempool = Assert(node.mempool.get());
1271 options.wipe_chainstate_db = do_reindex || do_reindex_chainstate;
1272 options.prune = chainman.m_blockman.IsPruneMode();
1273 options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
1274 options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
1275 options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
1276 options.coins_error_cb = [] {
1277 uiInterface.ThreadSafeMessageBox(
1278 _("Error reading from database, shutting down."),
1280 };
1281 uiInterface.InitMessage(_("Loading block index…"));
1282 auto catch_exceptions = [](auto&& f) -> ChainstateLoadResult {
1283 try {
1284 return f();
1285 } catch (const std::exception& e) {
1286 LogError("%s\n", e.what());
1287 return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error loading databases"));
1288 }
1289 };
1290 auto [status, error] = catch_exceptions([&] { return LoadChainstate(chainman, cache_sizes, options); });
1292 uiInterface.InitMessage(_("Verifying blocks…"));
1293 if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) {
1294 LogWarning("pruned datadir may not have more than %d blocks; only checking available blocks\n",
1296 }
1297 std::tie(status, error) = catch_exceptions([&] { return VerifyLoadedChainstate(chainman, options); });
1299 LogInfo("Block index and chainstate loaded");
1300 }
1301 }
1302 return {status, error};
1303};
1304
1306{
1307 const ArgsManager& args = *Assert(node.args);
1308 const CChainParams& chainparams = Params();
1309
1310 auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
1311 if (!opt_max_upload) {
1312 return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
1313 }
1314
1315 // ********************************************************* Step 4a: application initialization
1316 if (!CreatePidFile(args)) {
1317 // Detailed error printed inside CreatePidFile().
1318 return false;
1319 }
1320 if (!init::StartLogging(args)) {
1321 // Detailed error printed inside StartLogging().
1322 return false;
1323 }
1324
1325 LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, available_fds);
1326
1327 // Warn about relative -datadir path.
1328 if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) {
1329 LogPrintf("Warning: relative datadir option '%s' specified, which will be interpreted relative to the "
1330 "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1331 "from a different location, it will be unable to locate the current data files. There could "
1332 "also be data loss if bitcoin is started while in a temporary directory.\n",
1333 args.GetArg("-datadir", ""), fs::PathToString(fs::current_path()));
1334 }
1335
1336 assert(!node.scheduler);
1337 node.scheduler = std::make_unique<CScheduler>();
1338 auto& scheduler = *node.scheduler;
1339
1340 // Start the lightweight task scheduler thread
1341 scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); });
1342
1343 // Gather some entropy once per minute.
1344 scheduler.scheduleEvery([]{
1346 }, std::chrono::minutes{1});
1347
1348 // Check disk space every 5 minutes to avoid db corruption.
1349 scheduler.scheduleEvery([&args, &node]{
1350 constexpr uint64_t min_disk_space = 50 << 20; // 50 MB
1351 if (!CheckDiskSpace(args.GetBlocksDirPath(), min_disk_space)) {
1352 LogError("Shutting down due to lack of disk space!\n");
1353 if (!(Assert(node.shutdown_request))()) {
1354 LogError("Failed to send shutdown signal after disk space check\n");
1355 }
1356 }
1357 }, std::chrono::minutes{5});
1358
1359 assert(!node.validation_signals);
1360 node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler));
1361 auto& validation_signals = *node.validation_signals;
1362
1363 // Create client interfaces for wallets that are supposed to be loaded
1364 // according to -wallet and -disablewallet options. This only constructs
1365 // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1366 // when load() and start() interface methods are called below.
1368 uiInterface.InitWallet();
1369
1370 if (interfaces::Ipc* ipc = node.init->ipc()) {
1371 for (std::string address : gArgs.GetArgs("-ipcbind")) {
1372 try {
1373 ipc->listenAddress(address);
1374 } catch (const std::exception& e) {
1375 return InitError(Untranslated(strprintf("Unable to bind to IPC address '%s'. %s", address, e.what())));
1376 }
1377 LogPrintf("Listening for IPC requests on address %s\n", address);
1378 }
1379 }
1380
1381 /* Register RPC commands regardless of -server setting so they will be
1382 * available in the GUI RPC console even if external calls are disabled.
1383 */
1385 for (const auto& client : node.chain_clients) {
1386 client->registerRpcs();
1387 }
1388#ifdef ENABLE_ZMQ
1390#endif
1391
1392 // Check port numbers
1393 if (!CheckHostPortOptions(args)) return false;
1394
1395 /* Start the RPC server already. It will be started in "warmup" mode
1396 * and not really process calls already (but it will signify connections
1397 * that the server is there and will be ready later). Warmup mode will
1398 * be disabled when initialisation is finished.
1399 */
1400 if (args.GetBoolArg("-server", false)) {
1401 uiInterface.InitMessage_connect(SetRPCWarmupStatus);
1402 if (!AppInitServers(node))
1403 return InitError(_("Unable to start HTTP server. See debug log for details."));
1404 }
1405
1406 // ********************************************************* Step 5: verify wallet database integrity
1407 for (const auto& client : node.chain_clients) {
1408 if (!client->verify()) {
1409 return false;
1410 }
1411 }
1412
1413 // ********************************************************* Step 6: network initialization
1414 // Note that we absolutely cannot open any actual connections
1415 // until the very end ("start node") as the UTXO/block state
1416 // is not yet setup and may end up being set up twice if we
1417 // need to reindex later.
1418
1419 fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1420 fDiscover = args.GetBoolArg("-discover", true);
1421
1422 PeerManager::Options peerman_opts{};
1423 ApplyArgsManOptions(args, peerman_opts);
1424
1425 {
1426
1427 // Read asmap file if configured
1428 std::vector<bool> asmap;
1429 if (args.IsArgSet("-asmap") && !args.IsArgNegated("-asmap")) {
1430 fs::path asmap_path = args.GetPathArg("-asmap", DEFAULT_ASMAP_FILENAME);
1431 if (!asmap_path.is_absolute()) {
1432 asmap_path = args.GetDataDirNet() / asmap_path;
1433 }
1434 if (!fs::exists(asmap_path)) {
1435 InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1436 return false;
1437 }
1438 asmap = DecodeAsmap(asmap_path);
1439 if (asmap.size() == 0) {
1440 InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1441 return false;
1442 }
1443 const uint256 asmap_version = (HashWriter{} << asmap).GetHash();
1444 LogPrintf("Using asmap version %s for IP bucketing\n", asmap_version.ToString());
1445 } else {
1446 LogPrintf("Using /16 prefix for IP bucketing\n");
1447 }
1448
1449 // Initialize netgroup manager
1450 assert(!node.netgroupman);
1451 node.netgroupman = std::make_unique<NetGroupManager>(std::move(asmap));
1452
1453 // Initialize addrman
1454 assert(!node.addrman);
1455 uiInterface.InitMessage(_("Loading P2P addresses…"));
1456 auto addrman{LoadAddrman(*node.netgroupman, args)};
1457 if (!addrman) return InitError(util::ErrorString(addrman));
1458 node.addrman = std::move(*addrman);
1459 }
1460
1462 assert(!node.banman);
1463 node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1464 assert(!node.connman);
1465 node.connman = std::make_unique<CConnman>(rng.rand64(),
1466 rng.rand64(),
1467 *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
1468
1469 assert(!node.fee_estimator);
1470 // Don't initialize fee estimation with old data if we don't relay transactions,
1471 // as they would never get updated.
1472 if (!peerman_opts.ignore_incoming_txs) {
1473 bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
1474 if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
1475 return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
1476 }
1477 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
1478
1479 // Flush estimates to disk periodically
1480 CBlockPolicyEstimator* fee_estimator = node.fee_estimator.get();
1481 scheduler.scheduleEvery([fee_estimator] { fee_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
1482 validation_signals.RegisterValidationInterface(fee_estimator);
1483 }
1484
1485 for (const std::string& socket_addr : args.GetArgs("-bind")) {
1486 std::string host_out;
1487 uint16_t port_out{0};
1488 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('='));
1489 if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
1490 return InitError(InvalidPortErrMsg("-bind", socket_addr));
1491 }
1492 }
1493
1494 // sanitize comments per BIP-0014, format user agent and check total size
1495 std::vector<std::string> uacomments;
1496 for (const std::string& cmt : args.GetArgs("-uacomment")) {
1497 if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1498 return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1499 uacomments.push_back(cmt);
1500 }
1502 if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1503 return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1505 }
1506
1507 const auto onlynets = args.GetArgs("-onlynet");
1508 if (!onlynets.empty()) {
1510 for (const std::string& snet : onlynets) {
1511 enum Network net = ParseNetwork(snet);
1512 if (net == NET_UNROUTABLE)
1513 return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1514 g_reachable_nets.Add(net);
1515 }
1516 }
1517
1518 if (!args.IsArgSet("-cjdnsreachable")) {
1519 if (!onlynets.empty() && g_reachable_nets.Contains(NET_CJDNS)) {
1520 return InitError(
1521 _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1522 "-cjdnsreachable is not provided"));
1523 }
1525 }
1526 // Now g_reachable_nets.Contains(NET_CJDNS) is true if:
1527 // 1. -cjdnsreachable is given and
1528 // 2.1. -onlynet is not given or
1529 // 2.2. -onlynet=cjdns is given
1530
1531 // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit:
1532 // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip
1533 // the DNS seeds by adjusting -dnsseed in InitParameterInteraction.
1535 return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1536 };
1537
1538 // Check for host lookup allowed before parsing any network related parameters
1540
1541 Proxy onion_proxy;
1542
1543 bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1544 // -proxy sets a proxy for all outgoing network traffic
1545 // -noproxy (or -proxy=0) as well as the empty string can be used to not set a proxy, this is the default
1546 std::string proxyArg = args.GetArg("-proxy", "");
1547 if (proxyArg != "" && proxyArg != "0") {
1548 Proxy addrProxy;
1549 if (IsUnixSocketPath(proxyArg)) {
1550 addrProxy = Proxy(proxyArg, /*tor_stream_isolation=*/proxyRandomize);
1551 } else {
1552 const std::optional<CService> proxyAddr{Lookup(proxyArg, 9050, fNameLookup)};
1553 if (!proxyAddr.has_value()) {
1554 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg));
1555 }
1556
1557 addrProxy = Proxy(proxyAddr.value(), /*tor_stream_isolation=*/proxyRandomize);
1558 }
1559
1560 if (!addrProxy.IsValid())
1561 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxyArg));
1562
1563 SetProxy(NET_IPV4, addrProxy);
1564 SetProxy(NET_IPV6, addrProxy);
1565 SetProxy(NET_CJDNS, addrProxy);
1566 SetNameProxy(addrProxy);
1567 onion_proxy = addrProxy;
1568 }
1569
1570 const bool onlynet_used_with_onion{!onlynets.empty() && g_reachable_nets.Contains(NET_ONION)};
1571
1572 // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1573 // -noonion (or -onion=0) disables connecting to .onion entirely
1574 // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1575 std::string onionArg = args.GetArg("-onion", "");
1576 if (onionArg != "") {
1577 if (onionArg == "0") { // Handle -noonion/-onion=0
1578 onion_proxy = Proxy{};
1579 if (onlynet_used_with_onion) {
1580 return InitError(
1581 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1582 "reaching the Tor network is explicitly forbidden: -onion=0"));
1583 }
1584 } else {
1585 if (IsUnixSocketPath(onionArg)) {
1586 onion_proxy = Proxy(onionArg, /*tor_stream_isolation=*/proxyRandomize);
1587 } else {
1588 const std::optional<CService> addr{Lookup(onionArg, 9050, fNameLookup)};
1589 if (!addr.has_value() || !addr->IsValid()) {
1590 return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1591 }
1592
1593 onion_proxy = Proxy(addr.value(), /*tor_stream_isolation=*/proxyRandomize);
1594 }
1595 }
1596 }
1597
1598 if (onion_proxy.IsValid()) {
1599 SetProxy(NET_ONION, onion_proxy);
1600 } else {
1601 // If -listenonion is set, then we will (try to) connect to the Tor control port
1602 // later from the torcontrol thread and may retrieve the onion proxy from there.
1603 const bool listenonion_disabled{!args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
1604 if (onlynet_used_with_onion && listenonion_disabled) {
1605 return InitError(
1606 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1607 "reaching the Tor network is not provided: none of -proxy, -onion or "
1608 "-listenonion is given"));
1609 }
1611 }
1612
1613 for (const std::string& strAddr : args.GetArgs("-externalip")) {
1614 const std::optional<CService> addrLocal{Lookup(strAddr, GetListenPort(), fNameLookup)};
1615 if (addrLocal.has_value() && addrLocal->IsValid())
1616 AddLocal(addrLocal.value(), LOCAL_MANUAL);
1617 else
1618 return InitError(ResolveErrMsg("externalip", strAddr));
1619 }
1620
1621#ifdef ENABLE_ZMQ
1623 [&chainman = node.chainman](std::vector<uint8_t>& block, const CBlockIndex& index) {
1624 assert(chainman);
1625 return chainman->m_blockman.ReadRawBlock(block, WITH_LOCK(cs_main, return index.GetBlockPos()));
1626 });
1627
1629 validation_signals.RegisterValidationInterface(g_zmq_notification_interface.get());
1630 }
1631#endif
1632
1633 // ********************************************************* Step 7: load block chain
1634
1635 node.notifications = std::make_unique<KernelNotifications>(Assert(node.shutdown_request), node.exit_status, *Assert(node.warnings));
1636 auto& kernel_notifications{*node.notifications};
1637 ReadNotificationArgs(args, kernel_notifications);
1638
1639 // cache size calculations
1640 const auto [index_cache_sizes, kernel_cache_sizes] = CalculateCacheSizes(args, g_enabled_filter_types.size());
1641
1642 LogInfo("Cache configuration:");
1643 LogInfo("* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
1644 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1645 LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index * (1.0 / 1024 / 1024));
1646 }
1647 for (BlockFilterType filter_type : g_enabled_filter_types) {
1648 LogInfo("* Using %.1f MiB for %s block filter index database",
1649 index_cache_sizes.filter_index * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type));
1650 }
1651 LogInfo("* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db * (1.0 / 1024 / 1024));
1652
1653 assert(!node.mempool);
1654 assert(!node.chainman);
1655
1656 bool do_reindex{args.GetBoolArg("-reindex", false)};
1657 const bool do_reindex_chainstate{args.GetBoolArg("-reindex-chainstate", false)};
1658
1659 // Chainstate initialization and loading may be retried once with reindexing by GUI users
1660 auto [status, error] = InitAndLoadChainstate(
1661 node,
1662 do_reindex,
1663 do_reindex_chainstate,
1664 kernel_cache_sizes,
1665 args);
1666 if (status == ChainstateLoadStatus::FAILURE && !do_reindex && !ShutdownRequested(node)) {
1667 // suggest a reindex
1668 bool do_retry = uiInterface.ThreadSafeQuestion(
1669 error + Untranslated(".\n\n") + _("Do you want to rebuild the databases now?"),
1670 error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1672 if (!do_retry) {
1673 return false;
1674 }
1675 do_reindex = true;
1676 if (!Assert(node.shutdown_signal)->reset()) {
1677 LogError("Internal error: failed to reset shutdown signal.\n");
1678 }
1679 std::tie(status, error) = InitAndLoadChainstate(
1680 node,
1681 do_reindex,
1682 do_reindex_chainstate,
1683 kernel_cache_sizes,
1684 args);
1685 }
1686 if (status != ChainstateLoadStatus::SUCCESS && status != ChainstateLoadStatus::INTERRUPTED) {
1687 return InitError(error);
1688 }
1689
1690 // As LoadBlockIndex can take several minutes, it's possible the user
1691 // requested to kill the GUI during the last operation. If so, exit.
1692 if (ShutdownRequested(node)) {
1693 LogPrintf("Shutdown requested. Exiting.\n");
1694 return false;
1695 }
1696
1697 ChainstateManager& chainman = *Assert(node.chainman);
1698
1699 assert(!node.peerman);
1700 node.peerman = PeerManager::make(*node.connman, *node.addrman,
1701 node.banman.get(), chainman,
1702 *node.mempool, *node.warnings,
1703 peerman_opts);
1704 validation_signals.RegisterValidationInterface(node.peerman.get());
1705
1706 // ********************************************************* Step 8: start indexers
1707
1708 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1709 g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), index_cache_sizes.tx_index, false, do_reindex);
1710 node.indexes.emplace_back(g_txindex.get());
1711 }
1712
1713 for (const auto& filter_type : g_enabled_filter_types) {
1714 InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, index_cache_sizes.filter_index, false, do_reindex);
1715 node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
1716 }
1717
1718 if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1719 g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, do_reindex);
1720 node.indexes.emplace_back(g_coin_stats_index.get());
1721 }
1722
1723 // Init indexes
1724 for (auto index : node.indexes) if (!index->Init()) return false;
1725
1726 // ********************************************************* Step 9: load wallet
1727 for (const auto& client : node.chain_clients) {
1728 if (!client->load()) {
1729 return false;
1730 }
1731 }
1732
1733 // ********************************************************* Step 10: data directory maintenance
1734
1735 // if pruning, perform the initial blockstore prune
1736 // after any wallet rescanning has taken place.
1737 if (chainman.m_blockman.IsPruneMode()) {
1738 if (chainman.m_blockman.m_blockfiles_indexed) {
1739 LOCK(cs_main);
1740 for (Chainstate* chainstate : chainman.GetAll()) {
1741 uiInterface.InitMessage(_("Pruning blockstore…"));
1742 chainstate->PruneAndFlush();
1743 }
1744 }
1745 } else {
1746 // Prior to setting NODE_NETWORK, check if we can provide historical blocks.
1747 if (!WITH_LOCK(chainman.GetMutex(), return chainman.BackgroundSyncInProgress())) {
1748 LogPrintf("Setting NODE_NETWORK on non-prune mode\n");
1749 g_local_services = ServiceFlags(g_local_services | NODE_NETWORK);
1750 } else {
1751 LogPrintf("Running node in NODE_NETWORK_LIMITED mode until snapshot background sync completes\n");
1752 }
1753 }
1754
1755 // ********************************************************* Step 11: import blocks
1756
1758 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetDataDirNet()))));
1759 return false;
1760 }
1762 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
1763 return false;
1764 }
1765
1766 int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height());
1767
1768 // On first startup, warn on low block storage space
1769 if (!do_reindex && !do_reindex_chainstate && chain_active_height <= 1) {
1770 uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1024 * 1024 * 1024};
1771 uint64_t additional_bytes_needed{
1772 chainman.m_blockman.IsPruneMode() ?
1773 std::min(chainman.m_blockman.GetPruneTarget(), assumed_chain_bytes) :
1774 assumed_chain_bytes};
1775
1776 if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) {
1778 "Disk space for %s may not accommodate the block files. " \
1779 "Approximately %u GB of data will be stored in this directory."
1780 ),
1782 chainparams.AssumedBlockchainSize()
1783 ));
1784 }
1785 }
1786
1787#if HAVE_SYSTEM
1788 const std::string block_notify = args.GetArg("-blocknotify", "");
1789 if (!block_notify.empty()) {
1790 uiInterface.NotifyBlockTip_connect([block_notify](SynchronizationState sync_state, const CBlockIndex* pBlockIndex) {
1791 if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) return;
1792 std::string command = block_notify;
1793 ReplaceAll(command, "%s", pBlockIndex->GetBlockHash().GetHex());
1794 std::thread t(runCommand, command);
1795 t.detach(); // thread runs free
1796 });
1797 }
1798#endif
1799
1800 std::vector<fs::path> vImportFiles;
1801 for (const std::string& strFile : args.GetArgs("-loadblock")) {
1802 vImportFiles.push_back(fs::PathFromString(strFile));
1803 }
1804
1805 node.background_init_thread = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &node] {
1807 // Import blocks and ActivateBestChain()
1808 ImportBlocks(chainman, vImportFiles);
1809 if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {
1810 LogPrintf("Stopping after block import\n");
1811 if (!(Assert(node.shutdown_request))()) {
1812 LogError("Failed to send shutdown signal after finishing block import\n");
1813 }
1814 return;
1815 }
1816
1817 // Start indexes initial sync
1819 bilingual_str err_str = _("Failed to start indexes, shutting down…");
1820 chainman.GetNotifications().fatalError(err_str);
1821 return;
1822 }
1823 // Load mempool from disk
1824 if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
1825 LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
1826 pool->SetLoadTried(!chainman.m_interrupt);
1827 }
1828 });
1829
1830 /*
1831 * Wait for genesis block to be processed. Typically kernel_notifications.m_tip_block
1832 * has already been set by a call to LoadChainTip() in CompleteChainstateInitialization().
1833 * But this is skipped if the chainstate doesn't exist yet or is being wiped:
1834 *
1835 * 1. first startup with an empty datadir
1836 * 2. reindex
1837 * 3. reindex-chainstate
1838 *
1839 * In these case it's connected by a call to ActivateBestChain() in the initload thread.
1840 */
1841 {
1842 WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
1843 kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
1844 return kernel_notifications.TipBlock() || ShutdownRequested(node);
1845 });
1846 }
1847
1848 if (ShutdownRequested(node)) {
1849 return false;
1850 }
1851
1852 // ********************************************************* Step 12: start node
1853
1854 int64_t best_block_time{};
1855 {
1856 LOCK(chainman.GetMutex());
1857 const auto& tip{*Assert(chainman.ActiveTip())};
1858 LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
1859 chain_active_height = tip.nHeight;
1860 best_block_time = tip.GetBlockTime();
1861 if (tip_info) {
1862 tip_info->block_height = chain_active_height;
1863 tip_info->block_time = best_block_time;
1864 tip_info->verification_progress = chainman.GuessVerificationProgress(&tip);
1865 }
1866 if (tip_info && chainman.m_best_header) {
1867 tip_info->header_height = chainman.m_best_header->nHeight;
1868 tip_info->header_time = chainman.m_best_header->GetBlockTime();
1869 }
1870 }
1871 LogPrintf("nBestHeight = %d\n", chain_active_height);
1872 if (node.peerman) node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time});
1873
1874 // Map ports with NAT-PMP
1876
1877 CConnman::Options connOptions;
1878 connOptions.m_local_services = g_local_services;
1879 connOptions.m_max_automatic_connections = nMaxConnections;
1880 connOptions.uiInterface = &uiInterface;
1881 connOptions.m_banman = node.banman.get();
1882 connOptions.m_msgproc = node.peerman.get();
1883 connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
1884 connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
1885 connOptions.m_added_nodes = args.GetArgs("-addnode");
1886 connOptions.nMaxOutboundLimit = *opt_max_upload;
1887 connOptions.m_peer_connect_timeout = peer_connect_timeout;
1888 connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
1889 connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
1890
1891 // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
1892 const uint16_t default_bind_port =
1893 static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));
1894
1895 const uint16_t default_bind_port_onion = default_bind_port + 1;
1896
1897 const auto BadPortWarning = [](const char* prefix, uint16_t port) {
1898 return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and "
1899 "thus it is unlikely that any peer will connect to it. See "
1900 "doc/p2p-bad-ports.md for details and a full list."),
1901 prefix,
1902 port);
1903 };
1904
1905 for (const std::string& bind_arg : args.GetArgs("-bind")) {
1906 std::optional<CService> bind_addr;
1907 const size_t index = bind_arg.rfind('=');
1908 if (index == std::string::npos) {
1909 bind_addr = Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false);
1910 if (bind_addr.has_value()) {
1911 connOptions.vBinds.push_back(bind_addr.value());
1912 if (IsBadPort(bind_addr.value().GetPort())) {
1913 InitWarning(BadPortWarning("-bind", bind_addr.value().GetPort()));
1914 }
1915 continue;
1916 }
1917 } else {
1918 const std::string network_type = bind_arg.substr(index + 1);
1919 if (network_type == "onion") {
1920 const std::string truncated_bind_arg = bind_arg.substr(0, index);
1921 bind_addr = Lookup(truncated_bind_arg, default_bind_port_onion, false);
1922 if (bind_addr.has_value()) {
1923 connOptions.onion_binds.push_back(bind_addr.value());
1924 continue;
1925 }
1926 }
1927 }
1928 return InitError(ResolveErrMsg("bind", bind_arg));
1929 }
1930
1931 for (const std::string& strBind : args.GetArgs("-whitebind")) {
1932 NetWhitebindPermissions whitebind;
1933 bilingual_str error;
1934 if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
1935 connOptions.vWhiteBinds.push_back(whitebind);
1936 }
1937
1938 // If the user did not specify -bind= or -whitebind= then we bind
1939 // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
1940 connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
1941
1942 // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not
1943 // given, because if they are, then -port= is ignored.
1944 if (connOptions.bind_on_any && args.IsArgSet("-port")) {
1945 const uint16_t port_arg = args.GetIntArg("-port", 0);
1946 if (IsBadPort(port_arg)) {
1947 InitWarning(BadPortWarning("-port", port_arg));
1948 }
1949 }
1950
1951 CService onion_service_target;
1952 if (!connOptions.onion_binds.empty()) {
1953 onion_service_target = connOptions.onion_binds.front();
1954 } else if (!connOptions.vBinds.empty()) {
1955 onion_service_target = connOptions.vBinds.front();
1956 } else {
1957 onion_service_target = DefaultOnionServiceTarget(default_bind_port_onion);
1958 connOptions.onion_binds.push_back(onion_service_target);
1959 }
1960
1961 if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
1962 if (connOptions.onion_binds.size() > 1) {
1963 InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
1964 "for the automatically created Tor onion service."),
1965 onion_service_target.ToStringAddrPort()));
1966 }
1967 StartTorControl(onion_service_target);
1968 }
1969
1970 if (connOptions.bind_on_any) {
1971 // Only add all IP addresses of the machine if we would be listening on
1972 // any address - 0.0.0.0 (IPv4) and :: (IPv6).
1973 Discover();
1974 }
1975
1976 for (const auto& net : args.GetArgs("-whitelist")) {
1978 ConnectionDirection connection_direction;
1979 bilingual_str error;
1980 if (!NetWhitelistPermissions::TryParse(net, subnet, connection_direction, error)) return InitError(error);
1981 if (connection_direction & ConnectionDirection::In) {
1982 connOptions.vWhitelistedRangeIncoming.push_back(subnet);
1983 }
1984 if (connection_direction & ConnectionDirection::Out) {
1985 connOptions.vWhitelistedRangeOutgoing.push_back(subnet);
1986 }
1987 }
1988
1989 connOptions.vSeedNodes = args.GetArgs("-seednode");
1990
1991 const auto connect = args.GetArgs("-connect");
1992 if (!connect.empty() || args.IsArgNegated("-connect")) {
1993 // Do not initiate other outgoing connections when connecting to trusted
1994 // nodes, or when -noconnect is specified.
1995 connOptions.m_use_addrman_outgoing = false;
1996
1997 if (connect.size() != 1 || connect[0] != "0") {
1998 connOptions.m_specified_outgoing = connect;
1999 }
2000 if (!connOptions.m_specified_outgoing.empty() && !connOptions.vSeedNodes.empty()) {
2001 LogPrintf("-seednode is ignored when -connect is used\n");
2002 }
2003
2004 if (args.IsArgSet("-dnsseed") && args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED) && args.IsArgSet("-proxy")) {
2005 LogPrintf("-dnsseed is ignored when -connect is used and -proxy is specified\n");
2006 }
2007 }
2008
2009 const std::string& i2psam_arg = args.GetArg("-i2psam", "");
2010 if (!i2psam_arg.empty()) {
2011 const std::optional<CService> addr{Lookup(i2psam_arg, 7656, fNameLookup)};
2012 if (!addr.has_value() || !addr->IsValid()) {
2013 return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
2014 }
2015 SetProxy(NET_I2P, Proxy{addr.value()});
2016 } else {
2017 if (!onlynets.empty() && g_reachable_nets.Contains(NET_I2P)) {
2018 return InitError(
2019 _("Outbound connections restricted to i2p (-onlynet=i2p) but "
2020 "-i2psam is not provided"));
2021 }
2023 }
2024
2025 connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING);
2026
2027 if (!node.connman->Start(scheduler, connOptions)) {
2028 return false;
2029 }
2030
2031 // ********************************************************* Step 13: finished
2032
2033 // At this point, the RPC is "started", but still in warmup, which means it
2034 // cannot yet be called. Before we make it callable, we need to make sure
2035 // that the RPC's view of the best block is valid and consistent with
2036 // ChainstateManager's active tip.
2038
2039 uiInterface.InitMessage(_("Done loading"));
2040
2041 for (const auto& client : node.chain_clients) {
2042 client->start(scheduler);
2043 }
2044
2045 BanMan* banman = node.banman.get();
2046 scheduler.scheduleEvery([banman]{
2047 banman->DumpBanlist();
2049
2050 if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
2051
2052#if HAVE_SYSTEM
2053 StartupNotify(args);
2054#endif
2055
2056 return true;
2057}
2058
2060{
2061 // Find the oldest block among all indexes.
2062 // This block is used to verify that we have the required blocks' data stored on disk,
2063 // starting from that point up to the current tip.
2064 // indexes_start_block='nullptr' means "start from height 0".
2065 std::optional<const CBlockIndex*> indexes_start_block;
2066 std::string older_index_name;
2067 ChainstateManager& chainman = *Assert(node.chainman);
2068 const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing());
2069 const CChain& index_chain = chainstate.m_chain;
2070
2071 for (auto index : node.indexes) {
2072 const IndexSummary& summary = index->GetSummary();
2073 if (summary.synced) continue;
2074
2075 // Get the last common block between the index best block and the active chain
2076 LOCK(::cs_main);
2077 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash);
2078 if (!index_chain.Contains(pindex)) {
2079 pindex = index_chain.FindFork(pindex);
2080 }
2081
2082 if (!indexes_start_block || !pindex || pindex->nHeight < indexes_start_block.value()->nHeight) {
2083 indexes_start_block = pindex;
2084 older_index_name = summary.name;
2085 if (!pindex) break; // Starting from genesis so no need to look for earlier block.
2086 }
2087 };
2088
2089 // Verify all blocks needed to sync to current tip are present.
2090 if (indexes_start_block) {
2091 LOCK(::cs_main);
2092 const CBlockIndex* start_block = *indexes_start_block;
2093 if (!start_block) start_block = chainman.ActiveChain().Genesis();
2094 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(start_block))) {
2095 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)", older_index_name)));
2096 }
2097 }
2098
2099 // Start threads
2100 for (auto index : node.indexes) if (!index->StartBackgroundSync()) return false;
2101 return true;
2102}
util::Result< std::unique_ptr< AddrMan > > LoadAddrman(const NetGroupManager &netgroupman, const ArgsManager &args)
Returns an error string on failure.
Definition: addrdb.cpp:191
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
Definition: addrman.h:32
const std::vector< std::string > TEST_OPTIONS_DOC
Definition: args.cpp:710
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
Definition: args.cpp:689
const char *const BITCOIN_SETTINGS_FILENAME
Definition: args.cpp:40
ArgsManager gArgs
Definition: args.cpp:42
const char *const BITCOIN_CONF_FILENAME
Definition: args.cpp:39
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:226
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...
const auto cmd
int exit_status
const auto command
ArgsManager & args
Definition: bitcoind.cpp:277
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.
const std::string & ListBlockFilterTypes()
Get a comma-separated list of known filter type names.
bool BlockFilterTypeByName(const std::string &name, BlockFilterType &filter_type)
Find a filter type by its human-readable name.
BlockFilterType
Definition: blockfilter.h:93
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
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
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:11
ChainType
Definition: chaintype.h:11
#define Assert(val)
Identity function.
Definition: check.h:106
std::set< std::string > GetUnsuitableSectionOnlyArgs() const
Log warnings for options in m_section_only_args when they are specified in the default section but no...
Definition: args.cpp:136
bool IsArgNegated(const std::string &strArg) const
Return true if the argument was originally passed as a negated option, i.e.
Definition: args.cpp:452
std::list< SectionInfo > GetUnrecognizedSections() const
Log warnings for unrecognized section names in the config file.
Definition: args.cpp:156
@ NETWORK_ONLY
Definition: args.h:120
@ ALLOW_ANY
disable validation
Definition: args.h:106
@ DISALLOW_NEGATION
disallow -nofoo syntax
Definition: args.h:111
@ DISALLOW_ELISION
disallow -foo syntax that doesn't assign any value
Definition: args.h:112
@ DEBUG_ONLY
Definition: args.h:114
@ SENSITIVE
Definition: args.h:122
ChainType GetChainType() const
Returns the appropriate chain type from the program arguments.
Definition: args.cpp:774
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: args.cpp:362
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
Definition: args.h:234
bool SoftSetArg(const std::string &strArg, const std::string &strValue)
Set an argument if it doesn't already have a value.
Definition: args.cpp:530
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: args.cpp:371
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
Definition: args.cpp:482
fs::path GetBlocksDirPath() const
Get blocks directory path.
Definition: args.cpp:282
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: args.cpp:457
bool SoftSetBoolArg(const std::string &strArg, bool fValue)
Set a boolean argument if it doesn't already have a value.
Definition: args.cpp:538
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: args.cpp:507
void AddHiddenArgs(const std::vector< std::string > &args)
Add many hidden arguments.
Definition: args.cpp:585
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
Definition: args.cpp:564
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const
Return path argument or default value.
Definition: args.cpp:272
std::atomic< bool > m_reopen_file
Definition: logging.h:142
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:141
uint256 GetBlockHash() const
Definition: chain.h:243
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:153
The BlockPolicyEstimator is used for estimating the feerate needed for a transaction to be included i...
Definition: fees.h:149
void FlushFeeEstimates() EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator)
Record current fee estimations.
Definition: fees.cpp:961
An in-memory indexed chain of blocks.
Definition: chain.h:417
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:433
CBlockIndex * Genesis() const
Returns the index entry for the genesis block of this chain, or nullptr if none.
Definition: chain.h:427
int Height() const
Return the maximal height in the chain.
Definition: chain.h:462
const CBlockIndex * FindFork(const CBlockIndex *pindex) const
Find the last common block between this chain and a block index entry.
Definition: chain.cpp:60
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
Definition: chain.h:447
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:69
std::string GetChainTypeString() const
Return the chain type string.
Definition: chainparams.h:101
const MessageStartChars & MessageStart() const
Definition: chainparams.h:82
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
Definition: chainparams.h:88
uint64_t AssumedBlockchainSize() const
Minimum free space (in GB) needed for data directory.
Definition: chainparams.h:95
ChainType GetChainType() const
Return the chain type.
Definition: chainparams.h:103
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:531
std::string ToStringAddrPort() const
Definition: netaddress.cpp:907
static const int DEFAULT_ZMQ_SNDHWM
static std::unique_ptr< CZMQNotificationInterface > Create(std::function< bool(std::vector< uint8_t > &, 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:506
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:586
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:866
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1123
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
Definition: validation.h:1108
double GuessVerificationProgress(const CBlockIndex *pindex) const
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
kernel::Notifications & GetNotifications() const
Definition: validation.h:979
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:999
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1111
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
Definition: validation.h:1114
const util::SignalInterrupt & m_interrupt
Definition: validation.h:1001
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
Definition: validation.h:972
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1109
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:1078
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1005
Fast randomness source.
Definition: random.h:377
uint64_t rand64() noexcept
Generate a random 64-bit integer.
Definition: random.h:395
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:101
static bool TryParse(const std::string &str, NetWhitebindPermissions &output, bilingual_str &error)
static bool TryParse(const std::string &str, NetWhitelistPermissions &output, 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:59
bool IsValid() const
Definition: netbase.h:70
void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:103
bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:124
void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:110
void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:117
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
Interface providing access to interprocess-communication (IPC) functionality.
Definition: ipc.h:50
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:139
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
Definition: blockstorage.h:275
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
Definition: blockstorage.h:352
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
Definition: blockstorage.h:394
bool IsPruneMode() const
Whether running in -prune mode.
Definition: blockstorage.h:349
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
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
Definition: clientversion.h:31
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
static constexpr bool DEFAULT_COINSTATSINDEX
bool SetupNetworking()
Definition: system.cpp:91
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
Definition: consensus.h:15
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:17
fs::path FeeestPath(const ArgsManager &argsman)
Definition: fees_args.cpp:13
static auto quoted(const std::string &s)
Definition: fs.h:95
static bool exists(const path &p)
Definition: fs.h:89
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition: fs.h:151
static path PathFromString(const std::string &string)
Convert byte string to path object.
Definition: fs.h:174
int RaiseFileDescriptorLimit(int nMinFD)
this function tries to raise the file descriptor limit to the requested number.
Definition: fs_helpers.cpp:163
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
Definition: fs_helpers.cpp:93
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:29
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
Definition: httprpc.cpp:388
void StopHTTPRPC()
Stop HTTP RPC subsystem.
Definition: httprpc.cpp:393
bool StartHTTPRPC(const std::any &context)
Start HTTP RPC subsystem.
Definition: httprpc.cpp:370
void StartREST(const std::any &context)
Start HTTP REST subsystem.
Definition: rest.cpp:1026
void StopREST()
Stop HTTP REST subsystem.
Definition: rest.cpp:1038
void InterruptREST()
Interrupt RPC REST subsystem.
Definition: rest.cpp:1034
void InterruptHTTPServer()
Interrupt HTTP server threads.
Definition: httpserver.cpp:512
void StartHTTPServer()
Start HTTP server.
Definition: httpserver.cpp:501
bool InitHTTPServer(const util::SignalInterrupt &interrupt)
Initialize HTTP server.
Definition: httpserver.cpp:443
void StopHTTPServer()
Stop HTTP server.
Definition: httpserver.cpp:524
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:1092
static const char * BITCOIN_PID_FILENAME
The PID file facilities.
Definition: init.cpp:165
static bool CreatePidFile(const ArgsManager &args)
Definition: init.cpp:177
static bool g_generated_pid
True if this process has created a PID file.
Definition: init.cpp:170
static std::optional< util::SignalInterrupt > g_shutdown
Definition: init.cpp:205
static void RemovePidFile(const ArgsManager &args)
Definition: init.cpp:195
void Interrupt(NodeContext &node)
Interrupt threads.
Definition: init.cpp:264
void InitLogging(const ArgsManager &args)
Initialize global loggers.
Definition: init.cpp:800
static bool AppInitServers(NodeContext &node)
Definition: init.cpp:695
static bool LockDirectories(bool probeOnly)
Definition: init.cpp:1104
static constexpr int MIN_CORE_FDS
Definition: init.cpp:159
void Shutdown(NodeContext &node)
Definition: init.cpp:282
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
Definition: init.cpp:407
static void HandleSIGHUP(int)
Definition: init.cpp:414
bool AppInitBasicSetup(const ArgsManager &args, std::atomic< int > &exit_status)
Initialize bitcoin core: Basic context setup.
Definition: init.cpp:829
static fs::path GetPidFile(const ArgsManager &args)
Definition: init.cpp:172
static constexpr bool DEFAULT_PROXYRANDOMIZE
Definition: init.cpp:145
bool CheckHostPortOptions(const ArgsManager &args)
Definition: init.cpp:1148
static ChainstateLoadResult InitAndLoadChainstate(NodeContext &node, bool do_reindex, const bool do_reindex_chainstate, const kernel::CacheSizes &cache_sizes, const ArgsManager &args)
Definition: init.cpp:1196
bool ShutdownRequested(node::NodeContext &node)
Return whether node shutdown was requested.
Definition: init.cpp:246
bool StartIndexBackgroundSync(NodeContext &node)
Validates requirements to run the indexes and spawns each index initial sync thread.
Definition: init.cpp:2059
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:866
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1141
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
Definition: init.cpp:148
static const char * DEFAULT_ASMAP_FILENAME
Definition: init.cpp:160
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
Definition: init.cpp:711
static constexpr bool DEFAULT_REST_ENABLE
Definition: init.cpp:146
#define MIN_LEVELDB_FDS
Definition: init.cpp:156
static void registerSignalHandler(int signal, void(*handler)(int))
Definition: init.cpp:431
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
Definition: init.cpp:1305
static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING
Definition: init.cpp:147
bool AppInitLockDirectories()
Lock bitcoin core critical directories.
Definition: init.cpp:1129
void SetupServerArgs(ArgsManager &argsman, bool can_listen_ipc)
Register all arguments with the ArgsManager.
Definition: init.cpp:441
void InitContext(NodeContext &node)
Initialize node context shutdown and args variables.
Definition: init.cpp:207
static void new_handler_terminate()
Definition: init.cpp:816
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
Definition: init.cpp:1110
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.
bool ECC_InitSanityCheck()
Check that required EC support is available at runtime.
Definition: key.cpp:442
BCLog::Logger & LogInstance()
Definition: logging.cpp:24
#define LogWarning(...)
Definition: logging.h:262
#define LogInfo(...)
Definition: logging.h:261
#define LogError(...)
Definition: logging.h:263
#define LogPrintf(...)
Definition: logging.h:266
void StopMapPort()
Definition: mapport.cpp:154
void InterruptMapPort()
Definition: mapport.cpp:147
void StartMapPort(bool enable)
Definition: mapport.cpp:137
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.
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
Definition: moneystr.cpp:45
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:19
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
Definition: messages.cpp:167
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
Definition: messages.cpp:152
bilingual_str InvalidPortErrMsg(const std::string &optname, const std::string &invalid_value)
Definition: messages.cpp:157
void AddLoggingArgs(ArgsManager &argsman)
Definition: common.cpp:27
util::Result< void > SetLoggingCategories(const ArgsManager &args)
Definition: common.cpp:78
bool StartLogging(const ArgsManager &args)
Definition: common.cpp:103
util::Result< void > SetLoggingLevel(const ArgsManager &args)
Definition: common.cpp:59
void SetLoggingOptions(const ArgsManager &args)
Definition: common.cpp:45
void LogPackageVersion()
Definition: common.cpp:143
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
Definition: interfaces.cpp:997
Definition: ipc.h:12
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:20
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:24
fs::path MempoolPath(const ArgsManager &argsman)
util::Result< void > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
static const bool DEFAULT_PRINT_MODIFIED_FEE
Definition: miner.h:40
bool ShouldPersistMempool(const ArgsManager &argsman)
void ReadNotificationArgs(const ArgsManager &args, KernelNotifications &notifications)
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:144
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:229
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:55
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:16
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:233
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
Definition: string.h:192
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
Definition: string.cpp:11
LockResult LockDirectory(const fs::path &directory, const fs::path &lockfile_name, bool probe_only)
Definition: fs_helpers.cpp:53
uint16_t GetListenPort()
Definition: net.cpp:137
bool fDiscover
Definition: net.cpp:115
bool AddLocal(const CService &addr_, int nScore)
Definition: net.cpp:270
bool fListen
Definition: net.cpp:116
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:119
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:3179
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
Definition: net.h:78
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
Definition: net.h:66
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:70
static const size_t DEFAULT_MAXSENDBUFFER
Definition: net.h:94
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
Definition: net.h:86
static constexpr bool DEFAULT_FIXEDSEEDS
Definition: net.h:92
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
Definition: net.h:82
static const size_t DEFAULT_MAXRECEIVEBUFFER
Definition: net.h:93
static const std::string DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
Definition: net.h:80
static constexpr bool DEFAULT_FORCEDNSSEED
Definition: net.h:90
static constexpr bool DEFAULT_DNSSEED
Definition: net.h:91
static const bool DEFAULT_LISTEN
-listen default
Definition: net.h:76
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
Definition: net.h:84
@ LOCAL_MANUAL
Definition: net.h:153
static constexpr bool DEFAULT_V2_TRANSPORT
Definition: net.h:96
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 const uint32_t DEFAULT_MAX_ORPHAN_TRANSACTIONS
Default for -maxorphantx, maximum number of orphan transactions kept in memory.
static constexpr bool DEFAULT_TXRECONCILIATION_ENABLE
Whether transaction reconciliation protocol should be enabled by default.
static const bool DEFAULT_PEERBLOCKFILTERS
static const bool DEFAULT_PEERBLOOMFILTERS
Network
A network type.
Definition: netaddress.h:32
@ NET_I2P
I2P.
Definition: netaddress.h:46
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:49
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:43
@ NET_IPV6
IPv6.
Definition: netaddress.h:40
@ NET_IPV4
IPv4.
Definition: netaddress.h:37
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:34
bool SetNameProxy(const Proxy &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
Definition: netbase.cpp:722
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:100
bool SetProxy(enum Network net, const Proxy &addrProxy)
Definition: netbase.cpp:704
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:195
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:230
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:851
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:134
ConnectionDirection
Definition: netbase.h:33
static const int DEFAULT_NAME_LOOKUP
-dns default
Definition: netbase.h:28
const std::string ADDR_PREFIX_UNIX
Prefix for unix domain socket addresses (which are local filesystem paths)
Definition: netbase.h:31
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
Definition: netbase.h:26
static constexpr size_t MIN_DB_CACHE
min. -dbcache (bytes)
Definition: caches.h:16
static constexpr size_t DEFAULT_DB_CACHE
-dbcache default (bytes)
Definition: caches.h:18
static constexpr bool DEFAULT_ACCEPT_STALE_FEE_ESTIMATES
Definition: fees.h:36
static constexpr std::chrono::hours MAX_FILE_AGE
fee_estimates.dat that are more than 60 hours (2.5 days) old will not be read, as fee estimates are b...
Definition: fees.h:33
static constexpr std::chrono::hours FEE_FLUSH_INTERVAL
Definition: fees.h:27
unsigned int nBytesPerSigOp
Definition: settings.cpp:10
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for -datacarriersize.
Definition: policy.h:79
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:32
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:42
static constexpr unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT_KVB
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
Definition: policy.h:68
static constexpr bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
Definition: policy.h:46
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
Definition: policy.h:62
static constexpr unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
Definition: policy.h:70
static constexpr unsigned int DEFAULT_BYTES_PER_SIGOP
Default for -bytespersigop.
Definition: policy.h:44
static constexpr unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT_KVB
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
Definition: policy.h:72
static constexpr unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create.
Definition: policy.h:23
static constexpr unsigned int DEFAULT_BLOCK_RESERVED_WEIGHT
Default for -blockreservedweight.
Definition: policy.h:25
static const bool DEFAULT_ACCEPT_DATACARRIER
Default for -datacarrier.
Definition: policy.h:74
static constexpr unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
Definition: policy.h:66
static constexpr unsigned int MINIMUM_BLOCK_RESERVED_WEIGHT
This accounts for the block header, var_int encoding of the transaction count and a minimally viable ...
Definition: policy.h:30
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: policy.h:64
ServiceFlags
nServices flags
Definition: protocol.h:309
@ NODE_P2P_V2
Definition: protocol.h:330
@ NODE_WITNESS
Definition: protocol.h:320
@ NODE_NETWORK_LIMITED
Definition: protocol.h:327
@ NODE_BLOOM
Definition: protocol.h:317
@ NODE_NETWORK
Definition: protocol.h:315
@ NODE_COMPACT_FILTERS
Definition: protocol.h:323
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:1009
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:1010
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:46
static constexpr bool DEFAULT_RPC_DOC_CHECK
Definition: util.h:46
void SetRPCWarmupFinished()
Definition: server.cpp:330
void StartRPC()
Definition: server.cpp:284
void StopRPC()
Definition: server.cpp:301
void InterruptRPC()
Definition: server.cpp:290
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:324
CRPCTable tableRPC
Definition: server.cpp:577
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:319
static constexpr size_t DEFAULT_VALIDATION_CACHE_BYTES
Definition: sigcache.h:28
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
Definition: strencodings.h:33
unsigned int nReceiveFloodSize
Definition: net.h:1064
std::vector< NetWhitebindPermissions > vWhiteBinds
Definition: net.h:1070
uint64_t nMaxOutboundLimit
Definition: net.h:1065
CClientUIInterface * uiInterface
Definition: net.h:1060
std::vector< NetWhitelistPermissions > vWhitelistedRangeIncoming
Definition: net.h:1068
std::vector< CService > onion_binds
Definition: net.h:1072
std::vector< std::string > m_specified_outgoing
Definition: net.h:1077
bool whitelist_relay
Definition: net.h:1081
NetEventsInterface * m_msgproc
Definition: net.h:1061
std::vector< std::string > m_added_nodes
Definition: net.h:1078
int64_t m_peer_connect_timeout
Definition: net.h:1066
std::vector< CService > vBinds
Definition: net.h:1071
unsigned int nSendBufferMaxSize
Definition: net.h:1063
int m_max_automatic_connections
Definition: net.h:1059
ServiceFlags m_local_services
Definition: net.h:1058
bool m_i2p_accept_incoming
Definition: net.h:1079
std::vector< std::string > vSeedNodes
Definition: net.h:1067
BanMan * m_banman
Definition: net.h:1062
bool m_use_addrman_outgoing
Definition: net.h:1076
bool whitelist_forcerelay
Definition: net.h:1080
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Definition: net.h:1075
std::vector< NetWhitelistPermissions > vWhitelistedRangeOutgoing
Definition: net.h:1069
Application-specific storage settings.
Definition: dbwrapper.h:34
fs::path path
Location in the filesystem where leveldb data will be stored.
Definition: dbwrapper.h:36
std::string name
Definition: base.h:26
bool synced
Definition: base.h:27
uint256 best_block_hash
Definition: base.h:29
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:21
size_t coins
Definition: caches.h:23
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:56
#define WAIT_LOCK(cs, name)
Definition: sync.h:263
#define LOCK(cs)
Definition: sync.h:257
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:302
#define TRY_LOCK(cs, name)
Definition: sync.h:262
std::string SysErrorString(int err)
Return system error string from errno value.
Definition: syserror.cpp:19
#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:51
void InterruptTorControl()
Definition: torcontrol.cpp:707
CService DefaultOnionServiceTarget(uint16_t port)
Definition: torcontrol.cpp:726
void StartTorControl(CService onion_service_target)
Definition: torcontrol.cpp:688
void StopTorControl()
Definition: torcontrol.cpp:717
static const bool DEFAULT_LISTEN_ONION
Definition: torcontrol.h:24
constexpr int DEFAULT_TOR_CONTROL_PORT
Functionality for communicating with Tor.
Definition: torcontrol.h:22
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 const int64_t nDefaultDbBatchSize
-dbbatchsize default (bytes)
Definition: txdb.h:25
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
Definition: txindex.cpp:16
static constexpr bool DEFAULT_TXINDEX
Definition: txindex.h:10
std::vector< bool > DecodeAsmap(fs::path path)
Read asmap from provided binary file.
Definition: asmap.cpp:197
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 SanitizeString(std::string_view str, int rule)
Remove unsafe chars.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:40
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:83
static constexpr int DEFAULT_CHECKLEVEL
Definition: validation.h:71
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Definition: validation.h:80
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:69
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:86
static const signed int DEFAULT_CHECKBLOCKS
Definition: validation.h:70
const WalletInitInterface & g_wallet_init_interface
Definition: init.cpp:117
std::unique_ptr< CZMQNotificationInterface > g_zmq_notification_interface
void RegisterZMQRPCCommands(CRPCTable &t)
Definition: zmqrpc.cpp:66