2751                return {};
2752            }
2753            // A signature check is required for a miniscript to be sane. Therefore no sane miniscript
2754            // may have an empty list of public keys.
2755            CHECK_NONFATAL(!parser.m_keys.empty());
2756            // Make sure all vecs are of the same length, or exactly length 1
2757            // For length 1 vectors, clone subdescs until vector is the same length
2758            size_t num_multipath = std::max_element(parser.m_keys.begin(), parser.m_keys.end(),
2759                    [](const std::vector<std::unique_ptr<PubkeyProvider>>& a, const std::vector<std::unique_ptr<PubkeyProvider>>& b) {
2760                        return a.size() < b.size();
2761                    })->size();
2762
2763            for (auto& vec : parser.m_keys) {
2764                if (vec.size() == 1) {
2765                    for (size_t i = 1; i < num_multipath; ++i) {
2766                        vec.emplace_back(vec.at(0)->Clone());
2767                    }
2768                } else if (vec.size() != num_multipath) {
2769                    error = strprintf("Miniscript: Multipath derivation paths have mismatched lengths");
2770                    return {};
2771                }
2772            }
2773
2774            // Build the final descriptors vector
2775            for (size_t i = 0; i < num_multipath; ++i) {
2776                // Build final pubkeys vectors by retrieving the i'th subscript for each vector in subscripts
2777                std::vector<std::unique_ptr<PubkeyProvider>> pubs;
2778                pubs.reserve(parser.m_keys.size());
2779                for (auto& pub : parser.m_keys) {
2780                    pubs.emplace_back(std::move(pub.at(i)));
2781                }
2782                ret.emplace_back(std::make_unique<MiniscriptDescriptor>(std::move(pubs), node->Clone()));
2783            }
2784            return ret;
2785        }
2786    }
2787    if (ctx == ParseScriptContext::P2SH) {
2788        error = "A function is needed within P2SH";
2789        return {};
2790    } else if (ctx == ParseScriptContext::P2WSH) {
2791        error = "A function is needed within P2WSH";
2792        return {};
2793    }
2794    error = strprintf("'%s' is not a valid descriptor function", std::string(expr.begin(), expr.end()));
2795    return {};
2796}
2797
2798std::unique_ptr<DescriptorImpl> InferMultiA(const CScript& script, ParseScriptContext ctx, const SigningProvider& provider)
2799{
2800    auto match = MatchMultiA(script);
2801    if (!match) return {};
2802    std::vector<std::unique_ptr<PubkeyProvider>> keys;
2803    keys.reserve(match->second.size());
2804    for (const auto keyspan : match->second) {
2805        if (keyspan.size() != 32) return {};
2806        auto key = InferXOnlyPubkey(XOnlyPubKey{keyspan}, ctx, provider);
2807        if (!key) return {};
2808        keys.push_back(std::move(key));
2809    }
2810    return std::make_unique<MultiADescriptor>(match->first, std::move(keys));
2811}
2812
2813// NOLINTNEXTLINE(misc-no-recursion)
2814std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptContext ctx, const SigningProvider& provider)
2815{
2816    if (ctx == ParseScriptContext::P2TR && script.size() == 34 && script[0] == 32 && script[33] == OP_CHECKSIG) {
2817        XOnlyPubKey key{std::span{script}.subspan(1, 32)};
2818        return std::make_unique<PKDescriptor>(InferXOnlyPubkey(key, ctx, provider), true);
2819    }
2820
2821    if (ctx == ParseScriptContext::P2TR) {
2822        auto ret = InferMultiA(script, ctx, provider);
2823        if (ret) return ret;
2824    }
2825
2826    std::vector<std::vector<unsigned char>> data;
2827    TxoutType txntype = Solver(script, data);
2828
2829    if (txntype == TxoutType::PUBKEY && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
2830        CPubKey pubkey(data[0]);
2831        if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
2832            return std::make_unique<PKDescriptor>(std::move(pubkey_provider));
2833        }
2834    }
2835    if (txntype == TxoutType::PUBKEYHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
2836        uint160 hash(data[0]);
2837        CKeyID keyid(hash);
2838        CPubKey pubkey;
2839        if (provider.GetPubKey(keyid, pubkey)) {
2840            if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
2841                return std::make_unique<PKHDescriptor>(std::move(pubkey_provider));
2842            }
2843        }
2844    }
2845    if (txntype == TxoutType::WITNESS_V0_KEYHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH)) {
2846        uint160 hash(data[0]);
2847        CKeyID keyid(hash);
2848        CPubKey pubkey;
2849        if (provider.GetPubKey(keyid, pubkey)) {
2850            if (auto pubkey_provider = InferPubkey(pubkey, ParseScriptContext::P2WPKH, provider)) {
2851                return std::make_unique<WPKHDescriptor>(std::move(pubkey_provider));
2852            }
2853        }
2854    }
2855    if (txntype == TxoutType::MULTISIG && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH)) {
2856        bool ok = true;
2857        std::vector<std::unique_ptr<PubkeyProvider>> providers;
2858        for (size_t i = 1; i + 1 < data.size(); ++i) {
2859            CPubKey pubkey(data[i]);
2860            if (auto pubkey_provider = InferPubkey(pubkey, ctx, provider)) {
2861                providers.push_back(std::move(pubkey_provider));
2862            } else {
2863                ok = false;
2864                break;
2865            }
2866        }
2867        if (ok) return std::make_unique<MultisigDescriptor>((int)data[0][0], std::move(providers));
2868    }
2869    if (txntype == TxoutType::SCRIPTHASH && ctx == ParseScriptContext::TOP) {
2870        uint160 hash(data[0]);
2871        CScriptID scriptid(hash);
2872        CScript subscript;
2873        if (provider.GetCScript(scriptid, subscript)) {
2874            auto sub = InferScript(subscript, ParseScriptContext::P2SH, provider);
2875            if (sub) return std::make_unique<SHDescriptor>(std::move(sub));
2876        }
2877    }
2878    if (txntype == TxoutType::WITNESS_V0_SCRIPTHASH && (ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH)) {
2879        CScriptID scriptid{RIPEMD160(data[0])};
2880        CScript subscript;
2881        if (provider.GetCScript(scriptid, subscript)) {
2882            auto sub = InferScript(subscript, ParseScriptContext::P2WSH, provider);
2883            if (sub) return std::make_unique<WSHDescriptor>(std::move(sub));
2884        }
2885    }
2886    if (txntype == TxoutType::WITNESS_V1_TAPROOT && ctx == ParseScriptContext::TOP) {
2887        // Extract x-only pubkey from output.
2888        XOnlyPubKey pubkey;
2889        std::copy(data[0].begin(), data[0].end(), pubkey.begin());
2890        // Request spending data.
2891        TaprootSpendData tap;
2892        if (provider.GetTaprootSpendData(pubkey, tap)) {
2893            // If found, convert it back to tree form.
2894            auto tree = InferTaprootTree(tap, pubkey);
2895            if (tree) {
2896                // If that works, try to infer subdescriptors for all leaves.
2897                bool ok = true;
2898                std::vector<std::unique_ptr<DescriptorImpl>> subscripts; //!< list of script subexpressions
2899                std::vector<int> depths; //!< depth in the tree of each subexpression (same length subscripts)
2900                for (const auto& [depth, script, leaf_ver] : *tree) {
2901                    std::unique_ptr<DescriptorImpl> subdesc;
2902                    if (leaf_ver == TAPROOT_LEAF_TAPSCRIPT) {
2903                        subdesc = InferScript(CScript(script.begin(), script.end()), ParseScriptContext::P2TR, provider);
2904                    }
2905                    if (!subdesc) {
2906                        ok = false;
2907                        break;
2908                    } else {
2909                        subscripts.push_back(std::move(subdesc));
2910                        depths.push_back(depth);
2911                    }
2912                }
2913                if (ok) {
2914                    auto key = InferXOnlyPubkey(tap.internal_key, ParseScriptContext::P2TR, provider);
2915                    return std::make_unique<TRDescriptor>(std::move(key), std::move(subscripts), std::move(depths));
2916                }
2917            }
2918        }
2919        // If the above doesn't work, construct a rawtr() descriptor with just the encoded x-only pubkey.
2920        if (pubkey.IsFullyValid()) {
2921            auto key = InferXOnlyPubkey(pubkey, ParseScriptContext::P2TR, provider);
2922            if (key) {
2923                return std::make_unique<RawTRDescriptor>(std::move(key));
2924            }
2925        }
2926    }
2927
2928    if (ctx == ParseScriptContext::P2WSH || ctx == ParseScriptContext::P2TR) {
2929        const auto script_ctx{ctx == ParseScriptContext::P2WSH ? miniscript::MiniscriptContext::P2WSH : miniscript::MiniscriptContext::TAPSCRIPT};
2930        uint32_t key_exp_index = 0;
2931        KeyParser parser(/* out = */nullptr, /* in = */&provider, /* ctx = */script_ctx, key_exp_index);
2932        auto node = miniscript::FromScript(script, parser);
2933        if (node && node->IsSane()) {
2934            std::vector<std::unique_ptr<PubkeyProvider>> keys;
2935            keys.reserve(parser.m_keys.size());
2936            for (auto& key : parser.m_keys) {
2937                keys.emplace_back(std::move(key.at(0)));
2938            }
2939            return std::make_unique<MiniscriptDescriptor>(std::move(keys), std::move(*node));
2940        }
2941    }
2942
2943    // The following descriptors are all top-level only descriptors.
2944    // So if we are not at the top level, return early.
2945    if (ctx != ParseScriptContext::TOP) return nullptr;
2946
2947    CTxDestination dest;
2948    if (ExtractDestination(script, dest)) {
2949        if (GetScriptForDestination(dest) == script) {
2950            return std::make_unique<AddressDescriptor>(std::move(dest));
2951        }
2952    }
2953
2954    return std::make_unique<RawDescriptor>(script);
2955}
2956
2957
2958} // namespace
2959
2960/** Check a descriptor checksum, and update desc to be the checksum-less part. */
2961bool CheckChecksum(std::span<const char>& sp, bool require_checksum, std::string& error, std::string* out_checksum = nullptr)
2962{
2963    auto check_split = Split(sp, '#');
2964    if (check_split.size() > 2) {
2965        error = "Multiple '#' symbols";
2966        return false;
2967    }
2968    if (check_split.size() == 1 && require_checksum){
2969        error = "Missing checksum";
2970        return false;
2971    }
2972    if (check_split.size() == 2) {
2973        if (check_split[1].size() != 8) {
2974            error = strprintf("Expected 8 character checksum, not %u characters", check_split[1].size());
2975            return false;
2976        }
2977    }
2978    auto checksum = DescriptorChecksum(check_split[0]);
2979    if (checksum.empty()) {
2980        error = "Invalid characters in payload";
2981        return false;
2982    }
2983    if (check_split.size() == 2) {
2984        if (!std::equal(checksum.begin(), checksum.end(), check_split[1].begin())) {
2985            error = strprintf("Provided checksum '%s' does not match computed checksum '%s'", std::string(check_split[1].begin(), check_split[1].end()), checksum);
2986            return false;
2987        }
2988    }
2989    if (out_checksum) *out_checksum = std::move(checksum);
2990    sp = check_split[0];
2991    return true;
2992}
2993
2994std::vector<std::unique_ptr<Descriptor>> Parse(std::string_view descriptor, FlatSigningProvider& out, std::string& error, bool require_checksum)
2995{
2996    std::span<const char> sp{descriptor};
2997    if (!CheckChecksum(sp, require_checksum, error)) return {};
2998    uint32_t key_exp_index = 0;
2999    auto ret = ParseScript(key_exp_index, sp, ParseScriptContext::TOP, out, error);
3000    if (sp.empty() && !ret.empty()) {