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 <csignal>
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 const std::string proxy_doc_for_value =
553#ifdef HAVE_SOCKADDR_UN
554 "<ip>[:<port>]|unix:<path>";
555#else
556 "<ip>[:<port>]";
557#endif
558 const std::string proxy_doc_for_unix_socket =
559#ifdef HAVE_SOCKADDR_UN
560 "May be a local file path prefixed with 'unix:' if the proxy supports it. ";
561#else
562 "";
563#endif
564 argsman.AddArg("-proxy=" + proxy_doc_for_value + "[=<network>]",
565 "Connect through SOCKS5 proxy, set -noproxy to disable. " +
566 proxy_doc_for_unix_socket +
567 "Could end in =network to set the proxy only for that network. " +
568 "The network can be any of ipv4, ipv6, tor or cjdns. " +
569 "(default: disabled)",
572 argsman.AddArg("-proxyrandomize", strprintf("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)", DEFAULT_PROXYRANDOMIZE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
573 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);
574 argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
575 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);
576 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);
577 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);
578 argsman.AddArg("-torpassword=<pass>", "Tor control port password (default: empty)", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::CONNECTION);
579 argsman.AddArg("-natpmp", strprintf("Use PCP or NAT-PMP to map the listening port (default: %u)", DEFAULT_NATPMP), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
580 argsman.AddArg("-whitebind=<[permissions@]addr>", "Bind to the given address and add permission flags to the peers connecting to it. "
581 "Use [host]:port notation for IPv6. Allowed permissions: " + Join(NET_PERMISSIONS_DOC, ", ") + ". "
582 "Specify multiple permissions separated by commas (default: download,noban,mempool,relay). Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
583
584 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 "
585 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
586 "-whitebind. "
587 "Additional flags \"in\" and \"out\" control whether permissions apply to incoming connections and/or manual (default: incoming only). "
588 "Can be specified multiple times.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
589
591
592#ifdef ENABLE_ZMQ
593 argsman.AddArg("-zmqpubhashblock=<address>", "Enable publish hash block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
594 argsman.AddArg("-zmqpubhashtx=<address>", "Enable publish hash transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
595 argsman.AddArg("-zmqpubrawblock=<address>", "Enable publish raw block in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
596 argsman.AddArg("-zmqpubrawtx=<address>", "Enable publish raw transaction in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
597 argsman.AddArg("-zmqpubsequence=<address>", "Enable publish hash block and tx sequence in <address>", ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
598 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);
599 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);
600 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);
601 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);
602 argsman.AddArg("-zmqpubsequencehwm=<n>", strprintf("Set publish hash sequence message high water mark (default: %d)", CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM), ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
603#else
604 hidden_args.emplace_back("-zmqpubhashblock=<address>");
605 hidden_args.emplace_back("-zmqpubhashtx=<address>");
606 hidden_args.emplace_back("-zmqpubrawblock=<address>");
607 hidden_args.emplace_back("-zmqpubrawtx=<address>");
608 hidden_args.emplace_back("-zmqpubsequence=<n>");
609 hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
610 hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
611 hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
612 hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
613 hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
614#endif
615
616 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);
617 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);
618 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);
619 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);
620 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);
621 // Checkpoints were removed. We keep `-checkpoints` as a hidden arg to display a more user friendly error when set.
622 argsman.AddArg("-checkpoints", "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
623 argsman.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
624 argsman.AddArg("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", DEFAULT_STOPAFTERBLOCKIMPORT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
625 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);
626 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);
627 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);
628 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);
629 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);
630 argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
631 argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
632 argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
633 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);
634 argsman.AddArg("-maxtipage=<n>",
635 strprintf("Maximum tip age in seconds to consider node in initial block download (default: %u)",
636 Ticks<std::chrono::seconds>(DEFAULT_MAX_TIP_AGE)),
638 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);
639 argsman.AddArg("-uacomment=<cmt>", "Append comment to the user agent string", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
640
642
643 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);
644 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);
645 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);
646 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);
647 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);
648 argsman.AddArg("-datacarrier", strprintf("(DEPRECATED) Relay and mine data carrier transactions (default: %u)", DEFAULT_ACCEPT_DATACARRIER), ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
649 argsman.AddArg("-datacarriersize",
650 strprintf("(DEPRECATED) Relay and mine transactions whose data-carrying raw scriptPubKeys in aggregate "
651 "are of this size or less, allowing multiple outputs (default: %u)",
654 argsman.AddArg("-permitbaremultisig", strprintf("Relay transactions creating non-P2SH multisig outputs (default: %u)", DEFAULT_PERMIT_BAREMULTISIG), ArgsManager::ALLOW_ANY,
656 argsman.AddArg("-minrelaytxfee=<amt>", strprintf("Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
658 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);
659 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);
660
661
662 argsman.AddArg("-blockmaxweight=<n>", strprintf("Set maximum BIP141 block weight (default: %d)", DEFAULT_BLOCK_MAX_WEIGHT), ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
663 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);
664 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);
665 argsman.AddArg("-blockversion=<n>", "Override block version to test forking scenarios", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::BLOCK_CREATION);
666
667 argsman.AddArg("-rest", strprintf("Accept public REST requests (default: %u)", DEFAULT_REST_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
668 argsman.AddArg("-rpcallowip=<ip>", "Allow JSON-RPC connections from specified source. Valid values for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0), a network/CIDR (e.g. 1.2.3.4/24), all ipv4 (0.0.0.0/0), or all ipv6 (::/0). RFC4193 is allowed only if -cjdnsreachable=0. This option can be specified multiple times", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
669 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);
670 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);
671 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);
672 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);
673 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);
674 argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
675 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);
676 argsman.AddArg("-rpcservertimeout=<n>", strprintf("Timeout during HTTP requests (default: %d)", DEFAULT_HTTP_SERVER_TIMEOUT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
677 argsman.AddArg("-rpcthreads=<n>", strprintf("Set the number of threads to service RPC calls (default: %d)", DEFAULT_HTTP_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
678 argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
679 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);
680 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);
681 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);
682 argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
683 if (can_listen_ipc) {
684 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);
685 }
686
687#if HAVE_DECL_FORK
688 argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
689 argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
690#else
691 hidden_args.emplace_back("-daemon");
692 hidden_args.emplace_back("-daemonwait");
693#endif
694
695 // Add the hidden options
696 argsman.AddHiddenArgs(hidden_args);
697}
698
699#if HAVE_SYSTEM
700static void StartupNotify(const ArgsManager& args)
701{
702 std::string cmd = args.GetArg("-startupnotify", "");
703 if (!cmd.empty()) {
704 std::thread t(runCommand, cmd);
705 t.detach(); // thread runs free
706 }
707}
708#endif
709
711{
712 const ArgsManager& args = *Assert(node.args);
713 if (!InitHTTPServer(*Assert(node.shutdown_signal))) {
714 return false;
715 }
716 StartRPC();
717 node.rpc_interruption_point = RpcInterruptionPoint;
718 if (!StartHTTPRPC(&node))
719 return false;
722 return true;
723}
724
725// Parameter interaction based on rules
727{
728 // when specifying an explicit binding address, you want to listen on it
729 // even when -connect or -proxy is specified
730 if (!args.GetArgs("-bind").empty()) {
731 if (args.SoftSetBoolArg("-listen", true))
732 LogInfo("parameter interaction: -bind set -> setting -listen=1\n");
733 }
734 if (!args.GetArgs("-whitebind").empty()) {
735 if (args.SoftSetBoolArg("-listen", true))
736 LogInfo("parameter interaction: -whitebind set -> setting -listen=1\n");
737 }
738
739 if (!args.GetArgs("-connect").empty() || args.IsArgNegated("-connect") || args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS) <= 0) {
740 // when only connecting to trusted nodes, do not seed via DNS, or listen by default
741 // do the same when connections are disabled
742 if (args.SoftSetBoolArg("-dnsseed", false))
743 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n");
744 if (args.SoftSetBoolArg("-listen", false))
745 LogInfo("parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n");
746 }
747
748 std::string proxy_arg = args.GetArg("-proxy", "");
749 if (proxy_arg != "" && proxy_arg != "0") {
750 // to protect privacy, do not listen by default if a default proxy server is specified
751 if (args.SoftSetBoolArg("-listen", false))
752 LogInfo("parameter interaction: -proxy set -> setting -listen=0\n");
753 // to protect privacy, do not map ports when a proxy is set. The user may still specify -listen=1
754 // to listen locally, so don't rely on this happening through -listen below.
755 if (args.SoftSetBoolArg("-natpmp", false)) {
756 LogInfo("parameter interaction: -proxy set -> setting -natpmp=0\n");
757 }
758 // to protect privacy, do not discover addresses by default
759 if (args.SoftSetBoolArg("-discover", false))
760 LogInfo("parameter interaction: -proxy set -> setting -discover=0\n");
761 }
762
763 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
764 // do not map ports or try to retrieve public IP when not listening (pointless)
765 if (args.SoftSetBoolArg("-natpmp", false)) {
766 LogInfo("parameter interaction: -listen=0 -> setting -natpmp=0\n");
767 }
768 if (args.SoftSetBoolArg("-discover", false))
769 LogInfo("parameter interaction: -listen=0 -> setting -discover=0\n");
770 if (args.SoftSetBoolArg("-listenonion", false))
771 LogInfo("parameter interaction: -listen=0 -> setting -listenonion=0\n");
772 if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
773 LogInfo("parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n");
774 }
775 }
776
777 if (!args.GetArgs("-externalip").empty()) {
778 // if an explicit public IP is specified, do not try to find others
779 if (args.SoftSetBoolArg("-discover", false))
780 LogInfo("parameter interaction: -externalip set -> setting -discover=0\n");
781 }
782
783 if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
784 // disable whitelistrelay in blocksonly mode
785 if (args.SoftSetBoolArg("-whitelistrelay", false))
786 LogInfo("parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n");
787 // Reduce default mempool size in blocksonly mode to avoid unexpected resource usage
789 LogInfo("parameter interaction: -blocksonly=1 -> setting -maxmempool=%d\n", DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB);
790 }
791
792 // Forcing relay from whitelisted hosts implies we will accept relays from them in the first place.
793 if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
794 if (args.SoftSetBoolArg("-whitelistrelay", true))
795 LogInfo("parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n");
796 }
797 const auto onlynets = args.GetArgs("-onlynet");
798 if (!onlynets.empty()) {
799 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](const auto& net) {
800 const auto n = ParseNetwork(net);
801 return n == NET_IPV4 || n == NET_IPV6;
802 });
803 if (!clearnet_reachable && args.SoftSetBoolArg("-dnsseed", false)) {
804 LogInfo("parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n");
805 }
806 }
807}
808
816{
819}
820
821namespace { // Variables internal to initialization process only
822
823int nMaxConnections;
824int available_fds;
826int64_t peer_connect_timeout;
827std::set<BlockFilterType> g_enabled_filter_types;
828
829} // namespace
830
831[[noreturn]] static void new_handler_terminate()
832{
833 // Rather than throwing std::bad-alloc if allocation fails, terminate
834 // immediately to (try to) avoid chain corruption.
835 // Since logging may itself allocate memory, set the handler directly
836 // to terminate first.
837 std::set_new_handler(std::terminate);
838 LogError("Out of memory. Terminating.\n");
839
840 // The log was successful, terminate now.
841 std::terminate();
842};
843
844bool AppInitBasicSetup(const ArgsManager& args, std::atomic<int>& exit_status)
845{
846 // ********************************************************* Step 1: setup
847#ifdef _MSC_VER
848 // Turn off Microsoft heap dump noise
849 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
850 _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, 0));
851 // Disable confusing "helpful" text message on abort, Ctrl-C
852 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
853#endif
854#ifdef WIN32
855 // Enable heap terminate-on-corruption
856 HeapSetInformation(nullptr, HeapEnableTerminationOnCorruption, nullptr, 0);
857#endif
858 if (!SetupNetworking()) {
859 return InitError(Untranslated("Initializing networking failed."));
860 }
861
862#ifndef WIN32
863 // Clean shutdown on SIGTERM
866
867 // Reopen debug.log on SIGHUP
869
870 // Ignore SIGPIPE, otherwise it will bring the daemon down if the client closes unexpectedly
871 signal(SIGPIPE, SIG_IGN);
872#else
873 SetConsoleCtrlHandler(consoleCtrlHandler, true);
874#endif
875
876 std::set_new_handler(new_handler_terminate);
877
878 return true;
879}
880
882{
883 const CChainParams& chainparams = Params();
884 // ********************************************************* Step 2: parameter interactions
885
886 // also see: InitParameterInteraction()
887
888 // We removed checkpoints but keep the option to warn users who still have it in their config.
889 if (args.IsArgSet("-checkpoints")) {
890 InitWarning(_("Option '-checkpoints' is set but checkpoints were removed. This option has no effect."));
891 }
892
893 if (args.IsArgSet("-datacarriersize") || args.IsArgSet("-datacarrier")) {
894 InitWarning(_("Options '-datacarrier' or '-datacarriersize' are set but are marked as deprecated. They will be removed in a future version."));
895 }
896
897 // Error if network-specific options (-addnode, -connect, etc) are
898 // specified in default section of config file, but not overridden
899 // on the command line or in this chain's section of the config file.
900 ChainType chain = args.GetChainType();
901 if (chain == ChainType::SIGNET) {
902 LogPrintf("Signet derived magic (message start): %s\n", HexStr(chainparams.MessageStart()));
903 }
904 bilingual_str errors;
905 for (const auto& arg : args.GetUnsuitableSectionOnlyArgs()) {
906 errors += strprintf(_("Config setting for %s only applied on %s network when in [%s] section."), arg, ChainTypeToString(chain), ChainTypeToString(chain)) + Untranslated("\n");
907 }
908
909 if (!errors.empty()) {
910 return InitError(errors);
911 }
912
913 // Testnet3 deprecation warning
914 if (chain == ChainType::TESTNET) {
915 LogInfo("Warning: Support for testnet3 is deprecated and will be removed in an upcoming release. Consider switching to testnet4.\n");
916 }
917
918 // Warn if unrecognized section name are present in the config file.
919 bilingual_str warnings;
920 for (const auto& section : args.GetUnrecognizedSections()) {
921 warnings += Untranslated(strprintf("%s:%i ", section.m_file, section.m_line)) + strprintf(_("Section [%s] is not recognized."), section.m_name) + Untranslated("\n");
922 }
923
924 if (!warnings.empty()) {
925 InitWarning(warnings);
926 }
927
928 if (!fs::is_directory(args.GetBlocksDirPath())) {
929 return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
930 }
931
932 // parse and validate enabled filter types
933 std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
934 if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
935 g_enabled_filter_types = AllBlockFilterTypes();
936 } else if (blockfilterindex_value != "0") {
937 const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
938 for (const auto& name : names) {
939 BlockFilterType filter_type;
940 if (!BlockFilterTypeByName(name, filter_type)) {
941 return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
942 }
943 g_enabled_filter_types.insert(filter_type);
944 }
945 }
946
947 // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.
948 if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {
949 g_local_services = ServiceFlags(g_local_services | NODE_P2P_V2);
950 }
951
952 // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
953 if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
954 if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
955 return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
956 }
957
958 g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
959 }
960
961 if (args.GetIntArg("-prune", 0)) {
962 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
963 return InitError(_("Prune mode is incompatible with -txindex."));
964 if (args.GetBoolArg("-reindex-chainstate", false)) {
965 return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
966 }
967 }
968
969 // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
970 if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
971 return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
972 }
973
974 // -bind and -whitebind can't be set when not listening
975 size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
976 if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
977 return InitError(Untranslated("Cannot set -bind or -whitebind together with -listen=0"));
978 }
979
980 // if listen=0, then disallow listenonion=1
981 if (!args.GetBoolArg("-listen", DEFAULT_LISTEN) && args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
982 return InitError(Untranslated("Cannot set -listen=0 together with -listenonion=1"));
983 }
984
985 // Make sure enough file descriptors are available. We need to reserve enough FDs to account for the bare minimum,
986 // plus all manual connections and all bound interfaces. Any remainder will be available for connection sockets
987
988 // Number of bound interfaces (we have at least one)
989 int nBind = std::max(nUserBind, size_t(1));
990 // Maximum number of connections with other nodes, this accounts for all types of outbounds and inbounds except for manual
991 int user_max_connection = args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
992 if (user_max_connection < 0) {
993 return InitError(Untranslated("-maxconnections must be greater or equal than zero"));
994 }
995 // Reserve enough FDs to account for the bare minimum, plus any manual connections, plus the bound interfaces
996 int min_required_fds = MIN_CORE_FDS + MAX_ADDNODE_CONNECTIONS + nBind;
997
998 // Try raising the FD limit to what we need (available_fds may be smaller than the requested amount if this fails)
999 available_fds = RaiseFileDescriptorLimit(user_max_connection + min_required_fds);
1000 // If we are using select instead of poll, our actual limit may be even smaller
1001#ifndef USE_POLL
1002 available_fds = std::min(FD_SETSIZE, available_fds);
1003#endif
1004 if (available_fds < min_required_fds)
1005 return InitError(strprintf(_("Not enough file descriptors available. %d available, %d required."), available_fds, min_required_fds));
1006
1007 // Trim requested connection counts, to fit into system limitations
1008 nMaxConnections = std::min(available_fds - min_required_fds, user_max_connection);
1009
1010 if (nMaxConnections < user_max_connection)
1011 InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), user_max_connection, nMaxConnections));
1012
1013 // ********************************************************* Step 3: parameter-to-internal-flags
1014 if (auto result{init::SetLoggingCategories(args)}; !result) return InitError(util::ErrorString(result));
1015 if (auto result{init::SetLoggingLevel(args)}; !result) return InitError(util::ErrorString(result));
1016
1018 if (nConnectTimeout <= 0) {
1020 }
1021
1022 peer_connect_timeout = args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
1023 if (peer_connect_timeout <= 0) {
1024 return InitError(Untranslated("peertimeout must be a positive integer."));
1025 }
1026
1027 if (const auto arg{args.GetArg("-blockmintxfee")}) {
1028 if (!ParseMoney(*arg)) {
1029 return InitError(AmountErrMsg("blockmintxfee", *arg));
1030 }
1031 }
1032
1033 {
1034 const auto max_block_weight = args.GetIntArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT);
1035 if (max_block_weight > MAX_BLOCK_WEIGHT) {
1036 return InitError(strprintf(_("Specified -blockmaxweight (%d) exceeds consensus maximum block weight (%d)"), max_block_weight, MAX_BLOCK_WEIGHT));
1037 }
1038 }
1039
1040 {
1041 const auto block_reserved_weight = args.GetIntArg("-blockreservedweight", DEFAULT_BLOCK_RESERVED_WEIGHT);
1042 if (block_reserved_weight > MAX_BLOCK_WEIGHT) {
1043 return InitError(strprintf(_("Specified -blockreservedweight (%d) exceeds consensus maximum block weight (%d)"), block_reserved_weight, MAX_BLOCK_WEIGHT));
1044 }
1045 if (block_reserved_weight < MINIMUM_BLOCK_RESERVED_WEIGHT) {
1046 return InitError(strprintf(_("Specified -blockreservedweight (%d) is lower than minimum safety value of (%d)"), block_reserved_weight, MINIMUM_BLOCK_RESERVED_WEIGHT));
1047 }
1048 }
1049
1050 nBytesPerSigOp = args.GetIntArg("-bytespersigop", nBytesPerSigOp);
1051
1052 if (!g_wallet_init_interface.ParameterInteraction()) return false;
1053
1054 // Option to startup with mocktime set (used for regression testing):
1055 SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
1056
1057 if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS))
1058 g_local_services = ServiceFlags(g_local_services | NODE_BLOOM);
1059
1060 const std::vector<std::string> test_options = args.GetArgs("-test");
1061 if (!test_options.empty()) {
1062 if (chainparams.GetChainType() != ChainType::REGTEST) {
1063 return InitError(Untranslated("-test=<option> can only be used with regtest"));
1064 }
1065 for (const std::string& option : test_options) {
1066 auto it = std::find_if(TEST_OPTIONS_DOC.begin(), TEST_OPTIONS_DOC.end(), [&option](const std::string& doc_option) {
1067 size_t pos = doc_option.find(" (");
1068 return (pos != std::string::npos) && (doc_option.substr(0, pos) == option);
1069 });
1070 if (it == TEST_OPTIONS_DOC.end()) {
1071 InitWarning(strprintf(_("Unrecognised option \"%s\" provided in -test=<option>."), option));
1072 }
1073 }
1074 }
1075
1076 // Also report errors from parsing before daemonization
1077 {
1078 kernel::Notifications notifications{};
1079 ChainstateManager::Options chainman_opts_dummy{
1080 .chainparams = chainparams,
1081 .datadir = args.GetDataDirNet(),
1082 .notifications = notifications,
1083 };
1084 auto chainman_result{ApplyArgsManOptions(args, chainman_opts_dummy)};
1085 if (!chainman_result) {
1086 return InitError(util::ErrorString(chainman_result));
1087 }
1088 BlockManager::Options blockman_opts_dummy{
1089 .chainparams = chainman_opts_dummy.chainparams,
1090 .blocks_dir = args.GetBlocksDirPath(),
1091 .notifications = chainman_opts_dummy.notifications,
1092 .block_tree_db_params = DBParams{
1093 .path = args.GetDataDirNet() / "blocks" / "index",
1094 .cache_bytes = 0,
1095 },
1096 };
1097 auto blockman_result{ApplyArgsManOptions(args, blockman_opts_dummy)};
1098 if (!blockman_result) {
1099 return InitError(util::ErrorString(blockman_result));
1100 }
1101 CTxMemPool::Options mempool_opts{};
1102 auto mempool_result{ApplyArgsManOptions(args, chainparams, mempool_opts)};
1103 if (!mempool_result) {
1104 return InitError(util::ErrorString(mempool_result));
1105 }
1106 }
1107
1108 return true;
1109}
1110
1111static bool LockDirectory(const fs::path& dir, bool probeOnly)
1112{
1113 // Make sure only a single process is using the directory.
1114 switch (util::LockDirectory(dir, ".lock", probeOnly)) {
1116 return InitError(strprintf(_("Cannot write to directory '%s'; check permissions."), fs::PathToString(dir)));
1118 return InitError(strprintf(_("Cannot obtain a lock on directory %s. %s is probably already running."), fs::PathToString(dir), CLIENT_NAME));
1119 case util::LockResult::Success: return true;
1120 } // no default case, so the compiler can warn about missing cases
1121 assert(false);
1122}
1123static bool LockDirectories(bool probeOnly)
1124{
1125 return LockDirectory(gArgs.GetDataDirNet(), probeOnly) && \
1126 LockDirectory(gArgs.GetBlocksDirPath(), probeOnly);
1127}
1128
1130{
1131 // ********************************************************* Step 4: sanity checks
1132 auto result{kernel::SanityChecks(kernel)};
1133 if (!result) {
1135 return InitError(strprintf(_("Initialization sanity check failed. %s is shutting down."), CLIENT_NAME));
1136 }
1137
1138 if (!ECC_InitSanityCheck()) {
1139 return InitError(strprintf(_("Elliptic curve cryptography sanity check failure. %s is shutting down."), CLIENT_NAME));
1140 }
1141
1142 // Probe the directory locks to give an early error message, if possible
1143 // We cannot hold the directory locks here, as the forking for daemon() hasn't yet happened,
1144 // and a fork will cause weird behavior to them.
1145 return LockDirectories(true);
1146}
1147
1149{
1150 // After daemonization get the directory locks again and hold on to them until exit
1151 // This creates a slight window for a race condition to happen, however this condition is harmless: it
1152 // will at most make us exit without printing a message to console.
1153 if (!LockDirectories(false)) {
1154 // Detailed error printed inside LockDirectory
1155 return false;
1156 }
1157 return true;
1158}
1159
1161{
1162 node.chain = node.init->makeChain();
1163 node.mining = node.init->makeMining();
1164 return true;
1165}
1166
1168 for (const std::string port_option : {
1169 "-port",
1170 "-rpcport",
1171 }) {
1172 if (const auto port{args.GetArg(port_option)}) {
1173 const auto n{ToIntegral<uint16_t>(*port)};
1174 if (!n || *n == 0) {
1175 return InitError(InvalidPortErrMsg(port_option, *port));
1176 }
1177 }
1178 }
1179
1180 for ([[maybe_unused]] const auto& [param_name, unix, suffix_allowed] : std::vector<std::tuple<std::string, bool, bool>>{
1181 // arg name UNIX socket support =suffix allowed
1182 {"-i2psam", false, false},
1183 {"-onion", true, false},
1184 {"-proxy", true, true},
1185 {"-bind", false, true},
1186 {"-rpcbind", false, false},
1187 {"-torcontrol", false, false},
1188 {"-whitebind", false, false},
1189 {"-zmqpubhashblock", true, false},
1190 {"-zmqpubhashtx", true, false},
1191 {"-zmqpubrawblock", true, false},
1192 {"-zmqpubrawtx", true, false},
1193 {"-zmqpubsequence", true, false},
1194 }) {
1195 for (const std::string& param_value : args.GetArgs(param_name)) {
1196 const std::string param_value_hostport{
1197 suffix_allowed ? param_value.substr(0, param_value.rfind('=')) : param_value};
1198 std::string host_out;
1199 uint16_t port_out{0};
1200 if (!SplitHostPort(param_value_hostport, port_out, host_out)) {
1201#ifdef HAVE_SOCKADDR_UN
1202 // Allow unix domain sockets for some options e.g. unix:/some/file/path
1203 if (!unix || !param_value.starts_with(ADDR_PREFIX_UNIX)) {
1204 return InitError(InvalidPortErrMsg(param_name, param_value));
1205 }
1206#else
1207 return InitError(InvalidPortErrMsg(param_name, param_value));
1208#endif
1209 }
1210 }
1211 }
1212
1213 return true;
1214}
1215
1216// A GUI user may opt to retry once with do_reindex set if there is a failure during chainstate initialization.
1217// The function therefore has to support re-entry.
1220 bool do_reindex,
1221 const bool do_reindex_chainstate,
1222 const kernel::CacheSizes& cache_sizes,
1223 const ArgsManager& args)
1224{
1225 const CChainParams& chainparams = Params();
1226 CTxMemPool::Options mempool_opts{
1227 .check_ratio = chainparams.DefaultConsistencyChecks() ? 1 : 0,
1228 .signals = node.validation_signals.get(),
1229 };
1230 Assert(ApplyArgsManOptions(args, chainparams, mempool_opts)); // no error can happen, already checked in AppInitParameterInteraction
1231 bilingual_str mempool_error;
1232 node.mempool = std::make_unique<CTxMemPool>(mempool_opts, mempool_error);
1233 if (!mempool_error.empty()) {
1234 return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
1235 }
1236 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));
1237 ChainstateManager::Options chainman_opts{
1238 .chainparams = chainparams,
1239 .datadir = args.GetDataDirNet(),
1240 .notifications = *node.notifications,
1241 .signals = node.validation_signals.get(),
1242 };
1243 Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1244
1245 BlockManager::Options blockman_opts{
1246 .chainparams = chainman_opts.chainparams,
1247 .blocks_dir = args.GetBlocksDirPath(),
1248 .notifications = chainman_opts.notifications,
1249 .block_tree_db_params = DBParams{
1250 .path = args.GetDataDirNet() / "blocks" / "index",
1251 .cache_bytes = cache_sizes.block_tree_db,
1252 .wipe_data = do_reindex,
1253 },
1254 };
1255 Assert(ApplyArgsManOptions(args, blockman_opts)); // no error can happen, already checked in AppInitParameterInteraction
1256
1257 // Creating the chainstate manager internally creates a BlockManager, opens
1258 // the blocks tree db, and wipes existing block files in case of a reindex.
1259 // The coinsdb is opened at a later point on LoadChainstate.
1260 try {
1261 node.chainman = std::make_unique<ChainstateManager>(*Assert(node.shutdown_signal), chainman_opts, blockman_opts);
1262 } catch (dbwrapper_error& e) {
1263 LogError("%s", e.what());
1264 return {ChainstateLoadStatus::FAILURE, _("Error opening block database")};
1265 } catch (std::exception& e) {
1266 return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated(strprintf("Failed to initialize ChainstateManager: %s", e.what()))};
1267 }
1268 ChainstateManager& chainman = *node.chainman;
1269 if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
1270
1271 // This is defined and set here instead of inline in validation.h to avoid a hard
1272 // dependency between validation and index/base, since the latter is not in
1273 // libbitcoinkernel.
1274 chainman.snapshot_download_completed = [&node]() {
1275 if (!node.chainman->m_blockman.IsPruneMode()) {
1276 LogPrintf("[snapshot] re-enabling NODE_NETWORK services\n");
1277 node.connman->AddLocalServices(NODE_NETWORK);
1278 }
1279 LogPrintf("[snapshot] restarting indexes\n");
1280 // Drain the validation interface queue to ensure that the old indexes
1281 // don't have any pending work.
1282 Assert(node.validation_signals)->SyncWithValidationInterfaceQueue();
1283 for (auto* index : node.indexes) {
1284 index->Interrupt();
1285 index->Stop();
1286 if (!(index->Init() && index->StartBackgroundSync())) {
1287 LogPrintf("[snapshot] WARNING failed to restart index %s on snapshot chain\n", index->GetName());
1288 }
1289 }
1290 };
1292 options.mempool = Assert(node.mempool.get());
1293 options.wipe_chainstate_db = do_reindex || do_reindex_chainstate;
1294 options.prune = chainman.m_blockman.IsPruneMode();
1295 options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
1296 options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
1297 options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
1298 options.coins_error_cb = [] {
1299 uiInterface.ThreadSafeMessageBox(
1300 _("Error reading from database, shutting down."),
1302 };
1303 uiInterface.InitMessage(_("Loading block index…"));
1304 auto catch_exceptions = [](auto&& f) -> ChainstateLoadResult {
1305 try {
1306 return f();
1307 } catch (const std::exception& e) {
1308 LogError("%s\n", e.what());
1309 return std::make_tuple(node::ChainstateLoadStatus::FAILURE, _("Error loading databases"));
1310 }
1311 };
1312 auto [status, error] = catch_exceptions([&] { return LoadChainstate(chainman, cache_sizes, options); });
1314 uiInterface.InitMessage(_("Verifying blocks…"));
1315 if (chainman.m_blockman.m_have_pruned && options.check_blocks > MIN_BLOCKS_TO_KEEP) {
1316 LogWarning("pruned datadir may not have more than %d blocks; only checking available blocks\n",
1318 }
1319 std::tie(status, error) = catch_exceptions([&] { return VerifyLoadedChainstate(chainman, options); });
1321 LogInfo("Block index and chainstate loaded");
1322 }
1323 }
1324 return {status, error};
1325};
1326
1328{
1329 const ArgsManager& args = *Assert(node.args);
1330 const CChainParams& chainparams = Params();
1331
1332 auto opt_max_upload = ParseByteUnits(args.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET), ByteUnit::M);
1333 if (!opt_max_upload) {
1334 return InitError(strprintf(_("Unable to parse -maxuploadtarget: '%s'"), args.GetArg("-maxuploadtarget", "")));
1335 }
1336
1337 // ********************************************************* Step 4a: application initialization
1338 if (!CreatePidFile(args)) {
1339 // Detailed error printed inside CreatePidFile().
1340 return false;
1341 }
1342 if (!init::StartLogging(args)) {
1343 // Detailed error printed inside StartLogging().
1344 return false;
1345 }
1346
1347 LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, available_fds);
1348
1349 // Warn about relative -datadir path.
1350 if (args.IsArgSet("-datadir") && !args.GetPathArg("-datadir").is_absolute()) {
1351 LogPrintf("Warning: relative datadir option '%s' specified, which will be interpreted relative to the "
1352 "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1353 "from a different location, it will be unable to locate the current data files. There could "
1354 "also be data loss if bitcoin is started while in a temporary directory.\n",
1355 args.GetArg("-datadir", ""), fs::PathToString(fs::current_path()));
1356 }
1357
1358 assert(!node.scheduler);
1359 node.scheduler = std::make_unique<CScheduler>();
1360 auto& scheduler = *node.scheduler;
1361
1362 // Start the lightweight task scheduler thread
1363 scheduler.m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { scheduler.serviceQueue(); });
1364
1365 // Gather some entropy once per minute.
1366 scheduler.scheduleEvery([]{
1368 }, std::chrono::minutes{1});
1369
1370 // Check disk space every 5 minutes to avoid db corruption.
1371 scheduler.scheduleEvery([&args, &node]{
1372 constexpr uint64_t min_disk_space = 50 << 20; // 50 MB
1373 if (!CheckDiskSpace(args.GetBlocksDirPath(), min_disk_space)) {
1374 LogError("Shutting down due to lack of disk space!\n");
1375 if (!(Assert(node.shutdown_request))()) {
1376 LogError("Failed to send shutdown signal after disk space check\n");
1377 }
1378 }
1379 }, std::chrono::minutes{5});
1380
1381 assert(!node.validation_signals);
1382 node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler));
1383 auto& validation_signals = *node.validation_signals;
1384
1385 // Create client interfaces for wallets that are supposed to be loaded
1386 // according to -wallet and -disablewallet options. This only constructs
1387 // the interfaces, it doesn't load wallet data. Wallets actually get loaded
1388 // when load() and start() interface methods are called below.
1390 uiInterface.InitWallet();
1391
1392 if (interfaces::Ipc* ipc = node.init->ipc()) {
1393 for (std::string address : gArgs.GetArgs("-ipcbind")) {
1394 try {
1395 ipc->listenAddress(address);
1396 } catch (const std::exception& e) {
1397 return InitError(Untranslated(strprintf("Unable to bind to IPC address '%s'. %s", address, e.what())));
1398 }
1399 LogPrintf("Listening for IPC requests on address %s\n", address);
1400 }
1401 }
1402
1403 /* Register RPC commands regardless of -server setting so they will be
1404 * available in the GUI RPC console even if external calls are disabled.
1405 */
1407 for (const auto& client : node.chain_clients) {
1408 client->registerRpcs();
1409 }
1410#ifdef ENABLE_ZMQ
1412#endif
1413
1414 // Check port numbers
1415 if (!CheckHostPortOptions(args)) return false;
1416
1417 // Configure reachable networks before we start the RPC server.
1418 // This is necessary for -rpcallowip to distinguish CJDNS from other RFC4193
1419 const auto onlynets = args.GetArgs("-onlynet");
1420 if (!onlynets.empty()) {
1422 for (const std::string& snet : onlynets) {
1423 enum Network net = ParseNetwork(snet);
1424 if (net == NET_UNROUTABLE)
1425 return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
1426 g_reachable_nets.Add(net);
1427 }
1428 }
1429
1430 if (!args.IsArgSet("-cjdnsreachable")) {
1431 if (!onlynets.empty() && g_reachable_nets.Contains(NET_CJDNS)) {
1432 return InitError(
1433 _("Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1434 "-cjdnsreachable is not provided"));
1435 }
1437 }
1438 // Now g_reachable_nets.Contains(NET_CJDNS) is true if:
1439 // 1. -cjdnsreachable is given and
1440 // 2.1. -onlynet is not given or
1441 // 2.2. -onlynet=cjdns is given
1442
1443 /* Start the RPC server already. It will be started in "warmup" mode
1444 * and not really process calls already (but it will signify connections
1445 * that the server is there and will be ready later). Warmup mode will
1446 * be disabled when initialisation is finished.
1447 */
1448 if (args.GetBoolArg("-server", false)) {
1449 uiInterface.InitMessage_connect(SetRPCWarmupStatus);
1450 if (!AppInitServers(node))
1451 return InitError(_("Unable to start HTTP server. See debug log for details."));
1452 }
1453
1454 // ********************************************************* Step 5: verify wallet database integrity
1455 for (const auto& client : node.chain_clients) {
1456 if (!client->verify()) {
1457 return false;
1458 }
1459 }
1460
1461 // ********************************************************* Step 6: network initialization
1462 // Note that we absolutely cannot open any actual connections
1463 // until the very end ("start node") as the UTXO/block state
1464 // is not yet setup and may end up being set up twice if we
1465 // need to reindex later.
1466
1467 fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
1468 fDiscover = args.GetBoolArg("-discover", true);
1469
1470 PeerManager::Options peerman_opts{};
1471 ApplyArgsManOptions(args, peerman_opts);
1472
1473 {
1474
1475 // Read asmap file if configured
1476 std::vector<bool> asmap;
1477 if (args.IsArgSet("-asmap") && !args.IsArgNegated("-asmap")) {
1478 fs::path asmap_path = args.GetPathArg("-asmap", DEFAULT_ASMAP_FILENAME);
1479 if (!asmap_path.is_absolute()) {
1480 asmap_path = args.GetDataDirNet() / asmap_path;
1481 }
1482 if (!fs::exists(asmap_path)) {
1483 InitError(strprintf(_("Could not find asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1484 return false;
1485 }
1486 asmap = DecodeAsmap(asmap_path);
1487 if (asmap.size() == 0) {
1488 InitError(strprintf(_("Could not parse asmap file %s"), fs::quoted(fs::PathToString(asmap_path))));
1489 return false;
1490 }
1491 const uint256 asmap_version = (HashWriter{} << asmap).GetHash();
1492 LogPrintf("Using asmap version %s for IP bucketing\n", asmap_version.ToString());
1493 } else {
1494 LogPrintf("Using /16 prefix for IP bucketing\n");
1495 }
1496
1497 // Initialize netgroup manager
1498 assert(!node.netgroupman);
1499 node.netgroupman = std::make_unique<NetGroupManager>(std::move(asmap));
1500
1501 // Initialize addrman
1502 assert(!node.addrman);
1503 uiInterface.InitMessage(_("Loading P2P addresses…"));
1504 auto addrman{LoadAddrman(*node.netgroupman, args)};
1505 if (!addrman) return InitError(util::ErrorString(addrman));
1506 node.addrman = std::move(*addrman);
1507 }
1508
1510 assert(!node.banman);
1511 node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
1512 assert(!node.connman);
1513 node.connman = std::make_unique<CConnman>(rng.rand64(),
1514 rng.rand64(),
1515 *node.addrman, *node.netgroupman, chainparams, args.GetBoolArg("-networkactive", true));
1516
1517 assert(!node.fee_estimator);
1518 // Don't initialize fee estimation with old data if we don't relay transactions,
1519 // as they would never get updated.
1520 if (!peerman_opts.ignore_incoming_txs) {
1521 bool read_stale_estimates = args.GetBoolArg("-acceptstalefeeestimates", DEFAULT_ACCEPT_STALE_FEE_ESTIMATES);
1522 if (read_stale_estimates && (chainparams.GetChainType() != ChainType::REGTEST)) {
1523 return InitError(strprintf(_("acceptstalefeeestimates is not supported on %s chain."), chainparams.GetChainTypeString()));
1524 }
1525 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(FeeestPath(args), read_stale_estimates);
1526
1527 // Flush estimates to disk periodically
1528 CBlockPolicyEstimator* fee_estimator = node.fee_estimator.get();
1529 scheduler.scheduleEvery([fee_estimator] { fee_estimator->FlushFeeEstimates(); }, FEE_FLUSH_INTERVAL);
1530 validation_signals.RegisterValidationInterface(fee_estimator);
1531 }
1532
1533 for (const std::string& socket_addr : args.GetArgs("-bind")) {
1534 std::string host_out;
1535 uint16_t port_out{0};
1536 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind('='));
1537 if (!SplitHostPort(bind_socket_addr, port_out, host_out)) {
1538 return InitError(InvalidPortErrMsg("-bind", socket_addr));
1539 }
1540 }
1541
1542 // sanitize comments per BIP-0014, format user agent and check total size
1543 std::vector<std::string> uacomments;
1544 for (const std::string& cmt : args.GetArgs("-uacomment")) {
1545 if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT))
1546 return InitError(strprintf(_("User Agent comment (%s) contains unsafe characters."), cmt));
1547 uacomments.push_back(cmt);
1548 }
1550 if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
1551 return InitError(strprintf(_("Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1553 }
1554
1555 // Requesting DNS seeds entails connecting to IPv4/IPv6, which -onlynet options may prohibit:
1556 // If -dnsseed=1 is explicitly specified, abort. If it's left unspecified by the user, we skip
1557 // the DNS seeds by adjusting -dnsseed in InitParameterInteraction.
1559 return InitError(strprintf(_("Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1560 };
1561
1562 // Check for host lookup allowed before parsing any network related parameters
1564
1565 bool proxyRandomize = args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
1566 // -proxy sets a proxy for outgoing network traffic, possibly per network.
1567 // -noproxy, -proxy=0 or -proxy="" can be used to remove the proxy setting, this is the default
1568 Proxy ipv4_proxy;
1569 Proxy ipv6_proxy;
1570 Proxy onion_proxy;
1571 Proxy name_proxy;
1572 Proxy cjdns_proxy;
1573 for (const std::string& param_value : args.GetArgs("-proxy")) {
1574 const auto eq_pos{param_value.rfind('=')};
1575 const std::string proxy_str{param_value.substr(0, eq_pos)}; // e.g. 127.0.0.1:9050=ipv4 -> 127.0.0.1:9050
1576 std::string net_str;
1577 if (eq_pos != std::string::npos) {
1578 if (eq_pos + 1 == param_value.length()) {
1579 return InitError(strprintf(_("Invalid -proxy address or hostname, ends with '=': '%s'"), param_value));
1580 }
1581 net_str = ToLower(param_value.substr(eq_pos + 1)); // e.g. 127.0.0.1:9050=ipv4 -> ipv4
1582 }
1583
1584 Proxy proxy;
1585 if (!proxy_str.empty() && proxy_str != "0") {
1586 if (IsUnixSocketPath(proxy_str)) {
1587 proxy = Proxy{proxy_str, /*tor_stream_isolation=*/proxyRandomize};
1588 } else {
1589 const std::optional<CService> addr{Lookup(proxy_str, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1590 if (!addr.has_value()) {
1591 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1592 }
1593 proxy = Proxy{addr.value(), /*tor_stream_isolation=*/proxyRandomize};
1594 }
1595 if (!proxy.IsValid()) {
1596 return InitError(strprintf(_("Invalid -proxy address or hostname: '%s'"), proxy_str));
1597 }
1598 }
1599
1600 if (net_str.empty()) { // For all networks.
1601 ipv4_proxy = ipv6_proxy = name_proxy = cjdns_proxy = onion_proxy = proxy;
1602 } else if (net_str == "ipv4") {
1603 ipv4_proxy = name_proxy = proxy;
1604 } else if (net_str == "ipv6") {
1605 ipv6_proxy = name_proxy = proxy;
1606 } else if (net_str == "tor" || net_str == "onion") {
1607 onion_proxy = proxy;
1608 } else if (net_str == "cjdns") {
1609 cjdns_proxy = proxy;
1610 } else {
1611 return InitError(strprintf(_("Unrecognized network in -proxy='%s': '%s'"), param_value, net_str));
1612 }
1613 }
1614 if (ipv4_proxy.IsValid()) {
1615 SetProxy(NET_IPV4, ipv4_proxy);
1616 }
1617 if (ipv6_proxy.IsValid()) {
1618 SetProxy(NET_IPV6, ipv6_proxy);
1619 }
1620 if (name_proxy.IsValid()) {
1621 SetNameProxy(name_proxy);
1622 }
1623 if (cjdns_proxy.IsValid()) {
1624 SetProxy(NET_CJDNS, cjdns_proxy);
1625 }
1626
1627 const bool onlynet_used_with_onion{!onlynets.empty() && g_reachable_nets.Contains(NET_ONION)};
1628
1629 // -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
1630 // -noonion (or -onion=0) disables connecting to .onion entirely
1631 // An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
1632 std::string onionArg = args.GetArg("-onion", "");
1633 if (onionArg != "") {
1634 if (onionArg == "0") { // Handle -noonion/-onion=0
1635 onion_proxy = Proxy{};
1636 if (onlynet_used_with_onion) {
1637 return InitError(
1638 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1639 "reaching the Tor network is explicitly forbidden: -onion=0"));
1640 }
1641 } else {
1642 if (IsUnixSocketPath(onionArg)) {
1643 onion_proxy = Proxy(onionArg, /*tor_stream_isolation=*/proxyRandomize);
1644 } else {
1645 const std::optional<CService> addr{Lookup(onionArg, DEFAULT_TOR_SOCKS_PORT, fNameLookup)};
1646 if (!addr.has_value() || !addr->IsValid()) {
1647 return InitError(strprintf(_("Invalid -onion address or hostname: '%s'"), onionArg));
1648 }
1649
1650 onion_proxy = Proxy(addr.value(), /*tor_stream_isolation=*/proxyRandomize);
1651 }
1652 }
1653 }
1654
1655 if (onion_proxy.IsValid()) {
1656 SetProxy(NET_ONION, onion_proxy);
1657 } else {
1658 // If -listenonion is set, then we will (try to) connect to the Tor control port
1659 // later from the torcontrol thread and may retrieve the onion proxy from there.
1660 const bool listenonion_disabled{!args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)};
1661 if (onlynet_used_with_onion && listenonion_disabled) {
1662 return InitError(
1663 _("Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1664 "reaching the Tor network is not provided: none of -proxy, -onion or "
1665 "-listenonion is given"));
1666 }
1668 }
1669
1670 for (const std::string& strAddr : args.GetArgs("-externalip")) {
1671 const std::optional<CService> addrLocal{Lookup(strAddr, GetListenPort(), fNameLookup)};
1672 if (addrLocal.has_value() && addrLocal->IsValid())
1673 AddLocal(addrLocal.value(), LOCAL_MANUAL);
1674 else
1675 return InitError(ResolveErrMsg("externalip", strAddr));
1676 }
1677
1678#ifdef ENABLE_ZMQ
1680 [&chainman = node.chainman](std::vector<std::byte>& block, const CBlockIndex& index) {
1681 assert(chainman);
1682 return chainman->m_blockman.ReadRawBlock(block, WITH_LOCK(cs_main, return index.GetBlockPos()));
1683 });
1684
1686 validation_signals.RegisterValidationInterface(g_zmq_notification_interface.get());
1687 }
1688#endif
1689
1690 // ********************************************************* Step 7: load block chain
1691
1692 node.notifications = std::make_unique<KernelNotifications>(Assert(node.shutdown_request), node.exit_status, *Assert(node.warnings));
1693 auto& kernel_notifications{*node.notifications};
1694 ReadNotificationArgs(args, kernel_notifications);
1695
1696 // cache size calculations
1697 const auto [index_cache_sizes, kernel_cache_sizes] = CalculateCacheSizes(args, g_enabled_filter_types.size());
1698
1699 LogInfo("Cache configuration:");
1700 LogInfo("* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
1701 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1702 LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index * (1.0 / 1024 / 1024));
1703 }
1704 for (BlockFilterType filter_type : g_enabled_filter_types) {
1705 LogInfo("* Using %.1f MiB for %s block filter index database",
1706 index_cache_sizes.filter_index * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type));
1707 }
1708 LogInfo("* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db * (1.0 / 1024 / 1024));
1709
1710 assert(!node.mempool);
1711 assert(!node.chainman);
1712
1713 bool do_reindex{args.GetBoolArg("-reindex", false)};
1714 const bool do_reindex_chainstate{args.GetBoolArg("-reindex-chainstate", false)};
1715
1716 // Chainstate initialization and loading may be retried once with reindexing by GUI users
1717 auto [status, error] = InitAndLoadChainstate(
1718 node,
1719 do_reindex,
1720 do_reindex_chainstate,
1721 kernel_cache_sizes,
1722 args);
1723 if (status == ChainstateLoadStatus::FAILURE && !do_reindex && !ShutdownRequested(node)) {
1724 // suggest a reindex
1725 bool do_retry = uiInterface.ThreadSafeQuestion(
1726 error + Untranslated(".\n\n") + _("Do you want to rebuild the databases now?"),
1727 error.original + ".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1729 if (!do_retry) {
1730 return false;
1731 }
1732 do_reindex = true;
1733 if (!Assert(node.shutdown_signal)->reset()) {
1734 LogError("Internal error: failed to reset shutdown signal.\n");
1735 }
1736 std::tie(status, error) = InitAndLoadChainstate(
1737 node,
1738 do_reindex,
1739 do_reindex_chainstate,
1740 kernel_cache_sizes,
1741 args);
1742 }
1743 if (status != ChainstateLoadStatus::SUCCESS && status != ChainstateLoadStatus::INTERRUPTED) {
1744 return InitError(error);
1745 }
1746
1747 // As LoadBlockIndex can take several minutes, it's possible the user
1748 // requested to kill the GUI during the last operation. If so, exit.
1749 if (ShutdownRequested(node)) {
1750 LogPrintf("Shutdown requested. Exiting.\n");
1751 return false;
1752 }
1753
1754 ChainstateManager& chainman = *Assert(node.chainman);
1755
1756 assert(!node.peerman);
1757 node.peerman = PeerManager::make(*node.connman, *node.addrman,
1758 node.banman.get(), chainman,
1759 *node.mempool, *node.warnings,
1760 peerman_opts);
1761 validation_signals.RegisterValidationInterface(node.peerman.get());
1762
1763 // ********************************************************* Step 8: start indexers
1764
1765 if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
1766 g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), index_cache_sizes.tx_index, false, do_reindex);
1767 node.indexes.emplace_back(g_txindex.get());
1768 }
1769
1770 for (const auto& filter_type : g_enabled_filter_types) {
1771 InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, index_cache_sizes.filter_index, false, do_reindex);
1772 node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
1773 }
1774
1775 if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
1776 g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, do_reindex);
1777 node.indexes.emplace_back(g_coin_stats_index.get());
1778 }
1779
1780 // Init indexes
1781 for (auto index : node.indexes) if (!index->Init()) return false;
1782
1783 // ********************************************************* Step 9: load wallet
1784 for (const auto& client : node.chain_clients) {
1785 if (!client->load()) {
1786 return false;
1787 }
1788 }
1789
1790 // ********************************************************* Step 10: data directory maintenance
1791
1792 // if pruning, perform the initial blockstore prune
1793 // after any wallet rescanning has taken place.
1794 if (chainman.m_blockman.IsPruneMode()) {
1795 if (chainman.m_blockman.m_blockfiles_indexed) {
1796 LOCK(cs_main);
1797 for (Chainstate* chainstate : chainman.GetAll()) {
1798 uiInterface.InitMessage(_("Pruning blockstore…"));
1799 chainstate->PruneAndFlush();
1800 }
1801 }
1802 } else {
1803 // Prior to setting NODE_NETWORK, check if we can provide historical blocks.
1804 if (!WITH_LOCK(chainman.GetMutex(), return chainman.BackgroundSyncInProgress())) {
1805 LogPrintf("Setting NODE_NETWORK on non-prune mode\n");
1806 g_local_services = ServiceFlags(g_local_services | NODE_NETWORK);
1807 } else {
1808 LogPrintf("Running node in NODE_NETWORK_LIMITED mode until snapshot background sync completes\n");
1809 }
1810 }
1811
1812 // ********************************************************* Step 11: import blocks
1813
1815 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetDataDirNet()))));
1816 return false;
1817 }
1819 InitError(strprintf(_("Error: Disk space is low for %s"), fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
1820 return false;
1821 }
1822
1823 int chain_active_height = WITH_LOCK(cs_main, return chainman.ActiveChain().Height());
1824
1825 // On first startup, warn on low block storage space
1826 if (!do_reindex && !do_reindex_chainstate && chain_active_height <= 1) {
1827 uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1024 * 1024 * 1024};
1828 uint64_t additional_bytes_needed{
1829 chainman.m_blockman.IsPruneMode() ?
1830 std::min(chainman.m_blockman.GetPruneTarget(), assumed_chain_bytes) :
1831 assumed_chain_bytes};
1832
1833 if (!CheckDiskSpace(args.GetBlocksDirPath(), additional_bytes_needed)) {
1835 "Disk space for %s may not accommodate the block files. " \
1836 "Approximately %u GB of data will be stored in this directory."
1837 ),
1839 chainparams.AssumedBlockchainSize()
1840 ));
1841 }
1842 }
1843
1844#if HAVE_SYSTEM
1845 const std::string block_notify = args.GetArg("-blocknotify", "");
1846 if (!block_notify.empty()) {
1847 uiInterface.NotifyBlockTip_connect([block_notify](SynchronizationState sync_state, const CBlockIndex& block, double /* verification_progress */) {
1848 if (sync_state != SynchronizationState::POST_INIT) return;
1849 std::string command = block_notify;
1850 ReplaceAll(command, "%s", block.GetBlockHash().GetHex());
1851 std::thread t(runCommand, command);
1852 t.detach(); // thread runs free
1853 });
1854 }
1855#endif
1856
1857 std::vector<fs::path> vImportFiles;
1858 for (const std::string& strFile : args.GetArgs("-loadblock")) {
1859 vImportFiles.push_back(fs::PathFromString(strFile));
1860 }
1861
1862 node.background_init_thread = std::thread(&util::TraceThread, "initload", [=, &chainman, &args, &node] {
1864 // Import blocks and ActivateBestChain()
1865 ImportBlocks(chainman, vImportFiles);
1866 if (args.GetBoolArg("-stopafterblockimport", DEFAULT_STOPAFTERBLOCKIMPORT)) {
1867 LogPrintf("Stopping after block import\n");
1868 if (!(Assert(node.shutdown_request))()) {
1869 LogError("Failed to send shutdown signal after finishing block import\n");
1870 }
1871 return;
1872 }
1873
1874 // Start indexes initial sync
1876 bilingual_str err_str = _("Failed to start indexes, shutting down…");
1877 chainman.GetNotifications().fatalError(err_str);
1878 return;
1879 }
1880 // Load mempool from disk
1881 if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
1882 LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
1883 pool->SetLoadTried(!chainman.m_interrupt);
1884 }
1885 });
1886
1887 /*
1888 * Wait for genesis block to be processed. Typically kernel_notifications.m_tip_block
1889 * has already been set by a call to LoadChainTip() in CompleteChainstateInitialization().
1890 * But this is skipped if the chainstate doesn't exist yet or is being wiped:
1891 *
1892 * 1. first startup with an empty datadir
1893 * 2. reindex
1894 * 3. reindex-chainstate
1895 *
1896 * In these case it's connected by a call to ActivateBestChain() in the initload thread.
1897 */
1898 {
1899 WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
1900 kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
1901 return kernel_notifications.TipBlock() || ShutdownRequested(node);
1902 });
1903 }
1904
1905 if (ShutdownRequested(node)) {
1906 return false;
1907 }
1908
1909 // ********************************************************* Step 12: start node
1910
1911 int64_t best_block_time{};
1912 {
1913 LOCK(chainman.GetMutex());
1914 const auto& tip{*Assert(chainman.ActiveTip())};
1915 LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
1916 chain_active_height = tip.nHeight;
1917 best_block_time = tip.GetBlockTime();
1918 if (tip_info) {
1919 tip_info->block_height = chain_active_height;
1920 tip_info->block_time = best_block_time;
1921 tip_info->verification_progress = chainman.GuessVerificationProgress(&tip);
1922 }
1923 if (tip_info && chainman.m_best_header) {
1924 tip_info->header_height = chainman.m_best_header->nHeight;
1925 tip_info->header_time = chainman.m_best_header->GetBlockTime();
1926 }
1927 }
1928 LogPrintf("nBestHeight = %d\n", chain_active_height);
1929 if (node.peerman) node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time});
1930
1931 // Map ports with NAT-PMP
1933
1934 CConnman::Options connOptions;
1935 connOptions.m_local_services = g_local_services;
1936 connOptions.m_max_automatic_connections = nMaxConnections;
1937 connOptions.uiInterface = &uiInterface;
1938 connOptions.m_banman = node.banman.get();
1939 connOptions.m_msgproc = node.peerman.get();
1940 connOptions.nSendBufferMaxSize = 1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
1941 connOptions.nReceiveFloodSize = 1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
1942 connOptions.m_added_nodes = args.GetArgs("-addnode");
1943 connOptions.nMaxOutboundLimit = *opt_max_upload;
1944 connOptions.m_peer_connect_timeout = peer_connect_timeout;
1945 connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
1946 connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
1947
1948 // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
1949 const uint16_t default_bind_port =
1950 static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));
1951
1952 const uint16_t default_bind_port_onion = default_bind_port + 1;
1953
1954 const auto BadPortWarning = [](const char* prefix, uint16_t port) {
1955 return strprintf(_("%s request to listen on port %u. This port is considered \"bad\" and "
1956 "thus it is unlikely that any peer will connect to it. See "
1957 "doc/p2p-bad-ports.md for details and a full list."),
1958 prefix,
1959 port);
1960 };
1961
1962 for (const std::string& bind_arg : args.GetArgs("-bind")) {
1963 std::optional<CService> bind_addr;
1964 const size_t index = bind_arg.rfind('=');
1965 if (index == std::string::npos) {
1966 bind_addr = Lookup(bind_arg, default_bind_port, /*fAllowLookup=*/false);
1967 if (bind_addr.has_value()) {
1968 connOptions.vBinds.push_back(bind_addr.value());
1969 if (IsBadPort(bind_addr.value().GetPort())) {
1970 InitWarning(BadPortWarning("-bind", bind_addr.value().GetPort()));
1971 }
1972 continue;
1973 }
1974 } else {
1975 const std::string network_type = bind_arg.substr(index + 1);
1976 if (network_type == "onion") {
1977 const std::string truncated_bind_arg = bind_arg.substr(0, index);
1978 bind_addr = Lookup(truncated_bind_arg, default_bind_port_onion, false);
1979 if (bind_addr.has_value()) {
1980 connOptions.onion_binds.push_back(bind_addr.value());
1981 continue;
1982 }
1983 }
1984 }
1985 return InitError(ResolveErrMsg("bind", bind_arg));
1986 }
1987
1988 for (const std::string& strBind : args.GetArgs("-whitebind")) {
1989 NetWhitebindPermissions whitebind;
1990 bilingual_str error;
1991 if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
1992 connOptions.vWhiteBinds.push_back(whitebind);
1993 }
1994
1995 // If the user did not specify -bind= or -whitebind= then we bind
1996 // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
1997 connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
1998
1999 // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not
2000 // given, because if they are, then -port= is ignored.
2001 if (connOptions.bind_on_any && args.IsArgSet("-port")) {
2002 const uint16_t port_arg = args.GetIntArg("-port", 0);
2003 if (IsBadPort(port_arg)) {
2004 InitWarning(BadPortWarning("-port", port_arg));
2005 }
2006 }
2007
2008 CService onion_service_target;
2009 if (!connOptions.onion_binds.empty()) {
2010 onion_service_target = connOptions.onion_binds.front();
2011 } else if (!connOptions.vBinds.empty()) {
2012 onion_service_target = connOptions.vBinds.front();
2013 } else {
2014 onion_service_target = DefaultOnionServiceTarget(default_bind_port_onion);
2015 connOptions.onion_binds.push_back(onion_service_target);
2016 }
2017
2018 if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
2019 if (connOptions.onion_binds.size() > 1) {
2020 InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
2021 "for the automatically created Tor onion service."),
2022 onion_service_target.ToStringAddrPort()));
2023 }
2024 StartTorControl(onion_service_target);
2025 }
2026
2027 if (connOptions.bind_on_any) {
2028 // Only add all IP addresses of the machine if we would be listening on
2029 // any address - 0.0.0.0 (IPv4) and :: (IPv6).
2030 Discover();
2031 }
2032
2033 for (const auto& net : args.GetArgs("-whitelist")) {
2035 ConnectionDirection connection_direction;
2036 bilingual_str error;
2037 if (!NetWhitelistPermissions::TryParse(net, subnet, connection_direction, error)) return InitError(error);
2038 if (connection_direction & ConnectionDirection::In) {
2039 connOptions.vWhitelistedRangeIncoming.push_back(subnet);
2040 }
2041 if (connection_direction & ConnectionDirection::Out) {
2042 connOptions.vWhitelistedRangeOutgoing.push_back(subnet);
2043 }
2044 }
2045
2046 connOptions.vSeedNodes = args.GetArgs("-seednode");
2047
2048 const auto connect = args.GetArgs("-connect");
2049 if (!connect.empty() || args.IsArgNegated("-connect")) {
2050 // Do not initiate other outgoing connections when connecting to trusted
2051 // nodes, or when -noconnect is specified.
2052 connOptions.m_use_addrman_outgoing = false;
2053
2054 if (connect.size() != 1 || connect[0] != "0") {
2055 connOptions.m_specified_outgoing = connect;
2056 }
2057 if (!connOptions.m_specified_outgoing.empty() && !connOptions.vSeedNodes.empty()) {
2058 LogPrintf("-seednode is ignored when -connect is used\n");
2059 }
2060
2061 if (args.IsArgSet("-dnsseed") && args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED) && args.IsArgSet("-proxy")) {
2062 LogPrintf("-dnsseed is ignored when -connect is used and -proxy is specified\n");
2063 }
2064 }
2065
2066 const std::string& i2psam_arg = args.GetArg("-i2psam", "");
2067 if (!i2psam_arg.empty()) {
2068 const std::optional<CService> addr{Lookup(i2psam_arg, 7656, fNameLookup)};
2069 if (!addr.has_value() || !addr->IsValid()) {
2070 return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
2071 }
2072 SetProxy(NET_I2P, Proxy{addr.value()});
2073 } else {
2074 if (!onlynets.empty() && g_reachable_nets.Contains(NET_I2P)) {
2075 return InitError(
2076 _("Outbound connections restricted to i2p (-onlynet=i2p) but "
2077 "-i2psam is not provided"));
2078 }
2080 }
2081
2082 connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING);
2083
2084 if (!node.connman->Start(scheduler, connOptions)) {
2085 return false;
2086 }
2087
2088 // ********************************************************* Step 13: finished
2089
2090 // At this point, the RPC is "started", but still in warmup, which means it
2091 // cannot yet be called. Before we make it callable, we need to make sure
2092 // that the RPC's view of the best block is valid and consistent with
2093 // ChainstateManager's active tip.
2095
2096 uiInterface.InitMessage(_("Done loading"));
2097
2098 for (const auto& client : node.chain_clients) {
2099 client->start(scheduler);
2100 }
2101
2102 BanMan* banman = node.banman.get();
2103 scheduler.scheduleEvery([banman]{
2104 banman->DumpBanlist();
2106
2107 if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
2108
2109#if HAVE_SYSTEM
2110 StartupNotify(args);
2111#endif
2112
2113 return true;
2114}
2115
2117{
2118 // Find the oldest block among all indexes.
2119 // This block is used to verify that we have the required blocks' data stored on disk,
2120 // starting from that point up to the current tip.
2121 // indexes_start_block='nullptr' means "start from height 0".
2122 std::optional<const CBlockIndex*> indexes_start_block;
2123 std::string older_index_name;
2124 ChainstateManager& chainman = *Assert(node.chainman);
2125 const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing());
2126 const CChain& index_chain = chainstate.m_chain;
2127
2128 for (auto index : node.indexes) {
2129 const IndexSummary& summary = index->GetSummary();
2130 if (summary.synced) continue;
2131
2132 // Get the last common block between the index best block and the active chain
2133 LOCK(::cs_main);
2134 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash);
2135 if (!index_chain.Contains(pindex)) {
2136 pindex = index_chain.FindFork(pindex);
2137 }
2138
2139 if (!indexes_start_block || !pindex || pindex->nHeight < indexes_start_block.value()->nHeight) {
2140 indexes_start_block = pindex;
2141 older_index_name = summary.name;
2142 if (!pindex) break; // Starting from genesis so no need to look for earlier block.
2143 }
2144 };
2145
2146 // Verify all blocks needed to sync to current tip are present.
2147 if (indexes_start_block) {
2148 LOCK(::cs_main);
2149 const CBlockIndex* start_block = *indexes_start_block;
2150 if (!start_block) start_block = chainman.ActiveChain().Genesis();
2151 if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(start_block))) {
2152 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)));
2153 }
2154 }
2155
2156 // Start threads
2157 for (auto index : node.indexes) if (!index->StartBackgroundSync()) return false;
2158 return true;
2159}
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< std::byte > &, const CBlockIndex &)> get_block_by_index)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:507
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:587
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:867
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1106
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:1091
double GuessVerificationProgress(const CBlockIndex *pindex) const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
kernel::Notifications & GetNotifications() const
Definition: validation.h:980
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1000
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1094
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
Definition: validation.h:1097
const util::SignalInterrupt & m_interrupt
Definition: validation.h:1002
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
Definition: validation.h:973
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1092
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:1061
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1006
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
Definition: clientversion.h:26
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
static constexpr bool DEFAULT_COINSTATSINDEX
bool SetupNetworking()
Definition: system.cpp: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:152
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
Definition: fs_helpers.cpp:82
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:1111
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:815
static bool AppInitServers(NodeContext &node)
Definition: init.cpp:710
static bool LockDirectories(bool probeOnly)
Definition: init.cpp:1123
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:844
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:1167
static ChainstateLoadResult InitAndLoadChainstate(NodeContext &node, bool do_reindex, const bool do_reindex_chainstate, const kernel::CacheSizes &cache_sizes, const ArgsManager &args)
Definition: init.cpp:1218
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:2116
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
Definition: init.cpp:881
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
Definition: init.cpp:1160
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:726
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:1327
static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING
Definition: init.cpp:147
bool AppInitLockDirectories()
Lock bitcoin core critical directories.
Definition: init.cpp:1148
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:831
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
Definition: init.cpp:1129
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:42
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 in vbytes.
Definition: policy.h:78
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:706
CService DefaultOnionServiceTarget(uint16_t port)
Definition: torcontrol.cpp:725
void StartTorControl(CService onion_service_target)
Definition: torcontrol.cpp:687
void StopTorControl()
Definition: torcontrol.cpp:716
constexpr uint16_t DEFAULT_TOR_SOCKS_PORT
Functionality for communicating with Tor.
Definition: torcontrol.h:22
static const bool DEFAULT_LISTEN_ONION
Definition: torcontrol.h:25
constexpr int DEFAULT_TOR_CONTROL_PORT
Definition: torcontrol.h:23
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 ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp: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