6#include <bitcoin-build-config.h>
41#include <event2/buffer.h>
42#include <event2/keyvalq_struct.h>
63static constexpr std::array
NETWORKS{
"not_publicly_routable",
"ipv4",
"ipv6",
"onion",
"i2p",
"cjdns",
"internal"};
64static constexpr std::array
NETWORK_SHORT_NAMES{
"npr",
"ipv4",
"ipv6",
"onion",
"i2p",
"cjdns",
"int"};
86 argsman.
AddArg(
"-generate",
87 strprintf(
"Generate blocks, equivalent to RPC getnewaddress followed by RPC generatetoaddress. Optional positional integer "
88 "arguments are number of blocks to generate (default: %s) and maximum iterations to try (default: %s), equivalent to "
89 "RPC generatetoaddress nblocks and maxtries arguments. Example: bitcoin-cli -generate 4 1000",
93 argsman.
AddArg(
"-getinfo",
"Get general information from the remote server. Note that unlike server-side RPC calls, the output of -getinfo is the result of multiple non-atomic requests. Some entries in the output may represent results from different states (e.g. wallet balance may be as of a different block from the chain state reported)",
ArgsManager::ALLOW_ANY,
OptionsCategory::CLI_COMMANDS);
94 argsman.
AddArg(
"-netinfo",
strprintf(
"Get network peer connection information from the remote server. An optional argument from 0 to %d can be passed for different peers listings (default: 0). If a non-zero value is passed, an additional \"outonly\" (or \"o\") argument can be passed to see outbound peers only. Pass \"help\" (or \"h\") for detailed help documentation.",
NETINFO_MAX_LEVEL),
ArgsManager::ALLOW_ANY,
OptionsCategory::CLI_COMMANDS);
103 argsman.
AddArg(
"-rpcport=<port>",
strprintf(
"Connect to JSON-RPC on <port> (default: %u, testnet: %u, testnet4: %u, signet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), testnet4BaseParams->RPCPort(), signetBaseParams->RPCPort(), regtestBaseParams->RPCPort()),
ArgsManager::ALLOW_ANY |
ArgsManager::NETWORK_ONLY,
OptionsCategory::OPTIONS);
107 argsman.
AddArg(
"-rpcwallet=<walletname>",
"Send RPC for non-default wallet on RPC server (needs to exactly match corresponding -wallet option passed to bitcoind). This changes the RPC endpoint used, e.g. http://127.0.0.1:8332/wallet/<walletname>",
ArgsManager::ALLOW_ANY,
OptionsCategory::OPTIONS);
108 argsman.
AddArg(
"-stdin",
"Read extra arguments from standard input, one per line until EOF/Ctrl-D (recommended for sensitive information such as passphrases). When combined with -stdinrpcpass, the first line from standard input is used for the RPC password.",
ArgsManager::ALLOW_ANY,
OptionsCategory::OPTIONS);
109 argsman.
AddArg(
"-stdinrpcpass",
"Read RPC password from standard input as a single line. When combined with -stdin, the first line from standard input is used for the RPC password. When combined with -stdinwalletpassphrase, -stdinrpcpass consumes the first line, and -stdinwalletpassphrase consumes the second.",
ArgsManager::ALLOW_ANY,
OptionsCategory::OPTIONS);
124 if (severity >= EVENT_LOG_ERR) {
125 throw std::runtime_error(
strprintf(
"libevent error: %s",
msg));
148 tfm::format(std::cerr,
"Error parsing command line arguments: %s\n", error);
152 std::string strUsage = CLIENT_NAME
" RPC client version " +
FormatFullVersion() +
"\n";
158 "The bitcoin-cli utility provides a command line interface to interact with a " CLIENT_NAME
" RPC server.\n"
159 "\nIt can be used to query network information, manage wallets, create or broadcast transactions, and control the " CLIENT_NAME
" server.\n"
160 "\nUse the \"help\" command to list all commands. Use \"help <command>\" to show help for that command.\n"
161 "The -named option allows you to specify parameters using the key=value format, eliminating the need to pass unused positional parameters.\n"
163 "Usage: bitcoin-cli [options] <command> [params]\n"
164 "or: bitcoin-cli [options] -named <command> [name=value]...\n"
165 "or: bitcoin-cli [options] help\n"
166 "or: bitcoin-cli [options] help <command>\n"
173 tfm::format(std::cerr,
"Error: too few parameters\n");
179 tfm::format(std::cerr,
"Error: Specified data directory \"%s\" does not exist.\n",
gArgs.
GetArg(
"-datadir",
""));
183 tfm::format(std::cerr,
"Error reading configuration file: %s\n", error);
189 }
catch (
const std::exception& e) {
210 case EVREQ_HTTP_TIMEOUT:
211 return "timeout reached";
213 return "EOF reached";
214 case EVREQ_HTTP_INVALID_HEADER:
215 return "error while reading header, or invalid header";
216 case EVREQ_HTTP_BUFFER_ERROR:
217 return "error encountered while reading or writing";
218 case EVREQ_HTTP_REQUEST_CANCEL:
219 return "request was canceled";
220 case EVREQ_HTTP_DATA_TOO_LONG:
221 return "response body is larger than allowed";
231 if (req ==
nullptr) {
239 reply->
status = evhttp_request_get_response_code(req);
241 struct evbuffer *buf = evhttp_request_get_input_buffer(req);
244 size_t size = evbuffer_get_length(buf);
245 const char *
data = (
const char*)evbuffer_pullup(buf, size);
247 reply->
body = std::string(
data, size);
248 evbuffer_drain(buf, size);
260 for (
size_t i = 0; i <
NETWORKS.size(); ++i) {
280 throw std::runtime_error(
"-addrinfo takes no arguments");
288 if (!reply[
"error"].isNull())
return reply;
289 const std::vector<UniValue>& nodes{reply[
"result"].
getValues()};
290 if (!nodes.empty() && nodes.at(0)[
"network"].isNull()) {
291 throw std::runtime_error(
"-addrinfo requires bitcoind server to be running v22.0 and up");
294 std::array<uint64_t,
NETWORKS.size()> counts{{}};
296 std::string network_name{
node[
"network"].get_str()};
299 ++counts.at(network_id);
304 for (
size_t i = 1; i <
NETWORKS.size() - 1; ++i) {
305 addresses.pushKV(
NETWORKS[i], counts.at(i));
306 total += counts.at(i);
308 addresses.pushKV(
"total", total);
309 result.pushKV(
"addresses_known", std::move(addresses));
325 throw std::runtime_error(
"-getinfo takes no arguments");
358 result.
pushKV(
"connections", std::move(connections));
364 result.
pushKV(
"has_wallet",
true);
367 if (!batch[
ID_WALLETINFO][
"result"][
"unlocked_until"].isNull()) {
445 if (seconds < 0)
return "";
446 const double milliseconds{round(1000 * seconds)};
447 return milliseconds > 999999 ?
"-" :
ToString(milliseconds);
451 if (conn_type ==
"outbound-full-relay")
return "full";
452 if (conn_type ==
"block-relay-only")
return "block";
453 if (conn_type ==
"manual" || conn_type ==
"feeler")
return conn_type;
454 if (conn_type ==
"addr-fetch")
return "addr";
460 for (
size_t i = 0; i < services.
size(); ++i) {
461 const std::string
s{services[i].
get_str()};
462 str +=
s ==
"NETWORK_LIMITED" ?
'l' :
s ==
"P2P_V2" ?
'2' :
ToLower(
s[0]);
475 if (
const auto res{ToIntegral<uint8_t>(
args.at(0))}) {
479 throw std::runtime_error(
strprintf(
"invalid -netinfo level argument: %s\nFor more information, run: bitcoin-cli -netinfo help",
args.at(0)));
481 if (
args.size() > 1) {
482 if (std::string_view
s{
args.at(1)}; n && (
s ==
"o" ||
s ==
"outonly")) {
485 throw std::runtime_error(
strprintf(
"invalid -netinfo outonly argument: %s\nFor more information, run: bitcoin-cli -netinfo help",
s));
487 throw std::runtime_error(
strprintf(
"invalid -netinfo outonly argument: %s\nThe outonly argument is only valid for a level greater than 0 (the first argument). For more information, run: bitcoin-cli -netinfo help",
s));
504 if (networkinfo[
"version"].getInt<int>() < 209900) {
505 throw std::runtime_error(
"-netinfo requires bitcoind server to be running v0.21.0 and up");
507 const int64_t time_now{TicksSinceEpoch<std::chrono::seconds>(CliClock::now())};
511 const std::string network{peer[
"network"].get_str()};
514 const bool is_outbound{!peer[
"inbound"].get_bool()};
515 const bool is_tx_relay{peer[
"relaytxes"].isNull() ? true : peer[
"relaytxes"].get_bool()};
516 const std::string conn_type{peer[
"connection_type"].get_str()};
517 ++
m_counts.at(is_outbound).at(network_id);
526 const int peer_id{peer[
"id"].getInt<
int>()};
527 const int mapped_as{peer[
"mapped_as"].isNull() ? 0 : peer[
"mapped_as"].getInt<
int>()};
528 const int version{peer[
"version"].getInt<
int>()};
529 const int64_t addr_processed{peer[
"addr_processed"].isNull() ? 0 : peer[
"addr_processed"].getInt<int64_t>()};
530 const int64_t addr_rate_limited{peer[
"addr_rate_limited"].isNull() ? 0 : peer[
"addr_rate_limited"].getInt<int64_t>()};
531 const int64_t conn_time{peer[
"conntime"].getInt<int64_t>()};
532 const int64_t last_blck{peer[
"last_block"].getInt<int64_t>()};
533 const int64_t last_recv{peer[
"lastrecv"].getInt<int64_t>()};
534 const int64_t last_send{peer[
"lastsend"].getInt<int64_t>()};
535 const int64_t last_trxn{peer[
"last_transaction"].getInt<int64_t>()};
536 const double min_ping{peer[
"minping"].isNull() ? -1 : peer[
"minping"].get_real()};
537 const double ping{peer[
"pingtime"].isNull() ? -1 : peer[
"pingtime"].get_real()};
538 const std::string addr{peer[
"addr"].get_str()};
539 const std::string age{conn_time == 0 ?
"" :
ToString((time_now - conn_time) / 60)};
540 const std::string services{
FormatServices(peer[
"servicesnames"])};
541 const std::string sub_version{peer[
"subver"].get_str()};
542 const std::string transport{peer[
"transport_protocol_type"].isNull() ?
"v1" : peer[
"transport_protocol_type"].get_str()};
543 const bool is_addr_relay_enabled{peer[
"addr_relay_enabled"].isNull() ? false : peer[
"addr_relay_enabled"].get_bool()};
544 const bool is_bip152_hb_from{peer[
"bip152_hb_from"].get_bool()};
545 const bool is_bip152_hb_to{peer[
"bip152_hb_to"].get_bool()};
546 m_peers.push_back({addr, sub_version, conn_type,
NETWORK_SHORT_NAMES[network_id], age, services, transport, min_ping,
ping, addr_processed, addr_rate_limited, last_blck, last_recv, last_send, last_trxn, peer_id, mapped_as, version, is_addr_relay_enabled, is_bip152_hb_from, is_bip152_hb_to, is_outbound, is_tx_relay});
558 std::string result{
strprintf(
"%s client %s%s - server %i%s\n\n", CLIENT_NAME,
FormatFullVersion(),
ChainToString(), networkinfo[
"protocolversion"].getInt<int>(), networkinfo[
"subversion"].get_str())};
563 result +=
strprintf(
"<-> type net %*s v mping ping send recv txn blk hb %*s%*s%*s ",
571 std::string version{
ToString(peer.version) + peer.sub_version};
573 "%3s %6s %5s %*s %2s%7s%7s%5s%5s%5s%5s %2s %*s%*s%*s%*i %*s %-*s%s\n",
574 peer.is_outbound ?
"out" :
"in",
579 (peer.transport_protocol_type.size() == 2 && peer.transport_protocol_type[0] ==
'v') ? peer.transport_protocol_type[1] :
' ',
582 peer.last_send ?
ToString(time_now - peer.last_send) :
"",
583 peer.last_recv ?
ToString(time_now - peer.last_recv) :
"",
584 peer.last_trxn ?
ToString((time_now - peer.last_trxn) / 60) : peer.is_tx_relay ?
"" :
"*",
585 peer.last_blck ?
ToString((time_now - peer.last_blck) / 60) :
"",
586 strprintf(
"%s%s", peer.is_bip152_hb_to ?
"." :
" ", peer.is_bip152_hb_from ?
"*" :
" "),
588 peer.addr_processed ?
ToString(peer.addr_processed) : peer.is_addr_relay_enabled ?
"" :
".",
590 peer.addr_rate_limited ?
ToString(peer.addr_rate_limited) :
"",
606 std::vector<int8_t> reachable_networks;
607 for (
const UniValue& network : networkinfo[
"networks"].getValues()) {
608 if (network[
"reachable"].get_bool()) {
609 const std::string& network_name{network[
"name"].get_str()};
612 result +=
strprintf(
"%8s", network_name);
613 reachable_networks.push_back(network_id);
618 if (
m_counts.at(2).at(network_id) == 0)
continue;
620 reachable_networks.push_back(network_id);
623 result +=
" total block";
626 const std::array rows{
"in",
"out",
"total"};
627 for (
size_t i = 0; i < rows.size(); ++i) {
629 for (int8_t n : reachable_networks) {
640 result +=
"\n\nLocal addresses";
641 const std::vector<UniValue>& local_addrs{networkinfo[
"localaddresses"].getValues()};
642 if (local_addrs.empty()) {
645 size_t max_addr_size{0};
646 for (
const UniValue& addr : local_addrs) {
647 max_addr_size = std::max(addr[
"address"].get_str().length() + 1, max_addr_size);
649 for (
const UniValue& addr : local_addrs) {
650 result +=
strprintf(
"\n%-*s port %6i score %6i", max_addr_size, addr[
"address"].get_str(), addr[
"port"].getInt<int>(), addr[
"score"].getInt<int>());
658 "-netinfo (level [outonly]) | help\n\n"
659 "Returns a network peer connections dashboard with information from the remote server.\n"
660 "This human-readable interface will change regularly and is not intended to be a stable API.\n"
661 "Under the hood, -netinfo fetches the data by calling getpeerinfo and getnetworkinfo.\n"
663 "If that argument is passed, an optional additional \"outonly\" argument may be passed to obtain the listing with outbound peers only.\n"
664 "Pass \"help\" or \"h\" to see this detailed help documentation.\n"
665 "If more than two arguments are passed, only the first two are read and parsed.\n"
666 "Suggestion: use -netinfo with the Linux watch(1) command for a live dashboard; see example below.\n\n"
668 +
strprintf(
"1. level (integer 0-%d, optional) Specify the info level of the peers dashboard (default 0):\n",
NETINFO_MAX_LEVEL) +
669 " 0 - Peer counts for each reachable network as well as for block relay peers\n"
670 " and manual peers, and the list of local addresses and ports\n"
671 " 1 - Like 0 but preceded by a peers listing (without address and version columns)\n"
672 " 2 - Like 1 but with an address column\n"
673 " 3 - Like 1 but with a version column\n"
674 " 4 - Like 1 but with both address and version columns\n"
675 "2. outonly (\"outonly\" or \"o\", optional) Return the peers listing with outbound peers only, i.e. to save screen space\n"
676 " when a node has many inbound peers. Only valid if a level is passed.\n\n"
677 "help (\"help\" or \"h\", optional) Print this help documentation instead of the dashboard.\n\n"
679 +
strprintf(
"* The peers listing in levels 1-%d displays all of the peers sorted by direction and minimum ping time:\n\n",
NETINFO_MAX_LEVEL) +
680 " Column Description\n"
681 " ------ -----------\n"
683 " \"in\" - inbound connections are those initiated by the peer\n"
684 " \"out\" - outbound connections are those initiated by us\n"
685 " type Type of peer connection\n"
686 " \"full\" - full relay, the default\n"
687 " \"block\" - block relay; like full relay but does not relay transactions or addresses\n"
688 " \"manual\" - peer we manually added using RPC addnode or the -addnode/-connect config options\n"
689 " \"feeler\" - short-lived connection for testing addresses\n"
690 " \"addr\" - address fetch; short-lived connection for requesting addresses\n"
691 " net Network the peer connected through (\"ipv4\", \"ipv6\", \"onion\", \"i2p\", \"cjdns\", or \"npr\" (not publicly routable))\n"
692 " serv Services offered by the peer\n"
693 " \"n\" - NETWORK: peer can serve the full block chain\n"
694 " \"b\" - BLOOM: peer can handle bloom-filtered connections (see BIP 111)\n"
695 " \"w\" - WITNESS: peer can be asked for blocks and transactions with witness data (SegWit)\n"
696 " \"c\" - COMPACT_FILTERS: peer can handle basic block filter requests (see BIPs 157 and 158)\n"
697 " \"l\" - NETWORK_LIMITED: peer limited to serving only the last 288 blocks (~2 days)\n"
698 " \"2\" - P2P_V2: peer supports version 2 P2P transport protocol, as defined in BIP 324\n"
699 " \"u\" - UNKNOWN: unrecognized bit flag\n"
700 " v Version of transport protocol used for the connection\n"
701 " mping Minimum observed ping time, in milliseconds (ms)\n"
702 " ping Last observed ping time, in milliseconds (ms)\n"
703 " send Time since last message sent to the peer, in seconds\n"
704 " recv Time since last message received from the peer, in seconds\n"
705 " txn Time since last novel transaction received from the peer and accepted into our mempool, in minutes\n"
706 " \"*\" - we do not relay transactions to this peer (getpeerinfo \"relaytxes\" is false)\n"
707 " blk Time since last novel block passing initial validity checks received from the peer, in minutes\n"
708 " hb High-bandwidth BIP152 compact block relay\n"
709 " \".\" (to) - we selected the peer as a high-bandwidth peer\n"
710 " \"*\" (from) - the peer selected us as a high-bandwidth peer\n"
711 " addrp Total number of addresses processed, excluding those dropped due to rate limiting\n"
712 " \".\" - we do not relay addresses to this peer (getpeerinfo \"addr_relay_enabled\" is false)\n"
713 " addrl Total number of addresses dropped due to rate limiting\n"
714 " age Duration of connection to the peer, in minutes\n"
715 " asmap Mapped AS (Autonomous System) number at the end of the BGP route to the peer, used for diversifying\n"
716 " peer selection (only displayed if the -asmap config option is set)\n"
717 " id Peer index, in increasing order of peer connections since node startup\n"
718 " address IP address and port of the peer\n"
719 " version Peer version and subversion concatenated, e.g. \"70016/Satoshi:21.0.0/\"\n\n"
720 "* The peer counts table displays the number of peers for each reachable network as well as\n"
721 " the number of block relay peers and manual peers.\n\n"
722 "* The local addresses table lists each local address broadcast by the node, the port, and the score.\n\n"
724 "Peer counts table of reachable networks and list of local addresses\n"
725 "> bitcoin-cli -netinfo\n\n"
726 "The same, preceded by a peers listing without address and version columns\n"
727 "> bitcoin-cli -netinfo 1\n\n"
730 "Full dashboard, but with outbound peers only\n"
732 "Full live dashboard, adjust --interval or --no-title as needed (Linux)\n"
735 "> bitcoin-cli -netinfo help\n"};
788 uint16_t rpcconnect_port{0};
794 throw std::runtime_error(
strprintf(
"Invalid port provided in -rpcconnect: %s", rpcconnect_str));
796 if (rpcconnect_port != 0) {
798 port = rpcconnect_port;
802 if (std::optional<std::string> rpcport_arg =
gArgs.
GetArg(
"-rpcport")) {
804 const uint16_t rpcport_int{ToIntegral<uint16_t>(rpcport_arg.value()).value_or(0)};
805 if (rpcport_int == 0) {
809 throw std::runtime_error(
strprintf(
"Invalid port provided in -rpcport: %s", rpcport_arg.value()));
817 if (rpcconnect_port != 0) {
818 tfm::format(std::cerr,
"Warning: Port specified in both -rpcconnect and -rpcport. Using -rpcport %u\n", port);
833 evhttp_connection_set_timeout(evcon.get(), timeout);
838 constexpr int YEAR_IN_SECONDS = 31556952;
839 evhttp_connection_set_timeout(evcon.get(), 5 * YEAR_IN_SECONDS);
845 if (req ==
nullptr) {
846 throw std::runtime_error(
"create http request failed");
852 std::string strRPCUserColonPass;
853 bool failedToGetAuthCookie =
false;
857 failedToGetAuthCookie =
true;
863 struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
865 evhttp_add_header(output_headers,
"Host", host.c_str());
866 evhttp_add_header(output_headers,
"Connection",
"close");
867 evhttp_add_header(output_headers,
"Content-Type",
"application/json");
868 evhttp_add_header(output_headers,
"Authorization", (std::string(
"Basic ") +
EncodeBase64(strRPCUserColonPass)).c_str());
872 struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
874 evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
877 std::string endpoint =
"/";
879 char* encodedURI = evhttp_uriencode(rpcwallet->data(), rpcwallet->size(),
false);
881 endpoint =
"/wallet/" + std::string(encodedURI);
887 int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, endpoint.c_str());
893 event_base_dispatch(base.get());
895 if (response.
status == 0) {
896 std::string responseErrorMessage;
897 if (response.
error != -1) {
901 "Make sure the bitcoind server is running and that you are connecting to the correct RPC port.\n"
902 "Use \"bitcoin-cli -help\" for more info.",
903 host, port, responseErrorMessage));
905 if (failedToGetAuthCookie) {
907 "Could not locate RPC credentials. No authentication cookie could be found, and RPC password is not set. See -rpcpassword and -stdinrpcpass. Configuration file: (%s)",
910 throw std::runtime_error(
"Authorization failed: Incorrect rpcuser or rpcpassword");
913 throw std::runtime_error(
strprintf(
"Server response: %s", response.
body));
915 throw std::runtime_error(
strprintf(
"server returned HTTP error %d", response.
status));
916 else if (response.
body.empty())
917 throw std::runtime_error(
"no response from server");
921 if (!valReply.read(response.
body))
922 throw std::runtime_error(
"couldn't parse reply from server");
925 throw std::runtime_error(
"expected reply to have result, error and id properties");
945 const auto deadline{std::chrono::steady_clock::now() + 1
s * timeout};
949 response =
CallRPC(rh, strMethod,
args, rpcwallet);
951 const UniValue& error = response.find_value(
"error");
958 if (fWait && (timeout <= 0 || std::chrono::steady_clock::now() < deadline)) {
971 if (result.
isNull())
return;
984 if (err_msg.
isStr()) {
988 strPrint +=
" Or for the CLI, specify the \"-rpcwallet=<walletname>\" option before the command";
989 strPrint +=
" (run \"bitcoin-cli -h\" for help or \"bitcoin-cli listwallets\" to see which wallets are currently loaded).";
994 nRet = abs(error[
"code"].getInt<int>());
1007 if (!
listwallets.find_value(
"error").isNull())
return;
1009 if (wallets.
size() <= 1)
return;
1013 const std::string& wallet_name =
wallet.get_str();
1016 balances.
pushKV(wallet_name, balance);
1018 result.
pushKV(
"balances", std::move(balances));
1029 if (progress < 0 || progress > 1)
return;
1031 static constexpr double INCREMENT{0.05};
1032 static const std::string COMPLETE_BAR{
"\u2592"};
1033 static const std::string INCOMPLETE_BAR{
"\u2591"};
1035 for (
int i = 0; i < progress / INCREMENT; ++i) {
1036 progress_bar += COMPLETE_BAR;
1039 for (
int i = 0; i < (1 - progress) / INCREMENT; ++i) {
1040 progress_bar += INCOMPLETE_BAR;
1053 std::string RESET, GREEN, BLUE, YELLOW, MAGENTA, CYAN;
1054 bool should_colorize =
false;
1057 if (isatty(fileno(stdout))) {
1059 should_colorize =
true;
1065 if (color ==
"always") {
1066 should_colorize =
true;
1067 }
else if (color ==
"never") {
1068 should_colorize =
false;
1069 }
else if (color !=
"auto") {
1070 throw std::runtime_error(
"Invalid value for -color option. Valid values: always, auto, never.");
1074 if (should_colorize) {
1078 YELLOW =
"\x1B[33m";
1079 MAGENTA =
"\x1B[35m";
1083 std::string result_string =
strprintf(
"%sChain: %s%s\n", BLUE, result[
"chain"].getValStr(), RESET);
1084 result_string +=
strprintf(
"Blocks: %s\n", result[
"blocks"].getValStr());
1085 result_string +=
strprintf(
"Headers: %s\n", result[
"headers"].getValStr());
1087 const double ibd_progress{result[
"verificationprogress"].
get_real()};
1088 std::string ibd_progress_bar;
1090 if (ibd_progress < 0.99) {
1093 ibd_progress_bar +=
" ";
1096 result_string +=
strprintf(
"Verification progress: %s%.4f%%\n", ibd_progress_bar, ibd_progress * 100);
1097 result_string +=
strprintf(
"Difficulty: %s\n\n", result[
"difficulty"].getValStr());
1100 "%sNetwork: in %s, out %s, total %s%s\n",
1102 result[
"connections"][
"in"].getValStr(),
1103 result[
"connections"][
"out"].getValStr(),
1104 result[
"connections"][
"total"].getValStr(),
1106 result_string +=
strprintf(
"Version: %s\n", result[
"version"].getValStr());
1107 result_string +=
strprintf(
"Time offset (s): %s\n", result[
"timeoffset"].getValStr());
1110 std::map<std::string, std::vector<std::string>> proxy_networks;
1111 std::vector<std::string> ordered_proxies;
1113 for (
const UniValue& network : result[
"networks"].getValues()) {
1114 const std::string proxy = network[
"proxy"].getValStr();
1115 if (proxy.empty())
continue;
1117 if (proxy_networks.find(proxy) == proxy_networks.end()) ordered_proxies.push_back(proxy);
1119 proxy_networks[proxy].push_back(network[
"name"].getValStr());
1122 std::vector<std::string> formatted_proxies;
1123 formatted_proxies.reserve(ordered_proxies.size());
1124 for (
const std::string& proxy : ordered_proxies) {
1125 formatted_proxies.emplace_back(
strprintf(
"%s (%s)", proxy,
Join(proxy_networks.find(proxy)->second,
", ")));
1127 result_string +=
strprintf(
"Proxies: %s\n", formatted_proxies.empty() ?
"n/a" :
Join(formatted_proxies,
", "));
1129 result_string +=
strprintf(
"Min tx relay fee rate (%s/kvB): %s\n\n",
CURRENCY_UNIT, result[
"relayfee"].getValStr());
1131 if (!result[
"has_wallet"].isNull()) {
1132 const std::string walletname = result[
"walletname"].
getValStr();
1133 result_string +=
strprintf(
"%sWallet: %s%s\n", MAGENTA, walletname.empty() ?
"\"\"" : walletname, RESET);
1135 result_string +=
strprintf(
"Keypool size: %s\n", result[
"keypoolsize"].getValStr());
1136 if (!result[
"unlocked_until"].isNull()) {
1137 result_string +=
strprintf(
"Unlocked until: %s\n", result[
"unlocked_until"].getValStr());
1139 result_string +=
strprintf(
"Transaction fee rate (-paytxfee) (%s/kvB): %s\n\n",
CURRENCY_UNIT, result[
"paytxfee"].getValStr());
1141 if (!result[
"balance"].isNull()) {
1142 result_string +=
strprintf(
"%sBalance:%s %s\n\n", CYAN, RESET, result[
"balance"].getValStr());
1145 if (!result[
"balances"].isNull()) {
1146 result_string +=
strprintf(
"%sBalances%s\n", CYAN, RESET);
1148 size_t max_balance_length{10};
1150 for (
const std::string&
wallet : result[
"balances"].getKeys()) {
1151 max_balance_length = std::max(result[
"balances"][
wallet].getValStr().length(), max_balance_length);
1154 for (
const std::string&
wallet : result[
"balances"].getKeys()) {
1157 result[
"balances"][
wallet].getValStr(),
1160 result_string +=
"\n";
1163 const std::string warnings{result[
"warnings"].
getValStr()};
1164 result_string +=
strprintf(
"%sWarnings:%s %s", YELLOW, RESET, warnings.empty() ?
"(none)" : warnings);
1166 result.
setStr(result_string);
1186 if (
args.size() > 2)
throw std::runtime_error(
"too many arguments (maximum 2 for nblocks and maxtries)");
1187 if (
args.size() == 0) {
1189 }
else if (
args.at(0) ==
"0") {
1190 throw std::runtime_error(
"the first argument (number of blocks to generate, default: " +
DEFAULT_NBLOCKS +
") must be an integer value greater than zero");
1192 args.emplace(
args.begin() + 1, address);
1205 std::string rpcPass;
1209 fputs(
"RPC password> ", stderr);
1212 if (!std::getline(std::cin, rpcPass)) {
1213 throw std::runtime_error(
"-stdinrpcpass specified but failed to read from standard input");
1216 fputc(
'\n', stdout);
1220 std::vector<std::string>
args = std::vector<std::string>(&argv[1], &argv[argc]);
1223 std::string walletPass;
1224 if (
args.size() < 1 || !
args[0].starts_with(
"walletpassphrase")) {
1225 throw std::runtime_error(
"-stdinwalletpassphrase is only applicable for walletpassphrase(change)");
1228 fputs(
"Wallet passphrase> ", stderr);
1231 if (!std::getline(std::cin, walletPass)) {
1232 throw std::runtime_error(
"-stdinwalletpassphrase specified but failed to read from standard input");
1235 fputc(
'\n', stdout);
1237 args.insert(
args.begin() + 1, walletPass);
1242 while (std::getline(std::cin, line)) {
1243 args.push_back(line);
1246 fputc(
'\n', stdout);
1250 std::unique_ptr<BaseRequestHandler> rh;
1255 if (!
args.empty() && (
args.at(0) ==
"h" ||
args.at(0) ==
"help")) {
1273 if (
args.size() < 1) {
1274 throw std::runtime_error(
"too few parameters (need at least command)");
1300 }
catch (
const std::exception& e) {
1301 strPrint = std::string(
"error: ") + e.what();
1302 nRet = EXIT_FAILURE;
1317 common::WinCmdLineArgs winArgs;
1318 std::tie(argc, argv) = winArgs.get();
1322 tfm::format(std::cerr,
"Error: Initializing networking failed\n");
1323 return EXIT_FAILURE;
1332 catch (
const std::exception& e) {
1334 return EXIT_FAILURE;
1337 return EXIT_FAILURE;
1344 catch (
const std::exception& e) {
bool HelpRequested(const ArgsManager &args)
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
bool CheckDataDirOption(const ArgsManager &args)
const char *const BITCOIN_CONF_FILENAME
bool IsSwitchChar(char c)
static const char DEFAULT_RPCCONNECT[]
static constexpr int8_t UNKNOWN_NETWORK
static constexpr int DEFAULT_WAIT_CLIENT_TIMEOUT
static const int CONTINUE_EXECUTION
static int AppInitRPC(int argc, char *argv[])
static void ParseError(const UniValue &error, std::string &strPrint, int &nRet)
Parse UniValue error to update the message to print to std::cerr and the code to return.
static constexpr std::array UNREACHABLE_NETWORK_IDS
static void http_error_cb(enum evhttp_request_error err, void *ctx)
static int CommandLineRPC(int argc, char *argv[])
static constexpr uint8_t NETINFO_MAX_LEVEL
static const int DEFAULT_HTTP_CLIENT_TIMEOUT
static void ParseGetInfoResult(UniValue &result)
ParseGetInfoResult takes in -getinfo result in UniValue object and parses it into a user friendly Uni...
static void http_request_done(struct evhttp_request *req, void *ctx)
static void ParseResult(const UniValue &result, std::string &strPrint)
Parse UniValue result to update the message to print to std::cout.
static const std::string DEFAULT_NBLOCKS
Default number of blocks to generate for RPC generatetoaddress.
static UniValue ConnectAndCallRPC(BaseRequestHandler *rh, const std::string &strMethod, const std::vector< std::string > &args, const std::optional< std::string > &rpcwallet={})
ConnectAndCallRPC wraps CallRPC with -rpcwait and an exception handler.
static void SetGenerateToAddressArgs(const std::string &address, std::vector< std::string > &args)
Check bounds and set up args for RPC generatetoaddress params: nblocks, address, maxtries.
static void GetWalletBalances(UniValue &result)
GetWalletBalances calls listwallets; if more than one wallet is loaded, it then fetches mine....
static constexpr std::array NETWORKS
static void SetupCliArgs(ArgsManager &argsman)
static const std::string DEFAULT_COLOR_SETTING
Default -color setting.
std::optional< std::string > RpcWalletName(const ArgsManager &args)
const TranslateFn G_TRANSLATION_FUN
Translate string to current locale using Qt.
std::chrono::system_clock CliClock
static constexpr std::array NETWORK_SHORT_NAMES
static int8_t NetworkStringToId(const std::string &str)
static std::string http_errorstring(int code)
static const bool DEFAULT_NAMED
static void GetProgressBar(double progress, std::string &progress_bar)
GetProgressBar constructs a progress bar with 5% intervals.
static UniValue CallRPC(BaseRequestHandler *rh, const std::string &strMethod, const std::vector< std::string > &args, const std::optional< std::string > &rpcwallet={})
event_set_log_callback & libevent_log_cb
static UniValue GetNewAddress()
Call RPC getnewaddress.
const CBaseChainParams & BaseParams()
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.
void SelectBaseParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain.
bool IsArgNegated(const std::string &strArg) const
Return true if the argument was originally passed as a negated option, i.e.
@ ALLOW_ANY
disable validation
@ DISALLOW_NEGATION
disallow -nofoo syntax
ChainType GetChainType() const
Returns the appropriate chain type from the program arguments.
void ForceSetArg(const std::string &strArg, const std::string &strValue)
bool ParseParameters(int argc, const char *const argv[], std::string &error)
void CheckMultipleCLIArgs() const
Check CLI command args.
std::string GetHelpMessage() const
Get the help string.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
fs::path GetConfigFilePath() const
Return config file path (read-only)
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
bool ReadConfigFiles(std::string &error, bool ignore_invalid_keys=false)
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
Process RPC generatetoaddress request.
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
UniValue ProcessReply(const UniValue &reply) override
Process netinfo requests.
bool m_outbound_only_selected
uint8_t m_block_relay_peers_count
bool DetailsRequested() const
std::vector< Peer > m_peers
UniValue ProcessReply(const UniValue &batch_in) override
uint8_t m_details_level
Optional user-supplied arg to set dashboard details level.
size_t m_max_addr_rate_limited_length
size_t m_max_addr_processed_length
bool IsAddressSelected() const
std::string FormatServices(const UniValue &services)
std::string ConnectionTypeForNetinfo(const std::string &conn_type) const
bool IsVersionSelected() const
uint8_t m_manual_peers_count
const std::string m_help_doc
static constexpr int ID_PEERINFO
std::string ChainToString() const
size_t m_max_services_length
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
std::array< std::array< uint16_t, NETWORKS.size()+1 >, 3 > m_counts
Peer counts by (in/out/total, networks/total)
static constexpr int ID_NETWORKINFO
std::string PingTimeToString(double seconds) const
void push_back(UniValue val)
const std::string & get_str() const
const UniValue & find_value(std::string_view key) const
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
const std::string & getValStr() const
const UniValue & get_obj() const
const std::vector< UniValue > & getValues() const
void setStr(std::string str)
void pushKV(std::string key, UniValue val)
UniValue RPCConvertValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert positional arguments to command-specific RPC representation.
UniValue RPCConvertNamedValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert named arguments to command-specific RPC representation.
std::string FormatFullVersion()
std::string LicenseInfo()
Returns licensing information (for -version)
raii_evhttp_request obtain_evhttp_request(void(*cb)(struct evhttp_request *, void *), void *arg)
raii_evhttp_connection obtain_evhttp_connection_base(struct event_base *base, std::string host, uint16_t port)
raii_event_base obtain_event_base()
void PrintExceptionContinue(const std::exception *pex, std::string_view thread_name)
const std::string CURRENCY_UNIT
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.
static RPCHelpMan listwallets()
RPCHelpMan getnewaddress()
std::vector< UniValue > JSONRPCProcessBatchReply(const UniValue &in)
Parse JSON-RPC batch reply into a vector.
bool GetAuthCookie(std::string *cookie_out)
Read the RPC authentication cookie from disk.
UniValue JSONRPCRequestObj(const std::string &strMethod, const UniValue ¶ms, const UniValue &id)
JSON-RPC protocol.
UniValue JSONRPCReplyObj(UniValue result, UniValue error, std::optional< UniValue > id, JSONRPCVersion jsonrpc_version)
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
@ HTTP_SERVICE_UNAVAILABLE
@ HTTP_INTERNAL_SERVER_ERROR
@ RPC_WALLET_NOT_SPECIFIED
No wallet specified (error when there are multiple wallets loaded)
@ RPC_IN_WARMUP
Client still warming up.
Process addrinfo requests.
UniValue ProcessReply(const UniValue &reply) override
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
Handle the conversion from a command-line to a JSON-RPC request, as well as converting back to a JSON...
virtual UniValue ProcessReply(const UniValue &batch_in)=0
virtual ~BaseRequestHandler()=default
virtual UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args)=0
CConnectionFailed(const std::string &msg)
Process default single requests.
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
UniValue ProcessReply(const UniValue &reply) override
Process getinfo requests.
const int ID_BLOCKCHAININFO
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
Create a simulated getinfo request.
UniValue ProcessReply(const UniValue &batch_in) override
Collect values from the batch and form a simulated getinfo reply.
Reply structure for request_done to fill in.
bool is_addr_relay_enabled
std::string transport_protocol_type
int64_t addr_rate_limited
bool operator<(const Peer &rhs) const
std::function< std::string(const char *)> TranslateFn
Translate a message to the native language of the user.
const UniValue NullUniValue
std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
Format a paragraph of text to a fixed width, adding spaces for indentation to any added line.
bool SplitHostPort(std::string_view in, uint16_t &portOut, std::string &hostOut)
Splits socket address string into host string and port value.
std::string EncodeBase64(std::span< const unsigned char > input)
std::string ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.
void UninterruptibleSleep(const std::chrono::microseconds &n)