How bitcoin-cli talks to a node

1501    if (!result["balances"].isNull()) {
1502        result_string += strprintf("%sBalances%s\n", CYAN, RESET);
1503
1504        size_t max_balance_length{10};
1505
1506        for (const std::string& wallet : result["balances"].getKeys()) {
1507            max_balance_length = std::max(result["balances"][wallet].getValStr().length(), max_balance_length);
1508        }
1509
1510        for (const std::string& wallet : result["balances"].getKeys()) {
1511            result_string += strprintf("%*s %s\n",
1512                                       max_balance_length,
1513                                       result["balances"][wallet].getValStr(),
1514                                       wallet.empty() ? "\"\"" : wallet);
1515        }
1516        result_string += "\n";
1517    }
1518
1519    const std::string warnings{result["warnings"].getValStr()};
1520    result_string += strprintf("%sWarnings:%s %s", YELLOW, RESET, warnings.empty() ? "(none)" : warnings);
1521
1522    result.setStr(result_string);
1523}
1524
1525/**
1526 * Call RPC getnewaddress.
1527 * @returns getnewaddress response as a UniValue object.
1528 */
1529static UniValue GetNewAddress()
1530{
1531    DefaultRequestHandler rh;
1532    return ConnectAndCallRPC(&rh, "getnewaddress", /* args=*/{}, RpcWalletName(gArgs));
1533}
1534
1535/**
1536 * Check bounds and set up args for RPC generatetoaddress params: nblocks, address, maxtries.
1537 * @param[in] address  Reference to const string address to insert into the args.
1538 * @param     args     Reference to vector of string args to modify.
1539 */
1540static void SetGenerateToAddressArgs(const std::string& address, std::vector<std::string>& args)
1541{
1542    if (args.size() > 2) throw std::runtime_error("too many arguments (maximum 2 for nblocks and maxtries)");
1543    if (args.size() == 0) {
1544        args.emplace_back(DEFAULT_NBLOCKS);
1545    } else if (args.at(0) == "0") {
1546        throw std::runtime_error("the first argument (number of blocks to generate, default: " + DEFAULT_NBLOCKS + ") must be an integer value greater than zero");
1547    }
1548    args.emplace(args.begin() + 1, address);
1549}
1550
1551static int CommandLineRPC(int argc, char *argv[])
1552{
1553    std::string strPrint;
1554    int nRet = 0;
1555    try {
1556        // Skip switches
1557        while (argc > 1 && IsSwitchChar(argv[1][0])) {
1558            argc--;
1559            argv++;
1560        }
1561        std::string rpcPass;
1562        if (gArgs.GetBoolArg("-stdinrpcpass", false)) {
1563            NO_STDIN_ECHO();
1564            if (!StdinReady()) {
1565                fputs("RPC password> ", stderr);
1566                fflush(stderr);
1567            }
1568            if (!std::getline(std::cin, rpcPass)) {
1569                throw std::runtime_error("-stdinrpcpass specified but failed to read from standard input");
1570            }
1571            if (StdinTerminal()) {
1572                fputc('\n', stdout);
1573            }
1574            gArgs.ForceSetArg("-rpcpassword", rpcPass);
1575        }
1576        std::vector<std::string> args = std::vector<std::string>(&argv[1], &argv[argc]);
1577        if (gArgs.GetBoolArg("-stdinwalletpassphrase", false)) {
1578            NO_STDIN_ECHO();
1579            std::string walletPass;
1580            if (args.size() < 1 || !args[0].starts_with("walletpassphrase")) {
1581                throw std::runtime_error("-stdinwalletpassphrase is only applicable for walletpassphrase(change)");
1582            }
1583            if (!StdinReady()) {
1584                fputs("Wallet passphrase> ", stderr);
1585                fflush(stderr);
1586            }
1587            if (!std::getline(std::cin, walletPass)) {
1588                throw std::runtime_error("-stdinwalletpassphrase specified but failed to read from standard input");
1589            }
1590            if (StdinTerminal()) {
1591                fputc('\n', stdout);
1592            }
1593            args.insert(args.begin() + 1, walletPass);
1594        }
1595        if (gArgs.GetBoolArg("-stdin", false)) {
1596            // Read one arg per line from stdin and append
1597            std::string line;
1598            while (std::getline(std::cin, line)) {
1599                args.push_back(line);
1600            }
1601            if (StdinTerminal()) {
1602                fputc('\n', stdout);
1603            }
1604        }
1605        gArgs.CheckMultipleCLIArgs();
1606        std::unique_ptr<BaseRequestHandler> rh;
1607        std::string method;
1608        if (gArgs.GetBoolArg("-getinfo", false)) {
1609            rh.reset(new GetinfoRequestHandler());
1610        } else if (gArgs.GetBoolArg("-netinfo", false)) {
1611            if (!args.empty() && (args.at(0) == "h" || args.at(0) == "help")) {
1612                tfm::format(std::cout, "%s\n", NetinfoRequestHandler().m_help_doc);
1613                return 0;
1614            }
1615            rh.reset(new NetinfoRequestHandler());
1616        } else if (gArgs.GetBoolArg("-generate", false)) {
1617            const UniValue getnewaddress{GetNewAddress()};
1618            const UniValue& error{getnewaddress.find_value("error")};
1619            if (error.isNull()) {
1620                SetGenerateToAddressArgs(getnewaddress.find_value("result").get_str(), args);
1621                rh.reset(new GenerateToAddressRequestHandler());
1622            } else {
1623                ParseError(error, strPrint, nRet);
1624            }
1625        } else if (gArgs.GetBoolArg("-addrinfo", false)) {
1626            rh.reset(new AddrinfoRequestHandler());
1627        } else {
1628            rh.reset(new DefaultRequestHandler());
1629            if (args.size() < 1) {
1630                throw std::runtime_error("too few parameters (need at least command)");
1631            }
1632            method = args[0];
1633            args.erase(args.begin()); // Remove trailing method name from arguments vector
1634        }
1635        if (nRet == 0) {
1636            // Perform RPC call
1637            const std::optional<std::string> wallet_name{RpcWalletName(gArgs)};
1638            const UniValue reply = ConnectAndCallRPC(rh.get(), method, args, wallet_name);
1639
1640            // Parse reply
1641            UniValue result = reply.find_value("result");
1642            const UniValue& error = reply.find_value("error");
1643            if (error.isNull()) {
1644                if (gArgs.GetBoolArg("-getinfo", false)) {
1645                    if (!wallet_name) {
1646                        GetWalletBalances(result); // fetch multiwallet balances and append to result
1647                    }
1648                    ParseGetInfoResult(result);
1649                }
1650
1651                ParseResult(result, strPrint);
1652            } else {
1653                ParseError(error, strPrint, nRet);
1654            }
1655        }
1656    } catch (const std::exception& e) {
1657        strPrint = std::string("error: ") + e.what();
1658        nRet = EXIT_FAILURE;
1659    } catch (...) {
1660        PrintExceptionContinue(nullptr, "CommandLineRPC()");
1661        throw;
1662    }
1663
1664    if (strPrint != "") {
1665        tfm::format(nRet == 0 ? std::cout : std::cerr, "%s\n", strPrint);
1666    }
1667    return nRet;
1668}
1669
1670MAIN_FUNCTION
1671{
1672    SetupEnvironment();
1673    if (!SetupNetworking()) {
1674        tfm::format(std::cerr, "Error: Initializing networking failed\n");
1675        return EXIT_FAILURE;
1676    }
1677
1678    try {
1679        int ret = AppInitRPC(argc, argv);
1680        if (ret != CONTINUE_EXECUTION)
1681            return ret;
1682    }
1683    catch (const std::exception& e) {
1684        PrintExceptionContinue(&e, "AppInitRPC()");
1685        return EXIT_FAILURE;
1686    } catch (...) {
1687        PrintExceptionContinue(nullptr, "AppInitRPC()");
1688        return EXIT_FAILURE;
1689    }
1690
1691    int ret = EXIT_FAILURE;
1692    try {
1693        ret = CommandLineRPC(argc, argv);
1694    }
1695    catch (const std::exception& e) {
1696        PrintExceptionContinue(&e, "CommandLineRPC()");
1697    } catch (...) {
1698        PrintExceptionContinue(nullptr, "CommandLineRPC()");
1699    }
1700    return ret;
1701}
1702