Shared RPC parsing and method validation

251    }
252
253    script_out = GetScriptForMultisig(required, pubkeys);
254
255    // Check if any keys are uncompressed. If so, the type is legacy
256    for (const CPubKey& pk : pubkeys) {
257        if (!pk.IsCompressed()) {
258            type = OutputType::LEGACY;
259            break;
260        }
261    }
262
263    if (type == OutputType::LEGACY && script_out.size() > MAX_SCRIPT_ELEMENT_SIZE) {
264        throw JSONRPCError(RPC_INVALID_PARAMETER, (strprintf("redeemScript exceeds size limit: %d > %d", script_out.size(), MAX_SCRIPT_ELEMENT_SIZE)));
265    }
266
267    // Make the address
268    CTxDestination dest = AddAndGetDestinationForScript(keystore, script_out, type);
269
270    return dest;
271}
272
273class DescribeAddressVisitor
274{
275public:
276    explicit DescribeAddressVisitor() = default;
277
278    UniValue operator()(const CNoDestination& dest) const
279    {
280        return UniValue(UniValue::VOBJ);
281    }
282
283    UniValue operator()(const PubKeyDestination& dest) const
284    {
285        return UniValue(UniValue::VOBJ);
286    }
287
288    UniValue operator()(const PKHash& keyID) const
289    {
290        UniValue obj(UniValue::VOBJ);
291        obj.pushKV("isscript", false);
292        obj.pushKV("iswitness", false);
293        return obj;
294    }
295
296    UniValue operator()(const ScriptHash& scriptID) const
297    {
298        UniValue obj(UniValue::VOBJ);
299        obj.pushKV("isscript", true);
300        obj.pushKV("iswitness", false);
301        return obj;
302    }
303
304    UniValue operator()(const WitnessV0KeyHash& id) const
305    {
306        UniValue obj(UniValue::VOBJ);
307        obj.pushKV("isscript", false);
308        obj.pushKV("iswitness", true);
309        obj.pushKV("witness_version", 0);
310        obj.pushKV("witness_program", HexStr(id));
311        return obj;
312    }
313
314    UniValue operator()(const WitnessV0ScriptHash& id) const
315    {
316        UniValue obj(UniValue::VOBJ);
317        obj.pushKV("isscript", true);
318        obj.pushKV("iswitness", true);
319        obj.pushKV("witness_version", 0);
320        obj.pushKV("witness_program", HexStr(id));
321        return obj;
322    }
323
324    UniValue operator()(const WitnessV1Taproot& tap) const
325    {
326        UniValue obj(UniValue::VOBJ);
327        obj.pushKV("isscript", true);
328        obj.pushKV("iswitness", true);
329        obj.pushKV("witness_version", 1);
330        obj.pushKV("witness_program", HexStr(tap));
331        return obj;
332    }
333
334    UniValue operator()(const PayToAnchor& anchor) const
335    {
336        UniValue obj(UniValue::VOBJ);
337        obj.pushKV("isscript", true);
338        obj.pushKV("iswitness", true);
339        return obj;
340    }
341
342    UniValue operator()(const WitnessUnknown& id) const
343    {
344        UniValue obj(UniValue::VOBJ);
345        obj.pushKV("iswitness", true);
346        obj.pushKV("witness_version", id.GetWitnessVersion());
347        obj.pushKV("witness_program", HexStr(id.GetWitnessProgram()));
348        return obj;
349    }
350};
351
352UniValue DescribeAddress(const CTxDestination& dest)
353{
354    return std::visit(DescribeAddressVisitor(), dest);
355}
356
357/**
358 * Returns a sighash value corresponding to the passed in argument.
359 *
360 * @pre The sighash argument should be string or null.
361*/
362std::optional<int> ParseSighashString(const UniValue& sighash)
363{
364    if (sighash.isNull()) {
365        return std::nullopt;
366    }
367    const auto result{SighashFromStr(sighash.get_str())};
368    if (!result) {
369        throw JSONRPCError(RPC_INVALID_PARAMETER, util::ErrorString(result).original);
370    }
371    return result.value();
372}
373
374unsigned int ParseConfirmTarget(const UniValue& value, unsigned int max_target)
375{
376    const int target{value.getInt<int>()};
377    const unsigned int unsigned_target{static_cast<unsigned int>(target)};
378    if (target < 1 || unsigned_target > max_target) {
379        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid conf_target, must be between %u and %u", 1, max_target));
380    }
381    return unsigned_target;
382}
383
384RPCErrorCode RPCErrorFromPSBTError(PSBTError err)
385{
386    switch (err) {
387        case PSBTError::UNSUPPORTED:
388            return RPC_INVALID_PARAMETER;
389        case PSBTError::SIGHASH_MISMATCH:
390            return RPC_DESERIALIZATION_ERROR;
391        default: break;
392    }
393    return RPC_TRANSACTION_ERROR;
394}
395
396RPCErrorCode RPCErrorFromTransactionError(TransactionError terr)
397{
398    switch (terr) {
399        case TransactionError::MEMPOOL_REJECTED:
400            return RPC_TRANSACTION_REJECTED;
401        case TransactionError::ALREADY_IN_UTXO_SET:
402            return RPC_VERIFY_ALREADY_IN_UTXO_SET;
403        case TransactionError::PRIVATE_BROADCAST_FULL:
404            return RPC_LIMIT_EXCEEDED;
405        default: break;
406    }
407    return RPC_TRANSACTION_ERROR;
408}
409
410UniValue JSONRPCPSBTError(PSBTError err)
411{
412    return JSONRPCError(RPCErrorFromPSBTError(err), PSBTErrorString(err).original);
413}
414
415UniValue JSONRPCTransactionError(TransactionError terr, const std::string& err_string)
416{
417    if (err_string.length() > 0) {
418        return JSONRPCError(RPCErrorFromTransactionError(terr), err_string);
419    } else {
420        return JSONRPCError(RPCErrorFromTransactionError(terr), TransactionErrorString(terr).original);
421    }
422}
423
424/**
425 * A pair of strings that can be aligned (through padding) with other Sections
426 * later on
427 */
428struct Section {
429    Section(const std::string& left, const std::string& right)
430        : m_left{left}, m_right{right} {}
431    std::string m_left;
432    const std::string m_right;
433};
434
435/**
436 * Keeps track of RPCArgs by transforming them into sections for the purpose
437 * of serializing everything to a single string
438 */
439struct Sections {
440    std::vector<Section> m_sections;
441    size_t m_max_pad{0};
442
443    void PushSection(const Section& s)
444    {
445        m_max_pad = std::max(m_max_pad, s.m_left.size());
446        m_sections.push_back(s);
447    }
448
449    /**
450     * Recursive helper to translate an RPCArg into sections
451     */
452    // NOLINTNEXTLINE(misc-no-recursion)
453    void Push(const RPCArg& arg, const size_t current_indent = 5, const OuterType outer_type = OuterType::NONE)
454    {
455        const auto indent = std::string(current_indent, ' ');
456        const auto indent_next = std::string(current_indent + 2, ' ');
457        const bool push_name{outer_type == OuterType::OBJ}; // Dictionary keys must have a name
458        const bool is_top_level_arg{outer_type == OuterType::NONE}; // True on the first recursion
459
460        switch (arg.m_type) {
461        case RPCArg::Type::STR_HEX:
462        case RPCArg::Type::STR:
463        case RPCArg::Type::NUM:
464        case RPCArg::Type::AMOUNT:
465        case RPCArg::Type::RANGE:
466        case RPCArg::Type::BOOL:
467        case RPCArg::Type::OBJ_NAMED_PARAMS: {
468            if (is_top_level_arg) return; // Nothing more to do for non-recursive types on first recursion
469            auto left = indent;
470            if (arg.m_opts.type_str.size() != 0 && push_name) {
471                left += "\"" + arg.GetName() + "\": " + arg.m_opts.type_str.at(0);
472            } else {
473                left += push_name ? arg.ToStringObj(/*oneline=*/false) : arg.ToString(/*oneline=*/false);
474            }
475            left += ",";
476            PushSection({left, arg.ToDescriptionString(/*is_named_arg=*/push_name)});
477            break;
478        }
479        case RPCArg::Type::OBJ:
480        case RPCArg::Type::OBJ_USER_KEYS: {
481            const auto right = is_top_level_arg ? "" : arg.ToDescriptionString(/*is_named_arg=*/push_name);
482            PushSection({indent + (push_name ? "\"" + arg.GetName() + "\": " : "") + "{", right});
483            for (const auto& arg_inner : arg.m_inner) {
484                Push(arg_inner, current_indent + 2, OuterType::OBJ);
485            }
486            if (arg.m_type != RPCArg::Type::OBJ) {
487                PushSection({indent_next + "...", ""});
488            }
489            PushSection({indent + "}" + (is_top_level_arg ? "" : ","), ""});
490            break;
491        }
492        case RPCArg::Type::ARR: {
493            auto left = indent;
494            left += push_name ? "\"" + arg.GetName() + "\": " : "";
495            left += "[";
496            const auto right = is_top_level_arg ? "" : arg.ToDescriptionString(/*is_named_arg=*/push_name);
497            PushSection({left, right});
498            for (const auto& arg_inner : arg.m_inner) {
499                Push(arg_inner, current_indent + 2, OuterType::ARR);
500            }