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