6 #if defined(HAVE_CONFIG_H)
44 #include <event2/buffer.h>
45 #include <event2/keyvalq_struct.h>
63 static constexpr std::array
NETWORKS{
"not_publicly_routable",
"ipv4",
"ipv6",
"onion",
"i2p",
"cjdns",
"internal"};
64 static constexpr std::array
NETWORK_SHORT_NAMES{
"npr",
"ipv4",
"ipv6",
"onion",
"i2p",
"cjdns",
"int"};
85 argsman.
AddArg(
"-generate",
86 strprintf(
"Generate blocks, equivalent to RPC getnewaddress followed by RPC generatetoaddress. Optional positional integer "
87 "arguments are number of blocks to generate (default: %s) and maximum iterations to try (default: %s), equivalent to "
88 "RPC generatetoaddress nblocks and maxtries arguments. Example: bitcoin-cli -generate 4 1000",
92 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::OPTIONS);
93 argsman.
AddArg(
"-netinfo",
"Get network peer connection information from the remote server. An optional integer argument from 0 to 4 can be passed for different peers listings (default: 0). Pass \"help\" for detailed help documentation.",
ArgsManager::ALLOW_ANY,
OptionsCategory::OPTIONS);
102 argsman.
AddArg(
"-rpcport=<port>",
strprintf(
"Connect to JSON-RPC 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::OPTIONS);
106 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);
107 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);
108 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);
116 if (severity >= EVENT_LOG_ERR) {
117 throw std::runtime_error(
strprintf(
"libevent error: %s",
msg));
144 tfm::format(std::cerr,
"Error parsing command line arguments: %s\n", error);
154 "Usage: bitcoin-cli [options] <command> [params] Send command to " PACKAGE_NAME "\n"
155 "or: bitcoin-cli [options] -named <command> [name=value]... Send command to " PACKAGE_NAME " (with named arguments)\n"
156 "or: bitcoin-cli [options] help List commands\n"
157 "or: bitcoin-cli [options] help <command> Get help for a command\n";
163 tfm::format(std::cerr,
"Error: too few parameters\n");
169 tfm::format(std::cerr,
"Error: Specified data directory \"%s\" does not exist.\n",
gArgs.
GetArg(
"-datadir",
""));
173 tfm::format(std::cerr,
"Error reading configuration file: %s\n", error);
179 }
catch (
const std::exception& e) {
200 case EVREQ_HTTP_TIMEOUT:
201 return "timeout reached";
203 return "EOF reached";
204 case EVREQ_HTTP_INVALID_HEADER:
205 return "error while reading header, or invalid header";
206 case EVREQ_HTTP_BUFFER_ERROR:
207 return "error encountered while reading or writing";
208 case EVREQ_HTTP_REQUEST_CANCEL:
209 return "request was canceled";
210 case EVREQ_HTTP_DATA_TOO_LONG:
211 return "response body is larger than allowed";
221 if (req ==
nullptr) {
229 reply->
status = evhttp_request_get_response_code(req);
231 struct evbuffer *buf = evhttp_request_get_input_buffer(req);
234 size_t size = evbuffer_get_length(buf);
235 const char *data = (
const char*)evbuffer_pullup(buf, size);
237 reply->
body = std::string(data, size);
238 evbuffer_drain(buf, size);
265 for (
size_t i = 0; i <
NETWORKS.size(); ++i) {
275 throw std::runtime_error(
"-addrinfo takes no arguments");
283 if (!reply[
"error"].isNull())
return reply;
284 const std::vector<UniValue>& nodes{reply[
"result"].
getValues()};
285 if (!nodes.empty() && nodes.at(0)[
"network"].isNull()) {
286 throw std::runtime_error(
"-addrinfo requires bitcoind server to be running v22.0 and up");
289 std::array<uint64_t,
NETWORKS.size()> counts{{}};
291 std::string network_name{
node[
"network"].get_str()};
294 ++counts.at(network_id);
299 for (
size_t i = 1; i <
NETWORKS.size() - 1; ++i) {
300 addresses.pushKV(
NETWORKS[i], counts.at(i));
301 total += counts.at(i);
303 addresses.pushKV(
"total", total);
304 result.pushKV(
"addresses_known", addresses);
322 throw std::runtime_error(
"-getinfo takes no arguments");
355 result.
pushKV(
"connections", connections);
361 result.
pushKV(
"has_wallet",
true);
364 if (!batch[
ID_WALLETINFO][
"result"][
"unlocked_until"].isNull()) {
388 for (
size_t i = 0; i <
NETWORKS.size(); ++i) {
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";
469 throw std::runtime_error(
strprintf(
"invalid -netinfo argument: %s\nFor more information, run: bitcoin-cli -netinfo help",
args.at(0)));
485 if (networkinfo[
"version"].getInt<int>() < 209900) {
486 throw std::runtime_error(
"-netinfo requires bitcoind server to be running v0.21.0 and up");
488 const int64_t time_now{TicksSinceEpoch<std::chrono::seconds>(CliClock::now())};
492 const std::string network{peer[
"network"].get_str()};
495 const bool is_outbound{!peer[
"inbound"].get_bool()};
496 const bool is_tx_relay{peer[
"relaytxes"].isNull() ? true : peer[
"relaytxes"].get_bool()};
497 const std::string conn_type{peer[
"connection_type"].get_str()};
498 ++
m_counts.at(is_outbound).at(network_id);
506 const int peer_id{peer[
"id"].getInt<
int>()};
507 const int mapped_as{peer[
"mapped_as"].isNull() ? 0 : peer[
"mapped_as"].getInt<
int>()};
508 const int version{peer[
"version"].getInt<
int>()};
509 const int64_t addr_processed{peer[
"addr_processed"].isNull() ? 0 : peer[
"addr_processed"].getInt<int64_t>()};
510 const int64_t addr_rate_limited{peer[
"addr_rate_limited"].isNull() ? 0 : peer[
"addr_rate_limited"].getInt<int64_t>()};
511 const int64_t conn_time{peer[
"conntime"].getInt<int64_t>()};
512 const int64_t last_blck{peer[
"last_block"].getInt<int64_t>()};
513 const int64_t last_recv{peer[
"lastrecv"].getInt<int64_t>()};
514 const int64_t last_send{peer[
"lastsend"].getInt<int64_t>()};
515 const int64_t last_trxn{peer[
"last_transaction"].getInt<int64_t>()};
516 const double min_ping{peer[
"minping"].isNull() ? -1 : peer[
"minping"].get_real()};
517 const double ping{peer[
"pingtime"].isNull() ? -1 : peer[
"pingtime"].get_real()};
518 const std::string addr{peer[
"addr"].get_str()};
519 const std::string age{conn_time == 0 ?
"" :
ToString((time_now - conn_time) / 60)};
520 const std::string sub_version{peer[
"subver"].get_str()};
521 const std::string transport{peer[
"transport_protocol_type"].isNull() ?
"v1" : peer[
"transport_protocol_type"].get_str()};
522 const bool is_addr_relay_enabled{peer[
"addr_relay_enabled"].isNull() ? false : peer[
"addr_relay_enabled"].get_bool()};
523 const bool is_bip152_hb_from{peer[
"bip152_hb_from"].get_bool()};
524 const bool is_bip152_hb_to{peer[
"bip152_hb_to"].get_bool()};
525 m_peers.push_back({addr, sub_version, conn_type,
NETWORK_SHORT_NAMES[network_id], age, 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});
541 result +=
strprintf(
"<-> type net v mping ping send recv txn blk hb %*s%*s%*s ",
548 std::string version{
ToString(peer.version) + peer.sub_version};
550 "%3s %6s %5s %2s%7s%7s%5s%5s%5s%5s %2s %*s%*s%*s%*i %*s %-*s%s\n",
551 peer.is_outbound ?
"out" :
"in",
554 peer.transport_protocol_type.starts_with(
'v') ? peer.transport_protocol_type[1] :
' ',
557 peer.last_send ?
ToString(time_now - peer.last_send) :
"",
558 peer.last_recv ?
ToString(time_now - peer.last_recv) :
"",
559 peer.last_trxn ?
ToString((time_now - peer.last_trxn) / 60) : peer.is_tx_relay ?
"" :
"*",
560 peer.last_blck ?
ToString((time_now - peer.last_blck) / 60) :
"",
561 strprintf(
"%s%s", peer.is_bip152_hb_to ?
"." :
" ", peer.is_bip152_hb_from ?
"*" :
" "),
563 peer.addr_processed ?
ToString(peer.addr_processed) : peer.is_addr_relay_enabled ?
"" :
".",
565 peer.addr_rate_limited ?
ToString(peer.addr_rate_limited) :
"",
581 std::vector<int8_t> reachable_networks;
582 for (
const UniValue& network : networkinfo[
"networks"].getValues()) {
583 if (network[
"reachable"].get_bool()) {
584 const std::string& network_name{network[
"name"].get_str()};
587 result +=
strprintf(
"%8s", network_name);
588 reachable_networks.push_back(network_id);
593 if (
m_counts.at(2).at(network_id) == 0)
continue;
595 reachable_networks.push_back(network_id);
598 result +=
" total block";
601 const std::array rows{
"in",
"out",
"total"};
602 for (
size_t i = 0; i < rows.size(); ++i) {
604 for (int8_t n : reachable_networks) {
615 result +=
"\n\nLocal addresses";
616 const std::vector<UniValue>& local_addrs{networkinfo[
"localaddresses"].getValues()};
617 if (local_addrs.empty()) {
620 size_t max_addr_size{0};
621 for (
const UniValue& addr : local_addrs) {
622 max_addr_size = std::max(addr[
"address"].get_str().length() + 1, max_addr_size);
624 for (
const UniValue& addr : local_addrs) {
625 result +=
strprintf(
"\n%-*s port %6i score %6i", max_addr_size, addr[
"address"].get_str(), addr[
"port"].getInt<int>(), addr[
"score"].getInt<int>());
633 "-netinfo level|\"help\" \n\n"
634 "Returns a network peer connections dashboard with information from the remote server.\n"
635 "This human-readable interface will change regularly and is not intended to be a stable API.\n"
636 "Under the hood, -netinfo fetches the data by calling getpeerinfo and getnetworkinfo.\n"
638 "Pass \"help\" to see this detailed help documentation.\n"
639 "If more than one argument is passed, only the first one is read and parsed.\n"
640 "Suggestion: use with the Linux watch(1) command for a live dashboard; see example below.\n\n"
642 +
strprintf(
"1. level (integer 0-%d, optional) Specify the info level of the peers dashboard (default 0):\n",
MAX_DETAIL_LEVEL) +
643 " 0 - Peer counts for each reachable network as well as for block relay peers\n"
644 " and manual peers, and the list of local addresses and ports\n"
645 " 1 - Like 0 but preceded by a peers listing (without address and version columns)\n"
646 " 2 - Like 1 but with an address column\n"
647 " 3 - Like 1 but with a version column\n"
648 " 4 - Like 1 but with both address and version columns\n"
649 "2. help (string \"help\", optional) Print this help documentation instead of the dashboard.\n\n"
651 +
strprintf(
"* The peers listing in levels 1-%d displays all of the peers sorted by direction and minimum ping time:\n\n",
MAX_DETAIL_LEVEL) +
652 " Column Description\n"
653 " ------ -----------\n"
655 " \"in\" - inbound connections are those initiated by the peer\n"
656 " \"out\" - outbound connections are those initiated by us\n"
657 " type Type of peer connection\n"
658 " \"full\" - full relay, the default\n"
659 " \"block\" - block relay; like full relay but does not relay transactions or addresses\n"
660 " \"manual\" - peer we manually added using RPC addnode or the -addnode/-connect config options\n"
661 " \"feeler\" - short-lived connection for testing addresses\n"
662 " \"addr\" - address fetch; short-lived connection for requesting addresses\n"
663 " net Network the peer connected through (\"ipv4\", \"ipv6\", \"onion\", \"i2p\", \"cjdns\", or \"npr\" (not publicly routable))\n"
664 " v Version of transport protocol used for the connection\n"
665 " mping Minimum observed ping time, in milliseconds (ms)\n"
666 " ping Last observed ping time, in milliseconds (ms)\n"
667 " send Time since last message sent to the peer, in seconds\n"
668 " recv Time since last message received from the peer, in seconds\n"
669 " txn Time since last novel transaction received from the peer and accepted into our mempool, in minutes\n"
670 " \"*\" - we do not relay transactions to this peer (relaytxes is false)\n"
671 " blk Time since last novel block passing initial validity checks received from the peer, in minutes\n"
672 " hb High-bandwidth BIP152 compact block relay\n"
673 " \".\" (to) - we selected the peer as a high-bandwidth peer\n"
674 " \"*\" (from) - the peer selected us as a high-bandwidth peer\n"
675 " addrp Total number of addresses processed, excluding those dropped due to rate limiting\n"
676 " \".\" - we do not relay addresses to this peer (addr_relay_enabled is false)\n"
677 " addrl Total number of addresses dropped due to rate limiting\n"
678 " age Duration of connection to the peer, in minutes\n"
679 " asmap Mapped AS (Autonomous System) number in the BGP route to the peer, used for diversifying\n"
680 " peer selection (only displayed if the -asmap config option is set)\n"
681 " id Peer index, in increasing order of peer connections since node startup\n"
682 " address IP address and port of the peer\n"
683 " version Peer version and subversion concatenated, e.g. \"70016/Satoshi:21.0.0/\"\n\n"
684 "* The peer counts table displays the number of peers for each reachable network as well as\n"
685 " the number of block relay peers and manual peers.\n\n"
686 "* The local addresses table lists each local address broadcast by the node, the port, and the score.\n\n"
688 "Peer counts table of reachable networks and list of local addresses\n"
689 "> bitcoin-cli -netinfo\n\n"
690 "The same, preceded by a peers listing without address and version columns\n"
691 "> bitcoin-cli -netinfo 1\n\n"
694 "Full live dashboard, adjust --interval or --no-title as needed (Linux)\n"
697 "> bitcoin-cli -netinfo help\n"};
763 evhttp_connection_set_timeout(evcon.get(), timeout);
768 constexpr
int YEAR_IN_SECONDS = 31556952;
769 evhttp_connection_set_timeout(evcon.get(), 5 * YEAR_IN_SECONDS);
775 if (req ==
nullptr) {
776 throw std::runtime_error(
"create http request failed");
783 bool failedToGetAuthCookie =
false;
787 failedToGetAuthCookie =
true;
793 struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
795 evhttp_add_header(output_headers,
"Host", host.c_str());
796 evhttp_add_header(output_headers,
"Connection",
"close");
797 evhttp_add_header(output_headers,
"Content-Type",
"application/json");
802 struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
804 evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
807 std::string endpoint =
"/";
809 char* encodedURI = evhttp_uriencode(rpcwallet->data(), rpcwallet->size(),
false);
811 endpoint =
"/wallet/" + std::string(encodedURI);
817 int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, endpoint.c_str());
823 event_base_dispatch(base.get());
825 if (response.
status == 0) {
826 std::string responseErrorMessage;
827 if (response.
error != -1) {
830 throw CConnectionFailed(
strprintf(
"Could not connect to the server %s:%d%s\n\nMake sure the bitcoind server is running and that you are connecting to the correct RPC port.", host, port, responseErrorMessage));
832 if (failedToGetAuthCookie) {
834 "Could not locate RPC credentials. No authentication cookie could be found, and RPC password is not set. See -rpcpassword and -stdinrpcpass. Configuration file: (%s)",
837 throw std::runtime_error(
"Authorization failed: Incorrect rpcuser or rpcpassword");
840 throw std::runtime_error(
strprintf(
"Server response: %s", response.
body));
842 throw std::runtime_error(
strprintf(
"server returned HTTP error %d", response.
status));
843 else if (response.
body.empty())
844 throw std::runtime_error(
"no response from server");
848 if (!valReply.read(response.
body))
849 throw std::runtime_error(
"couldn't parse reply from server");
852 throw std::runtime_error(
"expected reply to have result, error and id properties");
872 const auto deadline{std::chrono::steady_clock::now() + 1s * timeout};
876 response =
CallRPC(rh, strMethod,
args, rpcwallet);
878 const UniValue& error = response.find_value(
"error");
885 if (fWait && (timeout <= 0 || std::chrono::steady_clock::now() < deadline)) {
898 if (result.
isNull())
return;
911 if (err_msg.
isStr()) {
915 strPrint +=
"\nTry adding \"-rpcwallet=<filename>\" option to bitcoin-cli command line.";
920 nRet = abs(error[
"code"].getInt<int>());
933 if (!
listwallets.find_value(
"error").isNull())
return;
935 if (wallets.
size() <= 1)
return;
939 const std::string& wallet_name =
wallet.get_str();
942 balances.
pushKV(wallet_name, balance);
944 result.
pushKV(
"balances", balances);
955 if (progress < 0 || progress > 1)
return;
957 static constexpr
double INCREMENT{0.05};
958 static const std::string COMPLETE_BAR{
"\u2592"};
959 static const std::string INCOMPLETE_BAR{
"\u2591"};
961 for (
int i = 0; i < progress / INCREMENT; ++i) {
962 progress_bar += COMPLETE_BAR;
965 for (
int i = 0; i < (1 - progress) / INCREMENT; ++i) {
966 progress_bar += INCOMPLETE_BAR;
979 std::string RESET, GREEN, BLUE, YELLOW, MAGENTA, CYAN;
980 bool should_colorize =
false;
983 if (isatty(fileno(stdout))) {
985 should_colorize =
true;
991 if (color ==
"always") {
992 should_colorize =
true;
993 }
else if (color ==
"never") {
994 should_colorize =
false;
995 }
else if (color !=
"auto") {
996 throw std::runtime_error(
"Invalid value for -color option. Valid values: always, auto, never.");
1000 if (should_colorize) {
1004 YELLOW =
"\x1B[33m";
1005 MAGENTA =
"\x1B[35m";
1009 std::string result_string =
strprintf(
"%sChain: %s%s\n", BLUE, result[
"chain"].getValStr(), RESET);
1010 result_string +=
strprintf(
"Blocks: %s\n", result[
"blocks"].getValStr());
1011 result_string +=
strprintf(
"Headers: %s\n", result[
"headers"].getValStr());
1013 const double ibd_progress{result[
"verificationprogress"].
get_real()};
1014 std::string ibd_progress_bar;
1016 if (ibd_progress < 0.99) {
1019 ibd_progress_bar +=
" ";
1022 result_string +=
strprintf(
"Verification progress: %s%.4f%%\n", ibd_progress_bar, ibd_progress * 100);
1023 result_string +=
strprintf(
"Difficulty: %s\n\n", result[
"difficulty"].getValStr());
1026 "%sNetwork: in %s, out %s, total %s%s\n",
1028 result[
"connections"][
"in"].getValStr(),
1029 result[
"connections"][
"out"].getValStr(),
1030 result[
"connections"][
"total"].getValStr(),
1032 result_string +=
strprintf(
"Version: %s\n", result[
"version"].getValStr());
1033 result_string +=
strprintf(
"Time offset (s): %s\n", result[
"timeoffset"].getValStr());
1036 std::map<std::string, std::vector<std::string>> proxy_networks;
1037 std::vector<std::string> ordered_proxies;
1039 for (
const UniValue& network : result[
"networks"].getValues()) {
1040 const std::string proxy = network[
"proxy"].getValStr();
1041 if (proxy.empty())
continue;
1043 if (proxy_networks.find(proxy) == proxy_networks.end()) ordered_proxies.push_back(proxy);
1045 proxy_networks[proxy].push_back(network[
"name"].getValStr());
1048 std::vector<std::string> formatted_proxies;
1049 formatted_proxies.reserve(ordered_proxies.size());
1050 for (
const std::string& proxy : ordered_proxies) {
1051 formatted_proxies.emplace_back(
strprintf(
"%s (%s)", proxy,
Join(proxy_networks.find(proxy)->second,
", ")));
1053 result_string +=
strprintf(
"Proxies: %s\n", formatted_proxies.empty() ?
"n/a" :
Join(formatted_proxies,
", "));
1055 result_string +=
strprintf(
"Min tx relay fee rate (%s/kvB): %s\n\n",
CURRENCY_UNIT, result[
"relayfee"].getValStr());
1057 if (!result[
"has_wallet"].isNull()) {
1058 const std::string walletname = result[
"walletname"].
getValStr();
1059 result_string +=
strprintf(
"%sWallet: %s%s\n", MAGENTA, walletname.empty() ?
"\"\"" : walletname, RESET);
1061 result_string +=
strprintf(
"Keypool size: %s\n", result[
"keypoolsize"].getValStr());
1062 if (!result[
"unlocked_until"].isNull()) {
1063 result_string +=
strprintf(
"Unlocked until: %s\n", result[
"unlocked_until"].getValStr());
1065 result_string +=
strprintf(
"Transaction fee rate (-paytxfee) (%s/kvB): %s\n\n",
CURRENCY_UNIT, result[
"paytxfee"].getValStr());
1067 if (!result[
"balance"].isNull()) {
1068 result_string +=
strprintf(
"%sBalance:%s %s\n\n", CYAN, RESET, result[
"balance"].getValStr());
1071 if (!result[
"balances"].isNull()) {
1072 result_string +=
strprintf(
"%sBalances%s\n", CYAN, RESET);
1074 size_t max_balance_length{10};
1076 for (
const std::string&
wallet : result[
"balances"].getKeys()) {
1077 max_balance_length = std::max(result[
"balances"][
wallet].getValStr().length(), max_balance_length);
1080 for (
const std::string&
wallet : result[
"balances"].getKeys()) {
1083 result[
"balances"][
wallet].getValStr(),
1086 result_string +=
"\n";
1089 const std::string warnings{result[
"warnings"].
getValStr()};
1090 result_string +=
strprintf(
"%sWarnings:%s %s", YELLOW, RESET, warnings.empty() ?
"(none)" : warnings);
1092 result.
setStr(result_string);
1101 std::optional<std::string> wallet_name{};
1114 if (
args.size() > 2)
throw std::runtime_error(
"too many arguments (maximum 2 for nblocks and maxtries)");
1115 if (
args.size() == 0) {
1117 }
else if (
args.at(0) ==
"0") {
1118 throw std::runtime_error(
"the first argument (number of blocks to generate, default: " +
DEFAULT_NBLOCKS +
") must be an integer value greater than zero");
1120 args.emplace(
args.begin() + 1, address);
1133 std::string rpcPass;
1137 fputs(
"RPC password> ", stderr);
1140 if (!std::getline(std::cin, rpcPass)) {
1141 throw std::runtime_error(
"-stdinrpcpass specified but failed to read from standard input");
1144 fputc(
'\n', stdout);
1148 std::vector<std::string>
args = std::vector<std::string>(&argv[1], &argv[argc]);
1151 std::string walletPass;
1152 if (
args.size() < 1 ||
args[0].substr(0, 16) !=
"walletpassphrase") {
1153 throw std::runtime_error(
"-stdinwalletpassphrase is only applicable for walletpassphrase(change)");
1156 fputs(
"Wallet passphrase> ", stderr);
1159 if (!std::getline(std::cin, walletPass)) {
1160 throw std::runtime_error(
"-stdinwalletpassphrase specified but failed to read from standard input");
1163 fputc(
'\n', stdout);
1165 args.insert(
args.begin() + 1, walletPass);
1170 while (std::getline(std::cin, line)) {
1171 args.push_back(line);
1174 fputc(
'\n', stdout);
1177 std::unique_ptr<BaseRequestHandler> rh;
1182 if (!
args.empty() &&
args.at(0) ==
"help") {
1200 if (
args.size() < 1) {
1201 throw std::runtime_error(
"too few parameters (need at least command)");
1208 std::optional<std::string> wallet_name{};
1228 }
catch (
const std::exception& e) {
1229 strPrint = std::string(
"error: ") + e.what();
1230 nRet = EXIT_FAILURE;
1245 common::WinCmdLineArgs winArgs;
1246 std::tie(argc, argv) = winArgs.get();
1250 tfm::format(std::cerr,
"Error: Initializing networking failed\n");
1251 return EXIT_FAILURE;
1260 catch (
const std::exception& e) {
1262 return EXIT_FAILURE;
1265 return EXIT_FAILURE;
1272 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
UrlDecodeFn *const URL_DECODE
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 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....
const std::function< std::string(const char *)> G_TRANSLATION_FUN
Translate string to current locale using Qt.
static constexpr std::array NETWORKS
static void SetupCliArgs(ArgsManager &argsman)
static const std::string DEFAULT_COLOR_SETTING
Default -color setting.
std::chrono::system_clock CliClock
static constexpr std::array NETWORK_SHORT_NAMES
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.
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.
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const ChainType chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 18445) have been chosen arbitrarily to...
Process addrinfo requests.
UniValue ProcessReply(const UniValue &reply) override
int8_t NetworkStringToId(const std::string &str) const
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
@ 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)
std::string GetHelpMessage() const
Get the help string.
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
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.
Class that handles the conversion from a command-line to a JSON-RPC request, as well as converting ba...
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 RPC generatetoaddress request.
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.
Process netinfo requests.
uint8_t m_block_relay_peers_count
static constexpr uint8_t MAX_DETAIL_LEVEL
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 ConnectionTypeForNetinfo(const std::string &conn_type) const
bool IsVersionSelected() const
uint8_t m_manual_peers_count
const std::string m_help_doc
int8_t NetworkStringToId(const std::string &str) const
static constexpr int ID_PEERINFO
std::string ChainToString() const
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 UniValue & get_obj() const
const std::string & getValStr() 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
static std::string strRPCUserColonPass
static std::string PathToString(const path &path)
Convert path object to a byte string.
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(const UniValue &result, const UniValue &error, const UniValue &id)
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.
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.
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
void UninterruptibleSleep(const std::chrono::microseconds &n)
const UniValue NullUniValue
std::string(const std::string &url_encoded) UrlDecodeFn
std::string EncodeBase64(Span< const unsigned char > input)
bool ParseUInt8(std::string_view str, uint8_t *out)
Convert decimal string to unsigned 8-bit integer with strict parse error feedback.
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.