6#include <bitcoin-build-config.h>
101#include <util/time.h>
110#include <condition_variable>
116#include <initializer_list>
124#include <system_error>
141#ifdef ENABLE_EMBEDDED_ASMAP
142#include <node/data/ip_asn.dat.h>
182#define MIN_LEVELDB_FDS 0
184#define MIN_LEVELDB_FDS 150
226 if (std::error_code error; !fs::remove(pid_path, error)) {
227 std::string
msg{error ? error.message() :
"File does not exist"};
243 if (!(*
node.shutdown_signal)())
return false;
279 std::vector<std::thread> threads;
281 threads.emplace_back(runCommand,
cmd);
283 for (
auto& t : threads) {
292 ShutdownNotify(*
node.args);
295 if (
node.notifications)
WITH_LOCK(
node.notifications->m_tip_block_mutex,
node.notifications->m_tip_block_cv.notify_all());
300 if (
node.tor_controller) {
301 node.tor_controller->Interrupt();
305 node.connman->Interrupt();
306 for (
auto* index :
node.indexes) {
313 static Mutex g_shutdown_mutex;
314 TRY_LOCK(g_shutdown_mutex, lock_shutdown);
315 if (!lock_shutdown)
return;
316 LogInfo(
"Shutdown in progress...");
324 if (
node.mempool)
node.mempool->AddTransactionsUpdated(1);
330 for (
auto& client :
node.chain_clients) {
342 if (
node.peerman &&
node.validation_signals)
node.validation_signals->UnregisterValidationInterface(
node.peerman.get());
343 if (
node.connman)
node.connman->Stop();
345 if (
node.tor_controller) {
346 node.tor_controller->Join();
347 node.tor_controller.reset();
350 if (
node.background_init_thread.joinable())
node.background_init_thread.join();
354 if (
node.scheduler)
node.scheduler->stop();
358 node.peerman.reset();
359 node.connman.reset();
361 node.addrman.reset();
362 node.netgroupman.reset();
370 if (
node.fee_estimator) {
371 node.fee_estimator->Flush();
372 if (
node.validation_signals) {
373 node.validation_signals->UnregisterValidationInterface(
node.fee_estimator.get());
380 for (
const auto& chainstate :
node.chainman->m_chainstates) {
381 if (chainstate->CanFlushToDisk()) {
382 chainstate->ForceFlushStateToDisk();
389 if (
node.validation_signals)
node.validation_signals->FlushBackgroundCallbacks();
392 for (
auto* index :
node.indexes) index->Stop();
397 node.indexes.clear();
407 for (
const auto& chainstate :
node.chainman->m_chainstates) {
408 if (chainstate->CanFlushToDisk()) {
409 chainstate->ForceFlushStateToDisk();
410 chainstate->ResetCoinsViews();
418 ipc->disconnectIncoming();
428 node.chain_clients.clear();
429 if (
node.validation_signals) {
430 node.validation_signals->UnregisterAllValidationInterfaces();
432 node.mempool.reset();
433 node.fee_estimator.reset();
434 node.chainman.reset();
435 node.validation_signals.reset();
436 node.scheduler.reset();
437 node.ecc_context.reset();
463static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
466 LogError(
"Failed to send shutdown signal on Ctrl-C\n");
479 sigemptyset(&sa.sa_mask);
481 sigaction(signal, &sa,
nullptr);
504 std::vector<std::string> hidden_args = {
505 "-dbcrashratio",
"-forcecompactdb",
507 "-choosedatadir",
"-lang=<lang>",
"-min",
"-resetguisettings",
"-splash",
"-uiplatform"};
513 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);
515 argsman.
AddArg(
"-blocksxor",
516 strprintf(
"Whether an XOR-key applies to blocksdir *.dat files. "
517 "The created XOR-key will be zeros for an existing blocksdir or when `-blocksxor=0` is "
518 "set, and random for a freshly initialized blocksdir. "
538 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);
539 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)",
542 argsman.
AddArg(
"-persistmempoolv1",
543 strprintf(
"Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format "
544 "(version 1) or the current format (version 2). This temporary option will be removed in the future. (default: %u)",
548 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. "
549 "Warning: Reverting this setting requires re-downloading the entire blockchain. "
551 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);
552 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);
556 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);
560 argsman.
AddArg(
"-blockfilterindex=<type>",
562 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
566 argsman.
AddArg(
"-asmap=<file>",
strprintf(
"Specify asn mapping used for bucketing of the peers. Relative paths will be prefixed by the net-specific datadir location.%s",
567 #ifdef ENABLE_EMBEDDED_ASMAP
568 " If a bool arg is given (-asmap or -asmap=1), the embedded mapping data in the binary will be used."
574 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);
589#ifdef HAVE_SOCKADDR_UN
601 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);
602 const std::string proxy_doc_for_value =
603#ifdef HAVE_SOCKADDR_UN
604 "<ip>[:<port>]|unix:<path>";
608 const std::string proxy_doc_for_unix_socket =
609#ifdef HAVE_SOCKADDR_UN
610 "May be a local file path prefixed with 'unix:' if the proxy supports it. ";
614 argsman.
AddArg(
"-proxy=" + proxy_doc_for_value +
"[=<network>]",
615 "Connect through SOCKS5 proxy, set -noproxy to disable. " +
616 proxy_doc_for_unix_socket +
617 "Could end in =network to set the proxy only for that network. " +
618 "The network can be any of ipv4, ipv6, tor or cjdns. " +
619 "(default: disabled)",
623 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);
630 argsman.
AddArg(
"-whitebind=<[permissions@]addr>",
"Bind to the given address and add permission flags to the peers connecting to it. "
634 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 "
635 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
637 "Additional flags \"in\" and \"out\" control whether permissions apply to incoming connections and/or manual (default: incoming only). "
654 hidden_args.emplace_back(
"-zmqpubhashblock=<address>");
655 hidden_args.emplace_back(
"-zmqpubhashtx=<address>");
656 hidden_args.emplace_back(
"-zmqpubrawblock=<address>");
657 hidden_args.emplace_back(
"-zmqpubrawtx=<address>");
658 hidden_args.emplace_back(
"-zmqpubsequence=<n>");
659 hidden_args.emplace_back(
"-zmqpubhashblockhwm=<n>");
660 hidden_args.emplace_back(
"-zmqpubhashtxhwm=<n>");
661 hidden_args.emplace_back(
"-zmqpubrawblockhwm=<n>");
662 hidden_args.emplace_back(
"-zmqpubrawtxhwm=<n>");
663 hidden_args.emplace_back(
"-zmqpubsequencehwm=<n>");
689 argsman.
AddArg(
"-maxtipage=<n>",
690 strprintf(
"Maximum tip age in seconds to consider node in initial block download (default: %u)",
704 argsman.
AddArg(
"-datacarriersize",
705 strprintf(
"Relay and mine transactions whose data-carrying raw scriptPubKeys in aggregate "
706 "are of this size or less, allowing multiple outputs (default: %u)",
711 argsman.
AddArg(
"-minrelaytxfee=<amt>",
strprintf(
"Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
713 argsman.
AddArg(
"-privatebroadcast",
715 "Broadcast transactions submitted via sendrawtransaction RPC using short-lived "
716 "connections through the Tor or I2P networks, without putting them in the mempool first. "
717 "Transactions submitted through the wallet are not affected by this option "
732 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);
733 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);
734 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);
739 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);
743 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);
744 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);
747 if (can_listen_ipc) {
748 argsman.
AddArg(
"-ipcbind=<address>",
"Bind to Unix socket address and listen for incoming connections. Valid address values are \"unix\" to listen on the default path, <datadir>/node.sock, or \"unix:/custom/path\" to specify a custom path. Can be specified multiple times to listen on multiple paths. Default behavior is not to listen on any path. If relative paths are specified, they are interpreted relative to the network data directory. If paths include any parent directory components and the parent directories do not exist, they will be created. Enabling this gives local processes that can access the socket unauthenticated RPC access, so it's important to choose a path with secure permissions if customizing this.",
ArgsManager::ALLOW_ANY,
OptionsCategory::IPC);
755 hidden_args.emplace_back(
"-daemon");
756 hidden_args.emplace_back(
"-daemonwait");
768 std::thread
t(runCommand,
cmd);
796 LogInfo(
"parameter interaction: -bind set -> setting -listen=1\n");
800 LogInfo(
"parameter interaction: -whitebind set -> setting -listen=1\n");
807 LogInfo(
"parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n");
809 LogInfo(
"parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n");
812 std::string proxy_arg =
args.
GetArg(
"-proxy",
"");
813 if (proxy_arg !=
"" && proxy_arg !=
"0") {
816 LogInfo(
"parameter interaction: -proxy set -> setting -listen=0\n");
820 LogInfo(
"parameter interaction: -proxy set -> setting -natpmp=0\n");
824 LogInfo(
"parameter interaction: -proxy set -> setting -discover=0\n");
830 LogInfo(
"parameter interaction: -listen=0 -> setting -natpmp=0\n");
833 LogInfo(
"parameter interaction: -listen=0 -> setting -discover=0\n");
835 LogInfo(
"parameter interaction: -listen=0 -> setting -listenonion=0\n");
837 LogInfo(
"parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n");
844 LogInfo(
"parameter interaction: -externalip set -> setting -discover=0\n");
850 LogInfo(
"parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n");
859 LogInfo(
"parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n");
862 if (!onlynets.empty()) {
863 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](
const auto& net) {
864 const auto n = ParseNetwork(net);
865 return n == NET_IPV4 || n == NET_IPV6;
868 LogInfo(
"parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n");
890int64_t peer_connect_timeout;
891std::set<BlockFilterType> g_enabled_filter_types;
901 std::set_new_handler(std::terminate);
902 LogError(
"Out of memory. Terminating.\n");
913 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
914 _CrtSetReportFile(_CRT_WARN, CreateFileA(
"NUL", GENERIC_WRITE, 0,
nullptr, OPEN_EXISTING, 0, 0));
916 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
920 HeapSetInformation(
nullptr, HeapEnableTerminationOnCorruption,
nullptr, 0);
935 signal(SIGPIPE, SIG_IGN);
937 SetConsoleCtrlHandler(consoleCtrlHandler,
true);
954 InitWarning(
_(
"Option '-checkpoints' is set but checkpoints were removed. This option has no effect."));
957 InitWarning(
_(
"Option '-limitancestorsize' is given but ancestor size limits have been replaced with cluster size limits (see -limitclustersize). This option has no effect."));
960 InitWarning(
_(
"Option '-limitdescendantsize' is given but descendant size limits have been replaced with cluster size limits (see -limitclustersize). This option has no effect."));
975 if (!errors.
empty()) {
981 LogInfo(
"Warning: Support for testnet3 is deprecated and will be removed in an upcoming release. Consider switching to testnet4.\n");
990 if (!warnings.
empty()) {
1000 if (blockfilterindex_value ==
"" || blockfilterindex_value ==
"1") {
1002 }
else if (blockfilterindex_value !=
"0") {
1003 const std::vector<std::string> names =
args.
GetArgs(
"-blockfilterindex");
1004 for (
const auto&
name : names) {
1009 g_enabled_filter_types.insert(filter_type);
1021 return InitError(
_(
"Cannot set -peerblockfilters without -blockfilterindex."));
1029 return InitError(
_(
"Prune mode is incompatible with -txindex."));
1031 return InitError(
_(
"Prune mode is incompatible with -txospenderindex."));
1033 return InitError(
_(
"Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
1039 return InitError(
_(
"Cannot set -forcednsseed to true when setting -dnsseed to false."));
1057 int nBind = std::max(nUserBind,
size_t(1));
1060 if (user_max_connection < 0) {
1073 available_fds = std::min(FD_SETSIZE, available_fds);
1075 if (available_fds < min_required_fds)
1076 return InitError(
strprintf(
_(
"Not enough file descriptors available. %d available, %d required."), available_fds, min_required_fds));
1079 nMaxConnections = std::min(available_fds - min_required_fds, user_max_connection);
1081 if (nMaxConnections < user_max_connection)
1082 InitWarning(
strprintf(
_(
"Reducing -maxconnections from %d to %d, because of system limitations."), user_max_connection, nMaxConnections));
1094 if (peer_connect_timeout <= 0) {
1099 if (!mining_result) {
1115 const std::vector<std::string> test_options =
args.
GetArgs(
"-test");
1116 if (!test_options.empty()) {
1120 for (
const std::string& option : test_options) {
1122 size_t pos = doc_option.find(
" (");
1123 return (pos != std::string::npos) && (doc_option.substr(0, pos) == option);
1134 return InitError(
_(
"The -testactivationheight option may not be used on mainnet."));
1137 return InitError(
_(
"The -vbparams option may not be used on mainnet."));
1147 .notifications = notifications,
1150 if (!chainman_result) {
1153 BlockManager::Options blockman_opts_dummy{
1154 .chainparams = chainman_opts_dummy.chainparams,
1156 .notifications = chainman_opts_dummy.notifications,
1163 if (!blockman_result) {
1168 if (!mempool_result) {
1200 return InitError(
strprintf(
_(
"Initialization sanity check failed. %s is shutting down."), CLIENT_NAME));
1204 return InitError(
strprintf(
_(
"Elliptic curve cryptography sanity check failure. %s is shutting down."), CLIENT_NAME));
1235 for (
const std::string port_option : {
1239 if (
const auto port{
args.
GetArg(port_option)}) {
1240 const auto n{ToIntegral<uint16_t>(*port)};
1241 if (!n || *n == 0) {
1247 for ([[maybe_unused]]
const auto& [param_name, unix, suffix_allowed] : std::vector<std::tuple<std::string, bool, bool>>{
1249 {
"-i2psam",
false,
false},
1250 {
"-onion",
true,
false},
1251 {
"-proxy",
true,
true},
1252 {
"-bind",
false,
true},
1253 {
"-rpcbind",
false,
false},
1254 {
"-torcontrol",
false,
false},
1255 {
"-whitebind",
false,
false},
1256 {
"-zmqpubhashblock",
true,
false},
1257 {
"-zmqpubhashtx",
true,
false},
1258 {
"-zmqpubrawblock",
true,
false},
1259 {
"-zmqpubrawtx",
true,
false},
1260 {
"-zmqpubsequence",
true,
false},
1262 for (
const std::string& param_value :
args.
GetArgs(param_name)) {
1263 const std::string param_value_hostport{
1264 suffix_allowed ? param_value.substr(0, param_value.rfind(
'=')) : param_value};
1265 std::string host_out;
1266 uint16_t port_out{0};
1267 if (!
SplitHostPort(param_value_hostport, port_out, host_out)) {
1268#ifdef HAVE_SOCKADDR_UN
1291 std::set<CService> seen;
1295 if (!seen.insert(wb.m_service).second) {
1296 return wb.m_service;
1301 for (
const auto& bind : conn_options.
vBinds) {
1302 if (!seen.insert(bind).second) {
1308 for (
const auto& onion_bind : conn_options.
onion_binds) {
1309 if (!seen.insert(onion_bind).second) {
1314 return std::nullopt;
1322 const bool do_reindex_chainstate,
1327 node.notifications->setChainstateLoaded(
false);
1328 node.mempool.reset();
1329 node.chainman.reset();
1335 .signals =
node.validation_signals.get(),
1340 node.mempool = std::make_unique<CTxMemPool>(mempool_opts, mempool_error);
1341 if (!mempool_error.
empty()) {
1342 return {ChainstateLoadStatus::FAILURE_FATAL, mempool_error};
1346 node.mining_args = std::move(*mining_args);
1347 LogInfo(
"* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)",
1348 cache_sizes.
coins /
double(1_MiB),
1349 mempool_opts.max_size_bytes /
double(1_MiB));
1353 .notifications = *
node.notifications,
1354 .signals =
node.validation_signals.get(),
1358 BlockManager::Options blockman_opts{
1359 .chainparams = chainman_opts.chainparams,
1361 .notifications = chainman_opts.notifications,
1365 .wipe_data = do_reindex,
1375 node.chainman = std::make_unique<ChainstateManager>(*
Assert(
node.shutdown_signal), chainman_opts, blockman_opts);
1378 return {ChainstateLoadStatus::FAILURE,
_(
"Error opening block database")};
1379 }
catch (std::exception& e) {
1380 return {ChainstateLoadStatus::FAILURE_FATAL,
Untranslated(
strprintf(
"Failed to initialize ChainstateManager: %s", e.what()))};
1383 if (chainman.
m_interrupt)
return {ChainstateLoadStatus::INTERRUPTED, {}};
1389 if (!
node.chainman->m_blockman.IsPruneMode()) {
1390 LogInfo(
"[snapshot] re-enabling NODE_NETWORK services");
1393 LogInfo(
"[snapshot] restarting indexes");
1396 Assert(
node.validation_signals)->SyncWithValidationInterfaceQueue();
1397 for (
auto* index :
node.indexes) {
1400 if (!(index->Init() && index->StartBackgroundSync())) {
1401 LogWarning(
"[snapshot] Failed to restart index %s on snapshot chain", index->GetName());
1414 _(
"Error reading from database, shutting down."),
1421 }
catch (
const std::exception& e) {
1426 auto [status, error] = catch_exceptions([&] {
return LoadChainstate(chainman, cache_sizes, options); });
1430 LogWarning(
"pruned datadir may not have more than %d blocks; only checking available blocks\n",
1435 LogInfo(
"Block index and chainstate loaded");
1436 node.notifications->setChainstateLoaded(
true);
1439 return {status, error};
1448 if (!opt_max_upload) {
1462 LogInfo(
"Using at most %i automatic connections (%i file descriptors available)", nMaxConnections, available_fds);
1466 LogWarning(
"Relative datadir option '%s' specified, which will be interpreted relative to the "
1467 "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1468 "from a different location, it will be unable to locate the current data files. There could "
1469 "also be data loss if bitcoin is started while in a temporary directory.",
1474 node.scheduler = std::make_unique<CScheduler>();
1475 auto& scheduler = *
node.scheduler;
1478 scheduler.m_service_thread = std::thread(
util::TraceThread,
"scheduler", [&] { scheduler.serviceQueue(); });
1481 scheduler.scheduleEvery([]{
1483 }, std::chrono::minutes{1});
1486 scheduler.scheduleEvery([&
args, &
node]{
1487 constexpr uint64_t min_disk_space{50_MiB};
1489 LogError(
"Shutting down due to lack of disk space!\n");
1491 LogError(
"Failed to send shutdown signal after disk space check\n");
1494 }, std::chrono::minutes{5});
1498 [&scheduler](
auto func,
auto window) { scheduler.scheduleEvery(std::move(func), window); },
1502 LogInfo(
"Log rate limiting disabled");
1506 node.validation_signals = std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(scheduler));
1507 auto& validation_signals = *
node.validation_signals;
1524 for (std::string address :
gArgs.
GetArgs(
"-ipcbind")) {
1526 ipc->listenAddress(address);
1527 }
catch (
const std::exception& e) {
1530 LogInfo(
"Listening for IPC requests on address %s", address);
1538 for (
const auto& client :
node.chain_clients) {
1539 client->registerRpcs();
1551 if (!onlynets.empty()) {
1553 for (
const std::string& snet : onlynets) {
1564 _(
"Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1565 "-cjdnsreachable is not provided"));
1582 return InitError(
_(
"Unable to start HTTP server. See debug log for details."));
1586 for (
const auto& client :
node.chain_clients) {
1587 if (!client->verify()) {
1612 if (!asmap_path.is_absolute()) {
1624 std::vector<std::byte> asmap{
DecodeAsmap(asmap_path)};
1625 if (asmap.empty()) {
1632 #ifdef ENABLE_EMBEDDED_ASMAP
1634 std::span<const std::byte> asmap{node::data::ip_asn};
1641 LogInfo(
"Opened asmap data (%zu bytes) from embedded byte array\n", asmap.size());
1649 LogInfo(
"Using asmap version %s for IP bucketing", asmap_version.ToString());
1652 LogInfo(
"Using /16 prefix for IP bucketing");
1660 node.addrman = std::move(*addrman);
1674 if (!peerman_opts.ignore_incoming_txs) {
1679 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(
FeeestPath(
args), read_stale_estimates);
1684 validation_signals.RegisterValidationInterface(fee_estimator);
1687 for (
const std::string& socket_addr :
args.
GetArgs(
"-bind")) {
1688 std::string host_out;
1689 uint16_t port_out{0};
1690 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind(
'='));
1697 std::vector<std::string> uacomments;
1698 for (
const std::string& cmt :
args.
GetArgs(
"-uacomment")) {
1700 return InitError(
strprintf(
_(
"User Agent comment (%s) contains unsafe characters."), cmt));
1701 uacomments.push_back(cmt);
1705 return InitError(
strprintf(
_(
"Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1713 return InitError(
strprintf(
_(
"Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1727 for (
const std::string& param_value :
args.
GetArgs(
"-proxy")) {
1728 const auto eq_pos{param_value.rfind(
'=')};
1729 const std::string proxy_str{param_value.substr(0, eq_pos)};
1730 std::string net_str;
1731 if (eq_pos != std::string::npos) {
1732 if (eq_pos + 1 == param_value.length()) {
1733 return InitError(
strprintf(
_(
"Invalid -proxy address or hostname, ends with '=': '%s'"), param_value));
1735 net_str =
ToLower(param_value.substr(eq_pos + 1));
1739 if (!proxy_str.empty() && proxy_str !=
"0") {
1741 proxy =
Proxy{proxy_str, proxyRandomize};
1744 if (!addr.has_value()) {
1747 proxy =
Proxy{addr.value(), proxyRandomize};
1754 if (net_str.empty()) {
1755 ipv4_proxy = ipv6_proxy = name_proxy = cjdns_proxy = onion_proxy = proxy;
1756 }
else if (net_str ==
"ipv4") {
1757 ipv4_proxy = name_proxy = proxy;
1758 }
else if (net_str ==
"ipv6") {
1759 ipv6_proxy = name_proxy = proxy;
1760 }
else if (net_str ==
"onion") {
1761 onion_proxy = proxy;
1762 }
else if (net_str ==
"cjdns") {
1763 cjdns_proxy = proxy;
1765 return InitError(
strprintf(
_(
"Unrecognized network in -proxy='%s': '%s'"), param_value, net_str));
1786 std::string onionArg =
args.
GetArg(
"-onion",
"");
1787 if (onionArg !=
"") {
1788 if (onionArg ==
"0") {
1789 onion_proxy =
Proxy{};
1790 if (onlynet_used_with_onion) {
1792 _(
"Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1793 "reaching the Tor network is explicitly forbidden: -onion=0"));
1797 onion_proxy =
Proxy(onionArg, proxyRandomize);
1800 if (!addr.has_value() || !addr->IsValid()) {
1804 onion_proxy =
Proxy(addr.value(), proxyRandomize);
1815 if (onlynet_used_with_onion && !listenonion) {
1817 _(
"Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1818 "reaching the Tor network is not provided: none of -proxy, -onion or "
1819 "-listenonion is given"));
1824 for (
const std::string& strAddr :
args.
GetArgs(
"-externalip")) {
1826 if (addrLocal.has_value() && addrLocal->IsValid())
1834 [&chainman =
node.chainman](std::vector<std::byte>& block,
const CBlockIndex& index) {
1836 if (auto ret{chainman->m_blockman.ReadRawBlock(WITH_LOCK(cs_main, return index.GetBlockPos()))}) {
1837 block = std::move(*
ret);
1852 const auto [index_cache_sizes, kernel_cache_sizes] =
CalculateCacheSizes(
args, g_enabled_filter_types.size());
1854 LogInfo(
"Cache configuration:");
1855 LogInfo(
"* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db /
double(1_MiB));
1857 LogInfo(
"* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index /
double(1_MiB));
1860 LogInfo(
"* Using %.1f MiB for transaction output spender index database", index_cache_sizes.txospender_index /
double(1_MiB));
1863 LogInfo(
"* Using %.1f MiB for %s block filter index database",
1866 LogInfo(
"* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db /
double(1_MiB));
1872 const bool do_reindex_chainstate{
args.
GetBoolArg(
"-reindex-chainstate",
false)};
1878 do_reindex_chainstate,
1883 bool do_retry{
HasTestOption(
args,
"reindex_after_failure_noninteractive_yes") ||
1885 error +
Untranslated(
".\n\n") +
_(
"Do you want to rebuild the databases now?"),
1886 error.original +
".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1892 if (!
Assert(
node.shutdown_signal)->reset()) {
1893 LogError(
"Internal error: failed to reset shutdown signal.\n");
1898 do_reindex_chainstate,
1902 if (status != ChainstateLoadStatus::SUCCESS && status != ChainstateLoadStatus::INTERRUPTED) {
1909 LogInfo(
"Shutdown requested. Exiting.");
1914 auto& kernel_notifications{*
Assert(
node.notifications)};
1918 node.banman.get(), chainman,
1921 validation_signals.RegisterValidationInterface(
node.peerman.get());
1935 for (
const auto& filter_type : g_enabled_filter_types) {
1946 for (
auto index :
node.indexes)
if (!index->Init())
return false;
1949 for (
const auto& client :
node.chain_clients) {
1950 if (!client->load()) {
1962 for (
const auto& chainstate : chainman.m_chainstates) {
1964 chainstate->PruneAndFlush();
1970 LogInfo(
"Setting NODE_NETWORK in non-prune mode");
1973 LogInfo(
"Running node in NODE_NETWORK_LIMITED mode until snapshot background sync completes");
1991 if (!do_reindex && !do_reindex_chainstate && chain_active_height <= 1) {
1992 uint64_t assumed_chain_bytes{chainparams.AssumedBlockchainSize() * 1_GiB};
1993 uint64_t additional_bytes_needed{
1996 assumed_chain_bytes};
2000 "Disk space for %s may not accommodate the block files. " \
2001 "Approximately %u GB of data will be stored in this directory."
2004 chainparams.AssumedBlockchainSize()
2010 auto check_and_warn_fs{[&](
const fs::path& path, std::string_view desc) {
2011 const auto path_desc{
strprintf(
"%s (\"%s\")", desc, fs::PathToString(path))};
2012 switch (GetFilesystemType(path)) {
2014 InitWarning(
strprintf(
_(
"The %s path uses exFAT, which is known to have intermittent corruption problems on macOS. "
2015 "Move this directory to a different filesystem to avoid data loss."), path_desc));
2018 LogInfo(
"Failed to detect filesystem type for %s", path_desc);
2030 const std::string block_notify =
args.
GetArg(
"-blocknotify",
"");
2031 if (!block_notify.empty()) {
2034 std::string
command = block_notify;
2036 std::thread
t(runCommand,
command);
2042 std::vector<fs::path> vImportFiles;
2043 for (
const std::string& strFile :
args.
GetArgs(
"-loadblock")) {
2044 vImportFiles.push_back(fs::PathFromString(strFile));
2054 LogInfo(
"Stopping after block import");
2056 LogError(
"Failed to send shutdown signal after finishing block import\n");
2063 bilingual_str err_str =
_(
"Failed to start indexes, shutting down…");
2086 WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
2087 kernel_notifications.m_tip_block_cv.wait(lock, [&]()
EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
2088 return kernel_notifications.TipBlock() || ShutdownRequested(node);
2098 int64_t best_block_time{};
2103 chain_active_height = tip.nHeight;
2104 best_block_time = tip.GetBlockTime();
2106 tip_info->block_height = chain_active_height;
2107 tip_info->block_time = best_block_time;
2110 if (tip_info && chainman.m_best_header) {
2111 tip_info->header_height = chainman.m_best_header->nHeight;
2112 tip_info->header_time = chainman.m_best_header->GetBlockTime();
2115 LogInfo(
"nBestHeight = %d", chain_active_height);
2116 if (
node.peerman)
node.peerman->SetBestBlock(chain_active_height, std::chrono::seconds{best_block_time});
2137 const uint16_t default_bind_port =
2140 const uint16_t default_bind_port_onion = default_bind_port + 1;
2142 const auto BadPortWarning = [](
const char*
prefix, uint16_t port) {
2143 return strprintf(
_(
"%s request to listen on port %u. This port is considered \"bad\" and "
2144 "thus it is unlikely that any peer will connect to it. See "
2145 "doc/p2p-bad-ports.md for details and a full list."),
2150 for (
const std::string& bind_arg :
args.
GetArgs(
"-bind")) {
2151 std::optional<CService> bind_addr;
2152 const size_t index = bind_arg.rfind(
'=');
2153 if (index == std::string::npos) {
2154 bind_addr =
Lookup(bind_arg, default_bind_port,
false);
2155 if (bind_addr.has_value()) {
2156 connOptions.
vBinds.push_back(bind_addr.value());
2157 if (
IsBadPort(bind_addr.value().GetPort())) {
2158 InitWarning(BadPortWarning(
"-bind", bind_addr.value().GetPort()));
2163 const std::string network_type = bind_arg.substr(index + 1);
2164 if (network_type ==
"onion") {
2165 const std::string truncated_bind_arg = bind_arg.substr(0, index);
2166 bind_addr =
Lookup(truncated_bind_arg, default_bind_port_onion,
false);
2167 if (bind_addr.has_value()) {
2168 connOptions.
onion_binds.push_back(bind_addr.value());
2176 for (
const std::string& strBind :
args.
GetArgs(
"-whitebind")) {
2198 onion_service_target = connOptions.
onion_binds.front();
2199 }
else if (!connOptions.
vBinds.empty()) {
2200 onion_service_target = connOptions.
vBinds.front();
2203 connOptions.
onion_binds.push_back(onion_service_target);
2209 "for the automatically created Tor onion service."),
2216 if (!should_discover) {
2217 for (
const auto& bind : connOptions.
vBinds) {
2218 if (bind.IsBindAny()) {
2219 should_discover =
true;
2225 if (!should_discover) {
2226 for (
const auto& whitebind : connOptions.
vWhiteBinds) {
2228 should_discover =
true;
2234 if (should_discover) {
2240 for (
const auto& net :
args.
GetArgs(
"-whitelist")) {
2261 if (connect.size() != 1 || connect[0] !=
"0") {
2265 LogInfo(
"-seednode is ignored when -connect is used");
2269 LogInfo(
"-dnsseed is ignored when -connect is used and -proxy is specified");
2273 const std::string& i2psam_arg =
args.
GetArg(
"-i2psam",
"");
2274 if (!i2psam_arg.empty()) {
2276 if (!addr.has_value() || !addr->IsValid()) {
2283 _(
"Outbound connections restricted to i2p (-onlynet=i2p) but "
2284 "-i2psam is not provided"));
2293 _(
"Duplicate binding configuration for address %s. "
2294 "Please check your -bind, -bind=...=onion and -whitebind settings."),
2295 conflict->ToStringAddrPort()));
2302 const bool onion_may_become_reachable{listenonion && (!
args.
IsArgSet(
"-onlynet") || onlynet_used_with_onion)};
2305 !onion_may_become_reachable) {
2306 return InitError(
_(
"Private broadcast of own transactions requested (-privatebroadcast), "
2307 "but none of Tor or I2P networks is reachable"));
2310 return InitError(
_(
"Private broadcast of own transactions requested (-privatebroadcast), "
2311 "but -connect is also configured. They are incompatible because the "
2312 "private broadcast needs to open new connections to randomly "
2313 "chosen Tor or I2P peers. Consider using -maxconnections=0 -addnode=... "
2317 InitWarning(
_(
"Private broadcast of own transactions requested (-privatebroadcast) and "
2318 "-proxyrandomize is disabled. Tor circuits for private broadcast connections "
2319 "may be correlated to other connections over Tor. For maximum privacy set "
2320 "-proxyrandomize=1."));
2324 if (!
node.connman->Start(scheduler, connOptions)) {
2338 for (
const auto& client :
node.chain_clients) {
2339 client->start(scheduler);
2343 scheduler.scheduleEvery([banman]{
2347 if (
node.peerman)
node.peerman->StartScheduledTasks(scheduler);
2350 StartupNotify(
args);
2364 if (current_height > 0) {
2377 std::optional<const CBlockIndex*> block_start;
2378 std::string block_start_name;
2379 std::optional<const CBlockIndex*> undo_start;
2380 std::string undo_start_name;
2382 for (
const auto& index :
node.indexes) {
2384 if (summary.
synced)
continue;
2392 LogWarning(
"Failed to find block manager entry for best block %s from %s, falling back to genesis for index sync",
2394 }
else if (!index_chain.
Contains(*pindex)) {
2395 pindex = index_chain.
FindFork(*pindex);
2399 pindex = index_chain.
Genesis();
2402 bool need_undo = index->CustomOptions().connect_undo_data;
2403 auto& op_start_index = need_undo ? undo_start : block_start;
2404 auto& name_index = need_undo ? undo_start_name : block_start_name;
2406 if (op_start_index && pindex->
nHeight >= op_start_index.value()->nHeight)
continue;
2407 op_start_index = pindex;
2408 name_index = summary.
name;
2414 if (!chainman.
m_blockman.CheckBlockDataAvailability(*index_chain.
Tip(), *
Assert(undo_start.value()),
BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO})) {
2415 return InitError(
Untranslated(
strprintf(
"%s best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)", undo_start_name)));
2420 if (block_start && !(undo_start && undo_start.value()->nHeight <= block_start.value()->nHeight)) {
2423 return InitError(
Untranslated(
strprintf(
"%s best block of the index goes beyond pruned data. Please disable the index or reindex (which will download the whole blockchain again)", block_start_name)));
2429 for (
auto index :
node.indexes)
if (!index->StartBackgroundSync())
return false;
util::Result< std::unique_ptr< AddrMan > > LoadAddrman(const NetGroupManager &netgroupman, const ArgsManager &args)
Returns an error string on failure.
static constexpr int32_t DEFAULT_ADDRMAN_CONSISTENCY_CHECKS
Default for -checkaddrman.
const std::vector< std::string > TEST_OPTIONS_DOC
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
const char *const BITCOIN_SETTINGS_FILENAME
bool HasTestOption(const ArgsManager &args, const std::string &test_option)
Checks if a particular test option is present in -test command-line arg options.
const char *const BITCOIN_CONF_FILENAME
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...
static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME
static constexpr std::chrono::minutes DUMP_BANS_INTERVAL
How often to dump banned addresses/subnets to disk.
void ScheduleBatchPriority()
On platforms that support it, tell the kernel the calling thread is CPU-intensive and non-interactive...
static constexpr bool DEFAULT_ACCEPT_STALE_FEE_ESTIMATES
static constexpr std::chrono::hours MAX_FILE_AGE
fee_estimates.dat that are more than 60 hours (2.5 days) old will not be read, as fee estimates are b...
static constexpr std::chrono::hours FEE_FLUSH_INTERVAL
fs::path FeeestPath(const ArgsManager &argsman)
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
const std::set< BlockFilterType > & AllBlockFilterTypes()
Get a list of known filter types.
bool BlockFilterTypeByName(std::string_view name, BlockFilterType &filter_type)
Find a filter type by its human-readable name.
const std::string & ListBlockFilterTypes()
Get a comma-separated list of known filter type names.
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)
#define Assert(val)
Identity function.
std::vector< std::string > GetArgs(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return a vector of strings of the given argument.
ChainType GetChainType() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Returns the appropriate chain type from the program arguments.
@ ALLOW_ANY
disable validation
@ DISALLOW_NEGATION
disallow -nofoo syntax
@ DISALLOW_ELISION
disallow -foo syntax that doesn't assign any value
std::list< SectionInfo > GetUnrecognizedSections() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Log warnings for unrecognized section names in the config file.
fs::path GetBlocksDirPath() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get blocks directory path.
bool SoftSetArg(const std::string &strArg, const std::string &strValue) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Set an argument if it doesn't already have a value.
std::set< std::string > GetUnsuitableSectionOnlyArgs() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Log warnings for options in m_section_only_args when they are specified in the default section but no...
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Add argument.
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return path argument or default value.
std::string GetArg(const std::string &strArg, const std::string &strDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return string argument or default value.
void AddHiddenArgs(const std::vector< std::string > &args) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Add many hidden arguments.
bool IsArgSet(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return true if the given argument has been manually set.
bool SoftSetBoolArg(const std::string &strArg, bool fValue) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Set a boolean argument if it doesn't already have a value.
fs::path GetDataDirNet() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get data directory path with appended network identifier.
bool IsArgNegated(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return true if the argument was originally passed as a negated option, i.e.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
bool GetBoolArg(const std::string &strArg, bool fDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return boolean argument or default value.
static std::shared_ptr< LogRateLimiter > Create(SchedulerFunction &&scheduler_func, uint64_t max_bytes, std::chrono::seconds reset_window)
void SetRateLimiting(std::shared_ptr< LogRateLimiter > limiter) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
std::atomic< bool > m_reopen_file
void DumpBanlist() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
The block chain is a tree shaped structure starting with the genesis block at the root,...
uint256 GetBlockHash() const
int nHeight
height of the entry in the chain. The genesis block has height 0
The BlockPolicyEstimator is used for estimating the feerate needed for a transaction to be included i...
void FlushFeeEstimates() EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator)
Record current fee estimations.
An in-memory indexed chain of blocks.
bool Contains(const CBlockIndex &index) const
Efficiently check whether a block is present in this chain.
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
const CBlockIndex * FindFork(const CBlockIndex &index) const
Find the last common block between this chain and a block index entry.
CBlockIndex * Genesis() const
Returns the index entry for the genesis block of this chain, or nullptr if none.
int Height() const
Return the maximal height in the chain.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
std::string GetChainTypeString() const
Return the chain type string.
const MessageStartChars & MessageStart() const
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
ChainType GetChainType() const
Return the chain type.
btcsignals::signal< void(const std::string &message)> InitMessage
Progress message during initialization.
btcsignals::signal< bool(const bilingual_str &message, const std::string &noninteractive_message, unsigned int style), btcsignals::any_of > ThreadSafeQuestion
If possible, ask the user a question.
btcsignals::signal< void()> InitWallet
Wallet loader created.
btcsignals::signal< void(const bilingual_str &message, unsigned int style)> ThreadSafeMessageBox
Show message box.
btcsignals::signal< void(SynchronizationState, const CBlockIndex &block, double verification_progress)> NotifyBlockTip
New block has been accepted.
A combination of a network address (CNetAddr) and a (TCP) port.
std::string ToStringAddrPort() const
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.
CChain m_chain
The current chain of blockheaders we consult and build on.
Interface for managing multiple Chainstate objects, where each chainstate is associated with chainsta...
Chainstate * HistoricalChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Return historical chainstate targeting a specific block, if any.
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
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
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Chainstate & ActiveChainstate() const
Alternatives to CurrentChainstate() used by older code to query latest chainstate information without...
const util::SignalInterrupt & m_interrupt
Chainstate & ValidatedChainstate() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Return fully validated chainstate that should be used for indexing, to support indexes that need to i...
std::function< void()> snapshot_download_completed
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
void UpdateIBDStatus() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Update and possibly latch the IBD status.
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
uint64_t rand64() noexcept
Generate a random 64-bit integer.
static NetGroupManager NoAsmap()
static NetGroupManager WithEmbeddedAsmap(std::span< const std::byte > asmap)
static NetGroupManager WithLoadedAsmap(std::vector< std::byte > &&asmap)
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)
void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
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
std::string GetHex() const
connection connect(Callable &&func) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Interface providing access to interprocess-communication (IPC) functionality.
Exception class thrown when a call to remote method fails due to an IPC error, like a socket getting ...
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...
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CBlockFileInfo *GetBlockFileInfo(size_t n) EXCLUSIVE_LOCKS_REQUIRED(bool WriteBlockUndo(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos WriteBlock(const CBlock &block, int nHeight) EXCLUSIVE_LOCKS_REQUIRED(void UpdateBlockInfo(const CBlock &block, unsigned int nHeight, const FlatFilePos &pos) EXCLUSIVE_LOCKS_REQUIRED(bool IsPruneMode() const
Get block file info entry for one block file.
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
uint64_t CalculateCurrentUsage() EXCLUSIVE_LOCKS_REQUIRED(bool CheckBlockDataAvailability(const CBlockIndex &upper_block, const CBlockIndex &lower_block, BlockStatus block_status=BLOCK_HAVE_DATA) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex &GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block LIFETIMEBOUND=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Calculate the amount of disk space the block & undo files currently use.
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
std::unique_ptr< CoinStatsIndex > g_coin_stats_index
The global UTXO set hash object.
static constexpr bool DEFAULT_COINSTATSINDEX
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
const std::string CURRENCY_UNIT
static auto quoted(const std::string &s)
static bool exists(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
int RaiseFileDescriptorLimit(int min_fd)
Try to raise the file descriptor limit to the requested number.
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
void InterruptHTTPRPC()
Interrupt HTTP RPC subsystem.
void StopHTTPRPC()
Stop HTTP RPC subsystem.
bool StartHTTPRPC(const std::any &context)
Start HTTP RPC subsystem.
void StartREST(const std::any &context)
Start HTTP REST subsystem.
void StopREST()
Stop HTTP REST subsystem.
void InterruptREST()
Interrupt RPC REST subsystem.
static const int DEFAULT_HTTP_SERVER_TIMEOUT
static const int DEFAULT_HTTP_WORKQUEUE
The default value for -rpcworkqueue.
static const int DEFAULT_HTTP_THREADS
The default value for -rpcthreads.
Common init functions shared by bitcoin-node, bitcoin-wallet, etc.
static bool LockDirectory(const fs::path &dir, bool probeOnly)
static const char * BITCOIN_PID_FILENAME
The PID file facilities.
static bool CreatePidFile(const ArgsManager &args)
static bool g_generated_pid
True if this process has created a PID file.
static std::optional< util::SignalInterrupt > g_shutdown
static void RemovePidFile(const ArgsManager &args)
void Interrupt(NodeContext &node)
Interrupt threads.
void InitLogging(const ArgsManager &args)
Initialize global loggers.
static bool AppInitServers(NodeContext &node)
static bool LockDirectories(bool probeOnly)
static constexpr int MIN_CORE_FDS
void Shutdown(NodeContext &node)
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
static void HandleSIGHUP(int)
bool AppInitBasicSetup(const ArgsManager &args, std::atomic< int > &exit_status)
Initialize bitcoin core: Basic context setup.
static fs::path GetPidFile(const ArgsManager &args)
static constexpr bool DEFAULT_PROXYRANDOMIZE
bool CheckHostPortOptions(const ArgsManager &args)
static std::optional< CService > CheckBindingConflicts(const CConnman::Options &conn_options)
Checks for duplicate bindings across all binding configurations.
static ChainstateLoadResult InitAndLoadChainstate(NodeContext &node, bool do_reindex, const bool do_reindex_chainstate, const kernel::CacheSizes &cache_sizes, const ArgsManager &args)
bool ShutdownRequested(node::NodeContext &node)
Return whether node shutdown was requested.
bool StartIndexBackgroundSync(NodeContext &node)
Validates requirements to run the indexes and spawns each index initial sync thread.
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
bool AppInitInterfaces(NodeContext &node)
Initialize node and wallet interface pointers.
static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
static constexpr bool DEFAULT_REST_ENABLE
static void registerSignalHandler(int signal, void(*handler)(int))
bool AppInitMain(NodeContext &node, interfaces::BlockAndHeaderTipInfo *tip_info)
Bitcoin core main initialization.
static constexpr bool DEFAULT_I2P_ACCEPT_INCOMING
bool AppInitLockDirectories()
Lock bitcoin core critical directories.
void SetupServerArgs(ArgsManager &argsman, bool can_listen_ipc)
Register all arguments with the ArgsManager.
void InitContext(NodeContext &node)
Initialize node context shutdown and args variables.
static void new_handler_terminate()
bool AppInitSanityChecks(const kernel::Context &kernel)
Initialization sanity checks.
static constexpr bool DEFAULT_DAEMON
Default value for -daemon option.
static constexpr bool DEFAULT_DAEMONWAIT
Default value for -daemonwait option.
CClientUIInterface uiInterface
void InitWarning(const bilingual_str &str)
Show warning message.
bool InitError(const bilingual_str &str)
Show error message.
static constexpr size_t DEFAULT_DB_CACHE_BATCH
Default LevelDB write batch size.
bool ECC_InitSanityCheck()
Check that required EC support is available at runtime.
#define LogDebug(category,...)
BCLog::Logger & LogInstance()
void StartMapPort(bool enable)
static constexpr bool DEFAULT_NATPMP
static constexpr unsigned int DEFAULT_MAX_MEMPOOL_SIZE_MB
Default for -maxmempool, maximum megabytes of mempool memory usage.
static constexpr bool DEFAULT_ACCEPT_NON_STD_TXN
Default for -acceptnonstdtxn.
static constexpr unsigned int DEFAULT_MEMPOOL_EXPIRY_HOURS
Default for -mempoolexpiry, expiration time for mempool transactions in hours.
static constexpr unsigned int DEFAULT_BLOCKSONLY_MAX_MEMPOOL_SIZE_MB
Default for -maxmempool when blocksonly is set.
static constexpr bool DEFAULT_PERSIST_V1_DAT
Whether to fall back to legacy V1 serialization when writing mempool.dat.
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
is used externally by mining IPC clients, so it should only declare simple data definitions.
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
constexpr auto RATELIMIT_WINDOW
constexpr bool DEFAULT_LOGRATELIMIT
constexpr uint64_t RATELIMIT_MAX_BYTES
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
bilingual_str InvalidPortErrMsg(const std::string &optname, const std::string &invalid_value)
void StartHTTPServer()
Start HTTP server.
void StopHTTPServer()
Stop HTTP server.
void InterruptHTTPServer()
Interrupt HTTP server threads.
bool InitHTTPServer()
Initialize HTTP server.
void AddLoggingArgs(ArgsManager &argsman)
util::Result< void > SetLoggingCategories(const ArgsManager &args)
bool StartLogging(const ArgsManager &args)
util::Result< void > SetLoggingLevel(const ArgsManager &args)
void SetLoggingOptions(const ArgsManager &args)
std::unique_ptr< Mining > MakeMining(const node::NodeContext &node, bool wait_loaded=true)
Return implementation of Mining interface.
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
static constexpr bool DEFAULT_XOR_BLOCKSDIR
util::Result< void > SanityChecks(const Context &)
Ensure a usable environment with all necessary library support.
ChainstateLoadStatus
Chainstate load status.
@ FAILURE
Generic failure which reindexing may fix.
std::tuple< ChainstateLoadStatus, bilingual_str > ChainstateLoadResult
Chainstate load status code and optional error string.
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
fs::path MempoolPath(const ArgsManager &argsman)
void LogOversizedDbCache(const ArgsManager &args) noexcept
util::Result< void > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
Result< BlockCreateOptions > ReadMiningArgs(const ArgsManager &args)
Read the mining options set in args.
static const bool DEFAULT_PRINT_MODIFIED_FEE
bool ShouldPersistMempool(const ArgsManager &argsman)
void ReadNotificationArgs(const ArgsManager &args, KernelNotifications ¬ifications)
size_t GetDefaultDBCache()
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
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 ThreadRename(const std::string &)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
bilingual_str ErrorString(const Result< T > &result)
void TraceThread(std::string_view thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
std::string ToString(const T &t)
Locale-independent version of std::to_string.
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
LockResult LockDirectory(const fs::path &directory, const fs::path &lockfile_name, bool probe_only)
bool AddLocal(const CService &addr_, int nScore)
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
void Discover()
Look up IP addresses from all interfaces on the machine and add them to the list of local addresses t...
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS
The maximum number of peer connections to maintain.
static constexpr bool DEFAULT_PRIVATE_BROADCAST
Default for -privatebroadcast.
static const unsigned int MAX_SUBVERSION_LENGTH
Maximum length of the user agent string in version message.
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
static const size_t DEFAULT_MAXSENDBUFFER
static const int NUM_FDS_MESSAGE_CAPTURE
Number of file descriptors required for message capture.
static constexpr bool DEFAULT_FIXEDSEEDS
static const bool DEFAULT_BLOCKSONLY
Default for blocks only.
static const size_t DEFAULT_MAXRECEIVEBUFFER
static const std::string DEFAULT_MAX_UPLOAD_TARGET
The default for -maxuploadtarget.
static constexpr bool DEFAULT_FORCEDNSSEED
static constexpr size_t MAX_PRIVATE_BROADCAST_CONNECTIONS
Maximum number of private broadcast connections.
static constexpr bool DEFAULT_DNSSEED
static const bool DEFAULT_LISTEN
-listen default
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT
-peertimeout default
static constexpr bool DEFAULT_V2_TRANSPORT
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
@ NET_ONION
TOR (v2 or v3)
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
bool SetNameProxy(const Proxy &addrProxy)
Set the name proxy to use for all connections to nodes specified by a hostname.
enum Network ParseNetwork(const std::string &net_in)
bool SetProxy(enum Network net, const Proxy &addrProxy)
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.
ReachableNets g_reachable_nets
bool IsUnixSocketPath(const std::string &name)
Check if a string is a valid UNIX domain socket path.
bool IsBadPort(uint16_t port)
Determine if a port is "bad" from the perspective of attempting to connect to a node on that port.
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
static const int DEFAULT_NAME_LOOKUP
-dns default
const std::string ADDR_PREFIX_UNIX
Prefix for unix domain socket addresses (which are local filesystem paths)
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
static constexpr size_t MIN_DB_CACHE
min. -dbcache (bytes)
unsigned int nBytesPerSigOp
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for -datacarriersize in vbytes.
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...
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or rep...
static constexpr bool DEFAULT_PERMIT_BAREMULTISIG
Default for -permitbaremultisig.
static constexpr unsigned int DUST_RELAY_TX_FEE
Min feerate for defining dust.
static constexpr unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
static constexpr unsigned int DEFAULT_BYTES_PER_SIGOP
Default for -bytespersigop.
static constexpr unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create.
static constexpr unsigned int DEFAULT_CLUSTER_SIZE_LIMIT_KVB
Maximum size of cluster in virtual kilobytes.
static constexpr unsigned int DEFAULT_BLOCK_RESERVED_WEIGHT
Default for -blockreservedweight.
static const bool DEFAULT_ACCEPT_DATACARRIER
Default for -datacarrier.
static constexpr unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
static constexpr unsigned int DEFAULT_CLUSTER_LIMIT
Maximum number of transactions per cluster (default)
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
ServiceFlags
nServices flags
void RandAddPeriodic() noexcept
Gather entropy from various expensive sources, and feed them to the PRNG state.
static void RegisterAllCoreRPCCommands(CRPCTable &t)
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
static constexpr bool DEFAULT_RPC_DOC_CHECK
void SetRPCWarmupFinished()
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
static constexpr size_t DEFAULT_VALIDATION_CACHE_BYTES
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
unsigned int nReceiveFloodSize
std::vector< NetWhitebindPermissions > vWhiteBinds
uint64_t nMaxOutboundLimit
CClientUIInterface * uiInterface
std::vector< NetWhitelistPermissions > vWhitelistedRangeIncoming
std::vector< CService > onion_binds
std::vector< std::string > m_specified_outgoing
NetEventsInterface * m_msgproc
std::vector< std::string > m_added_nodes
int64_t m_peer_connect_timeout
std::vector< CService > vBinds
unsigned int nSendBufferMaxSize
int m_max_automatic_connections
ServiceFlags m_local_services
bool m_i2p_accept_incoming
std::vector< std::string > vSeedNodes
bool m_use_addrman_outgoing
bool whitelist_forcerelay
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
std::vector< NetWhitelistPermissions > vWhitelistedRangeOutgoing
Application-specific storage settings.
fs::path path
Location in the filesystem where leveldb data will be stored.
Block and header tip information.
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
const CChainParams & chainparams
Context struct holding the kernel library's logically global state, and passed to external libbitcoin...
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...
std::function< void()> coins_error_cb
NodeContext struct containing references to chain state and connection state.
#define WAIT_LOCK(cs, name)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define TRY_LOCK(cs, name)
std::string SysErrorString(int err)
Return system error string from errno value.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
const std::string DEFAULT_TOR_CONTROL
Default control ip and port.
CService DefaultOnionServiceTarget(uint16_t port)
constexpr uint16_t DEFAULT_TOR_SOCKS_PORT
Functionality for communicating with Tor.
static const bool DEFAULT_LISTEN_ONION
constexpr int DEFAULT_TOR_CONTROL_PORT
consteval auto _(util::TranslatedLiteral str)
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
static constexpr unsigned MAX_CLUSTER_COUNT_LIMIT
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
static constexpr bool DEFAULT_TXINDEX
std::unique_ptr< TxoSpenderIndex > g_txospenderindex
The global txo spender index. May be null.
static constexpr bool DEFAULT_TXOSPENDERINDEX
bool CheckStandardAsmap(const std::span< const std::byte > data)
Provides a safe interface for validating ASMap data before use.
std::vector< std::byte > DecodeAsmap(fs::path path)
Loads an ASMap file from disk and validates it.
uint256 AsmapVersion(const std::span< const std::byte > data)
Computes SHA256 hash of ASMap data for versioning and consistency checks.
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.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
static constexpr int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
static constexpr int DEFAULT_CHECKLEVEL
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
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...
SynchronizationState
Current sync state passed to tip changed callbacks.
static const signed int DEFAULT_CHECKBLOCKS
const WalletInitInterface & g_wallet_init_interface
std::unique_ptr< CZMQNotificationInterface > g_zmq_notification_interface
void RegisterZMQRPCCommands(CRPCTable &t)