{

SetupHelpOptions(gArgs);

const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);

const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);

const auto regtestBaseParams = CreateBaseChainParams(CBaseChainParams::REGTEST);

gArgs.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-conf=<file>", strprintf("Specify configuration file. Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.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);

SetupChainParamsBaseOptions();

gArgs.AddArg("-named", strprintf("Pass named instead of positional arguments (default: %s)", DEFAULT_NAMED), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpcclienttimeout=<n>", strprintf("Timeout in seconds during HTTP requests, or 0 for no timeout. (default: %d)", DEFAULT_HTTP_CLIENT_TIMEOUT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpcconnect=<ip>", strprintf("Send commands to node running on <ip> (default: %s)", DEFAULT_RPCCONNECT), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpccookiefile=<loc>", "Location of the auth cookie. Relative paths will be prefixed by a net-specific datadir location. (default: data dir)", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpcport=<port>", strprintf("Connect to JSON-RPC on <port> (default: %u, testnet: %u, regtest: %u)", defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort(), regtestBaseParams->RPCPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.AddArg("-rpcwait", "Wait for RPC server to start", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

gArgs.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);

gArgs.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);

gArgs.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.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);

{

#ifndef EVENT_LOG_ERR // EVENT_LOG_ERR was added in 2.0.19; but before then _EVENT_LOG_ERR existed.

# define EVENT_LOG_ERR _EVENT_LOG_ERR

#endif

// Ignore everything other than errors

if (severity >= EVENT_LOG_ERR) {

throw std::runtime_error(strprintf("libevent error: %s", msg));

}

{

explicit inline CConnectionFailed(const std::string& msg) :

std::runtime_error(msg)

{}

{

//

// Parameters

//

SetupCliArgs();

std::string error;

if (!gArgs.ParseParameters(argc, argv, error)) {

tfm::format(std::cerr, "Error parsing command line arguments: %s\n", error.c_str());

return EXIT_FAILURE;

}

if (argc < 2 || HelpRequested(gArgs) || gArgs.IsArgSet("-version")) {

std::string strUsage = PACKAGE_NAME " RPC client version " + FormatFullVersion() + "\n";

if (!gArgs.IsArgSet("-version")) {

strUsage += "\n"

"Usage: bitcoin-cli [options] <command> [params] Send command to " PACKAGE_NAME "\n"

"or: bitcoin-cli [options] -named <command> [name=value]... Send command to " PACKAGE_NAME " (with named arguments)\n"

"or: bitcoin-cli [options] help List commands\n"

"or: bitcoin-cli [options] help <command> Get help for a command\n";

strUsage += "\n" + gArgs.GetHelpMessage();

}

tfm::format(std::cout, "%s", strUsage.c_str());

if (argc < 2) {

tfm::format(std::cerr, "Error: too few parameters\n");

return EXIT_FAILURE;

}

return EXIT_SUCCESS;

}

if (!CheckDataDirOption()) {

tfm::format(std::cerr, "Error: Specified data directory \"%s\" does not exist.\n", gArgs.GetArg("-datadir", "").c_str());

return EXIT_FAILURE;

}

if (!gArgs.ReadConfigFiles(error, true)) {

tfm::format(std::cerr, "Error reading configuration file: %s\n", error.c_str());

return EXIT_FAILURE;

}

// Check for -chain, -testnet or -regtest parameter (BaseParams() calls are only valid after this clause)

try {

SelectBaseParams(gArgs.GetChainName());

} catch (const std::exception& e) {

tfm::format(std::cerr, "Error: %s\n", e.what());

return EXIT_FAILURE;

}

return CONTINUE_EXECUTION;

{

HTTPReply(): status(0), error(-1) {}

int status;

int error;

std::string body;

{

HTTPReply *reply = static_cast<HTTPReply*>(ctx);

if (req == nullptr) {

/* If req is nullptr, it means an error occurred while connecting: the

reply->status = 0;

return;

}

reply->status = evhttp_request_get_response_code(req);

struct evbuffer *buf = evhttp_request_get_input_buffer(req);

if (buf)

{

size_t size = evbuffer_get_length(buf);

const char *data = (const char*)evbuffer_pullup(buf, size);

if (data)

reply->body = std::string(data, size);

evbuffer_drain(buf, size);

}

{

HTTPReply *reply = static_cast<HTTPReply*>(ctx);

reply->error = err;

{

virtual ~BaseRequestHandler() {}

virtual UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) = 0;

virtual UniValue ProcessReply(const UniValue &batch_in) = 0;

{

const int ID_NETWORKINFO = 0;

const int ID_BLOCKCHAININFO = 1;

const int ID_WALLETINFO = 2;

/** Create a simulated `getinfo` request. */

UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override

{

if (!args.empty()) {

throw std::runtime_error("-getinfo takes no arguments");

}

UniValue result(UniValue::VARR);

result.push_back(JSONRPCRequestObj("getnetworkinfo", NullUniValue, ID_NETWORKINFO));

result.push_back(JSONRPCRequestObj("getblockchaininfo", NullUniValue, ID_BLOCKCHAININFO));

result.push_back(JSONRPCRequestObj("getwalletinfo", NullUniValue, ID_WALLETINFO));

return result;

}

/** Collect values from the batch and form a simulated `getinfo` reply. */

UniValue ProcessReply(const UniValue &batch_in) override

{

UniValue result(UniValue::VOBJ);

std::vector<UniValue> batch = JSONRPCProcessBatchReply(batch_in, 3);

// Errors in getnetworkinfo() and getblockchaininfo() are fatal, pass them on

// getwalletinfo() is allowed to fail in case there is no wallet.

if (!batch[ID_NETWORKINFO]["error"].isNull()) {

return batch[ID_NETWORKINFO];

}

if (!batch[ID_BLOCKCHAININFO]["error"].isNull()) {

return batch[ID_BLOCKCHAININFO];

}

result.pushKV("version", batch[ID_NETWORKINFO]["result"]["version"]);

result.pushKV("protocolversion", batch[ID_NETWORKINFO]["result"]["protocolversion"]);

result.pushKV("blocks", batch[ID_BLOCKCHAININFO]["result"]["blocks"]);

result.pushKV("timeoffset", batch[ID_NETWORKINFO]["result"]["timeoffset"]);

result.pushKV("connections", batch[ID_NETWORKINFO]["result"]["connections"]);

result.pushKV("proxy", batch[ID_NETWORKINFO]["result"]["networks"][0]["proxy"]);

result.pushKV("difficulty", batch[ID_BLOCKCHAININFO]["result"]["difficulty"]);

result.pushKV("chain", UniValue(batch[ID_BLOCKCHAININFO]["result"]["chain"]));

if (!batch[ID_WALLETINFO]["result"].isNull()) {

result.pushKV("walletversion", batch[ID_WALLETINFO]["result"]["walletversion"]);

result.pushKV("balance", batch[ID_WALLETINFO]["result"]["balance"]);

result.pushKV("keypoololdest", batch[ID_WALLETINFO]["result"]["keypoololdest"]);

result.pushKV("keypoolsize", batch[ID_WALLETINFO]["result"]["keypoolsize"]);

if (!batch[ID_WALLETINFO]["result"]["unlocked_until"].isNull()) {

result.pushKV("unlocked_until", batch[ID_WALLETINFO]["result"]["unlocked_until"]);

}

result.pushKV("paytxfee", batch[ID_WALLETINFO]["result"]["paytxfee"]);

}

result.pushKV("relayfee", batch[ID_NETWORKINFO]["result"]["relayfee"]);

result.pushKV("warnings", batch[ID_NETWORKINFO]["result"]["warnings"]);

return JSONRPCReplyObj(result, NullUniValue, 1);

}

UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override

{

UniValue params;

if(gArgs.GetBoolArg("-named", DEFAULT_NAMED)) {

params = RPCConvertNamedValues(method, args);

} else {

params = RPCConvertValues(method, args);

}

return JSONRPCRequestObj(method, params, 1);

}

UniValue ProcessReply(const UniValue &reply) override

{

return reply.get_obj();

}

{

std::string host;

// In preference order, we choose the following for the port:

// 1. -rpcport

// 2. port in -rpcconnect (ie following : in ipv4 or ]: in ipv6)

// 3. default port for chain

int port = BaseParams().RPCPort();

SplitHostPort(gArgs.GetArg("-rpcconnect", DEFAULT_RPCCONNECT), port, host);

port = gArgs.GetArg("-rpcport", port);

// Obtain event base

raii_event_base base = obtain_event_base();

// Synchronously look up hostname

raii_evhttp_connection evcon = obtain_evhttp_connection_base(base.get(), host, port);

// Set connection timeout

{

const int timeout = gArgs.GetArg("-rpcclienttimeout", DEFAULT_HTTP_CLIENT_TIMEOUT);

if (timeout > 0) {

evhttp_connection_set_timeout(evcon.get(), timeout);

} else {

// Indefinite request timeouts are not possible in libevent-http, so we

// set the timeout to a very long time period instead.

constexpr int YEAR_IN_SECONDS = 31556952; // Average length of year in Gregorian calendar

evhttp_connection_set_timeout(evcon.get(), 5 * YEAR_IN_SECONDS);

}

}

HTTPReply response;

raii_evhttp_request req = obtain_evhttp_request(http_request_done, (void*)&response);

if (req == nullptr)

throw std::runtime_error("create http request failed");

#if LIBEVENT_VERSION_NUMBER >= 0x02010300

evhttp_request_set_error_cb(req.get(), http_error_cb);

#endif

// Get credentials

std::string strRPCUserColonPass;

bool failedToGetAuthCookie = false;

if (gArgs.GetArg("-rpcpassword", "") == "") {

// Try fall back to cookie-based authentication if no password is provided

if (!GetAuthCookie(&strRPCUserColonPass)) {

failedToGetAuthCookie = true;

}

} else {

strRPCUserColonPass = gArgs.GetArg("-rpcuser", "") + ":" + gArgs.GetArg("-rpcpassword", "");

}

struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());

assert(output_headers);

evhttp_add_header(output_headers, "Host", host.c_str());

evhttp_add_header(output_headers, "Connection", "close");

evhttp_add_header(output_headers, "Authorization", (std::string("Basic ") + EncodeBase64(strRPCUserColonPass)).c_str());

// Attach request data

std::string strRequest = rh->PrepareRequest(strMethod, args).write() + "\n";

struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());

assert(output_buffer);

evbuffer_add(output_buffer, strRequest.data(), strRequest.size());

// check if we should use a special wallet endpoint

std::string endpoint = "/";

if (!gArgs.GetArgs("-rpcwallet").empty()) {

std::string walletName = gArgs.GetArg("-rpcwallet", "");

char *encodedURI = evhttp_uriencode(walletName.c_str(), walletName.size(), false);

if (encodedURI) {

endpoint = "/wallet/"+ std::string(encodedURI);

free(encodedURI);

}

else {

throw CConnectionFailed("uri-encode failed");

}

}

int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, endpoint.c_str());

req.release(); // ownership moved to evcon in above call

if (r != 0) {

throw CConnectionFailed("send http request failed");

}

event_base_dispatch(base.get());

if (response.status == 0) {

std::string responseErrorMessage;

if (response.error != -1) {

responseErrorMessage = strprintf(" (error code %d - \"%s\")", response.error, http_errorstring(response.error));

}

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));

} else if (response.status == HTTP_UNAUTHORIZED) {

if (failedToGetAuthCookie) {

throw std::runtime_error(strprintf(

"Could not locate RPC credentials. No authentication cookie could be found, and RPC password is not set. See -rpcpassword and -stdinrpcpass. Configuration file: (%s)",

GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME)).string().c_str()));

} else {

throw std::runtime_error("Authorization failed: Incorrect rpcuser or rpcpassword");

}

} else if (response.status >= 400 && response.status != HTTP_BAD_REQUEST && response.status != HTTP_NOT_FOUND && response.status != HTTP_INTERNAL_SERVER_ERROR)

