Shared RPC parsing and method validation

1001    ret += m_description.empty() ? "" : " " + m_description;
1002    return ret;
1003}
1004
1005// NOLINTNEXTLINE(misc-no-recursion)
1006void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const int current_indent) const
1007{
1008    // Indentation
1009    const std::string indent(current_indent, ' ');
1010    const std::string indent_next(current_indent + 2, ' ');
1011
1012    // Elements in a JSON structure (dictionary or array) are separated by a comma
1013    const std::string maybe_separator{outer_type != OuterType::NONE ? "," : ""};
1014
1015    // The key name if recursed into a dictionary
1016    const std::string maybe_key{
1017        outer_type == OuterType::OBJ ?
1018            "\"" + this->m_key_name + "\" : " :
1019            ""};
1020
1021    // Format description with type
1022    const auto Description = [&](const std::string& type) {
1023        return "(" + type + (this->m_optional ? ", optional" : "") + ")" +
1024               (this->m_description.empty() ? "" : " " + this->m_description);
1025    };
1026
1027    // Ensure at least one visible field exists when elision is used
1028    const auto elision_has_description{[](const std::vector<RPCResult>& inner) {
1029        return std::ranges::any_of(inner, [](const auto& res) {
1030            return !std::holds_alternative<HelpElisionSkip>(res.m_opts.print_elision);
1031        });
1032    }};
1033
1034    if (const auto* text = std::get_if<std::string>(&m_opts.print_elision)) {
1035        sections.PushSection({indent + "..." + maybe_separator, *text});
1036        return;
1037    }
1038    if (std::holds_alternative<HelpElisionSkip>(m_opts.print_elision)) {
1039        return;
1040    }
1041
1042    switch (m_type) {
1043    case Type::ANY: {
1044        sections.PushSection({indent + maybe_key + "xxx" + maybe_separator, Description("any")});
1045        return;
1046    }
1047    case Type::NONE: {
1048        sections.PushSection({indent + "null" + maybe_separator, Description("json null")});
1049        return;
1050    }
1051    case Type::STR: {
1052        sections.PushSection({indent + maybe_key + "\"str\"" + maybe_separator, Description("string")});
1053        return;
1054    }
1055    case Type::STR_AMOUNT: {
1056        sections.PushSection({indent + maybe_key + "n" + maybe_separator, Description("numeric")});
1057        return;
1058    }
1059    case Type::STR_HEX: {
1060        sections.PushSection({indent + maybe_key + "\"hex\"" + maybe_separator, Description("string")});
1061        return;
1062    }
1063    case Type::NUM: {
1064        sections.PushSection({indent + maybe_key + "n" + maybe_separator, Description("numeric")});
1065        return;
1066    }
1067    case Type::NUM_TIME: {
1068        sections.PushSection({indent + maybe_key + "xxx" + maybe_separator, Description("numeric")});
1069        return;
1070    }
1071    case Type::BOOL: {
1072        sections.PushSection({indent + maybe_key + "true|false" + maybe_separator, Description("boolean")});
1073        return;
1074    }
1075    case Type::ARR_FIXED:
1076    case Type::ARR: {
1077        sections.PushSection({indent + maybe_key + "[", Description("json array")});
1078        for (const auto& i : m_inner) {
1079            i.ToSections(sections, OuterType::ARR, current_indent + 2);
1080        }
1081        CHECK_NONFATAL(!m_inner.empty());
1082        CHECK_NONFATAL(elision_has_description(m_inner));
1083        if (m_type == Type::ARR && !std::holds_alternative<std::string>(m_inner.back().m_opts.print_elision)) {
1084            sections.PushSection({indent_next + "...", ""});
1085        } else {
1086            // Remove final comma, which would be invalid JSON
1087            sections.m_sections.back().m_left.pop_back();
1088        }
1089        sections.PushSection({indent + "]" + maybe_separator, ""});
1090        return;
1091    }
1092    case Type::OBJ_DYN:
1093    case Type::OBJ: {
1094        if (m_inner.empty()) {
1095            sections.PushSection({indent + maybe_key + "{}", Description("empty JSON object")});
1096            return;
1097        }
1098        CHECK_NONFATAL(elision_has_description(m_inner));
1099        sections.PushSection({indent + maybe_key + "{", Description("json object")});
1100        for (const auto& i : m_inner) {
1101            i.ToSections(sections, OuterType::OBJ, current_indent + 2);
1102        }
1103        if (m_type == Type::OBJ_DYN) {
1104            // If the dictionary keys are dynamic, use three dots for continuation
1105            sections.PushSection({indent_next + "...", ""});
1106        } else {
1107            // Remove final comma, which would be invalid JSON
1108            sections.m_sections.back().m_left.pop_back();
1109        }
1110        sections.PushSection({indent + "}" + maybe_separator, ""});
1111        return;
1112    }
1113    } // no default case, so the compiler can warn about missing cases
1114    NONFATAL_UNREACHABLE();
1115}
1116
1117static std::optional<UniValue::VType> ExpectedType(RPCResult::Type type)
1118{
1119    using Type = RPCResult::Type;
1120    switch (type) {
1121    case Type::ANY: {
1122        return std::nullopt;
1123    }
1124    case Type::NONE: {
1125        return UniValue::VNULL;
1126    }
1127    case Type::STR:
1128    case Type::STR_HEX: {
1129        return UniValue::VSTR;
1130    }
1131    case Type::NUM:
1132    case Type::STR_AMOUNT:
1133    case Type::NUM_TIME: {
1134        return UniValue::VNUM;
1135    }
1136    case Type::BOOL: {
1137        return UniValue::VBOOL;
1138    }
1139    case Type::ARR_FIXED:
1140    case Type::ARR: {
1141        return UniValue::VARR;
1142    }
1143    case Type::OBJ_DYN:
1144    case Type::OBJ: {
1145        return UniValue::VOBJ;
1146    }
1147    } // no default case, so the compiler can warn about missing cases
1148    NONFATAL_UNREACHABLE();
1149}
1150
1151// NOLINTNEXTLINE(misc-no-recursion)
1152UniValue RPCResult::MatchesType(const UniValue& result) const
1153{
1154    if (m_opts.skip_type_check) {
1155        return true;
1156    }
1157
1158    const auto exp_type = ExpectedType(m_type);
1159    if (!exp_type) return true; // can be any type, so nothing to check
1160
1161    if (*exp_type != result.getType()) {
1162        return strprintf("returned type is %s, but declared as %s in doc", uvTypeName(result.getType()), uvTypeName(*exp_type));
1163    }
1164
1165    if (UniValue::VARR == result.getType()) {
1166        UniValue errors(UniValue::VOBJ);
1167        for (size_t i{0}; i < result.get_array().size(); ++i) {
1168            // If there are more results than documented, reuse the last doc_inner.
1169            const RPCResult& doc_inner{m_inner.at(std::min(m_inner.size() - 1, i))};
1170            UniValue match{doc_inner.MatchesType(result.get_array()[i])};
1171            if (!match.isTrue()) errors.pushKV(strprintf("%d", i), std::move(match));
1172        }
1173        if (errors.empty()) return true; // empty result array is valid
1174        return errors;
1175    }
1176
1177    if (UniValue::VOBJ == result.getType()) {
1178        UniValue errors(UniValue::VOBJ);
1179        if (m_type == Type::OBJ_DYN) {
1180            const RPCResult& doc_inner{m_inner.at(0)}; // Assume all types are the same, randomly pick the first
1181            for (size_t i{0}; i < result.get_obj().size(); ++i) {
1182                UniValue match{doc_inner.MatchesType(result.get_obj()[i])};
1183                if (!match.isTrue()) errors.pushKV(result.getKeys()[i], std::move(match));
1184            }
1185            if (errors.empty()) return true; // empty result obj is valid
1186            return errors;
1187        }
1188        std::set<std::string> doc_keys;
1189        for (const auto& doc_entry : m_inner) {
1190            doc_keys.insert(doc_entry.m_key_name);
1191        }
1192        std::map<std::string, UniValue> result_obj;
1193        result.getObjMap(result_obj);
1194        for (const auto& result_entry : result_obj) {
1195            if (!doc_keys.contains(result_entry.first)) {
1196                errors.pushKV(result_entry.first, "key returned that was not in doc");
1197            }
1198        }
1199
1200        for (const auto& doc_entry : m_inner) {
1201            const auto result_it{result_obj.find(doc_entry.m_key_name)};
1202            if (result_it == result_obj.end()) {
1203                if (!doc_entry.m_optional) {
1204                    errors.pushKV(doc_entry.m_key_name, "key missing, despite not being optional in doc");
1205                }
1206                continue;
1207            }
1208            UniValue match{doc_entry.MatchesType(result_it->second)};
1209            if (!match.isTrue()) errors.pushKV(doc_entry.m_key_name, std::move(match));
1210        }
1211        if (errors.empty()) return true;
1212        return errors;
1213    }
1214
1215    return true;
1216}
1217
1218void RPCResult::CheckInnerDoc() const
1219{
1220    if (m_type == Type::OBJ) {
1221        // May or may not be empty
1222        return;
1223    }
1224    // Everything else must either be empty or not
1225    const bool inner_needed{m_type == Type::ARR || m_type == Type::ARR_FIXED || m_type == Type::OBJ_DYN};
1226    CHECK_NONFATAL(inner_needed != m_inner.empty());
1227}
1228
1229// NOLINTNEXTLINE(misc-no-recursion)
1230std::string RPCArg::ToStringObj(const bool oneline) const
1231{
1232    std::string res;
1233    res += "\"";
1234    res += GetFirstName();
1235    if (oneline) {
1236        res += "\":";
1237    } else {
1238        res += "\": ";
1239    }
1240    switch (m_type) {
1241    case Type::STR:
1242        return res + "\"str\"";
1243    case Type::STR_HEX:
1244        return res + "\"hex\"";
1245    case Type::NUM:
1246        return res + "n";
1247    case Type::RANGE:
1248        return res + "n or [n,n]";
1249    case Type::AMOUNT:
1250        return res + "amount";