1251        } else {
1252            error += "Incorrect rpcuser or rpcpassword were specified.";
1253        }
1254        error += strprintf(" Configuration file: (%s)", fs::PathToString(gArgs.GetConfigFilePath()));
1255        throw std::runtime_error(error);
1256    } else if (response.status == HTTP_SERVICE_UNAVAILABLE) {
1257        throw std::runtime_error(strprintf("Server response: %s", response.body));
1258    } else if (response.status >= 400 && response.status != HTTP_BAD_REQUEST && response.status != HTTP_NOT_FOUND && response.status != HTTP_INTERNAL_SERVER_ERROR)
1259        throw std::runtime_error(strprintf("server returned HTTP error %d", response.status));
1260    else if (response.body.empty())
1261        throw std::runtime_error("no response from server");
1262
1263    // Parse reply
1264    UniValue valReply(UniValue::VSTR);
1265    if (!valReply.read(response.body))
1266        throw std::runtime_error("couldn't parse reply from server");
1267    UniValue reply = rh->ProcessReply(valReply);
1268    if (reply.empty())
1269        throw std::runtime_error("expected reply to have result, error and id properties");
1270
1271    return reply;
1272}
1273
1274/**
1275 * ConnectAndCallRPC wraps CallRPC with -rpcwait and an exception handler.
1276 *
1277 * @param[in] rh         Pointer to RequestHandler.
1278 * @param[in] strMethod  Reference to const string method to forward to CallRPC.
1279 * @param[in] rpcwallet  Reference to const optional string wallet name to forward to CallRPC.
1280 * @returns the RPC response as a UniValue object.
1281 * @throws a CConnectionFailed std::runtime_error if connection failed or RPC server still in warmup.
1282 */
1283static UniValue ConnectAndCallRPC(BaseRequestHandler* rh, const std::string& strMethod, const std::vector<std::string>& args, const std::optional<std::string>& rpcwallet = {})
1284{
1285    UniValue response(UniValue::VOBJ);
1286    // Execute and handle connection failures with -rpcwait.
1287    const bool fWait = gArgs.GetBoolArg("-rpcwait", false);
1288    const int timeout = gArgs.GetIntArg("-rpcwaittimeout", DEFAULT_WAIT_CLIENT_TIMEOUT);
1289    const auto deadline{std::chrono::steady_clock::now() + 1s * timeout};
1290
1291    // check if we should use a special wallet endpoint
1292    std::string endpoint = "/";
1293    if (rpcwallet) {
1294        endpoint = "/wallet/" + UrlEncode(*rpcwallet);
1295    }
1296
1297    std::string username{gArgs.GetArg("-rpcuser", "")};
1298    do {
1299        try {
1300            if (auto ipc_response{CallIPC(rh, strMethod, args, endpoint, username)}) {
1301                response = std::move(*ipc_response);
1302            } else {
1303                response = CallRPC(rh, strMethod, args, endpoint, username);
1304            }
1305            if (fWait) {
1306                const UniValue& error = response.find_value("error");
1307                if (!error.isNull() && error["code"].getInt<int>() == RPC_IN_WARMUP) {
1308                    throw CConnectionFailed("server in warmup");
1309                }
1310            }
1311            break; // Connection succeeded, no need to retry.
1312        } catch (const CConnectionFailed& e) {
1313            if (fWait && (timeout <= 0 || std::chrono::steady_clock::now() < deadline)) {
1314                UninterruptibleSleep(1s);
1315            } else if (fWait) {
1316                throw CConnectionFailed(strprintf("timeout on transient error: %s", e.what()));
1317            } else {
1318                throw;
1319            }
1320        }
1321    } while (fWait);
1322    return response;
1323}
1324
1325/** Parse UniValue result to update the message to print to std::cout. */
1326static void ParseResult(const UniValue& result, std::string& strPrint)
1327{
1328    if (result.isNull()) return;
1329    strPrint = result.isStr() ? result.get_str() : result.write(2);
1330}
1331
1332/** Parse UniValue error to update the message to print to std::cerr and the code to return. */
1333static void ParseError(const UniValue& error, std::string& strPrint, int& nRet)
1334{
1335    if (error.isObject()) {
1336        const UniValue& err_code = error.find_value("code");
1337        const UniValue& err_msg = error.find_value("message");
1338        if (!err_code.isNull()) {
1339            strPrint = "error code: " + err_code.getValStr() + "\n";
1340        }
1341        if (err_msg.isStr()) {
1342            strPrint += ("error message:\n" + err_msg.get_str());
1343        }
1344        if (err_code.isNum() && err_code.getInt<int>() == RPC_WALLET_NOT_SPECIFIED) {
1345            strPrint += " Or for the CLI, specify the \"-rpcwallet=<walletname>\" option before the command";
1346            strPrint += " (run \"bitcoin-cli -h\" for help or \"bitcoin-cli listwallets\" to see which wallets are currently loaded).";
1347        }
1348    } else {
1349        strPrint = "error: " + error.write();
1350    }
1351    nRet = abs(error["code"].getInt<int>());
1352}
1353
1354/**
1355 * GetWalletBalances calls listwallets; if more than one wallet is loaded, it then
1356 * fetches mine.trusted balances for each loaded wallet and pushes them to `result`.
1357 *
1358 * @param result  Reference to UniValue object the wallet names and balances are pushed to.
1359 */
1360static void GetWalletBalances(UniValue& result)
1361{
1362    DefaultRequestHandler rh;
1363    const UniValue listwallets = ConnectAndCallRPC(&rh, "listwallets", /* args=*/{});
1364    if (!listwallets.find_value("error").isNull()) return;
1365    const UniValue& wallets = listwallets.find_value("result");
1366    if (wallets.size() <= 1) return;
1367
1368    UniValue balances(UniValue::VOBJ);
1369    for (const UniValue& wallet : wallets.getValues()) {
1370        const std::string& wallet_name = wallet.get_str();
1371        const UniValue getbalances = ConnectAndCallRPC(&rh, "getbalances", /* args=*/{}, wallet_name);
1372        const UniValue& balance = getbalances.find_value("result")["mine"]["trusted"];
1373        balances.pushKV(wallet_name, balance);
1374    }
1375    result.pushKV("balances", std::move(balances));
1376}
1377
1378/**
1379 * GetProgressBar constructs a progress bar with 5% intervals.
1380 *
1381 * @param[in]   progress      The proportion of the progress bar to be filled between 0 and 1.
1382 * @param[out]  progress_bar  String representation of the progress bar.
1383 */
1384static void GetProgressBar(double progress, std::string& progress_bar)
1385{
1386    if (progress < 0 || progress > 1) return;
1387
1388    static constexpr double INCREMENT{0.05};
1389    static const std::string COMPLETE_BAR{"\u2592"};
1390    static const std::string INCOMPLETE_BAR{"\u2591"};
1391
1392    for (int i = 0; i < progress / INCREMENT; ++i) {
1393        progress_bar += COMPLETE_BAR;
1394    }
1395
1396    for (int i = 0; i < (1 - progress) / INCREMENT; ++i) {
1397        progress_bar += INCOMPLETE_BAR;
1398    }
1399}
1400
1401/**
1402 * ParseGetInfoResult takes in -getinfo result in UniValue object and parses it
1403 * into a user friendly UniValue string to be printed on the console.
1404 * @param[out] result  Reference to UniValue result containing the -getinfo output.
1405 */
1406static void ParseGetInfoResult(UniValue& result)
1407{
1408    if (!result.find_value("error").isNull()) return;
1409
1410    std::string RESET, GREEN, BLUE, YELLOW, MAGENTA, CYAN;
1411    bool should_colorize = false;
1412
1413#ifndef WIN32
1414    if (isatty(fileno(stdout))) {
1415        // By default, only print colored text if OS is not WIN32 and stdout is connected to a terminal.
1416        should_colorize = true;
1417    }
1418#endif
1419
1420    {
1421        const std::string color{gArgs.GetArg("-color", DEFAULT_COLOR_SETTING)};
1422        if (color == "always") {
1423            should_colorize = true;
1424        } else if (color == "never") {
1425            should_colorize = false;
1426        } else if (color != "auto") {
1427            throw std::runtime_error("Invalid value for -color option. Valid values: always, auto, never.");
1428        }
1429    }
1430
1431    if (should_colorize) {
1432        RESET = "\x1B[0m";
1433        GREEN = "\x1B[32m";
1434        BLUE = "\x1B[34m";
1435        YELLOW = "\x1B[33m";
1436        MAGENTA = "\x1B[35m";
1437        CYAN = "\x1B[36m";
1438    }
1439
1440    std::string result_string = strprintf("%sChain: %s%s\n", BLUE, result["chain"].getValStr(), RESET);
1441    result_string += strprintf("Blocks: %s\n", result["blocks"].getValStr());
1442    result_string += strprintf("Headers: %s\n", result["headers"].getValStr());
1443
1444    const double ibd_progress{result["verificationprogress"].get_real()};
1445    std::string ibd_progress_bar;
1446    // Display the progress bar only if IBD progress is less than 99%
1447    if (ibd_progress < 0.99) {
1448      GetProgressBar(ibd_progress, ibd_progress_bar);
1449      // Add padding between progress bar and IBD progress
1450      ibd_progress_bar += " ";
1451    }
1452
1453    result_string += strprintf("Verification progress: %s%.4f%%\n", ibd_progress_bar, ibd_progress * 100);
1454    result_string += strprintf("Difficulty: %s\n\n", result["difficulty"].getValStr());
1455
1456    result_string += strprintf(
1457        "%sNetwork: in %s, out %s, total %s%s\n",
1458        GREEN,
1459        result["connections"]["in"].getValStr(),
1460        result["connections"]["out"].getValStr(),
1461        result["connections"]["total"].getValStr(),
1462        RESET);
1463    result_string += strprintf("Version: %s\n", result["version"].getValStr());
1464    result_string += strprintf("Time offset (s): %s\n", result["timeoffset"].getValStr());
1465
1466    // proxies
1467    std::map<std::string, std::vector<std::string>> proxy_networks;
1468    std::vector<std::string> ordered_proxies;
1469
1470    for (const UniValue& network : result["networks"].getValues()) {
1471        const std::string proxy = network["proxy"].getValStr();
1472        if (proxy.empty()) continue;
1473        // Add proxy to ordered_proxy if has not been processed
1474        if (!proxy_networks.contains(proxy)) ordered_proxies.push_back(proxy);
1475
1476        proxy_networks[proxy].push_back(network["name"].getValStr());
1477    }
1478
1479    std::vector<std::string> formatted_proxies;
1480    formatted_proxies.reserve(ordered_proxies.size());
1481    for (const std::string& proxy : ordered_proxies) {
1482        formatted_proxies.emplace_back(strprintf("%s (%s)", proxy, Join(proxy_networks.find(proxy)->second, ", ")));
1483    }
1484    result_string += strprintf("Proxies: %s\n", formatted_proxies.empty() ? "n/a" : Join(formatted_proxies, ", "));
1485
1486    result_string += strprintf("Min tx relay fee rate (%s/kvB): %s\n\n", CURRENCY_UNIT, result["relayfee"].getValStr());
1487
1488    if (!result["has_wallet"].isNull()) {
1489        const std::string walletname = result["walletname"].getValStr();
1490        result_string += strprintf("%sWallet: %s%s\n", MAGENTA, walletname.empty() ? "\"\"" : walletname, RESET);
1491
1492        result_string += strprintf("Keypool size: %s\n", result["keypoolsize"].getValStr());
1493        if (!result["unlocked_until"].isNull()) {
1494            result_string += strprintf("Unlocked until: %s\n", result["unlocked_until"].getValStr());
1495        }
1496    }
1497    if (!result["balance"].isNull()) {
1498        result_string += strprintf("%sBalance:%s %s\n\n", CYAN, RESET, result["balance"].getValStr());
1499    }
1500