throw std::runtime_error(strprintf("server returned HTTP error %d", response.status));

else if (response.body.empty())

throw std::runtime_error("no response from server");

// Parse reply

UniValue valReply(UniValue::VSTR);

if (!valReply.read(response.body))

throw std::runtime_error("couldn't parse reply from server");

const UniValue reply = rh->ProcessReply(valReply);

if (reply.empty())

throw std::runtime_error("expected reply to have result, error and id properties");

return reply;

{

std::string strPrint;

int nRet = 0;

try {

// Skip switches

while (argc > 1 && IsSwitchChar(argv[1][0])) {

argc--;

argv++;

}

std::string rpcPass;

if (gArgs.GetBoolArg("-stdinrpcpass", false)) {

if (!std::getline(std::cin, rpcPass)) {

throw std::runtime_error("-stdinrpcpass specified but failed to read from standard input");

}

gArgs.ForceSetArg("-rpcpassword", rpcPass);

}

std::vector<std::string> args = std::vector<std::string>(&argv[1], &argv[argc]);

if (gArgs.GetBoolArg("-stdin", false)) {

// Read one arg per line from stdin and append

std::string line;

while (std::getline(std::cin, line)) {

args.push_back(line);

}

}

std::unique_ptr<BaseRequestHandler> rh;

std::string method;

if (gArgs.GetBoolArg("-getinfo", false)) {

rh.reset(new GetinfoRequestHandler());

method = "";

} else {

rh.reset(new DefaultRequestHandler());

if (args.size() < 1) {

throw std::runtime_error("too few parameters (need at least command)");

}

method = args[0];

args.erase(args.begin()); // Remove trailing method name from arguments vector

}

// Execute and handle connection failures with -rpcwait

const bool fWait = gArgs.GetBoolArg("-rpcwait", false);

do {

try {

const UniValue reply = CallRPC(rh.get(), method, args);

// Parse reply

const UniValue& result = find_value(reply, "result");

const UniValue& error = find_value(reply, "error");

if (!error.isNull()) {

// Error

int code = error["code"].get_int();

if (fWait && code == RPC_IN_WARMUP)

throw CConnectionFailed("server in warmup");

strPrint = "error: " + error.write();

nRet = abs(code);

if (error.isObject())

{

UniValue errCode = find_value(error, "code");

UniValue errMsg = find_value(error, "message");

strPrint = errCode.isNull() ? "" : "error code: "+errCode.getValStr()+"\n";

if (errMsg.isStr())

strPrint += "error message:\n"+errMsg.get_str();

if (errCode.isNum() && errCode.get_int() == RPC_WALLET_NOT_SPECIFIED) {

strPrint += "\nTry adding \"-rpcwallet=<filename>\" option to bitcoin-cli command line.";

}

}

} else {

// Result

if (result.isNull())

strPrint = "";

else if (result.isStr())

strPrint = result.get_str();

else

strPrint = result.write(2);

}

// Connection succeeded, no need to retry.

break;

}

catch (const CConnectionFailed&) {

if (fWait)

MilliSleep(1000);

else

throw;

}

} while (fWait);

}

catch (const std::exception& e) {

strPrint = std::string("error: ") + e.what();

nRet = EXIT_FAILURE;

}

catch (...) {

PrintExceptionContinue(nullptr, "CommandLineRPC()");

throw;

}

if (strPrint != "") {

tfm::format(nRet == 0 ? std::cout : std::cerr, "%s\n", strPrint.c_str());

}

return nRet;

{

#ifdef WIN32

util::WinCmdLineArgs winArgs;

std::tie(argc, argv) = winArgs.get();

#endif

SetupEnvironment();

if (!SetupNetworking()) {

tfm::format(std::cerr, "Error: Initializing networking failed\n");

return EXIT_FAILURE;

}

event_set_log_callback(&libevent_log_cb);

try {

int ret = AppInitRPC(argc, argv);

if (ret != CONTINUE_EXECUTION)

return ret;

}

catch (const std::exception& e) {

PrintExceptionContinue(&e, "AppInitRPC()");

return EXIT_FAILURE;

} catch (...) {

PrintExceptionContinue(nullptr, "AppInitRPC()");

return EXIT_FAILURE;

}

int ret = EXIT_FAILURE;

try {

ret = CommandLineRPC(argc, argv);

}

catch (const std::exception& e) {

PrintExceptionContinue(&e, "CommandLineRPC()");

} catch (...) {

PrintExceptionContinue(nullptr, "CommandLineRPC()");

}

return ret;