 |
Bitcoin Core
21.99.0
P2P Digital Currency
|
Go to the documentation of this file.
6 #if defined(HAVE_CONFIG_H)
31 #include <event2/buffer.h>
32 #include <event2/keyvalq_struct.h>
62 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);
63 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);
71 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);
74 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);
75 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);
76 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);
83 #ifndef EVENT_LOG_ERR // EVENT_LOG_ERR was added in 2.0.19; but before then _EVENT_LOG_ERR existed.
84 # define EVENT_LOG_ERR _EVENT_LOG_ERR
88 throw std::runtime_error(
strprintf(
"libevent error: %s", msg));
101 std::runtime_error(msg)
115 tfm::format(std::cerr,
"Error parsing command line arguments: %s\n",
error);
122 "Usage: bitcoin-cli [options] <command> [params] Send command to " PACKAGE_NAME "\n"
123 "or: bitcoin-cli [options] -named <command> [name=value]... Send command to " PACKAGE_NAME " (with named arguments)\n"
124 "or: bitcoin-cli [options] help List commands\n"
125 "or: bitcoin-cli [options] help <command> Get help for a command\n";
131 tfm::format(std::cerr,
"Error: too few parameters\n");
137 tfm::format(std::cerr,
"Error: Specified data directory \"%s\" does not exist.\n",
gArgs.
GetArg(
"-datadir",
""));
147 }
catch (
const std::exception& e) {
168 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
169 case EVREQ_HTTP_TIMEOUT:
170 return "timeout reached";
172 return "EOF reached";
173 case EVREQ_HTTP_INVALID_HEADER:
174 return "error while reading header, or invalid header";
175 case EVREQ_HTTP_BUFFER_ERROR:
176 return "error encountered while reading or writing";
177 case EVREQ_HTTP_REQUEST_CANCEL:
178 return "request was canceled";
179 case EVREQ_HTTP_DATA_TOO_LONG:
180 return "response body is larger than allowed";
191 if (req ==
nullptr) {
199 reply->
status = evhttp_request_get_response_code(req);
201 struct evbuffer *buf = evhttp_request_get_input_buffer(req);
204 size_t size = evbuffer_get_length(buf);
205 const char *data = (
const char*)evbuffer_pullup(buf, size);
207 reply->
body = std::string(data, size);
208 evbuffer_drain(buf, size);
212 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
213 static void http_error_cb(
enum evhttp_request_error err,
void *
ctx)
244 throw std::runtime_error(
"-getinfo takes no arguments");
277 result.
pushKV(
"connections", connections);
284 if (!batch[
ID_WALLETINFO][
"result"][
"unlocked_until"].isNull()) {
305 const std::array<std::string, m_networks_size>
m_networks{{
"ipv4",
"ipv6",
"onion",
"i2p"}};
306 std::array<std::array<uint16_t, m_networks_size + 1>, 3>
m_counts{{{}}};
355 if (seconds < 0)
return "";
356 const double milliseconds{round(1000 * seconds)};
357 return milliseconds > 999999 ?
"-" :
ToString(milliseconds);
361 if (conn_type ==
"outbound-full-relay")
return "full";
362 if (conn_type ==
"block-relay-only")
return "block";
363 if (conn_type ==
"manual" || conn_type ==
"feeler")
return conn_type;
364 if (conn_type ==
"addr-fetch")
return "addr";
380 throw std::runtime_error(
strprintf(
"invalid -netinfo argument: %s\nFor more information, run: bitcoin-cli -netinfo help", args.at(0)));
396 if (networkinfo[
"version"].get_int() < 209900) {
397 throw std::runtime_error(
"-netinfo requires bitcoind server to be running v0.21.0 and up");
402 const std::string network{peer[
"network"].get_str()};
405 const bool is_outbound{!peer[
"inbound"].get_bool()};
406 const bool is_block_relay{!peer[
"relaytxes"].get_bool()};
407 const std::string conn_type{peer[
"connection_type"].get_str()};
408 ++
m_counts.at(is_outbound).at(network_id);
416 const int peer_id{peer[
"id"].get_int()};
417 const int mapped_as{peer[
"mapped_as"].isNull() ? 0 : peer[
"mapped_as"].get_int()};
418 const int version{peer[
"version"].get_int()};
419 const int64_t conn_time{peer[
"conntime"].get_int64()};
420 const int64_t last_blck{peer[
"last_block"].get_int64()};
421 const int64_t last_recv{peer[
"lastrecv"].get_int64()};
422 const int64_t last_send{peer[
"lastsend"].get_int64()};
423 const int64_t last_trxn{peer[
"last_transaction"].get_int64()};
424 const double min_ping{peer[
"minping"].isNull() ? -1 : peer[
"minping"].get_real()};
425 const double ping{peer[
"pingtime"].isNull() ? -1 : peer[
"pingtime"].get_real()};
426 const std::string addr{peer[
"addr"].get_str()};
428 const std::string sub_version{peer[
"subver"].get_str()};
429 const bool is_bip152_hb_from{peer[
"bip152_hb_from"].get_bool()};
430 const bool is_bip152_hb_to{peer[
"bip152_hb_to"].get_bool()};
431 m_peers.push_back({addr, sub_version, conn_type, network, age, min_ping,
ping, last_blck, last_recv, last_send, last_trxn, peer_id, mapped_as, version, is_bip152_hb_from, is_bip152_hb_to, is_block_relay, is_outbound});
449 std::string version{
ToString(peer.version) + peer.sub_version};
451 "%3s %6s %5s%7s%7s%5s%5s%5s%5s %2s %*s%*i %*s %-*s%s\n",
452 peer.is_outbound ?
"out" :
"in",
461 strprintf(
"%s%s", peer.is_bip152_hb_to ?
"." :
" ", peer.is_bip152_hb_from ?
"*" :
" "),
476 result +=
" ipv4 ipv6 onion";
477 const bool any_i2p_peers =
m_counts.at(2).at(3);
478 if (any_i2p_peers) result +=
" i2p";
479 result +=
" total block";
481 const std::array<std::string, 3> rows{{
"in",
"out",
"total"}};
482 for (uint8_t i = 0; i < 3; ++i) {
493 result +=
"\n\nLocal addresses";
494 const std::vector<UniValue>& local_addrs{networkinfo[
"localaddresses"].getValues()};
495 if (local_addrs.empty()) {
498 size_t max_addr_size{0};
499 for (
const UniValue& addr : local_addrs) {
500 max_addr_size = std::max(addr[
"address"].get_str().length() + 1, max_addr_size);
502 for (
const UniValue& addr : local_addrs) {
503 result +=
strprintf(
"\n%-*s port %6i score %6i", max_addr_size, addr[
"address"].get_str(), addr[
"port"].get_int(), addr[
"score"].get_int());
511 "-netinfo level|\"help\" \n\n"
512 "Returns a network peer connections dashboard with information from the remote server.\n"
513 "This human-readable interface will change regularly and is not intended to be a stable API.\n"
514 "Under the hood, -netinfo fetches the data by calling getpeerinfo and getnetworkinfo.\n"
516 "Pass \"help\" to see this detailed help documentation.\n"
517 "If more than one argument is passed, only the first one is read and parsed.\n"
518 "Suggestion: use with the Linux watch(1) command for a live dashboard; see example below.\n\n"
520 +
strprintf(
"1. level (integer 0-%d, optional) Specify the info level of the peers dashboard (default 0):\n",
MAX_DETAIL_LEVEL) +
521 " 0 - Connection counts and local addresses\n"
522 " 1 - Like 0 but with a peers listing (without address or version columns)\n"
523 " 2 - Like 1 but with an address column\n"
524 " 3 - Like 1 but with a version column\n"
525 " 4 - Like 1 but with both address and version columns\n"
526 "2. help (string \"help\", optional) Print this help documentation instead of the dashboard.\n\n"
528 +
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) +
529 " Column Description\n"
530 " ------ -----------\n"
532 " \"in\" - inbound connections are those initiated by the peer\n"
533 " \"out\" - outbound connections are those initiated by us\n"
534 " type Type of peer connection\n"
535 " \"full\" - full relay, the default\n"
536 " \"block\" - block relay; like full relay but does not relay transactions or addresses\n"
537 " \"manual\" - peer we manually added using RPC addnode or the -addnode/-connect config options\n"
538 " \"feeler\" - short-lived connection for testing addresses\n"
539 " \"addr\" - address fetch; short-lived connection for requesting addresses\n"
540 " net Network the peer connected through (\"ipv4\", \"ipv6\", \"onion\", \"i2p\", or \"cjdns\")\n"
541 " mping Minimum observed ping time, in milliseconds (ms)\n"
542 " ping Last observed ping time, in milliseconds (ms)\n"
543 " send Time since last message sent to the peer, in seconds\n"
544 " recv Time since last message received from the peer, in seconds\n"
545 " txn Time since last novel transaction received from the peer and accepted into our mempool, in minutes\n"
546 " blk Time since last novel block passing initial validity checks received from the peer, in minutes\n"
547 " hb High-bandwidth BIP152 compact block relay\n"
548 " \".\" (to) - we selected the peer as a high-bandwidth peer\n"
549 " \"*\" (from) - the peer selected us as a high-bandwidth peer\n"
550 " age Duration of connection to the peer, in minutes\n"
551 " asmap Mapped AS (Autonomous System) number in the BGP route to the peer, used for diversifying\n"
552 " peer selection (only displayed if the -asmap config option is set)\n"
553 " id Peer index, in increasing order of peer connections since node startup\n"
554 " address IP address and port of the peer\n"
555 " version Peer version and subversion concatenated, e.g. \"70016/Satoshi:21.0.0/\"\n\n"
556 "* The connection counts table displays the number of peers by direction, network, and the totals\n"
557 " for each, as well as two special outbound columns for block relay peers and manual peers.\n\n"
558 "* The local addresses table lists each local address broadcast by the node, the port, and the score.\n\n"
560 "Connection counts and local addresses only\n"
561 "> bitcoin-cli -netinfo\n\n"
562 "Compact peers listing\n"
563 "> bitcoin-cli -netinfo 1\n\n"
566 "Full live dashboard, adjust --interval or --no-title as needed (Linux)\n"
569 "> bitcoin-cli -netinfo help\n"};
623 port =
static_cast<uint16_t
>(
gArgs.
GetArg(
"-rpcport", port));
635 evhttp_connection_set_timeout(evcon.get(), timeout);
640 constexpr
int YEAR_IN_SECONDS = 31556952;
641 evhttp_connection_set_timeout(evcon.get(), 5 * YEAR_IN_SECONDS);
648 throw std::runtime_error(
"create http request failed");
649 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
650 evhttp_request_set_error_cb(req.get(), http_error_cb);
655 bool failedToGetAuthCookie =
false;
659 failedToGetAuthCookie =
true;
665 struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
667 evhttp_add_header(output_headers,
"Host", host.c_str());
668 evhttp_add_header(output_headers,
"Connection",
"close");
669 evhttp_add_header(output_headers,
"Content-Type",
"application/json");
674 struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
676 evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
679 std::string endpoint =
"/";
681 char* encodedURI = evhttp_uriencode(rpcwallet->data(), rpcwallet->size(),
false);
683 endpoint =
"/wallet/" + std::string(encodedURI);
689 int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, endpoint.c_str());
695 event_base_dispatch(base.get());
697 if (response.
status == 0) {
698 std::string responseErrorMessage;
699 if (response.
error != -1) {
702 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));
704 if (failedToGetAuthCookie) {
706 "Could not locate RPC credentials. No authentication cookie could be found, and RPC password is not set. See -rpcpassword and -stdinrpcpass. Configuration file: (%s)",
709 throw std::runtime_error(
"Authorization failed: Incorrect rpcuser or rpcpassword");
712 throw std::runtime_error(
strprintf(
"Server response: %s", response.
body));
714 throw std::runtime_error(
strprintf(
"server returned HTTP error %d", response.
status));
715 else if (response.
body.empty())
716 throw std::runtime_error(
"no response from server");
720 if (!valReply.read(response.
body))
721 throw std::runtime_error(
"couldn't parse reply from server");
724 throw std::runtime_error(
"expected reply to have result, error and id properties");
745 response =
CallRPC(rh, strMethod, args, rpcwallet);
767 if (result.
isNull())
return;
774 if (
error.isObject()) {
778 strPrint =
"error code: " + err_code.
getValStr() +
"\n";
780 if (err_msg.
isStr()) {
781 strPrint += (
"error message:\n" + err_msg.
get_str());
784 strPrint +=
"\nTry adding \"-rpcwallet=<filename>\" option to bitcoin-cli command line.";
787 strPrint =
"error: " +
error.write();
789 nRet = abs(
error[
"code"].get_int());
804 if (wallets.
size() <= 1)
return;
808 const std::string wallet_name =
wallet.get_str();
813 result.
pushKV(
"balances", balances);
822 std::optional<std::string> wallet_name{};
835 if (args.size() > 2)
throw std::runtime_error(
"too many arguments (maximum 2 for nblocks and maxtries)");
836 if (args.size() == 0) {
838 }
else if (args.at(0) ==
"0") {
839 throw std::runtime_error(
"the first argument (number of blocks to generate, default: " +
DEFAULT_NBLOCKS +
") must be an integer value greater than zero");
841 args.emplace(args.begin() + 1, address);
846 std::string strPrint;
858 fputs(
"RPC password> ", stderr);
861 if (!std::getline(std::cin, rpcPass)) {
862 throw std::runtime_error(
"-stdinrpcpass specified but failed to read from standard input");
869 std::vector<std::string> args = std::vector<std::string>(&argv[1], &argv[argc]);
872 std::string walletPass;
873 if (args.size() < 1 || args[0].substr(0, 16) !=
"walletpassphrase") {
874 throw std::runtime_error(
"-stdinwalletpassphrase is only applicable for walletpassphrase(change)");
877 fputs(
"Wallet passphrase> ", stderr);
880 if (!std::getline(std::cin, walletPass)) {
881 throw std::runtime_error(
"-stdinwalletpassphrase specified but failed to read from standard input");
886 args.insert(args.begin() + 1, walletPass);
891 while (std::getline(std::cin, line)) {
892 args.push_back(line);
898 std::unique_ptr<BaseRequestHandler> rh;
903 if (!args.empty() && args.at(0) ==
"help") {
911 if (
error.isNull()) {
919 if (args.size() < 1) {
920 throw std::runtime_error(
"too few parameters (need at least command)");
923 args.erase(args.begin());
927 std::optional<std::string> wallet_name{};
934 if (
error.isNull()) {
943 }
catch (
const std::exception& e) {
944 strPrint = std::string(
"error: ") + e.what();
951 if (strPrint !=
"") {
952 tfm::format(nRet == 0 ? std::cout : std::cerr,
"%s\n", strPrint);
963 __declspec(dllexport)
int main(
int argc,
char* argv[])
965 util::WinCmdLineArgs winArgs;
966 std::tie(argc, argv) = winArgs.get();
968 int main(
int argc,
char* argv[])
973 tfm::format(std::cerr,
"Error: Initializing networking failed\n");
983 catch (
const std::exception& e) {
991 int ret = EXIT_FAILURE;
995 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
fs::path GetConfigFile(const std::string &confPath)
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
const std::array< std::string, m_networks_size > m_networks
bool CheckDataDirOption()
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
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
Process getinfo requests.
static int AppInitRPC(int argc, char *argv[])
static constexpr int ID_PEERINFO
static constexpr uint8_t MAX_DETAIL_LEVEL
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
std::string GetChainName() const
Returns the appropriate chain name from the program arguments.
static RPCHelpMan getnewaddress()
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.
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
static const std::string TESTNET
void SelectBaseParams(const std::string &chain)
Sets the params returned by Params() to those for the given network.
UniValue ProcessReply(const UniValue &reply) override
bool GetAuthCookie(std::string *cookie_out)
Read the RPC authentication cookie from disk.
static const int DEFAULT_HTTP_CLIENT_TIMEOUT
UniValue JSONRPCReplyObj(const UniValue &result, const UniValue &error, const UniValue &id)
UniValue RPCConvertValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert positional arguments to command-specific RPC representation.
std::string EncodeBase64(Span< const unsigned char > input)
static constexpr int8_t UNKNOWN_NETWORK
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
CConnectionFailed(const std::string &msg)
bool pushKV(const std::string &key, const UniValue &val)
static std::string http_errorstring(int code)
const std::string & get_str() const
bool IsAddressSelected() const
bool HelpRequested(const ArgsManager &args)
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
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 constexpr uint8_t m_networks_size
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
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
int64_t GetSystemTimeInSeconds()
Returns the system time (not mockable)
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)
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)
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)
static RPCHelpMan listwallets()
const std::string & getValStr() const
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()
static RPCHelpMan getbalances()
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 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 char *const BITCOIN_CONF_FILENAME
const std::vector< UniValue > & getValues() const
Process RPC generatetoaddress request.
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)
std::array< std::array< uint16_t, m_networks_size+1 >, 3 > m_counts
Peer counts by (in/out/total, networks/total)
static UniValue GetNewAddress()
Call RPC getnewaddress.
std::string ChainToString() const
bool DetailsRequested() const
UniValue ProcessReply(const UniValue &reply) override
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.
assert(std::addressof(::ChainstateActive().CoinsTip())==std::addressof(coins_cache))
const int ID_BLOCKCHAININFO
void PrintExceptionContinue(const std::exception *pex, const char *pszThread)
static secp256k1_context * ctx
static const std::string SIGNET
virtual UniValue PrepareRequest(const std::string &method, const std::vector< std::string > &args)=0
@ 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.