Shared RPC parsing and method validation

501            PushSection({indent_next + "...", ""});
502            PushSection({indent + "]" + (is_top_level_arg ? "" : ","), ""});
503            break;
504        }
505        } // no default case, so the compiler can warn about missing cases
506    }
507
508    /**
509     * Concatenate all sections with proper padding
510     */
511    std::string ToString() const
512    {
513        std::string ret;
514        const size_t pad = m_max_pad + 4;
515        for (const auto& s : m_sections) {
516            // The left part of a section is assumed to be a single line, usually it is the name of the JSON struct or a
517            // brace like {, }, [, or ]
518            CHECK_NONFATAL(s.m_left.find('\n') == std::string::npos);
519            if (s.m_right.empty()) {
520                ret += s.m_left;
521                ret += "\n";
522                continue;
523            }
524
525            std::string left = s.m_left;
526            left.resize(pad, ' ');
527            ret += left;
528
529            // Properly pad after newlines
530            std::string right;
531            size_t begin = 0;
532            size_t new_line_pos = s.m_right.find_first_of('\n');
533            while (true) {
534                right += s.m_right.substr(begin, new_line_pos - begin);
535                if (new_line_pos == std::string::npos) {
536                    break; //No new line
537                }
538                right += "\n" + std::string(pad, ' ');
539                begin = s.m_right.find_first_not_of(' ', new_line_pos + 1);
540                if (begin == std::string::npos) {
541                    break; // Empty line
542                }
543                new_line_pos = s.m_right.find_first_of('\n', begin + 1);
544            }
545            ret += right;
546            ret += "\n";
547        }
548        return ret;
549    }
550};
551
552RPCMethod::RPCMethod(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples)
553    : RPCMethod{std::move(name), std::move(description), std::move(args), std::move(results), std::move(examples), nullptr} {}
554
555RPCMethod::RPCMethod(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples, RPCMethodImpl fun)
556    : m_name{std::move(name)},
557      m_fun{std::move(fun)},
558      m_description{std::move(description)},
559      m_args{std::move(args)},
560      m_results{std::move(results)},
561      m_examples{std::move(examples)}
562{
563    // Map of parameter names and types just used to check whether the names are
564    // unique. Parameter names always need to be unique, with the exception that
565    // there can be pairs of POSITIONAL and NAMED parameters with the same name.
566    enum ParamType { POSITIONAL = 1, NAMED = 2, NAMED_ONLY = 4 };
567    std::map<std::string, int> param_names;
568
569    for (const auto& arg : m_args) {
570        std::vector<std::string> names = SplitString(arg.m_names, '|');
571        // Should have unique named arguments
572        for (const std::string& name : names) {
573            auto& param_type = param_names[name];
574            CHECK_NONFATAL(!(param_type & POSITIONAL));
575            CHECK_NONFATAL(!(param_type & NAMED_ONLY));
576            param_type |= POSITIONAL;
577        }
578        if (arg.m_type == RPCArg::Type::OBJ_NAMED_PARAMS) {
579            for (const auto& inner : arg.m_inner) {
580                std::vector<std::string> inner_names = SplitString(inner.m_names, '|');
581                for (const std::string& inner_name : inner_names) {
582                    auto& param_type = param_names[inner_name];
583                    CHECK_NONFATAL(!(param_type & POSITIONAL) || inner.m_opts.also_positional);
584                    CHECK_NONFATAL(!(param_type & NAMED));
585                    CHECK_NONFATAL(!(param_type & NAMED_ONLY));
586                    param_type |= inner.m_opts.also_positional ? NAMED : NAMED_ONLY;
587                }
588            }
589        }
590        // Default value type should match argument type only when defined
591        if (arg.m_fallback.index() == 2) {
592            const RPCArg::Type type = arg.m_type;
593            [&]() {
594                switch (std::get<RPCArg::Default>(arg.m_fallback).getType()) {
595                case UniValue::VOBJ:
596                    CHECK_NONFATAL(type == RPCArg::Type::OBJ);
597                    return;
598                case UniValue::VARR:
599                    CHECK_NONFATAL(type == RPCArg::Type::ARR);
600                    return;
601                case UniValue::VSTR:
602                    CHECK_NONFATAL(type == RPCArg::Type::STR || type == RPCArg::Type::STR_HEX || type == RPCArg::Type::AMOUNT);
603                    return;
604                case UniValue::VNUM:
605                    CHECK_NONFATAL(type == RPCArg::Type::NUM || type == RPCArg::Type::AMOUNT || type == RPCArg::Type::RANGE);
606                    return;
607                case UniValue::VBOOL:
608                    CHECK_NONFATAL(type == RPCArg::Type::BOOL);
609                    return;
610                case UniValue::VNULL:
611                    // Null values are accepted in all arguments
612                    return;
613                } // no default case, so the compiler can warn about missing cases
614                NONFATAL_UNREACHABLE();
615            }();
616        }
617    }
618}
619
620std::string RPCResults::ToDescriptionString() const
621{
622    std::string result;
623    for (const auto& r : m_results) {
624        Sections sections;
625        r.ToSections(sections);
626        // A result can be empty via HelpElisionSkip
627        if (sections.m_sections.empty()) continue;
628
629        if (r.m_cond.empty()) {
630            result += "\nResult:\n";
631        } else {
632            result += "\nResult (" + r.m_cond + "):\n";
633        }
634        result += sections.ToString();
635    }
636    return result;
637}
638
639std::string RPCExamples::ToDescriptionString() const
640{
641    return m_examples.empty() ? m_examples : "\nExamples:\n" + m_examples;
642}
643
644UniValue RPCMethod::HandleRequest(const JSONRPCRequest& request) const
645{
646    if (request.mode == JSONRPCRequest::GET_ARGS) {
647        return GetArgMap();
648    }
649    /*
650     * Check if the given request is valid according to this command or if
651     * the user is asking for help information, and throw help when appropriate.
652     */
653    if (request.mode == JSONRPCRequest::GET_HELP || !IsValidNumArgs(request.params.size())) {
654        throw HelpResult{ToString()};
655    }
656    UniValue arg_mismatch{UniValue::VOBJ};
657    for (size_t i{0}; i < m_args.size(); ++i) {
658        const auto& arg{m_args.at(i)};
659        UniValue match{arg.MatchesType(request.params[i])};
660        if (!match.isTrue()) {
661            arg_mismatch.pushKV(strprintf("Position %s (%s)", i + 1, arg.m_names), std::move(match));
662        }
663    }
664    if (!arg_mismatch.empty()) {
665        throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Wrong type passed:\n%s", arg_mismatch.write(4)));
666    }
667    CHECK_NONFATAL(m_req == nullptr);
668    m_req = &request;
669    UniValue ret = m_fun(*this, request);
670    m_req = nullptr;
671    if (gArgs.GetBoolArg("-rpcdoccheck", DEFAULT_RPC_DOC_CHECK)) {
672        UniValue mismatch{UniValue::VARR};
673        for (const auto& res : m_results.m_results) {
674            UniValue match{res.MatchesType(ret)};
675            if (match.isTrue()) {
676                mismatch.setNull();
677                break;
678            }
679            mismatch.push_back(std::move(match));
680        }
681        if (!mismatch.isNull()) {
682            std::string explain{
683                mismatch.empty() ? "no possible results defined" :
684                mismatch.size() == 1 ? mismatch[0].write(4) :
685                mismatch.write(4)};
686            throw std::runtime_error{
687                STR_INTERNAL_BUG(strprintf("RPC call \"%s\" returned incorrect type:\n%s", m_name, explain)),
688            };
689        }
690    }
691    return ret;
692}
693
694using CheckFn = void(const RPCArg&);
695static const UniValue* DetailMaybeArg(CheckFn* check, const std::vector<RPCArg>& params, const JSONRPCRequest* req, size_t i)
696{
697    CHECK_NONFATAL(i < params.size());
698    const UniValue& arg{CHECK_NONFATAL(req)->params[i]};
699    const RPCArg& param{params.at(i)};
700    if (check) check(param);
701
702    if (!arg.isNull()) return &arg;
703    if (!std::holds_alternative<RPCArg::Default>(param.m_fallback)) return nullptr;
704    return &std::get<RPCArg::Default>(param.m_fallback);
705}
706
707static void CheckRequiredOrDefault(const RPCArg& param)
708{
709    // Must use `Arg<Type>(key)` to get the argument or its default value.
710    const bool required{
711        std::holds_alternative<RPCArg::Optional>(param.m_fallback) && RPCArg::Optional::NO == std::get<RPCArg::Optional>(param.m_fallback),
712    };
713    CHECK_NONFATAL(required || std::holds_alternative<RPCArg::Default>(param.m_fallback));
714}
715
716#define TMPL_INST(check_param, ret_type, return_code)       \
717    template <>                                             \
718    ret_type RPCMethod::ArgValue<ret_type>(size_t i) const \
719    {                                                       \
720        const UniValue* maybe_arg{                          \
721            DetailMaybeArg(check_param, m_args, m_req, i),  \
722        };                                                  \
723        return return_code                                  \
724    }                                                       \
725    void force_semicolon(ret_type)
726
727// Optional arg (without default). Can also be called on required args, if needed.
728TMPL_INST(nullptr, const UniValue*, maybe_arg;);
729TMPL_INST(nullptr, std::optional<double>, maybe_arg ? std::optional{maybe_arg->get_real()} : std::nullopt;);
730TMPL_INST(nullptr, std::optional<bool>, maybe_arg ? std::optional{maybe_arg->get_bool()} : std::nullopt;);
731TMPL_INST(nullptr, std::optional<int64_t>, maybe_arg ? std::optional{maybe_arg->getInt<int64_t>()} : std::nullopt;);
732TMPL_INST(nullptr, std::optional<std::string_view>, maybe_arg ? std::optional<std::string_view>{maybe_arg->get_str()} : std::nullopt;);
733
734// Required arg or optional arg with default value.
735TMPL_INST(CheckRequiredOrDefault, const UniValue&, *CHECK_NONFATAL(maybe_arg););
736TMPL_INST(CheckRequiredOrDefault, bool, CHECK_NONFATAL(maybe_arg)->get_bool(););
737TMPL_INST(CheckRequiredOrDefault, int, CHECK_NONFATAL(maybe_arg)->getInt<int>(););
738TMPL_INST(CheckRequiredOrDefault, uint64_t, CHECK_NONFATAL(maybe_arg)->getInt<uint64_t>(););
739TMPL_INST(CheckRequiredOrDefault, uint32_t, CHECK_NONFATAL(maybe_arg)->getInt<uint32_t>(););
740TMPL_INST(CheckRequiredOrDefault, std::string_view, CHECK_NONFATAL(maybe_arg)->get_str(););
741
742bool RPCMethod::IsValidNumArgs(size_t num_args) const
743{
744    size_t num_required_args = 0;
745    for (size_t n = m_args.size(); n > 0; --n) {
746        if (!m_args.at(n - 1).IsOptional()) {
747            num_required_args = n;
748            break;
749        }
750    }