Shared RPC parsing and method validation

751    return num_required_args <= num_args && num_args <= m_args.size();
752}
753
754std::vector<std::pair<std::string, bool>> RPCMethod::GetArgNames() const
755{
756    std::vector<std::pair<std::string, bool>> ret;
757    ret.reserve(m_args.size());
758    for (const auto& arg : m_args) {
759        if (arg.m_type == RPCArg::Type::OBJ_NAMED_PARAMS) {
760            for (const auto& inner : arg.m_inner) {
761                ret.emplace_back(inner.m_names, /*named_only=*/true);
762            }
763        }
764        ret.emplace_back(arg.m_names, /*named_only=*/false);
765    }
766    return ret;
767}
768
769size_t RPCMethod::GetParamIndex(std::string_view key) const
770{
771    auto it{std::find_if(
772        m_args.begin(), m_args.end(), [&key](const auto& arg) { return arg.GetName() == key;}
773    )};
774
775    CHECK_NONFATAL(it != m_args.end());  // TODO: ideally this is checked at compile time
776    return std::distance(m_args.begin(), it);
777}
778
779std::string RPCMethod::ToString() const
780{
781    std::string ret;
782
783    // Oneline summary
784    ret += m_name;
785    bool was_optional{false};
786    for (const auto& arg : m_args) {
787        if (arg.m_opts.hidden) break; // Any arg that follows is also hidden
788        const bool optional = arg.IsOptional();
789        ret += " ";
790        if (optional) {
791            if (!was_optional) ret += "( ";
792            was_optional = true;
793        } else {
794            if (was_optional) ret += ") ";
795            was_optional = false;
796        }
797        ret += arg.ToString(/*oneline=*/true);
798    }
799    if (was_optional) ret += " )";
800
801    // Description
802    CHECK_NONFATAL(!m_description.starts_with('\n'));  // Historically \n was required, but reject it for new code.
803    ret += "\n\n" + TrimString(m_description) + "\n";
804
805    // Arguments
806    Sections sections;
807    Sections named_only_sections;
808    for (size_t i{0}; i < m_args.size(); ++i) {
809        const auto& arg = m_args.at(i);
810        if (arg.m_opts.hidden) break; // Any arg that follows is also hidden
811
812        // Push named argument name and description
813        sections.m_sections.emplace_back(util::ToString(i + 1) + ". " + arg.GetFirstName(), arg.ToDescriptionString(/*is_named_arg=*/true));
814        sections.m_max_pad = std::max(sections.m_max_pad, sections.m_sections.back().m_left.size());
815
816        // Recursively push nested args
817        sections.Push(arg);
818
819        // Push named-only argument sections
820        if (arg.m_type == RPCArg::Type::OBJ_NAMED_PARAMS) {
821            for (const auto& arg_inner : arg.m_inner) {
822                named_only_sections.PushSection({arg_inner.GetFirstName(), arg_inner.ToDescriptionString(/*is_named_arg=*/true)});
823                named_only_sections.Push(arg_inner);
824            }
825        }
826    }
827
828    if (!sections.m_sections.empty()) ret += "\nArguments:\n";
829    ret += sections.ToString();
830    if (!named_only_sections.m_sections.empty()) ret += "\nNamed Arguments:\n";
831    ret += named_only_sections.ToString();
832
833    // Result
834    ret += m_results.ToDescriptionString();
835
836    // Examples
837    ret += m_examples.ToDescriptionString();
838
839    return ret;
840}
841
842UniValue RPCMethod::GetArgMap() const
843{
844    UniValue arr{UniValue::VARR};
845
846    auto push_back_arg_info = [&arr](const std::string& rpc_name, int pos, const std::string& arg_name, const RPCArg::Type& type) {
847        UniValue map{UniValue::VARR};
848        map.push_back(rpc_name);
849        map.push_back(pos);
850        map.push_back(arg_name);
851        map.push_back(type == RPCArg::Type::STR ||
852                      type == RPCArg::Type::STR_HEX);
853        arr.push_back(std::move(map));
854    };
855
856    for (int i{0}; i < int(m_args.size()); ++i) {
857        const auto& arg = m_args.at(i);
858        std::vector<std::string> arg_names = SplitString(arg.m_names, '|');
859        for (const auto& arg_name : arg_names) {
860            push_back_arg_info(m_name, i, arg_name, arg.m_type);
861            if (arg.m_type == RPCArg::Type::OBJ_NAMED_PARAMS) {
862                for (const auto& inner : arg.m_inner) {
863                    std::vector<std::string> inner_names = SplitString(inner.m_names, '|');
864                    for (const std::string& inner_name : inner_names) {
865                        push_back_arg_info(m_name, i, inner_name, inner.m_type);
866                    }
867                }
868            }
869        }
870    }
871    return arr;
872}
873
874static std::optional<UniValue::VType> ExpectedType(RPCArg::Type type)
875{
876    using Type = RPCArg::Type;
877    switch (type) {
878    case Type::STR_HEX:
879    case Type::STR: {
880        return UniValue::VSTR;
881    }
882    case Type::NUM: {
883        return UniValue::VNUM;
884    }
885    case Type::AMOUNT: {
886        // VNUM or VSTR, checked inside AmountFromValue()
887        return std::nullopt;
888    }
889    case Type::RANGE: {
890        // VNUM or VARR, checked inside ParseRange()
891        return std::nullopt;
892    }
893    case Type::BOOL: {
894        return UniValue::VBOOL;
895    }
896    case Type::OBJ:
897    case Type::OBJ_NAMED_PARAMS:
898    case Type::OBJ_USER_KEYS: {
899        return UniValue::VOBJ;
900    }
901    case Type::ARR: {
902        return UniValue::VARR;
903    }
904    } // no default case, so the compiler can warn about missing cases
905    NONFATAL_UNREACHABLE();
906}
907
908UniValue RPCArg::MatchesType(const UniValue& request) const
909{
910    if (m_opts.skip_type_check) return true;
911    if (IsOptional() && request.isNull()) return true;
912    const auto exp_type{ExpectedType(m_type)};
913    if (!exp_type) return true; // nothing to check
914
915    if (*exp_type != request.getType()) {
916        return strprintf("JSON value of type %s is not of expected type %s", uvTypeName(request.getType()), uvTypeName(*exp_type));
917    }
918    return true;
919}
920
921std::string RPCArg::GetFirstName() const
922{
923    return m_names.substr(0, m_names.find('|'));
924}
925
926std::string RPCArg::GetName() const
927{
928    CHECK_NONFATAL(std::string::npos == m_names.find('|'));
929    return m_names;
930}
931
932bool RPCArg::IsOptional() const
933{
934    if (m_fallback.index() != 0) {
935        return true;
936    } else {
937        return RPCArg::Optional::NO != std::get<RPCArg::Optional>(m_fallback);
938    }
939}
940
941std::string RPCArg::ToDescriptionString(bool is_named_arg) const
942{
943    std::string ret;
944    ret += "(";
945    if (m_opts.type_str.size() != 0) {
946        ret += m_opts.type_str.at(1);
947    } else {
948        switch (m_type) {
949        case Type::STR_HEX:
950        case Type::STR: {
951            ret += "string";
952            break;
953        }
954        case Type::NUM: {
955            ret += "numeric";
956            break;
957        }
958        case Type::AMOUNT: {
959            ret += "numeric or string";
960            break;
961        }
962        case Type::RANGE: {
963            ret += "numeric or array";
964            break;
965        }
966        case Type::BOOL: {
967            ret += "boolean";
968            break;
969        }
970        case Type::OBJ:
971        case Type::OBJ_NAMED_PARAMS:
972        case Type::OBJ_USER_KEYS: {
973            ret += "json object";
974            break;
975        }
976        case Type::ARR: {
977            ret += "json array";
978            break;
979        }
980        } // no default case, so the compiler can warn about missing cases
981    }
982    if (m_fallback.index() == 1) {
983        ret += ", optional, default=" + std::get<RPCArg::DefaultHint>(m_fallback);
984    } else if (m_fallback.index() == 2) {
985        ret += ", optional, default=" + std::get<RPCArg::Default>(m_fallback).write();
986    } else {
987        switch (std::get<RPCArg::Optional>(m_fallback)) {
988        case RPCArg::Optional::OMITTED: {
989            if (is_named_arg) ret += ", optional"; // Default value is "null" in dicts. Otherwise,
990            // nothing to do. Element is treated as if not present and has no default value
991            break;
992        }
993        case RPCArg::Optional::NO: {
994            ret += ", required";
995            break;
996        }
997        } // no default case, so the compiler can warn about missing cases
998    }
999    ret += ")";
1000    if (m_type == Type::OBJ_NAMED_PARAMS) ret += " Options object that can be used to pass named arguments, listed below.";