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