501            UniValue prop{OpenRPCResultSchema(inner)};
502            if (!inner.m_description.empty()) prop.pushKV("description", inner.m_description);
503            properties.pushKV(inner.m_key_name, std::move(prop));
504            if (!inner.m_optional) required.push_back(inner.m_key_name);
505        }
506        UniValue schema{UniValue::VOBJ};
507        schema.pushKV("type", "object");
508        schema.pushKV("properties", std::move(properties));
509        schema.pushKV("additionalProperties", false);
510        if (!required.empty()) schema.pushKV("required", std::move(required));
511        return schema;
512    }
513    case RPCResult::Type::OBJ_DYN: {
514        UniValue schema{UniValue::VOBJ};
515        schema.pushKV("type", "object");
516        if (!result.m_inner.empty()) {
517            schema.pushKV("additionalProperties", OpenRPCResultSchema(result.m_inner[0]));
518        } else {
519            schema.pushKV("additionalProperties", UniValue{UniValue::VOBJ});
520        }
521        return schema;
522    }
523    case RPCResult::Type::ANY:
524        return UniValue{UniValue::VOBJ};
525    } // no default case, so the compiler can warn about missing cases
526    NONFATAL_UNREACHABLE();
527}
528} // namespace
529
530static RPCResult OpenRPCDocResult()
531{
532    return RPCResult{
533        RPCResult::Type::OBJ, "", "",
534        {
535            {RPCResult::Type::STR, "openrpc", "OpenRPC specification version."},
536            {RPCResult::Type::OBJ, "info", "Metadata about this JSON-RPC interface.",
537                {
538                    {RPCResult::Type::STR, "title", "API title."},
539                    {RPCResult::Type::STR, "version", "Bitcoin Core version string."},
540                    {RPCResult::Type::STR, "description", "API description."},
541                }},
542            {RPCResult::Type::ARR, "methods", "Documented RPC methods.",
543                {{RPCResult::Type::OBJ, "", "An RPC method description object.",
544                    {
545                        {RPCResult::Type::STR, "name", "Method name."},
546                        {RPCResult::Type::STR, "description", "Method description."},
547                        {RPCResult::Type::ARR, "params", "Method parameters.",
548                            {{RPCResult::Type::OBJ, "", "A parameter.",
549                                {
550                                    {RPCResult::Type::STR, "name", "Parameter name."},
551                                    {RPCResult::Type::BOOL, "required", "Whether the parameter is required."},
552                                    {RPCResult::Type::ANY, "schema", "JSON Schema for the parameter."},
553                                    {RPCResult::Type::STR, "description", /*optional=*/true, "Parameter description."},
554                                    {RPCResult::Type::ARR, "x-bitcoin-aliases", /*optional=*/true, "Alternative parameter names.",
555                                        {{RPCResult::Type::STR, "", "An alias."}}},
556                                    {RPCResult::Type::BOOL, "x-bitcoin-placeholder", /*optional=*/true, "Whether the parameter is retained only for compatibility."},
557                                    {RPCResult::Type::BOOL, "x-bitcoin-also-positional", /*optional=*/true, "Whether the parameter can also be passed positionally."},
558                                }}}},
559                        {RPCResult::Type::OBJ, "result", "Method result.",
560                            {
561                                {RPCResult::Type::STR, "name", "Result name."},
562                                {RPCResult::Type::ANY, "schema", "JSON Schema for the result. Numeric schemas may include "
563                                    "\"x-bitcoin-unit\" property: \"amount\" which denotes a Bitcoin amount in BTC."},
564                            }},
565                        {RPCResult::Type::STR, "x-bitcoin-category", "RPC category."},
566                    }}}},
567        },
568        {.skip_type_check = true}};
569}
570
571static RPCMethod getopenrpcinfo()
572{
573    return RPCMethod{
574        "getopenrpcinfo",
575        "Returns an OpenRPC document for currently available RPC commands.\n",
576        {
577            {"show_hidden", RPCArg::Type::BOOL, RPCArg::Default{false}, "Also include hidden RPC commands and arguments."},
578        },
579        OpenRPCDocResult(),
580        RPCExamples{
581            HelpExampleCli("getopenrpcinfo", "")
582            + HelpExampleRpc("getopenrpcinfo", "")
583        },
584        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
585        {
586            const bool include_hidden{self.Arg<bool>("show_hidden")};
587            return tableRPC.buildOpenRPCDoc(include_hidden);
588        },
589    };
590}
591
592static RPCMethod rpc_discover()
593{
594    return RPCMethod{
595        "rpc.discover",
596        "Returns an OpenRPC schema as a description of this service.\n",
597        {},
598        OpenRPCDocResult(),
599        RPCExamples{
600            HelpExampleCli("rpc.discover", "")
601            + HelpExampleRpc("rpc.discover", "")
602        },
603        [](const RPCMethod&, const JSONRPCRequest&) -> UniValue
604        {
605            return tableRPC.buildOpenRPCDoc(/*include_hidden=*/false);
606        },
607    };
608}
609
610static const CRPCCommand vRPCCommands[]{
611    /* Overall control/query calls */
612    {"control", &getopenrpcinfo},
613    {"control", &rpc_discover},
614    {"control", &getrpcinfo},
615    {"control", &help},
616    {"control", &stop},
617    {"control", &uptime},
618};
619
620CRPCTable::CRPCTable()
621{
622    for (const auto& c : vRPCCommands) {
623        appendCommand(c.name, &c);
624    }
625}
626
627void CRPCTable::appendCommand(const std::string& name, const CRPCCommand* pcmd)
628{
629    CHECK_NONFATAL(!IsRPCRunning()); // Only add commands before rpc is running
630
631    mapCommands[name].push_back(pcmd);
632}
633
634bool CRPCTable::removeCommand(const std::string& name, const CRPCCommand* pcmd)
635{
636    auto it = mapCommands.find(name);
637    if (it != mapCommands.end()) {
638        auto new_end = std::remove(it->second.begin(), it->second.end(), pcmd);
639        if (it->second.end() != new_end) {
640            it->second.erase(new_end, it->second.end());
641            if (it->second.empty()) {
642                mapCommands.erase(it);
643            }
644            return true;
645        }
646    }
647    return false;
648}
649
650void StartRPC()
651{
652    LogDebug(BCLog::RPC, "Starting RPC\n");
653    g_rpc_running = true;
654}
655
656void InterruptRPC()
657{
658    static std::once_flag g_rpc_interrupt_flag;
659    // This function could be called twice if the GUI has been started with -server=1.
660    std::call_once(g_rpc_interrupt_flag, []() {
661        LogDebug(BCLog::RPC, "Interrupting RPC\n");
662        // Interrupt e.g. running longpolls
663        g_rpc_running = false;
664    });
665}
666
667void StopRPC()
668{
669    static std::once_flag g_rpc_stop_flag;
670    // This function could be called twice if the GUI has been started with -server=1.
671    assert(!g_rpc_running);
672    std::call_once(g_rpc_stop_flag, [&]() {
673        LogDebug(BCLog::RPC, "Stopping RPC\n");
674        DeleteAuthCookie();
675        LogDebug(BCLog::RPC, "RPC stopped.\n");
676    });
677}
678
679bool IsRPCRunning()
680{
681    return g_rpc_running;
682}
683
684void RpcInterruptionPoint()
685{
686    if (!IsRPCRunning()) throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
687}
688
689void SetRPCWarmupStatus(const std::string& newStatus)
690{
691    LOCK(g_rpc_warmup_mutex);
692    rpcWarmupStatus = newStatus;
693}
694
695void SetRPCWarmupStarting()
696{
697    LOCK(g_rpc_warmup_mutex);
698    fRPCInWarmup = true;
699}
700
701void SetRPCWarmupFinished()
702{
703    LOCK(g_rpc_warmup_mutex);
704    assert(fRPCInWarmup);
705    fRPCInWarmup = false;
706}
707
708bool RPCIsInWarmup(std::string *outStatus)
709{
710    LOCK(g_rpc_warmup_mutex);
711    if (outStatus)
712        *outStatus = rpcWarmupStatus;
713    return fRPCInWarmup;
714}
715
716bool IsDeprecatedRPCEnabled(const std::string& method)
717{
718    const std::vector<std::string> enabled_methods = gArgs.GetArgs("-deprecatedrpc");
719
720    return find(enabled_methods.begin(), enabled_methods.end(), method) != enabled_methods.end();
721}
722
723UniValue JSONRPCExec(const JSONRPCRequest& jreq, bool catch_errors)
724{
725    UniValue result;
726    if (catch_errors) {
727        try {
728            result = tableRPC.execute(jreq);
729        } catch (UniValue& e) {
730            return JSONRPCReplyObj(NullUniValue, std::move(e), jreq.id, jreq.m_json_version);
731        } catch (const std::exception& e) {
732            return JSONRPCReplyObj(NullUniValue, JSONRPCError(RPC_MISC_ERROR, e.what()), jreq.id, jreq.m_json_version);
733        }
734    } else {
735        result = tableRPC.execute(jreq);
736    }
737
738    return JSONRPCReplyObj(std::move(result), NullUniValue, jreq.id, jreq.m_json_version);
739}
740
741/**
742 * Process named arguments into a vector of positional arguments, based on the
743 * passed-in specification for the RPC call's arguments.
744 */
745static inline JSONRPCRequest transformNamedArguments(const JSONRPCRequest& in, const std::vector<std::pair<std::string, bool>>& argNames)
746{
747    JSONRPCRequest out = in;
748    out.params = UniValue(UniValue::VARR);
749    // Build a map of parameters, and remove ones that have been processed, so that we can throw a focused error if
750    // there is an unknown one.