Shared RPC parsing and method validation

1251    case Type::BOOL:
1252        return res + "bool";
1253    case Type::ARR:
1254        res += "[";
1255        for (const auto& i : m_inner) {
1256            res += i.ToString(oneline) + ",";
1257        }
1258        return res + "...]";
1259    case Type::OBJ:
1260    case Type::OBJ_NAMED_PARAMS:
1261    case Type::OBJ_USER_KEYS:
1262        // Currently unused, so avoid writing dead code
1263        NONFATAL_UNREACHABLE();
1264    } // no default case, so the compiler can warn about missing cases
1265    NONFATAL_UNREACHABLE();
1266}
1267
1268// NOLINTNEXTLINE(misc-no-recursion)
1269std::string RPCArg::ToString(const bool oneline) const
1270{
1271    if (oneline && !m_opts.oneline_description.empty()) {
1272        if (m_opts.oneline_description[0] == '\"' && m_type != Type::STR_HEX && m_type != Type::STR && gArgs.GetBoolArg("-rpcdoccheck", DEFAULT_RPC_DOC_CHECK)) {
1273            throw std::runtime_error{
1274                STR_INTERNAL_BUG(strprintf("non-string RPC arg \"%s\" quotes oneline_description:\n%s",
1275                    m_names, m_opts.oneline_description)
1276                )};
1277        }
1278        return m_opts.oneline_description;
1279    }
1280
1281    switch (m_type) {
1282    case Type::STR_HEX:
1283    case Type::STR: {
1284        return "\"" + GetFirstName() + "\"";
1285    }
1286    case Type::NUM:
1287    case Type::RANGE:
1288    case Type::AMOUNT:
1289    case Type::BOOL: {
1290        return GetFirstName();
1291    }
1292    case Type::OBJ:
1293    case Type::OBJ_NAMED_PARAMS:
1294    case Type::OBJ_USER_KEYS: {
1295        // NOLINTNEXTLINE(misc-no-recursion)
1296        const std::string res = Join(m_inner, ",", [&](const RPCArg& i) { return i.ToStringObj(oneline); });
1297        if (m_type == Type::OBJ) {
1298            return "{" + res + "}";
1299        } else {
1300            return "{" + res + ",...}";
1301        }
1302    }
1303    case Type::ARR: {
1304        std::string res;
1305        for (const auto& i : m_inner) {
1306            res += i.ToString(oneline) + ",";
1307        }
1308        return "[" + res + "...]";
1309    }
1310    } // no default case, so the compiler can warn about missing cases
1311    NONFATAL_UNREACHABLE();
1312}
1313
1314static std::pair<int64_t, int64_t> ParseRange(const UniValue& value)
1315{
1316    if (value.isNum()) {
1317        return {0, value.getInt<int64_t>()};
1318    }
1319    if (value.isArray() && value.size() == 2 && value[0].isNum() && value[1].isNum()) {
1320        int64_t low = value[0].getInt<int64_t>();
1321        int64_t high = value[1].getInt<int64_t>();
1322        if (low > high) throw JSONRPCError(RPC_INVALID_PARAMETER, "Range specified as [begin,end] must not have begin after end");
1323        return {low, high};
1324    }
1325    throw JSONRPCError(RPC_INVALID_PARAMETER, "Range must be specified as end or as [begin,end]");
1326}
1327
1328std::pair<int64_t, int64_t> ParseDescriptorRange(const UniValue& value)
1329{
1330    int64_t low, high;
1331    std::tie(low, high) = ParseRange(value);
1332    if (low < 0) {
1333        throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should be greater or equal than 0");
1334    }
1335    if ((high >> 31) != 0) {
1336        throw JSONRPCError(RPC_INVALID_PARAMETER, "End of range is too high");
1337    }
1338    if (high >= low + 1000000) {
1339        throw JSONRPCError(RPC_INVALID_PARAMETER, "Range is too large");
1340    }
1341    return {low, high};
1342}
1343
1344std::vector<CScript> EvalDescriptorStringOrObject(const UniValue& scanobject, FlatSigningProvider& provider, const bool expand_priv)
1345{
1346    std::string desc_str;
1347    std::pair<int64_t, int64_t> range = {0, 1000};
1348    if (scanobject.isStr()) {
1349        desc_str = scanobject.get_str();
1350    } else if (scanobject.isObject()) {
1351        const UniValue& desc_uni{scanobject.find_value("desc")};
1352        if (desc_uni.isNull()) throw JSONRPCError(RPC_INVALID_PARAMETER, "Descriptor needs to be provided in scan object");
1353        desc_str = desc_uni.get_str();
1354        const UniValue& range_uni{scanobject.find_value("range")};
1355        if (!range_uni.isNull()) {
1356            range = ParseDescriptorRange(range_uni);
1357        }
1358    } else {
1359        throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan object needs to be either a string or an object");
1360    }
1361
1362    std::string error;
1363    auto descs = Parse(desc_str, provider, error);
1364    if (descs.empty()) {
1365        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
1366    }
1367    if (!descs.at(0)->IsRange()) {
1368        range.first = 0;
1369        range.second = 0;
1370    }
1371    std::vector<CScript> ret;
1372    for (int64_t i = range.first; i <= range.second; ++i) {
1373        for (const auto& desc : descs) {
1374            std::vector<CScript> scripts;
1375            if (!desc->Expand(i, provider, scripts, provider)) {
1376                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Cannot derive script without private keys: '%s'", desc_str));
1377            }
1378            if (expand_priv) {
1379                desc->ExpandPrivate(/*pos=*/i, provider, /*out=*/provider);
1380            }
1381            std::move(scripts.begin(), scripts.end(), std::back_inserter(ret));
1382        }
1383    }
1384    return ret;
1385}
1386
1387std::vector<uint32_t> ParsePathBIP32(const std::string& path)
1388{
1389    std::vector<uint32_t> out;
1390    if (!ParseHDKeypath(path, out)) {
1391        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid BIP32 keypath");
1392    }
1393    return out;
1394}
1395
1396/** Convert a vector of bilingual strings to a UniValue::VARR containing their original untranslated values. */
1397[[nodiscard]] static UniValue BilingualStringsToUniValue(const std::vector<bilingual_str>& bilingual_strings)
1398{
1399    CHECK_NONFATAL(!bilingual_strings.empty());
1400    UniValue result{UniValue::VARR};
1401    for (const auto& s : bilingual_strings) {
1402        result.push_back(s.original);
1403    }
1404    return result;
1405}
1406
1407void PushWarnings(const UniValue& warnings, UniValue& obj)
1408{
1409    if (warnings.empty()) return;
1410    obj.pushKV("warnings", warnings);
1411}
1412
1413void PushWarnings(const std::vector<bilingual_str>& warnings, UniValue& obj)
1414{
1415    if (warnings.empty()) return;
1416    obj.pushKV("warnings", BilingualStringsToUniValue(warnings));
1417}
1418
1419std::vector<RPCResult> ScriptPubKeyDoc() {
1420    return
1421         {
1422             {RPCResult::Type::STR, "asm", "Disassembly of the output script"},
1423             {RPCResult::Type::STR, "desc", "Inferred descriptor for the output"},
1424             {RPCResult::Type::STR_HEX, "hex", "The raw output script bytes, hex-encoded"},
1425             {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"},
1426             {RPCResult::Type::STR, "type", "The type (one of: " + GetAllOutputTypes() + ")"},
1427         };
1428}
1429
1430uint256 GetTarget(const CBlockIndex& blockindex, const uint256 pow_limit)
1431{
1432    arith_uint256 target{*CHECK_NONFATAL(DeriveTarget(blockindex.nBits, pow_limit))};
1433    return ArithToUint256(target);
1434}
1435
1436std::vector<RPCResult> ElideGroup(std::vector<RPCResult> fields, std::string summary)
1437{
1438    if (fields.empty()) return fields;
1439    std::vector<RPCResult> result;
1440    result.reserve(fields.size());
1441    for (size_t i = 0; i < fields.size(); ++i) {
1442        RPCResultOptions opts = fields[i].m_opts;
1443        if (i == 0) {
1444            opts.print_elision = summary;
1445        } else {
1446            opts.print_elision = HelpElisionSkip{};
1447        }
1448        result.emplace_back(fields[i], std::move(opts));
1449    }
1450    return result;
1451}
1452