251        tfm::format(std::cerr, "Error: %s\n", e.what());
252        return EXIT_FAILURE;
253    }
254    return CONTINUE_EXECUTION;
255}
256
257struct HTTPResponse
258{
259    int status{0};
260    std::string body;
261};
262
263static int8_t NetworkStringToId(const std::string& str)
264{
265    for (size_t i = 0; i < NETWORKS.size(); ++i) {
266        if (str == NETWORKS[i]) return i;
267    }
268    return UNKNOWN_NETWORK;
269}
270
271/** Handle the conversion from a command-line to a JSON-RPC request,
272 * as well as converting back to a JSON object that can be shown as result.
273 */
274struct BaseRequestHandler {
275    virtual ~BaseRequestHandler() = default;
276    virtual UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) = 0;
277    virtual UniValue ProcessReply(const UniValue &batch_in) = 0;
278};
279
280/** Process addrinfo requests */
281struct AddrinfoRequestHandler : BaseRequestHandler {
282    UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override
283    {
284        if (!args.empty()) {
285            throw std::runtime_error("-addrinfo takes no arguments");
286        }
287        return JSONRPCRequestObj("getaddrmaninfo", NullUniValue, 1);
288    }
289
290    UniValue ProcessReply(const UniValue& reply) override
291    {
292        if (!reply["error"].isNull()) {
293            if (reply["error"]["code"].getInt<int>() == RPC_METHOD_NOT_FOUND) {
294                throw std::runtime_error("-addrinfo requires bitcoind v26.0 or later which supports getaddrmaninfo RPC. Please upgrade your node or use bitcoin-cli from the same version.");
295            }
296            return reply;
297        }
298        // Process getaddrmaninfo reply
299        const std::vector<std::string>& network_types{reply["result"].getKeys()};
300        const std::vector<UniValue>& addrman_counts{reply["result"].getValues()};
301
302        // Prepare result to return to user.
303        UniValue result{UniValue::VOBJ}, addresses{UniValue::VOBJ};
304
305        for (size_t i = 0; i < network_types.size(); ++i) {
306            int addr_count = addrman_counts[i]["total"].getInt<int>();
307            if (network_types[i] == "all_networks") {
308                addresses.pushKV("total", addr_count);
309            } else {
310                addresses.pushKV(network_types[i], addr_count);
311            }
312        }
313        result.pushKV("addresses_known", std::move(addresses));
314        return JSONRPCReplyObj(std::move(result), NullUniValue, /*id=*/1, JSONRPCVersion::V2);
315    }
316};
317
318/** Process getinfo requests */
319struct GetinfoRequestHandler : BaseRequestHandler {
320    const int ID_NETWORKINFO = 0;
321    const int ID_BLOCKCHAININFO = 1;
322    const int ID_WALLETINFO = 2;
323    const int ID_BALANCES = 3;
324
325    /** Create a simulated `getinfo` request. */
326    UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override
327    {
328        if (!args.empty()) {
329            throw std::runtime_error("-getinfo takes no arguments");
330        }
331        UniValue result(UniValue::VARR);
332        result.push_back(JSONRPCRequestObj("getnetworkinfo", NullUniValue, ID_NETWORKINFO));
333        result.push_back(JSONRPCRequestObj("getblockchaininfo", NullUniValue, ID_BLOCKCHAININFO));
334        result.push_back(JSONRPCRequestObj("getwalletinfo", NullUniValue, ID_WALLETINFO));
335        result.push_back(JSONRPCRequestObj("getbalances", NullUniValue, ID_BALANCES));
336        return result;
337    }
338
339    /** Collect values from the batch and form a simulated `getinfo` reply. */
340    UniValue ProcessReply(const UniValue &batch_in) override
341    {
342        UniValue result(UniValue::VOBJ);
343        const std::vector<UniValue> batch = JSONRPCProcessBatchReply(batch_in);
344        // Errors in getnetworkinfo() and getblockchaininfo() are fatal, pass them on;
345        // getwalletinfo() and getbalances() are allowed to fail if there is no wallet.
346        if (!batch[ID_NETWORKINFO]["error"].isNull()) {
347            return batch[ID_NETWORKINFO];
348        }
349        if (!batch[ID_BLOCKCHAININFO]["error"].isNull()) {
350            return batch[ID_BLOCKCHAININFO];
351        }
352        result.pushKV("version", batch[ID_NETWORKINFO]["result"]["version"]);
353        result.pushKV("blocks", batch[ID_BLOCKCHAININFO]["result"]["blocks"]);
354        result.pushKV("headers", batch[ID_BLOCKCHAININFO]["result"]["headers"]);
355        result.pushKV("verificationprogress", batch[ID_BLOCKCHAININFO]["result"]["verificationprogress"]);
356        result.pushKV("timeoffset", batch[ID_NETWORKINFO]["result"]["timeoffset"]);
357
358        UniValue connections(UniValue::VOBJ);
359        connections.pushKV("in", batch[ID_NETWORKINFO]["result"]["connections_in"]);
360        connections.pushKV("out", batch[ID_NETWORKINFO]["result"]["connections_out"]);
361        connections.pushKV("total", batch[ID_NETWORKINFO]["result"]["connections"]);
362        result.pushKV("connections", std::move(connections));
363
364        result.pushKV("networks", batch[ID_NETWORKINFO]["result"]["networks"]);
365        result.pushKV("difficulty", batch[ID_BLOCKCHAININFO]["result"]["difficulty"]);
366        result.pushKV("chain", UniValue(batch[ID_BLOCKCHAININFO]["result"]["chain"]));
367        if (!batch[ID_WALLETINFO]["result"].isNull()) {
368            result.pushKV("has_wallet", true);
369            result.pushKV("keypoolsize", batch[ID_WALLETINFO]["result"]["keypoolsize"]);
370            result.pushKV("walletname", batch[ID_WALLETINFO]["result"]["walletname"]);
371            if (!batch[ID_WALLETINFO]["result"]["unlocked_until"].isNull()) {
372                result.pushKV("unlocked_until", batch[ID_WALLETINFO]["result"]["unlocked_until"]);
373            }
374        }
375        if (!batch[ID_BALANCES]["result"].isNull()) {
376            result.pushKV("balance", batch[ID_BALANCES]["result"]["mine"]["trusted"]);
377        }
378        result.pushKV("relayfee", batch[ID_NETWORKINFO]["result"]["relayfee"]);
379        result.pushKV("warnings", batch[ID_NETWORKINFO]["result"]["warnings"]);
380        return JSONRPCReplyObj(std::move(result), NullUniValue,  /*id=*/1, JSONRPCVersion::V2);
381    }
382};
383
384/** Process netinfo requests */
385class NetinfoRequestHandler : public BaseRequestHandler
386{
387private:
388    std::array<std::array<uint16_t, NETWORKS.size() + 1>, 3> m_counts{{{}}}; //!< Peer counts by (in/out/total, networks/total)
389    uint8_t m_block_relay_peers_count{0};
390    uint8_t m_manual_peers_count{0};
391    uint8_t m_details_level{0}; //!< Optional user-supplied arg to set dashboard details level
392    bool DetailsRequested() const { return m_details_level; }
393    bool IsAddressSelected() const { return m_details_level == 2 || m_details_level == 4; }
394    bool IsVersionSelected() const { return m_details_level == 3 || m_details_level == 4; }
395    bool m_outbound_only_selected{false};
396    bool m_is_asmap_on{false};
397    size_t m_max_addr_length{0};
398    size_t m_max_addr_processed_length{5};
399    size_t m_max_addr_rate_limited_length{6};
400    size_t m_max_age_length{5};
401    size_t m_max_id_length{2};
402    size_t m_max_services_length{6};
403    struct Peer {
404        std::string addr;
405        std::string sub_version;
406        std::string conn_type;
407        std::string network;
408        std::string age;
409        std::string services;
410        std::string transport_protocol_type;
411        double min_ping;
412        double ping;
413        int64_t addr_processed;
414        int64_t addr_rate_limited;
415        int64_t last_blck;
416        int64_t last_recv;
417        int64_t last_send;
418        int64_t last_trxn;
419        int id;
420        int mapped_as;
421        int version;
422        bool is_addr_relay_enabled;
423        bool is_bip152_hb_from;
424        bool is_bip152_hb_to;
425        bool is_outbound;
426        bool is_tx_relay;
427        bool operator<(const Peer& rhs) const { return std::tie(is_outbound, min_ping) < std::tie(rhs.is_outbound, rhs.min_ping); }
428    };
429    std::vector<Peer> m_peers;
430    std::string ChainToString() const
431    {
432        switch (gArgs.GetChainType()) {
433        case ChainType::TESTNET4:
434            return " testnet4";
435        case ChainType::TESTNET:
436            return " testnet";
437        case ChainType::SIGNET:
438            return " signet";
439        case ChainType::REGTEST:
440            return " regtest";
441        case ChainType::MAIN:
442            return "";
443        }
444        assert(false);
445    }
446    std::string PingTimeToString(double seconds) const
447    {
448        if (seconds < 0) return "";
449        const double milliseconds{round(1000 * seconds)};
450        return milliseconds > 999999 ? "-" : ToString(milliseconds);
451    }
452    std::string ConnectionTypeForNetinfo(const std::string& conn_type) const
453    {
454        if (conn_type == "outbound-full-relay") return "full";
455        if (conn_type == "block-relay-only") return "block";
456        if (conn_type == "manual" || conn_type == "feeler") return conn_type;
457        if (conn_type == "addr-fetch") return "addr";
458        if (conn_type == "private-broadcast") return "priv";
459        return "";
460    }
461    std::string FormatServices(const UniValue& services)
462    {
463        std::string str;
464        for (size_t i = 0; i < services.size(); ++i) {
465            const std::string s{services[i].get_str()};
466            str += s == "NETWORK_LIMITED" ? 'l' : s == "P2P_V2" ? '2' : ToLower(s[0]);
467        }
468        return str;
469    }
470    static std::string ServicesList(const UniValue& services)
471    {
472        std::string str{services.size() ? services[0].get_str() : ""};
473        for (size_t i{1}; i < services.size(); ++i) {
474            str += ", " + services[i].get_str();
475        }
476        for (auto& c: str) {
477            c = (c == '_' ? ' ' : ToLower(c));
478        }
479        return str;
480    }
481
482public:
483    static constexpr int ID_PEERINFO = 0;
484    static constexpr int ID_NETWORKINFO = 1;
485
486    UniValue PrepareRequest(const std::string& method, const std::vector<std::string>& args) override
487    {
488        if (!args.empty()) {
489            uint8_t n{0};
490            if (const auto res{ToIntegral<uint8_t>(args.at(0))}) {
491                n = *res;
492                m_details_level = std::min(n, NETINFO_MAX_LEVEL);
493            } else {
494                throw std::runtime_error(strprintf("invalid -netinfo level argument: %s\nFor more information, run: bitcoin-cli -netinfo help", args.at(0)));
495            }
496            if (args.size() > 1) {
497                if (std::string_view s{args.at(1)}; n && (s == "o" || s == "outonly")) {
498                    m_outbound_only_selected = true;
499                } else if (n) {
500                    throw std::runtime_error(strprintf("invalid -netinfo outonly argument: %s\nFor more information, run: bitcoin-cli -netinfo help", s));