6 #if defined(HAVE_CONFIG_H)
94 #include <condition_variable>
107 #include <sys/stat.h>
110 #include <boost/signals2/signal.hpp>
147 #define MIN_CORE_FILEDESCRIPTORS 0
149 #define MIN_CORE_FILEDESCRIPTORS 150
189 if (std::error_code
error; !fs::remove(pid_path,
error)) {
190 std::string
msg{
error ?
error.message() :
"File does not exist"};
224 std::vector<std::thread> threads;
226 threads.emplace_back(runCommand,
cmd);
228 for (
auto& t : threads) {
237 ShutdownNotify(*
node.args);
246 node.connman->Interrupt();
258 static Mutex g_shutdown_mutex;
259 TRY_LOCK(g_shutdown_mutex, lock_shutdown);
260 if (!lock_shutdown)
return;
261 LogPrintf(
"%s: In progress...\n", __func__);
269 if (
node.mempool)
node.mempool->AddTransactionsUpdated(1);
275 for (
const auto& client :
node.chain_clients) {
283 if (
node.connman)
node.connman->Stop();
289 if (
node.scheduler)
node.scheduler->stop();
290 if (
node.chainman &&
node.chainman->m_thread_load.joinable())
node.chainman->m_thread_load.join();
294 node.peerman.reset();
295 node.connman.reset();
297 node.addrman.reset();
298 node.netgroupman.reset();
306 if (
node.fee_estimator) {
307 node.fee_estimator->Flush();
315 if (chainstate->CanFlushToDisk()) {
316 chainstate->ForceFlushStateToDisk();
346 if (chainstate->CanFlushToDisk()) {
347 chainstate->ForceFlushStateToDisk();
348 chainstate->ResetCoinsViews();
352 for (
const auto& client :
node.chain_clients) {
363 node.chain_clients.clear();
366 node.mempool.reset();
367 node.fee_estimator.reset();
368 node.chainman.reset();
369 node.scheduler.reset();
393 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
406 sigemptyset(&sa.sa_mask);
408 sigaction(signal, &sa,
nullptr);
443 std::vector<std::string> hidden_args = {
444 "-dbcrashratio",
"-forcecompactdb",
446 "-choosedatadir",
"-lang=<lang>",
"-min",
"-resetguisettings",
"-splash",
"-uiplatform"};
452 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, testnet: %s, signet: %s)", defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(), testnetChainParams->GetConsensus().defaultAssumeValid.GetHex(), signetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
ArgsManager::ALLOW_ANY,
OptionsCategory::OPTIONS);
472 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)",
475 argsman.
AddArg(
"-persistmempoolv1",
476 strprintf(
"Whether a mempool.dat file created by -persistmempool or the savemempool RPC will be written in the legacy format "
477 "(version 1) or the current format (version 2). This temporary option will be removed in the future. (default: %u)",
481 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. "
482 "Warning: Reverting this setting requires re-downloading the entire blockchain. "
484 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);
485 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);
489 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);
492 argsman.
AddArg(
"-blockfilterindex=<type>",
494 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
500 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, testnet: 127.0.0.1:%u=onion, signet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)", defaultBaseParams->OnionServiceTargetPort(), testnetBaseParams->OnionServiceTargetPort(), signetBaseParams->OnionServiceTargetPort(), regtestBaseParams->OnionServiceTargetPort()),
ArgsManager::ALLOW_ANY |
ArgsManager::NETWORK_ONLY,
OptionsCategory::CONNECTION);
526 argsman.
AddArg(
"-port=<port>",
strprintf(
"Listen for connections on <port>. Nodes not using the default ports (default: %u, testnet: %u, signet: %u, regtest: %u) are unlikely to get incoming connections. Not relevant for I2P (see doc/i2p.md).", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()),
ArgsManager::ALLOW_ANY |
ArgsManager::NETWORK_ONLY,
OptionsCategory::CONNECTION);
542 hidden_args.emplace_back(
"-upnp");
547 hidden_args.emplace_back(
"-natpmp");
549 argsman.
AddArg(
"-whitebind=<[permissions@]addr>",
"Bind to the given address and add permission flags to the peers connecting to it. "
553 argsman.
AddArg(
"-whitelist=<[permissions@]IP address or network>",
"Add permission flags to the peers connecting from the given IP address (e.g. 1.2.3.4) or "
554 "CIDR-notated network (e.g. 1.2.3.0/24). Uses the same permissions as "
571 hidden_args.emplace_back(
"-zmqpubhashblock=<address>");
572 hidden_args.emplace_back(
"-zmqpubhashtx=<address>");
573 hidden_args.emplace_back(
"-zmqpubrawblock=<address>");
574 hidden_args.emplace_back(
"-zmqpubrawtx=<address>");
575 hidden_args.emplace_back(
"-zmqpubsequence=<n>");
576 hidden_args.emplace_back(
"-zmqpubhashblockhwm=<n>");
577 hidden_args.emplace_back(
"-zmqpubhashtxhwm=<n>");
578 hidden_args.emplace_back(
"-zmqpubrawblockhwm=<n>");
579 hidden_args.emplace_back(
"-zmqpubrawtxhwm=<n>");
580 hidden_args.emplace_back(
"-zmqpubsequencehwm=<n>");
600 argsman.
AddArg(
"-maxtipage=<n>",
601 strprintf(
"Maximum tip age in seconds to consider node in initial block download (default: %u)",
615 argsman.
AddArg(
"-datacarriersize",
616 strprintf(
"Relay and mine transactions whose data-carrying raw scriptPubKey "
617 "is of this size or less (default: %u)",
623 argsman.
AddArg(
"-minrelaytxfee=<amt>",
strprintf(
"Fees (in %s/kvB) smaller than this are considered zero fee for relaying, mining and transaction creation (default: %s)",
634 argsman.
AddArg(
"-rpcallowip=<ip>",
"Allow JSON-RPC connections from specified source. Valid values for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0), a network/CIDR (e.g. 1.2.3.4/24), all ipv4 (0.0.0.0/0), or all ipv6 (::/0). This option can be specified multiple times",
ArgsManager::ALLOW_ANY,
OptionsCategory::RPC);
635 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);
636 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);
640 argsman.
AddArg(
"-rpcport=<port>",
strprintf(
"Listen for JSON-RPC connections on <port> (default: %u, testnet: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()),
ArgsManager::ALLOW_ANY |
ArgsManager::NETWORK_ONLY,
OptionsCategory::RPC);
645 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);
646 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);
654 hidden_args.emplace_back(
"-daemon");
655 hidden_args.emplace_back(
"-daemonwait");
668 if (pBlockIndex !=
nullptr) {
682 std::thread
t(runCommand,
cmd);
711 LogPrintf(
"%s: parameter interaction: -bind set -> setting -listen=1\n", __func__);
715 LogPrintf(
"%s: parameter interaction: -whitebind set -> setting -listen=1\n", __func__);
721 LogPrintf(
"%s: parameter interaction: -connect or -maxconnections=0 set -> setting -dnsseed=0\n", __func__);
723 LogPrintf(
"%s: parameter interaction: -connect or -maxconnections=0 set -> setting -listen=0\n", __func__);
726 std::string proxy_arg =
args.
GetArg(
"-proxy",
"");
727 if (proxy_arg !=
"" && proxy_arg !=
"0") {
730 LogPrintf(
"%s: parameter interaction: -proxy set -> setting -listen=0\n", __func__);
734 LogPrintf(
"%s: parameter interaction: -proxy set -> setting -upnp=0\n", __func__);
736 LogPrintf(
"%s: parameter interaction: -proxy set -> setting -natpmp=0\n", __func__);
740 LogPrintf(
"%s: parameter interaction: -proxy set -> setting -discover=0\n", __func__);
746 LogPrintf(
"%s: parameter interaction: -listen=0 -> setting -upnp=0\n", __func__);
748 LogPrintf(
"%s: parameter interaction: -listen=0 -> setting -natpmp=0\n", __func__);
751 LogPrintf(
"%s: parameter interaction: -listen=0 -> setting -discover=0\n", __func__);
753 LogPrintf(
"%s: parameter interaction: -listen=0 -> setting -listenonion=0\n", __func__);
755 LogPrintf(
"%s: parameter interaction: -listen=0 -> setting -i2pacceptincoming=0\n", __func__);
762 LogPrintf(
"%s: parameter interaction: -externalip set -> setting -discover=0\n", __func__);
768 LogPrintf(
"%s: parameter interaction: -blocksonly=1 -> setting -whitelistrelay=0\n", __func__);
777 LogPrintf(
"%s: parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n", __func__);
781 bool clearnet_reachable = std::any_of(onlynets.begin(), onlynets.end(), [](
const auto& net) {
782 const auto n = ParseNetwork(net);
783 return n == NET_IPV4 || n == NET_IPV6;
786 LogPrintf(
"%s: parameter interaction: -onlynet excludes IPv4 and IPv6 -> setting -dnsseed=0\n", __func__);
806 int nUserMaxConnections;
809 int64_t peer_connect_timeout;
810 std::set<BlockFilterType> g_enabled_filter_types;
820 std::set_new_handler(std::terminate);
821 LogPrintf(
"Error: Out of memory. Terminating.\n");
832 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
833 _CrtSetReportFile(_CRT_WARN, CreateFileA(
"NUL", GENERIC_WRITE, 0,
nullptr, OPEN_EXISTING, 0, 0));
835 _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
839 HeapSetInformation(
nullptr, HeapEnableTerminationOnCorruption,
nullptr, 0);
854 signal(SIGPIPE, SIG_IGN);
856 SetConsoleCtrlHandler(consoleCtrlHandler,
true);
883 if (!errors.
empty()) {
893 if (!warnings.
empty()) {
903 if (blockfilterindex_value ==
"" || blockfilterindex_value ==
"1") {
905 }
else if (blockfilterindex_value !=
"0") {
906 const std::vector<std::string> names =
args.
GetArgs(
"-blockfilterindex");
907 for (
const auto&
name : names) {
912 g_enabled_filter_types.insert(filter_type);
924 return InitError(
_(
"Cannot set -peerblockfilters without -blockfilterindex."));
932 return InitError(
_(
"Prune mode is incompatible with -txindex."));
934 return InitError(
_(
"Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
940 return InitError(
_(
"Cannot set -forcednsseed to true when setting -dnsseed to false."));
955 int nBind = std::max(nUserBind,
size_t(1));
957 nMaxConnections = std::max(nUserMaxConnections, 0);
964 int fd_max = FD_SETSIZE;
970 return InitError(
_(
"Not enough file descriptors available."));
973 if (nMaxConnections < nUserMaxConnections)
974 InitWarning(
strprintf(
_(
"Reducing -maxconnections from %d to %d, because of system limitations."), nUserMaxConnections, nMaxConnections));
988 if (peer_connect_timeout <= 0) {
1017 return InitError(
Untranslated(
"-rpcserialversion=0 is deprecated and will be removed in the future. Specify -deprecatedrpc=serialversion to allow anyway."));
1026 .notifications = notifications,
1029 if (!chainman_result) {
1032 BlockManager::Options blockman_opts_dummy{
1033 .chainparams = chainman_opts_dummy.chainparams,
1035 .notifications = chainman_opts_dummy.notifications,
1038 if (!blockman_result) {
1088 node.chain =
node.init->makeChain();
1098 if (!opt_max_upload) {
1112 LogPrintf(
"Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, nFD);
1116 LogPrintf(
"Warning: relative datadir option '%s' specified, which will be interpreted relative to the "
1117 "current working directory '%s'. This is fragile, because if bitcoin is started in the future "
1118 "from a different location, it will be unable to locate the current data files. There could "
1119 "also be data loss if bitcoin is started while in a temporary directory.\n",
1132 node.scheduler = std::make_unique<CScheduler>();
1135 node.scheduler->m_service_thread = std::thread(
util::TraceThread,
"scheduler", [&] {
node.scheduler->serviceQueue(); });
1138 node.scheduler->scheduleEvery([]{
1140 }, std::chrono::minutes{1});
1143 node.scheduler->scheduleEvery([&
args]{
1144 constexpr uint64_t min_disk_space = 50 << 20;
1146 LogPrintf(
"Shutting down due to lack of disk space!\n");
1149 }, std::chrono::minutes{5});
1164 for (
const auto& client :
node.chain_clients) {
1165 client->registerRpcs();
1179 return InitError(
_(
"Unable to start HTTP server. See debug log for details."));
1183 for (
const auto& client :
node.chain_clients) {
1184 if (!client->verify()) {
1204 std::vector<bool> asmap;
1207 if (!asmap_path.is_absolute()) {
1215 if (asmap.size() == 0) {
1220 LogPrintf(
"Using asmap version %s for IP bucketing\n", asmap_version.
ToString());
1222 LogPrintf(
"Using /16 prefix for IP bucketing\n");
1227 node.netgroupman = std::make_unique<NetGroupManager>(std::move(asmap));
1231 uiInterface.InitMessage(
_(
"Loading P2P addresses…").translated);
1234 node.addrman = std::move(*addrman);
1240 node.connman = std::make_unique<CConnman>(GetRand<uint64_t>(),
1241 GetRand<uint64_t>(),
1247 if (!peerman_opts.ignore_incoming_txs) {
1252 node.fee_estimator = std::make_unique<CBlockPolicyEstimator>(
FeeestPath(
args), read_stale_estimates);
1261 for (
const std::string port_option : {
1266 const std::string port =
args.
GetArg(port_option,
"");
1274 for (
const std::string port_option : {
1287 for (
const std::string& socket_addr :
args.
GetArgs(port_option)) {
1288 std::string host_out;
1289 uint16_t port_out{0};
1296 for (
const std::string& socket_addr :
args.
GetArgs(
"-bind")) {
1297 std::string host_out;
1298 uint16_t port_out{0};
1299 std::string bind_socket_addr = socket_addr.substr(0, socket_addr.rfind(
'='));
1306 std::vector<std::string> uacomments;
1307 for (
const std::string& cmt :
args.
GetArgs(
"-uacomment")) {
1309 return InitError(
strprintf(
_(
"User Agent comment (%s) contains unsafe characters."), cmt));
1310 uacomments.push_back(cmt);
1314 return InitError(
strprintf(
_(
"Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments."),
1320 for (
const std::string& snet :
args.
GetArgs(
"-onlynet")) {
1331 _(
"Outbound connections restricted to CJDNS (-onlynet=cjdns) but "
1332 "-cjdnsreachable is not provided"));
1345 return InitError(
strprintf(
_(
"Incompatible options: -dnsseed=1 was explicitly specified, but -onlynet forbids connections to IPv4/IPv6")));
1356 std::string proxyArg =
args.
GetArg(
"-proxy",
"");
1357 if (proxyArg !=
"" && proxyArg !=
"0") {
1359 if (!proxyAddr.has_value()) {
1363 Proxy addrProxy =
Proxy(proxyAddr.value(), proxyRandomize);
1371 onion_proxy = addrProxy;
1379 std::string onionArg =
args.
GetArg(
"-onion",
"");
1380 if (onionArg !=
"") {
1381 if (onionArg ==
"0") {
1382 onion_proxy =
Proxy{};
1383 if (onlynet_used_with_onion) {
1385 _(
"Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1386 "reaching the Tor network is explicitly forbidden: -onion=0"));
1390 if (!addr.has_value() || !addr->IsValid()) {
1393 onion_proxy =
Proxy{addr.value(), proxyRandomize};
1403 if (onlynet_used_with_onion && listenonion_disabled) {
1405 _(
"Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
1406 "reaching the Tor network is not provided: none of -proxy, -onion or "
1407 "-listenonion is given"));
1412 for (
const std::string& strAddr :
args.
GetArgs(
"-externalip")) {
1414 if (addrLocal.has_value() && addrLocal->IsValid())
1424 return chainman->m_blockman.ReadBlockFromDisk(block, index);
1434 node.notifications = std::make_unique<KernelNotifications>(
node.exit_status);
1437 bool fReindexChainState =
args.
GetBoolArg(
"-reindex-chainstate",
false);
1442 .notifications = *
node.notifications,
1446 BlockManager::Options blockman_opts{
1447 .chainparams = chainman_opts.chainparams,
1449 .notifications = chainman_opts.notifications,
1457 LogPrintf(
"* Using %.1f MiB for block index database\n", cache_sizes.
block_tree_db * (1.0 / 1024 / 1024));
1459 LogPrintf(
"* Using %.1f MiB for transaction index database\n", cache_sizes.
tx_index * (1.0 / 1024 / 1024));
1462 LogPrintf(
"* Using %.1f MiB for %s block filter index database\n",
1465 LogPrintf(
"* Using %.1f MiB for chain state database\n", cache_sizes.
coins_db * (1.0 / 1024 / 1024));
1477 mempool_opts.check_ratio = std::clamp<int>(mempool_opts.check_ratio, 0, 1'000'000);
1479 int64_t descendant_limit_bytes = mempool_opts.limits.descendant_size_vbytes * 40;
1480 if (mempool_opts.max_size_bytes < 0 || mempool_opts.max_size_bytes < descendant_limit_bytes) {
1481 return InitError(
strprintf(
_(
"-maxmempool must be at least %d MB"), std::ceil(descendant_limit_bytes / 1'000'000.0)));
1483 LogPrintf(
"* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of unused mempool space)\n", cache_sizes.
coins * (1.0 / 1024 / 1024), mempool_opts.max_size_bytes * (1.0 / 1024 / 1024));
1486 node.mempool = std::make_unique<CTxMemPool>(mempool_opts);
1488 node.chainman = std::make_unique<ChainstateManager>(
node.kernel->interrupt, chainman_opts, blockman_opts);
1495 LogPrintf(
"[snapshot] restarting indexes\n");
1501 for (
auto* index :
node.indexes) {
1504 if (!(index->Init() && index->StartBackgroundSync())) {
1505 LogPrintf(
"[snapshot] WARNING failed to restart index %s on snapshot chain\n", index->GetName());
1521 _(
"Error reading from database, shutting down."),
1525 uiInterface.InitMessage(
_(
"Loading block index…").translated);
1526 const auto load_block_index_start_time{SteadyClock::now()};
1527 auto catch_exceptions = [](
auto&& f) {
1530 }
catch (
const std::exception& e) {
1535 auto [status,
error] = catch_exceptions([&]{
return LoadChainstate(chainman, cache_sizes, options); });
1545 LogPrintf(
" block index %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - load_block_index_start_time));
1558 error.original +
".\nPlease restart with -reindex or -reindex-chainstate to recover.",
1564 LogPrintf(
"Aborted block database rebuild. Exiting.\n");
1577 LogPrintf(
"Shutdown requested. Exiting.\n");
1585 node.banman.get(), chainman,
1586 *
node.mempool, peerman_opts);
1596 for (
const auto& filter_type : g_enabled_filter_types) {
1607 for (
auto index :
node.indexes)
if (!index->Init())
return false;
1610 for (
const auto& client :
node.chain_clients) {
1611 if (!client->load()) {
1624 uiInterface.InitMessage(
_(
"Pruning blockstore…").translated);
1625 chainstate->PruneAndFlush();
1629 LogPrintf(
"Setting NODE_NETWORK on non-prune mode\n");
1647 if (!
fReindex && !fReindexChainState && chain_active_height <= 1) {
1649 uint64_t additional_bytes_needed{
1652 assumed_chain_bytes};
1656 "Disk space for %s may not accommodate the block files. " \
1657 "Approximately %u GB of data will be stored in this directory."
1667 boost::signals2::connection block_notify_genesis_wait_connection;
1675 const std::string block_notify =
args.
GetArg(
"-blocknotify",
"");
1676 if (!block_notify.empty()) {
1679 std::string
command = block_notify;
1681 std::thread
t(runCommand,
command);
1687 std::vector<fs::path> vImportFiles;
1688 for (
const std::string& strFile :
args.
GetArgs(
"-loadblock")) {
1696 LogPrintf(
"Stopping after block import\n");
1703 bilingual_str err_str =
_(
"Failed to start indexes, shutting down..");
1723 block_notify_genesis_wait_connection.disconnect();
1742 if (tip_info && chainman.m_best_header) {
1744 tip_info->
header_time = chainman.m_best_header->GetBlockTime();
1747 LogPrintf(
"nBestHeight = %d\n", chain_active_height);
1748 if (
node.peerman)
node.peerman->SetBestHeight(chain_active_height);
1766 const uint16_t default_bind_port =
1769 const auto BadPortWarning = [](
const char*
prefix, uint16_t port) {
1770 return strprintf(
_(
"%s request to listen on port %u. This port is considered \"bad\" and "
1771 "thus it is unlikely that any peer will connect to it. See "
1772 "doc/p2p-bad-ports.md for details and a full list."),
1777 for (
const std::string& bind_arg :
args.
GetArgs(
"-bind")) {
1778 std::optional<CService> bind_addr;
1779 const size_t index = bind_arg.rfind(
'=');
1780 if (index == std::string::npos) {
1781 bind_addr =
Lookup(bind_arg, default_bind_port,
false);
1782 if (bind_addr.has_value()) {
1783 connOptions.
vBinds.push_back(bind_addr.value());
1784 if (
IsBadPort(bind_addr.value().GetPort())) {
1785 InitWarning(BadPortWarning(
"-bind", bind_addr.value().GetPort()));
1790 const std::string network_type = bind_arg.substr(index + 1);
1791 if (network_type ==
"onion") {
1792 const std::string truncated_bind_arg = bind_arg.substr(0, index);
1793 bind_addr =
Lookup(truncated_bind_arg,
BaseParams().OnionServiceTargetPort(),
false);
1794 if (bind_addr.has_value()) {
1795 connOptions.
onion_binds.push_back(bind_addr.value());
1803 for (
const std::string& strBind :
args.
GetArgs(
"-whitebind")) {
1825 onion_service_target = connOptions.
onion_binds.front();
1828 connOptions.
onion_binds.push_back(onion_service_target);
1834 "for the automatically created Tor onion service."),
1846 for (
const auto& net :
args.
GetArgs(
"-whitelist")) {
1859 if (connect.size() != 1 || connect[0] !=
"0") {
1863 LogPrintf(
"-seednode is ignored when -connect is used\n");
1867 LogPrintf(
"-dnsseed is ignored when -connect is used and -proxy is specified\n");
1871 const std::string& i2psam_arg =
args.
GetArg(
"-i2psam",
"");
1872 if (!i2psam_arg.empty()) {
1874 if (!addr.has_value() || !addr->IsValid()) {
1881 _(
"Outbound connections restricted to i2p (-onlynet=i2p) but "
1882 "-i2psam is not provided"));
1889 if (!
node.connman->Start(*
node.scheduler, connOptions)) {
1908 for (
const auto& client :
node.chain_clients) {
1909 client->start(*
node.scheduler);
1913 node.scheduler->scheduleEvery([banman]{
1917 if (
node.peerman)
node.peerman->StartScheduledTasks(*
node.scheduler);
1920 StartupNotify(
args);
1932 std::optional<const CBlockIndex*> indexes_start_block;
1933 std::string older_index_name;
1938 for (
auto index :
node.indexes) {
1940 if (summary.
synced)
continue;
1945 if (!index_chain.
Contains(pindex)) {
1946 pindex = index_chain.
FindFork(pindex);
1949 if (!indexes_start_block || !pindex || pindex->
nHeight < indexes_start_block.value()->nHeight) {
1950 indexes_start_block = pindex;
1951 older_index_name = summary.
name;
1957 if (indexes_start_block) {
1959 const CBlockIndex* start_block = *indexes_start_block;
1961 if (!chainman.
m_blockman.CheckBlockDataAvailability(*index_chain.
Tip(), *
Assert(start_block))) {
1962 return InitError(
strprintf(
Untranslated(
"%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));
1967 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.
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
const char *const BITCOIN_SETTINGS_FILENAME
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 RPCNotifyBlockChange(const CBlockIndex *pindex)
Callback for when block tip changed.
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
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.
const std::set< BlockFilterType > & AllBlockFilterTypes()
Get a list of known filter types.
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
void ForEachBlockFilterIndex(std::function< void(BlockFilterIndex &)> fn)
Iterate over all running block filter indexes, invoking fn on each.
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
const CChainParams & Params()
Return the currently selected parameters.
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 CBaseChainParams & BaseParams()
Return the currently selected parameters.
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const ChainType chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 18445) have been chosen arbitrarily to...
static constexpr int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
static constexpr int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
static constexpr bool DEFAULT_CHECKPOINTS_ENABLED
static constexpr auto DEFAULT_MAX_TIP_AGE
std::string ChainTypeToString(ChainType chain)
#define Assert(val)
Identity function.
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...
const fs::path & GetBlocksDirPath() const
Get blocks directory path.
std::list< SectionInfo > GetUnrecognizedSections() const
Log warnings for unrecognized section names in the config file.
@ ALLOW_ANY
disable validation
@ DISALLOW_ELISION
disallow -foo syntax that doesn't assign any value
ChainType GetChainType() const
Returns the appropriate chain type from the program arguments.
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
bool SoftSetArg(const std::string &strArg, const std::string &strValue)
Set an argument if it doesn't already have a value.
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
const fs::path & GetDataDirNet() const
Get data directory path with appended network identifier.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
bool SoftSetBoolArg(const std::string &strArg, bool fValue)
Set a boolean argument if it doesn't already have a value.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
void AddHiddenArgs(const std::vector< std::string > &args)
Add many hidden arguments.
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const
Return path argument or default value.
std::atomic< bool > m_reopen_file
void DumpBanlist() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
void Stop()
Stops the instance from staying in sync with blockchain updates.
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
The block chain is a tree shaped structure starting with the genesis block at the root,...
uint256 GetBlockHash() const
int64_t GetBlockTime() 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.
CBlockIndex * Genesis() const
Returns the index entry for the genesis block of this chain, or nullptr if none.
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
int Height() const
Return the maximal height in the chain.
const CBlockIndex * FindFork(const CBlockIndex *pindex) const
Find the last common block between this chain and a block index entry.
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
std::string GetChainTypeString() const
Return the chain type string.
bool DefaultConsistencyChecks() const
Default value for -checkmempool and -checkblockindex argument.
const ChainTxData & TxData() const
uint64_t AssumedBlockchainSize() const
Minimum free space (in GB) needed for data directory.
const MessageStartChars & MessageStart() const
ChainType GetChainType() const
Return the chain type.
const CBlock & GenesisBlock() const
void UnregisterBackgroundSignalScheduler()
Unregister a CScheduler to give callbacks which should run in the background - these callbacks will n...
void RegisterBackgroundSignalScheduler(CScheduler &scheduler)
Register a CScheduler to give callbacks which should run in the background (may only be called once)
void FlushBackgroundCallbacks()
Call any remaining callbacks on the calling thread.
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(CBlock &, 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.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
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...
const CChainParams & GetParams() const
std::thread m_thread_load
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
std::function< void()> restart_indexes
Function to restart active indexes; set dynamically to avoid a circular dependency on base/index....
const util::SignalInterrupt & m_interrupt
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
kernel::Notifications & GetNotifications() const
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Different type to mark Mutex at global scope.
A writer stream (for serialization) that computes a 256-bit hash.
static bool TryParse(const std::string &str, NetWhitebindPermissions &output, bilingual_str &error)
static bool TryParse(const std::string &str, NetWhitelistPermissions &output, bilingual_str &error)
static std::unique_ptr< PeerManager > make(CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, 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
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
A base class defining functions for notifying about certain kernel events.
virtual void fatalError(const std::string &debug_message, const bilingual_str &user_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)
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstStoredBlock(const CBlockIndex &start_block LIFETIMEBOUND, const CBlockIndex *lower_block=nullptr) EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
bool IsPruneMode() const
Whether running in -prune mode.
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...
static const int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
const std::string CLIENT_NAME
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.
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
bilingual_str ResolveErrMsg(const std::string &optname, const std::string &strBind)
bilingual_str InvalidPortErrMsg(const std::string &optname, const std::string &invalid_value)
const std::string CURRENCY_UNIT
fs::path FeeestPath(const ArgsManager &argsman)
bool LockDirectory(const fs::path &directory, const fs::path &lockfile_name, bool probe_only)
bool DirIsWritable(const fs::path &directory)
int RaiseFileDescriptorLimit(int nMinFD)
this function tries to raise the file descriptor limit to the requested number.
bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes)
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.
void InterruptHTTPServer()
Interrupt HTTP server threads.
void StartHTTPServer()
Start HTTP server.
bool InitHTTPServer()
Initialize HTTP server.
void StopHTTPServer()
Stop HTTP server.
static const int DEFAULT_HTTP_SERVER_TIMEOUT
static const int DEFAULT_HTTP_WORKQUEUE
static const int DEFAULT_HTTP_THREADS
Common init functions shared by bitcoin-node, bitcoin-wallet, etc.
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 void RemovePidFile(const ArgsManager &args)
void Interrupt(NodeContext &node)
Interrupt threads.
void InitLogging(const ArgsManager &args)
Initialize global loggers.
static bool AppInitServers(NodeContext &node)
bool AppInitLockDataDirectory()
Lock bitcoin core data directory.
void SetupServerArgs(ArgsManager &argsman)
Register all arguments with the ArgsManager.
#define MIN_CORE_FILEDESCRIPTORS
void Shutdown(NodeContext &node)
static void HandleSIGTERM(int)
Signal handlers are very limited in what they are allowed to do.
static GlobalMutex g_genesis_wait_mutex
static void OnRPCStarted()
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 std::condition_variable g_genesis_wait_cv
static constexpr bool DEFAULT_PROXYRANDOMIZE
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
static const char * DEFAULT_ASMAP_FILENAME
void InitParameterInteraction(ArgsManager &args)
Parameter interaction: change current parameters depending on various rules.
static constexpr bool DEFAULT_REST_ENABLE
static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex)
static void OnRPCStopped()
static bool LockDataDirectory(bool probeOnly)
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
static boost::signals2::connection rpc_notify_block_change_connection
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.
BCLog::Logger & LogInstance()
#define LogPrint(category,...)
bool error(const char *fmt, const Args &... args)
#define LogPrintfCategory(category,...)
void StartMapPort(bool use_upnp, bool use_natpmp)
static constexpr bool DEFAULT_NATPMP
static constexpr bool DEFAULT_UPNP
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 bool DEFAULT_MEMPOOL_FULL_RBF
Default for -mempoolfullrbf, if the transaction replaceability signaling is ignored.
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::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
void OnStarted(std::function< void()> slot)
void OnStopped(std::function< void()> slot)
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.
static path PathFromString(const std::string &string)
Convert byte string to path object.
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< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
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.
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
util::Result< void > SanityChecks(const Context &)
Ensure a usable environment with all necessary library support.
@ FAILURE_INCOMPATIBLE_DB
@ FAILURE_FATAL
Fatal error which should not prompt to reindex.
@ FAILURE
Generic failure which reindexing may fix.
@ FAILURE_INSUFFICIENT_DBCACHE
static const bool DEFAULT_PRINTPRIORITY
void ImportBlocks(ChainstateManager &chainman, std::vector< fs::path > vImportFiles)
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
fs::path MempoolPath(const ArgsManager &argsman)
util::Result< void > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
bool ShouldPersistMempool(const ArgsManager &argsman)
void ReadNotificationArgs(const ArgsManager &args, KernelNotifications ¬ifications)
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
This sequence can have 4 types of outcomes:
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
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
std::atomic_bool fReindex
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.
void ThreadRename(std::string &&)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
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 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 bool DEFAULT_WHITELISTFORCERELAY
Default for -whitelistforcerelay.
static const bool DEFAULT_WHITELISTRELAY
Default for -whitelistrelay.
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 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
static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN
Default number of non-mempool transactions to keep around for block reconstruction.
static const uint32_t DEFAULT_MAX_ORPHAN_TRANSACTIONS
Default for -maxorphantx, maximum number of orphan transactions kept in memory.
static constexpr bool DEFAULT_TXRECONCILIATION_ENABLE
Whether transaction reconciliation protocol should be enabled by default.
static const bool DEFAULT_PEERBLOCKFILTERS
static const bool DEFAULT_PEERBLOOMFILTERS
@ NET_ONION
TOR (v2 or v3)
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
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.
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)
ReachableNets g_reachable_nets
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
bool IsBadPort(uint16_t port)
Determine if a port is "bad" from the perspective of attempting to connect to a node on that port.
static const int DEFAULT_NAME_LOOKUP
-dns default
static const int DEFAULT_CONNECT_TIMEOUT
-timeout default
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
unsigned int nBytesPerSigOp
static const unsigned int MAX_OP_RETURN_RELAY
Default setting for -datacarriersize.
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 unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT_KVB
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
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_DESCENDANT_SIZE_LIMIT_KVB
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
static constexpr unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create.
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_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
bool IsDeprecatedRPCEnabled(const std::string &method)
void SetRPCWarmupFinished()
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
static const unsigned int DEFAULT_RPC_SERIALIZE_VERSION
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
void StartShutdown()
Request shutdown of the application.
void AbortShutdown()
Clear shutdown flag.
bool InitSignatureCache(size_t max_size_bytes)
static constexpr size_t DEFAULT_MAX_SIG_CACHE_BYTES
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
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.
unsigned int nReceiveFloodSize
std::vector< NetWhitebindPermissions > vWhiteBinds
uint64_t nMaxOutboundLimit
std::vector< NetWhitelistPermissions > vWhitelistedRange
CClientUIInterface * uiInterface
std::vector< CService > onion_binds
std::vector< std::string > m_specified_outgoing
NetEventsInterface * m_msgproc
ServiceFlags nLocalServices
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
bool m_i2p_accept_incoming
std::vector< std::string > vSeedNodes
bool m_use_addrman_outgoing
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
Block and header tip information.
double verification_progress
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
std::function< bool()> check_interrupt
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.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
NodeClock::time_point GetAdjustedTime()
static const int64_t DEFAULT_MAX_TIME_ADJUSTMENT
CService DefaultOnionServiceTarget()
const std::string DEFAULT_TOR_CONTROL
Default control ip and port.
void InterruptTorControl()
void StartTorControl(CService onion_service_target)
static const bool DEFAULT_LISTEN_ONION
constexpr int DEFAULT_TOR_CONTROL_PORT
Functionality for communicating with Tor.
bilingual_str _(const char *psz)
Translation function.
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
static const int64_t nMinDbCache
min. -dbcache (MiB)
static const int64_t nDefaultDbBatchSize
-dbbatchsize default (bytes)
static const int64_t nMaxDbCache
max. -dbcache (MiB)
static const int64_t nDefaultDbCache
-dbcache default (MiB)
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
static constexpr bool DEFAULT_TXINDEX
std::vector< bool > DecodeAsmap(fs::path path)
Read asmap from provided binary file.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
bool ParseUInt16(std::string_view str, uint16_t *out)
Convert decimal string to unsigned 16-bit integer with strict parse error feedback.
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].
bool SplitHostPort(std::string_view in, uint16_t &portOut, std::string &hostOut)
Splits socket address string into host string and port value.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
std::condition_variable g_best_block_cv
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess how far we are in the verification process at the given block index require cs_main if pindex h...
bool InitScriptExecutionCache(size_t max_size_bytes)
Initializes the script-execution cache.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
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
CMainSignals & GetMainSignals()
void UnregisterAllValidationInterfaces()
Unregister all subscribers.
void UnregisterValidationInterface(CValidationInterface *callbacks)
Unregister subscriber.
void RegisterValidationInterface(CValidationInterface *callbacks)
Register subscriber.
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
const WalletInitInterface & g_wallet_init_interface
std::unique_ptr< CZMQNotificationInterface > g_zmq_notification_interface
void RegisterZMQRPCCommands(CRPCTable &t)