Describing wallet spending conditions

2251}
2252
2253std::unique_ptr<PubkeyProvider> InferXOnlyPubkey(const XOnlyPubKey& xkey, ParseScriptContext ctx, const SigningProvider& provider)
2254{
2255    CPubKey pubkey{xkey.GetEvenCorrespondingCPubKey()};
2256    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(0, pubkey, true);
2257    KeyOriginInfo info;
2258    if (provider.GetKeyOriginByXOnly(xkey, info)) {
2259        return std::make_unique<OriginPubkeyProvider>(0, std::move(info), std::move(key_provider), /*apostrophe=*/false);
2260    }
2261    return key_provider;
2262}
2263
2264/**
2265 * The context for parsing a Miniscript descriptor (either from Script or from its textual representation).
2266 */
2267struct KeyParser {
2268    //! The Key type is an index in DescriptorImpl::m_pubkey_args
2269    using Key = uint32_t;
2270    //! Must not be nullptr if parsing from string.
2271    FlatSigningProvider* m_out;
2272    //! Must not be nullptr if parsing from Script.
2273    const SigningProvider* m_in;
2274    //! List of multipath expanded keys contained in the Miniscript.
2275    mutable std::vector<std::vector<std::unique_ptr<PubkeyProvider>>> m_keys;
2276    //! Used to detect key parsing errors within a Miniscript.
2277    mutable std::string m_key_parsing_error;
2278    //! The script context we're operating within (Tapscript or P2WSH).
2279    const miniscript::MiniscriptContext m_script_ctx;
2280    //! The current key expression index
2281    uint32_t& m_expr_index;
2282
2283    KeyParser(FlatSigningProvider* out LIFETIMEBOUND, const SigningProvider* in LIFETIMEBOUND,
2284              miniscript::MiniscriptContext ctx, uint32_t& key_exp_index LIFETIMEBOUND)
2285        : m_out(out), m_in(in), m_script_ctx(ctx), m_expr_index(key_exp_index) {}
2286
2287    bool KeyCompare(const Key& a, const Key& b) const {
2288        // Deriving a hardened step needs the private key, so use the provider that was filled
2289        // while parsing, or the one we are inferring from, rather than an empty one.
2290        const SigningProvider& provider{m_out ? *m_out : (m_in ? *m_in : DUMMY_SIGNING_PROVIDER)};
2291        const PubkeyProvider& key_a{*m_keys.at(a).at(0)};
2292        const PubkeyProvider& key_b{*m_keys.at(b).at(0)};
2293        FlatSigningProvider out_a, out_b;
2294        const std::optional<CPubKey> pub_a{key_a.GetPubKey(0, provider, out_a)};
2295        const std::optional<CPubKey> pub_b{key_b.GetPubKey(0, provider, out_b)};
2296        if (pub_a && pub_b) return *pub_a < *pub_b;
2297        // Keys that cannot be derived sort before the ones that can, and are compared by their
2298        // expression so that two different keys are not taken for duplicates.
2299        if (pub_a.has_value() != pub_b.has_value()) return !pub_a.has_value();
2300        return key_a.ToString(PubkeyProvider::StringType::PUBLIC) < key_b.ToString(PubkeyProvider::StringType::PUBLIC);
2301    }
2302
2303    ParseScriptContext ParseContext() const {
2304        switch (m_script_ctx) {
2305            case miniscript::MiniscriptContext::P2WSH: return ParseScriptContext::P2WSH;
2306            case miniscript::MiniscriptContext::TAPSCRIPT: return ParseScriptContext::P2TR;
2307        }
2308        assert(false);
2309    }
2310
2311    std::optional<Key> FromString(std::span<const char>& in) const
2312    {
2313        assert(m_out);
2314        Key key = m_keys.size();
2315        auto pk = ParsePubkey(m_expr_index, in, ParseContext(), *m_out, m_key_parsing_error);
2316        if (pk.empty()) return {};
2317        m_keys.emplace_back(std::move(pk));
2318        return key;
2319    }
2320
2321    std::optional<std::string> ToString(const Key& key, bool&) const
2322    {
2323        return m_keys.at(key).at(0)->ToString(PubkeyProvider::StringType::PUBLIC);
2324    }
2325
2326    template<typename I> std::optional<Key> FromPKBytes(I begin, I end) const
2327    {
2328        assert(m_in);
2329        Key key = m_keys.size();
2330        if (miniscript::IsTapscript(m_script_ctx) && end - begin == 32) {
2331            XOnlyPubKey pubkey;
2332            std::copy(begin, end, pubkey.begin());
2333            if (auto pubkey_provider = InferXOnlyPubkey(pubkey, ParseContext(), *m_in)) {
2334                m_keys.emplace_back();
2335                m_keys.back().push_back(std::move(pubkey_provider));
2336                return key;
2337            }
2338        } else if (!miniscript::IsTapscript(m_script_ctx)) {
2339            CPubKey pubkey(begin, end);
2340            if (auto pubkey_provider = InferPubkey(pubkey, ParseContext(), *m_in)) {
2341                m_keys.emplace_back();
2342                m_keys.back().push_back(std::move(pubkey_provider));
2343                return key;
2344            }
2345        }
2346        return {};
2347    }
2348
2349    template<typename I> std::optional<Key> FromPKHBytes(I begin, I end) const
2350    {
2351        assert(end - begin == 20);
2352        assert(m_in);
2353        uint160 hash;
2354        std::copy(begin, end, hash.begin());
2355        CKeyID keyid(hash);
2356        CPubKey pubkey;
2357        if (m_in->GetPubKey(keyid, pubkey)) {
2358            if (auto pubkey_provider = InferPubkey(pubkey, ParseContext(), *m_in)) {
2359                Key key = m_keys.size();
2360                m_keys.emplace_back();
2361                m_keys.back().push_back(std::move(pubkey_provider));
2362                return key;
2363            }
2364        }
2365        return {};
2366    }
2367
2368    miniscript::MiniscriptContext MsContext() const {
2369        return m_script_ctx;
2370    }
2371};
2372
2373/** Parse a script in a particular context. */
2374// NOLINTNEXTLINE(misc-no-recursion)
2375std::vector<std::unique_ptr<DescriptorImpl>> ParseScript(uint32_t& key_exp_index, std::span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error)
2376{
2377    using namespace script;
2378    Assume(ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH || ctx == ParseScriptContext::P2TR);
2379    std::vector<std::unique_ptr<DescriptorImpl>> ret;
2380    auto expr = Expr(sp);
2381    if (Func("pk", expr)) {
2382        auto pubkeys = ParsePubkey(key_exp_index, expr, ctx, out, error);
2383        if (pubkeys.empty()) {
2384            error = strprintf("pk(): %s", error);
2385            return {};
2386        }
2387        for (auto& pubkey : pubkeys) {
2388            ret.emplace_back(std::make_unique<PKDescriptor>(std::move(pubkey), ctx == ParseScriptContext::P2TR));
2389        }
2390        return ret;
2391    }
2392    if ((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH) && Func("pkh", expr)) {
2393        auto pubkeys = ParsePubkey(key_exp_index, expr, ctx, out, error);
2394        if (pubkeys.empty()) {
2395            error = strprintf("pkh(): %s", error);
2396            return {};
2397        }
2398        for (auto& pubkey : pubkeys) {
2399            ret.emplace_back(std::make_unique<PKHDescriptor>(std::move(pubkey)));
2400        }
2401        return ret;
2402    }
2403    if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
2404        auto pubkeys = ParsePubkey(key_exp_index, expr, ctx, out, error);
2405        if (pubkeys.empty()) {
2406            error = strprintf("combo(): %s", error);
2407            return {};
2408        }
2409        for (auto& pubkey : pubkeys) {
2410            ret.emplace_back(std::make_unique<ComboDescriptor>(std::move(pubkey)));
2411        }
2412        return ret;
2413    } else if (Func("combo", expr)) {
2414        error = "Can only have combo() at top level";
2415        return {};
2416    }
2417    const bool multi = Func("multi", expr);
2418    const bool sortedmulti = !multi && Func("sortedmulti", expr);
2419    const bool multi_a = !(multi || sortedmulti) && Func("multi_a", expr);
2420    const bool sortedmulti_a = !(multi || sortedmulti || multi_a) && Func("sortedmulti_a", expr);
2421    if (((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH) && (multi || sortedmulti)) ||
2422        (ctx == ParseScriptContext::P2TR && (multi_a || sortedmulti_a))) {
2423        auto threshold = Expr(expr);
2424        uint32_t thres;
2425        std::vector<std::vector<std::unique_ptr<PubkeyProvider>>> providers; // List of multipath expanded pubkeys
2426        if (const auto maybe_thres{ToIntegral<uint32_t>(std::string_view{threshold.begin(), threshold.end()})}) {
2427            thres = *maybe_thres;
2428        } else {
2429            error = strprintf("Multi threshold '%s' is not valid", std::string(threshold.begin(), threshold.end()));
2430            return {};
2431        }
2432        size_t script_size = 0;
2433        size_t max_providers_len = 0;
2434        while (expr.size()) {
2435            if (!Const(",", expr)) {
2436                error = strprintf("Multi: expected ',', got '%c'", expr[0]);
2437                return {};
2438            }
2439            auto arg = Expr(expr);
2440            auto pks = ParsePubkey(key_exp_index, arg, ctx, out, error);
2441            if (pks.empty()) {
2442                error = strprintf("Multi: %s", error);
2443                return {};
2444            }
2445            script_size += pks.at(0)->GetSize() + 1;
2446            max_providers_len = std::max(max_providers_len, pks.size());
2447            providers.emplace_back(std::move(pks));
2448        }
2449        if ((multi || sortedmulti) && (providers.empty() || providers.size() > MAX_PUBKEYS_PER_MULTISIG)) {
2450            error = strprintf("Cannot have %u keys in multisig; must have between 1 and %d keys, inclusive", providers.size(), MAX_PUBKEYS_PER_MULTISIG);
2451            return {};
2452        } else if ((multi_a || sortedmulti_a) && (providers.empty() || providers.size() > MAX_PUBKEYS_PER_MULTI_A)) {
2453            error = strprintf("Cannot have %u keys in multi_a; must have between 1 and %d keys, inclusive", providers.size(), MAX_PUBKEYS_PER_MULTI_A);
2454            return {};
2455        } else if (thres < 1) {
2456            error = strprintf("Multisig threshold cannot be %d, must be at least 1", thres);
2457            return {};
2458        } else if (thres > providers.size()) {
2459            error = strprintf("Multisig threshold cannot be larger than the number of keys; threshold is %d but only %u keys specified", thres, providers.size());
2460            return {};
2461        }
2462        if (ctx == ParseScriptContext::TOP) {
2463            if (providers.size() > 3) {
2464                error = strprintf("Cannot have %u pubkeys in bare multisig; only at most 3 pubkeys", providers.size());
2465                return {};
2466            }
2467        }
2468        if (ctx == ParseScriptContext::P2SH) {
2469            // This limits the maximum number of compressed pubkeys to 15.
2470            if (script_size + 3 > MAX_SCRIPT_ELEMENT_SIZE) {
2471                error = strprintf("P2SH script is too large, %d bytes is larger than %d bytes", script_size + 3, MAX_SCRIPT_ELEMENT_SIZE);
2472                return {};
2473            }
2474        }
2475
2476        // Make sure all vecs are of the same length, or exactly length 1
2477        // For length 1 vectors, clone key providers until vector is the same length
2478        for (auto& vec : providers) {
2479            if (vec.size() == 1) {
2480                for (size_t i = 1; i < max_providers_len; ++i) {
2481                    vec.emplace_back(vec.at(0)->Clone());
2482                }
2483            } else if (vec.size() != max_providers_len) {
2484                error = strprintf("multi(): Multipath derivation paths have mismatched lengths");
2485                return {};
2486            }
2487        }
2488
2489        // Build the final descriptors vector
2490        for (size_t i = 0; i < max_providers_len; ++i) {
2491            // Build final pubkeys vectors by retrieving the i'th subscript for each vector in subscripts
2492            std::vector<std::unique_ptr<PubkeyProvider>> pubs;
2493            pubs.reserve(providers.size());
2494            for (auto& pub : providers) {
2495                pubs.emplace_back(std::move(pub.at(i)));
2496            }
2497            if (multi || sortedmulti) {
2498                ret.emplace_back(std::make_unique<MultisigDescriptor>(thres, std::move(pubs), sortedmulti));
2499            } else {
2500                ret.emplace_back(std::make_unique<MultiADescriptor>(thres, std::move(pubs), sortedmulti_a));