 |
Bitcoin Core
22.99.0
P2P Digital Currency
|
Go to the documentation of this file.
6 #if defined(HAVE_CONFIG_H)
36 #include <event2/buffer.h>
37 #include <event2/keyvalq_struct.h>
52 static constexpr std::array
NETWORKS{
"ipv4",
"ipv6",
"onion",
"i2p",
"cjdns"};
74 argsman.
AddArg(
"-getinfo",
"Get general information from the remote server. Note that unlike server-side RPC calls, the results of -getinfo is the result of multiple non-atomic requests. Some entries in the result 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);
75 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);
84 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);
88 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);
89 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);
90 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);
98 if (severity >= EVENT_LOG_ERR) {
99 throw std::runtime_error(
strprintf(
"libevent error: %s", msg));
112 std::runtime_error(msg)
126 tfm::format(std::cerr,
"Error parsing command line arguments: %s\n",
error);
133 "Usage: bitcoin-cli [options] <command> [params] Send command to " PACKAGE_NAME "\n"
134 "or: bitcoin-cli [options] -named <command> [name=value]... Send command to " PACKAGE_NAME " (with named arguments)\n"
135 "or: bitcoin-cli [options] help List commands\n"
136 "or: bitcoin-cli [options] help <command> Get help for a command\n";
142 tfm::format(std::cerr,
"Error: too few parameters\n");
148 tfm::format(std::cerr,
"Error: Specified data directory \"%s\" does not exist.\n",
gArgs.
GetArg(
"-datadir",
""));
158 }
catch (
const std::exception& e) {
179 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
180 case EVREQ_HTTP_TIMEOUT:
181 return "timeout reached";
183 return "EOF reached";
184 case EVREQ_HTTP_INVALID_HEADER:
185 return "error while reading header, or invalid header";
186 case EVREQ_HTTP_BUFFER_ERROR:
187 return "error encountered while reading or writing";
188 case EVREQ_HTTP_REQUEST_CANCEL:
189 return "request was canceled";
190 case EVREQ_HTTP_DATA_TOO_LONG:
191 return "response body is larger than allowed";
202 if (req ==
nullptr) {
210 reply->
status = evhttp_request_get_response_code(req);
212 struct evbuffer *buf = evhttp_request_get_input_buffer(req);
215 size_t size = evbuffer_get_length(buf);
216 const char *data = (
const char*)evbuffer_pullup(buf, size);
218 reply->
body = std::string(data, size);
219 evbuffer_drain(buf, size);
223 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
224 static void http_error_cb(
enum evhttp_request_error err,
void *
ctx)
248 for (
size_t i = 0; i <
NETWORKS.size(); ++i) {
258 throw std::runtime_error(
"-addrinfo takes no arguments");
266 if (!reply[
"error"].isNull())
return reply;
267 const std::vector<UniValue>& nodes{reply[
"result"].
getValues()};
268 if (!nodes.empty() && nodes.at(0)[
"network"].isNull()) {
269 throw std::runtime_error(
"-addrinfo requires bitcoind server to be running v22.0 and up");
272 std::array<uint64_t,
NETWORKS.size()> counts{{}};
274 std::string network_name{
node[
"network"].get_str()};
277 ++counts.at(network_id);
282 for (
size_t i = 0; i <
NETWORKS.size(); ++i) {
283 addresses.pushKV(
NETWORKS[i], counts.at(i));
284 total += counts.at(i);
286 addresses.pushKV(
"total", total);
287 result.pushKV(
"addresses_known", addresses);
305 throw std::runtime_error(
"-getinfo takes no arguments");
338 result.
pushKV(
"connections", connections);
344 result.
pushKV(
"has_wallet",
true);
347 if (!batch[
ID_WALLETINFO][
"result"][
"unlocked_until"].isNull()) {
371 for (
size_t i = 0; i <
NETWORKS.size(); ++i) {
420 if (seconds < 0)
return "";
421 const double milliseconds{round(1000 * seconds)};
422 return milliseconds > 999999 ?
"-" :
ToString(milliseconds);
426 if (conn_type ==
"outbound-full-relay")
return "full";
427 if (conn_type ==
"block-relay-only")
return "block";
428 if (conn_type ==
"manual" || conn_type ==
"feeler")
return conn_type;
429 if (conn_type ==
"addr-fetch")
return "addr";
445 throw std::runtime_error(
strprintf(
"invalid -netinfo argument: %s\nFor more information, run: bitcoin-cli -netinfo help",
args.at(0)));
461 if (networkinfo[
"version"].get_int() < 209900) {
462 throw std::runtime_error(
"-netinfo requires bitcoind server to be running v0.21.0 and up");
467 const std::string network{peer[
"network"].get_str()};
470 const bool is_outbound{!peer[
"inbound"].get_bool()};
471 const bool is_block_relay{!peer[
"relaytxes"].get_bool()};
472 const std::string conn_type{peer[
"connection_type"].get_str()};
473 ++
m_counts.at(is_outbound).at(network_id);
481 const int peer_id{peer[
"id"].get_int()};
482 const int mapped_as{peer[
"mapped_as"].isNull() ? 0 : peer[
"mapped_as"].get_int()};
483 const int version{peer[
"version"].get_int()};
484 const int64_t addr_processed{peer[
"addr_processed"].isNull() ? 0 : peer[
"addr_processed"].get_int64()};
485 const int64_t addr_rate_limited{peer[
"addr_rate_limited"].isNull() ? 0 : peer[
"addr_rate_limited"].get_int64()};
486 const int64_t conn_time{peer[
"conntime"].get_int64()};
487 const int64_t last_blck{peer[
"last_block"].get_int64()};
488 const int64_t last_recv{peer[
"lastrecv"].get_int64()};
489 const int64_t last_send{peer[
"lastsend"].get_int64()};
490 const int64_t last_trxn{peer[
"last_transaction"].get_int64()};
491 const double min_ping{peer[
"minping"].isNull() ? -1 : peer[
"minping"].get_real()};
492 const double ping{peer[
"pingtime"].isNull() ? -1 : peer[
"pingtime"].get_real()};
493 const std::string addr{peer[
"addr"].get_str()};
495 const std::string sub_version{peer[
"subver"].get_str()};
496 const bool is_addr_relay_enabled{peer[
"addr_relay_enabled"].isNull() ? false : peer[
"addr_relay_enabled"].get_bool()};
497 const bool is_bip152_hb_from{peer[
"bip152_hb_from"].get_bool()};
498 const bool is_bip152_hb_to{peer[
"bip152_hb_to"].get_bool()};
499 m_peers.push_back({addr, sub_version, conn_type, network, age, 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_block_relay, is_outbound});
515 result +=
strprintf(
"<-> type net mping ping send recv txn blk hb %*s%*s%*s ",
522 std::string version{
ToString(peer.version) + peer.sub_version};
524 "%3s %6s %5s%7s%7s%5s%5s%5s%5s %2s %*s%*s%*s%*i %*s %-*s%s\n",
525 peer.is_outbound ?
"out" :
"in",
532 peer.last_trxn ?
ToString((
m_time_now - peer.last_trxn) / 60) : peer.is_block_relay ?
"*" :
"",
534 strprintf(
"%s%s", peer.is_bip152_hb_to ?
"." :
" ", peer.is_bip152_hb_from ?
"*" :
" "),
536 peer.addr_processed ?
ToString(peer.addr_processed) : peer.is_addr_relay_enabled ?
"" :
".",
538 peer.addr_rate_limited ?
ToString(peer.addr_rate_limited) :
"",
554 std::vector<int8_t> reachable_networks;
555 for (
const UniValue& network : networkinfo[
"networks"].getValues()) {
556 if (network[
"reachable"].get_bool()) {
557 const std::string& network_name{network[
"name"].get_str()};
560 result +=
strprintf(
"%8s", network_name);
561 reachable_networks.push_back(network_id);
564 result +=
" total block";
567 const std::array rows{
"in",
"out",
"total"};
568 for (
size_t i = 0; i < rows.size(); ++i) {
570 for (int8_t n : reachable_networks) {
581 result +=
"\n\nLocal addresses";
582 const std::vector<UniValue>& local_addrs{networkinfo[
"localaddresses"].getValues()};
583 if (local_addrs.empty()) {
586 size_t max_addr_size{0};
587 for (
const UniValue& addr : local_addrs) {
588 max_addr_size = std::max(addr[
"address"].get_str().length() + 1, max_addr_size);
590 for (
const UniValue& addr : local_addrs) {
591 result +=
strprintf(
"\n%-*s port %6i score %6i", max_addr_size, addr[
"address"].get_str(), addr[
"port"].get_int(), addr[
"score"].get_int());
599 "-netinfo level|\"help\" \n\n"
600 "Returns a network peer connections dashboard with information from the remote server.\n"
601 "This human-readable interface will change regularly and is not intended to be a stable API.\n"
602 "Under the hood, -netinfo fetches the data by calling getpeerinfo and getnetworkinfo.\n"
604 "Pass \"help\" to see this detailed help documentation.\n"
605 "If more than one argument is passed, only the first one is read and parsed.\n"
606 "Suggestion: use with the Linux watch(1) command for a live dashboard; see example below.\n\n"
608 +
strprintf(
"1. level (integer 0-%d, optional) Specify the info level of the peers dashboard (default 0):\n",
MAX_DETAIL_LEVEL) +
609 " 0 - Peer counts for each reachable network as well as for block relay peers\n"
610 " and manual peers, and the list of local addresses and ports\n"
611 " 1 - Like 0 but preceded by a peers listing (without address and version columns)\n"
612 " 2 - Like 1 but with an address column\n"
613 " 3 - Like 1 but with a version column\n"
614 " 4 - Like 1 but with both address and version columns\n"
615 "2. help (string \"help\", optional) Print this help documentation instead of the dashboard.\n\n"
617 +
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) +
618 " Column Description\n"
619 " ------ -----------\n"
621 " \"in\" - inbound connections are those initiated by the peer\n"
622 " \"out\" - outbound connections are those initiated by us\n"
623 " type Type of peer connection\n"
624 " \"full\" - full relay, the default\n"
625 " \"block\" - block relay; like full relay but does not relay transactions or addresses\n"
626 " \"manual\" - peer we manually added using RPC addnode or the -addnode/-connect config options\n"
627 " \"feeler\" - short-lived connection for testing addresses\n"
628 " \"addr\" - address fetch; short-lived connection for requesting addresses\n"
629 " net Network the peer connected through (\"ipv4\", \"ipv6\", \"onion\", \"i2p\", or \"cjdns\")\n"
630 " mping Minimum observed ping time, in milliseconds (ms)\n"
631 " ping Last observed ping time, in milliseconds (ms)\n"
632 " send Time since last message sent to the peer, in seconds\n"
633 " recv Time since last message received from the peer, in seconds\n"
634 " txn Time since last novel transaction received from the peer and accepted into our mempool, in minutes\n"
635 " \"*\" - the peer requested we not relay transactions to it (relaytxes is false)\n"
636 " blk Time since last novel block passing initial validity checks received from the peer, in minutes\n"
637 " hb High-bandwidth BIP152 compact block relay\n"
638 " \".\" (to) - we selected the peer as a high-bandwidth peer\n"
639 " \"*\" (from) - the peer selected us as a high-bandwidth peer\n"
640 " addrp Total number of addresses processed, excluding those dropped due to rate limiting\n"
641 " \".\" - we do not relay addresses to this peer (addr_relay_enabled is false)\n"
642 " addrl Total number of addresses dropped due to rate limiting\n"
643 " age Duration of connection to the peer, in minutes\n"
644 " asmap Mapped AS (Autonomous System) number in the BGP route to the peer, used for diversifying\n"
645 " peer selection (only displayed if the -asmap config option is set)\n"
646 " id Peer index, in increasing order of peer connections since node startup\n"
647 " address IP address and port of the peer\n"
648 " version Peer version and subversion concatenated, e.g. \"70016/Satoshi:21.0.0/\"\n\n"
649 "* The peer counts table displays the number of peers for each reachable network as well as\n"
650 " the number of block relay peers and manual peers.\n\n"
651 "* The local addresses table lists each local address broadcast by the node, the port, and the score.\n\n"
653 "Peer counts table of reachable networks and list of local addresses\n"
654 "> bitcoin-cli -netinfo\n\n"
655 "The same, preceded by a peers listing without address and version columns\n"
656 "> bitcoin-cli -netinfo 1\n\n"
659 "Full live dashboard, adjust --interval or --no-title as needed (Linux)\n"
662 "> bitcoin-cli -netinfo help\n"};
728 evhttp_connection_set_timeout(evcon.get(), timeout);
733 constexpr
int YEAR_IN_SECONDS = 31556952;
734 evhttp_connection_set_timeout(evcon.get(), 5 * YEAR_IN_SECONDS);
741 throw std::runtime_error(
"create http request failed");
742 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
743 evhttp_request_set_error_cb(req.get(), http_error_cb);
748 bool failedToGetAuthCookie =
false;
752 failedToGetAuthCookie =
true;
758 struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
760 evhttp_add_header(output_headers,
"Host", host.c_str());
761 evhttp_add_header(output_headers,
"Connection",
"close");
762 evhttp_add_header(output_headers,
"Content-Type",
"application/json");
767 struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
769 evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
772 std::string endpoint =
"/";
774 char* encodedURI = evhttp_uriencode(rpcwallet->data(), rpcwallet->size(),
false);
776 endpoint =
"/wallet/" + std::string(encodedURI);
782 int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, endpoint.c_str());
788 event_base_dispatch(base.get());
790 if (response.
status == 0) {
791 std::string responseErrorMessage;
792 if (response.
error != -1) {
795 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));
797 if (failedToGetAuthCookie) {
799 "Could not locate RPC credentials. No authentication cookie could be found, and RPC password is not set. See -rpcpassword and -stdinrpcpass. Configuration file: (%s)",
802 throw std::runtime_error(
"Authorization failed: Incorrect rpcuser or rpcpassword");
805 throw std::runtime_error(
strprintf(
"Server response: %s", response.
body));
807 throw std::runtime_error(
strprintf(
"server returned HTTP error %d", response.
status));
808 else if (response.
body.empty())
809 throw std::runtime_error(
"no response from server");
813 if (!valReply.read(response.
body))
814 throw std::runtime_error(
"couldn't parse reply from server");
817 throw std::runtime_error(
"expected reply to have result, error and id properties");
837 const auto deadline{GetTime<std::chrono::microseconds>() + 1s * timeout};
841 response =
CallRPC(rh, strMethod,
args, rpcwallet);
850 const auto now{GetTime<std::chrono::microseconds>()};
851 if (fWait && (timeout <= 0 || now < deadline)) {
864 if (result.
isNull())
return;
871 if (
error.isObject()) {
875 strPrint =
"error code: " + err_code.
getValStr() +
"\n";
877 if (err_msg.
isStr()) {
878 strPrint += (
"error message:\n" + err_msg.
get_str());
881 strPrint +=
"\nTry adding \"-rpcwallet=<filename>\" option to bitcoin-cli command line.";
884 strPrint =
"error: " +
error.write();
886 nRet = abs(
error[
"code"].get_int());
901 if (wallets.
size() <= 1)
return;
905 const std::string wallet_name =
wallet.get_str();
908 balances.
pushKV(wallet_name, balance);
910 result.
pushKV(
"balances", balances);
921 if (progress < 0 || progress > 1)
return;
923 static constexpr
double INCREMENT{0.05};
924 static const std::string COMPLETE_BAR{
"\u2592"};
925 static const std::string INCOMPLETE_BAR{
"\u2591"};
927 for (
int i = 0; i < progress / INCREMENT; ++i) {
928 progress_bar += COMPLETE_BAR;
931 for (
int i = 0; i < (1 - progress) / INCREMENT; ++i) {
932 progress_bar += INCOMPLETE_BAR;
943 if (!
find_value(result,
"error").isNull())
return;
945 std::string RESET, GREEN, BLUE, YELLOW, MAGENTA, CYAN;
946 bool should_colorize =
false;
949 if (isatty(fileno(stdout))) {
951 should_colorize =
true;
957 if (color ==
"always") {
958 should_colorize =
true;
959 }
else if (color ==
"never") {
960 should_colorize =
false;
961 }
else if (color !=
"auto") {
962 throw std::runtime_error(
"Invalid value for -color option. Valid values: always, auto, never.");
966 if (should_colorize) {
971 MAGENTA =
"\x1B[35m";
975 std::string result_string =
strprintf(
"%sChain: %s%s\n", BLUE, result[
"chain"].getValStr(), RESET);
976 result_string +=
strprintf(
"Blocks: %s\n", result[
"blocks"].getValStr());
977 result_string +=
strprintf(
"Headers: %s\n", result[
"headers"].getValStr());
979 const double ibd_progress{result[
"verificationprogress"].
get_real()};
980 std::string ibd_progress_bar;
982 if (ibd_progress < 0.99) {
985 ibd_progress_bar +=
" ";
988 result_string +=
strprintf(
"Verification progress: %s%.4f%%\n", ibd_progress_bar, ibd_progress * 100);
989 result_string +=
strprintf(
"Difficulty: %s\n\n", result[
"difficulty"].getValStr());
992 "%sNetwork: in %s, out %s, total %s%s\n",
994 result[
"connections"][
"in"].getValStr(),
995 result[
"connections"][
"out"].getValStr(),
996 result[
"connections"][
"total"].getValStr(),
998 result_string +=
strprintf(
"Version: %s\n", result[
"version"].getValStr());
999 result_string +=
strprintf(
"Time offset (s): %s\n", result[
"timeoffset"].getValStr());
1002 std::map<std::string, std::vector<std::string>> proxy_networks;
1003 std::vector<std::string> ordered_proxies;
1005 for (
const UniValue& network : result[
"networks"].getValues()) {
1006 const std::string proxy = network[
"proxy"].getValStr();
1007 if (proxy.empty())
continue;
1009 if (proxy_networks.find(proxy) == proxy_networks.end()) ordered_proxies.push_back(proxy);
1011 proxy_networks[proxy].push_back(network[
"name"].getValStr());
1014 std::vector<std::string> formatted_proxies;
1015 for (
const std::string& proxy : ordered_proxies) {
1016 formatted_proxies.emplace_back(
strprintf(
"%s (%s)", proxy,
Join(proxy_networks.find(proxy)->second,
", ")));
1018 result_string +=
strprintf(
"Proxies: %s\n", formatted_proxies.empty() ?
"n/a" :
Join(formatted_proxies,
", "));
1020 result_string +=
strprintf(
"Min tx relay fee rate (%s/kvB): %s\n\n",
CURRENCY_UNIT, result[
"relayfee"].getValStr());
1022 if (!result[
"has_wallet"].isNull()) {
1023 const std::string walletname = result[
"walletname"].
getValStr();
1024 result_string +=
strprintf(
"%sWallet: %s%s\n", MAGENTA, walletname.empty() ?
"\"\"" : walletname, RESET);
1026 result_string +=
strprintf(
"Keypool size: %s\n", result[
"keypoolsize"].getValStr());
1027 if (!result[
"unlocked_until"].isNull()) {
1028 result_string +=
strprintf(
"Unlocked until: %s\n", result[
"unlocked_until"].getValStr());
1030 result_string +=
strprintf(
"Transaction fee rate (-paytxfee) (%s/kvB): %s\n\n",
CURRENCY_UNIT, result[
"paytxfee"].getValStr());
1032 if (!result[
"balance"].isNull()) {
1033 result_string +=
strprintf(
"%sBalance:%s %s\n\n", CYAN, RESET, result[
"balance"].getValStr());
1036 if (!result[
"balances"].isNull()) {
1037 result_string +=
strprintf(
"%sBalances%s\n", CYAN, RESET);
1039 size_t max_balance_length{10};
1041 for (
const std::string&
wallet : result[
"balances"].getKeys()) {
1042 max_balance_length = std::max(result[
"balances"][
wallet].getValStr().length(), max_balance_length);
1045 for (
const std::string&
wallet : result[
"balances"].getKeys()) {
1048 result[
"balances"][
wallet].getValStr(),
1051 result_string +=
"\n";
1054 result_string +=
strprintf(
"%sWarnings:%s %s", YELLOW, RESET, result[
"warnings"].getValStr());
1055 result.
setStr(result_string);
1064 std::optional<std::string> wallet_name{};
1077 if (
args.size() > 2)
throw std::runtime_error(
"too many arguments (maximum 2 for nblocks and maxtries)");
1078 if (
args.size() == 0) {
1080 }
else if (
args.at(0) ==
"0") {
1081 throw std::runtime_error(
"the first argument (number of blocks to generate, default: " +
DEFAULT_NBLOCKS +
") must be an integer value greater than zero");
1083 args.emplace(
args.begin() + 1, address);
1088 std::string strPrint;
1096 std::string rpcPass;
1100 fputs(
"RPC password> ", stderr);
1103 if (!std::getline(std::cin, rpcPass)) {
1104 throw std::runtime_error(
"-stdinrpcpass specified but failed to read from standard input");
1107 fputc(
'\n', stdout);
1111 std::vector<std::string>
args = std::vector<std::string>(&argv[1], &argv[argc]);
1114 std::string walletPass;
1115 if (
args.size() < 1 ||
args[0].substr(0, 16) !=
"walletpassphrase") {
1116 throw std::runtime_error(
"-stdinwalletpassphrase is only applicable for walletpassphrase(change)");
1119 fputs(
"Wallet passphrase> ", stderr);
1122 if (!std::getline(std::cin, walletPass)) {
1123 throw std::runtime_error(
"-stdinwalletpassphrase specified but failed to read from standard input");
1126 fputc(
'\n', stdout);
1128 args.insert(
args.begin() + 1, walletPass);
1133 while (std::getline(std::cin, line)) {
1134 args.push_back(line);
1137 fputc(
'\n', stdout);
1140 std::unique_ptr<BaseRequestHandler> rh;
1145 if (!
args.empty() &&
args.at(0) ==
"help") {
1153 if (
error.isNull()) {
1163 if (
args.size() < 1) {
1164 throw std::runtime_error(
"too few parameters (need at least command)");
1171 std::optional<std::string> wallet_name{};
1178 if (
error.isNull()) {
1191 }
catch (
const std::exception& e) {
1192 strPrint = std::string(
"error: ") + e.what();
1193 nRet = EXIT_FAILURE;
1199 if (strPrint !=
"") {
1200 tfm::format(nRet == 0 ? std::cout : std::cerr,
"%s\n", strPrint);
1211 __declspec(dllexport)
int main(
int argc,
char* argv[])
1213 util::WinCmdLineArgs winArgs;
1214 std::tie(argc, argv) = winArgs.get();
1221 tfm::format(std::cerr,
"Error: Initializing networking failed\n");
1222 return EXIT_FAILURE;
1231 catch (
const std::exception& e) {
1233 return EXIT_FAILURE;
1236 return EXIT_FAILURE;
1239 int ret = EXIT_FAILURE;
1243 catch (
const std::exception& e) {
Process default single requests.
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
std::string ConnectionTypeForNetinfo(const std::string &conn_type) const
std::vector< Peer > m_peers
Reply structure for request_done to fill in.
Process netinfo requests.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
@ HTTP_SERVICE_UNAVAILABLE
std::string ToString(const T &t)
Locale-independent version of std::to_string.
static const std::string DEFAULT_NBLOCKS
Default number of blocks to generate for RPC generatetoaddress.
bool IsVersionSelected() const
size_t m_max_addr_processed_length
static const std::string DEFAULT_COLOR_SETTING
Default -color setting.
uint8_t m_details_level
Optional user-supplied arg to set dashboard details level.
std::string GetHelpMessage() const
Get the help string.
const UniValue NullUniValue
static void libevent_log_cb(int severity, const char *msg)
libevent event log callback
bool is_addr_relay_enabled
Process getinfo requests.
static int AppInitRPC(int argc, char *argv[])
static constexpr int ID_PEERINFO
static constexpr uint8_t MAX_DETAIL_LEVEL
@ ALLOW_ANY
disable validation
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
@ DISALLOW_NEGATION
disallow -nofoo syntax
std::string GetChainName() const
Returns the appropriate chain name from the program arguments.
int8_t NetworkStringToId(const std::string &str) const
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
static const std::string TESTNET
std::array< std::array< uint16_t, NETWORKS.size()+1 >, 3 > m_counts
Peer counts by (in/out/total, networks/total)
void SelectBaseParams(const std::string &chain)
Sets the params returned by Params() to those for the given network.
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
UniValue ProcessReply(const UniValue &reply) override
bool GetAuthCookie(std::string *cookie_out)
Read the RPC authentication cookie from disk.
size_t m_max_addr_rate_limited_length
static const int DEFAULT_HTTP_CLIENT_TIMEOUT
bool HelpRequested(const ArgsManager &args)
UniValue JSONRPCReplyObj(const UniValue &result, const UniValue &error, const UniValue &id)
static std::string PathToString(const path &path)
Convert path object to a byte string.
UniValue RPCConvertValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert positional arguments to command-specific RPC representation.
int64_t addr_rate_limited
std::string EncodeBase64(Span< const unsigned char > input)
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
CConnectionFailed(const std::string &msg)
bool pushKV(const std::string &key, const UniValue &val)
const char *const BITCOIN_CONF_FILENAME
static std::string http_errorstring(int code)
static constexpr int8_t UNKNOWN_NETWORK
const std::string & get_str() const
bool IsAddressSelected() const
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
static const char DEFAULT_RPCCONNECT[]
UniValue ProcessReply(const UniValue &batch_in) override
std::string getnewaddress(wallet::CWallet &w)
Returns a new address from the wallet.
Process addrinfo requests.
const std::string CURRENCY_UNIT
void SplitHostPort(std::string in, uint16_t &portOut, std::string &hostOut)
const UniValue & get_obj() const
static UniValue CallRPC(BaseRequestHandler *rh, const std::string &strMethod, const std::vector< std::string > &args, const std::optional< std::string > &rpcwallet={})
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.
uint8_t m_manual_peers_count
static void ParseGetInfoResult(UniValue &result)
ParseGetInfoResult takes in -getinfo result in UniValue object and parses it into a user friendly Uni...
std::string PingTimeToString(double seconds) const
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
const std::string m_help_doc
static const std::string REGTEST
UniValue RPCConvertNamedValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert named arguments to command-specific RPC representation.
bool IsSwitchChar(char c)
static void GetProgressBar(double progress, std::string &progress_bar)
GetProgressBar constructs a progress bar with 5% intervals.
UniValue JSONRPCRequestObj(const std::string &strMethod, const UniValue ¶ms, const UniValue &id)
JSON-RPC protocol.
void ForceSetArg(const std::string &strArg, const std::string &strValue)
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)
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
std::unique_ptr< CBaseChainParams > CreateBaseChainParams(const std::string &chain)
Port numbers for incoming Tor connections (8334, 18334, 38334, 18445) have been chosen arbitrarily to...
uint8_t m_block_relay_peers_count
@ RPC_IN_WARMUP
Client still warming up.
int main(int argc, char *argv[])
bool ParseParameters(int argc, const char *const argv[], std::string &error)
static constexpr int DEFAULT_WAIT_CLIENT_TIMEOUT
virtual ~BaseRequestHandler()
virtual UniValue ProcessReply(const UniValue &batch_in)=0
UniValue ProcessReply(const UniValue &batch_in) override
Collect values from the batch and form a simulated getinfo reply.
bool ReadConfigFiles(std::string &error, bool ignore_invalid_keys=false)
static void SetupCliArgs(ArgsManager &argsman)
static const int CONTINUE_EXECUTION
static void GetWalletBalances(UniValue &result)
GetWalletBalances calls listwallets; if more than one wallet is loaded, it then fetches mine....
static const std::string MAIN
Chain name strings.
@ RPC_WALLET_NOT_SPECIFIED
No wallet specified (error when there are multiple wallets loaded)
void UninterruptibleSleep(const std::chrono::microseconds &n)
bool CheckDataDirOption()
const std::string & getValStr() const
auto Join(const std::vector< T > &list, const BaseType &separator, UnaryOp unary_op) -> decltype(unary_op(list.at(0)))
Join a list of items.
UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args) override
Create a simulated getinfo request.
std::vector< UniValue > JSONRPCProcessBatchReply(const UniValue &in)
Parse JSON-RPC batch reply into a vector.
static constexpr int ID_NETWORKINFO
raii_event_base obtain_event_base()
fs::path GetConfigFile(const std::string &confPath)
static constexpr std::array NETWORKS
const CBaseChainParams & BaseParams()
Return the currently selected parameters.
static void ParseResult(const UniValue &result, std::string &strPrint)
Parse UniValue result to update the message to print to std::cout.
static std::string strRPCUserColonPass
static RPCHelpMan listwallets()
static const bool DEFAULT_NAMED
Class that handles the conversion from a command-line to a JSON-RPC request, as well as converting ba...
bool push_back(const UniValue &val)
std::string(const std::string &url_encoded) UrlDecodeFn
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.
const std::vector< UniValue > & getValues() const
UniValue ProcessReply(const UniValue &reply) override
Process RPC generatetoaddress request.
void PrintExceptionContinue(const std::exception *pex, const char *pszThread)
const std::function< std::string(const char *)> G_TRANSLATION_FUN
Translate string to current locale using Qt.
const UniValue & find_value(const UniValue &obj, const std::string &name)
bool operator<(const Peer &rhs) const
UrlDecodeFn *const URL_DECODE
std::string FormatFullVersion()
bool error(const char *fmt, const Args &... args)
static UniValue GetNewAddress()
Call RPC getnewaddress.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
std::string ChainToString() const
bool DetailsRequested() const
UniValue ProcessReply(const UniValue &reply) override
int8_t NetworkStringToId(const std::string &str) const
static void http_request_done(struct evhttp_request *req, void *ctx)
bool ParseUInt8(const std::string &str, uint8_t *out)
Convert decimal string to unsigned 8-bit integer with strict parse error feedback.
bool setStr(const std::string &val)
const int ID_BLOCKCHAININFO
static secp256k1_context * ctx
static const std::string SIGNET
virtual UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args)=0
int64_t GetTimeSeconds()
Returns the system time (not mockable)
@ HTTP_INTERNAL_SERVER_ERROR
static int CommandLineRPC(int argc, char *argv[])
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.