Describing wallet spending conditions

2501            }
2502        }
2503        return ret;
2504    } else if (multi || sortedmulti) {
2505        error = "Can only have multi/sortedmulti at top level, in sh(), or in wsh()";
2506        return {};
2507    } else if (multi_a || sortedmulti_a) {
2508        error = "Can only have multi_a/sortedmulti_a inside tr()";
2509        return {};
2510    }
2511    if ((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH) && Func("wpkh", expr)) {
2512        auto pubkeys = ParsePubkey(key_exp_index, expr, ParseScriptContext::P2WPKH, out, error);
2513        if (pubkeys.empty()) {
2514            error = strprintf("wpkh(): %s", error);
2515            return {};
2516        }
2517        for (auto& pubkey : pubkeys) {
2518            ret.emplace_back(std::make_unique<WPKHDescriptor>(std::move(pubkey)));
2519        }
2520        return ret;
2521    } else if (Func("wpkh", expr)) {
2522        error = "Can only have wpkh() at top level or inside sh()";
2523        return {};
2524    }
2525    if (ctx == ParseScriptContext::TOP && Func("sh", expr)) {
2526        auto descs = ParseScript(key_exp_index, expr, ParseScriptContext::P2SH, out, error);
2527        if (descs.empty() || expr.size()) return {};
2528        std::vector<std::unique_ptr<DescriptorImpl>> ret;
2529        ret.reserve(descs.size());
2530        for (auto& desc : descs) {
2531            ret.push_back(std::make_unique<SHDescriptor>(std::move(desc)));
2532        }
2533        return ret;
2534    } else if (Func("sh", expr)) {
2535        error = "Can only have sh() at top level";
2536        return {};
2537    }
2538    if ((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH) && Func("wsh", expr)) {
2539        auto descs = ParseScript(key_exp_index, expr, ParseScriptContext::P2WSH, out, error);
2540        if (descs.empty() || expr.size()) return {};
2541        for (auto& desc : descs) {
2542            ret.emplace_back(std::make_unique<WSHDescriptor>(std::move(desc)));
2543        }
2544        return ret;
2545    } else if (Func("wsh", expr)) {
2546        error = "Can only have wsh() at top level or inside sh()";
2547        return {};
2548    }
2549    if (ctx == ParseScriptContext::TOP && Func("addr", expr)) {
2550        CTxDestination dest = DecodeDestination(std::string(expr.begin(), expr.end()));
2551        if (!IsValidDestination(dest)) {
2552            error = "Address is not valid";
2553            return {};
2554        }
2555        ret.emplace_back(std::make_unique<AddressDescriptor>(std::move(dest)));
2556        return ret;
2557    } else if (Func("addr", expr)) {
2558        error = "Can only have addr() at top level";
2559        return {};
2560    }
2561    if (ctx == ParseScriptContext::TOP && Func("tr", expr)) {
2562        auto arg = Expr(expr);
2563        auto internal_keys = ParsePubkey(key_exp_index, arg, ParseScriptContext::P2TR, out, error);
2564        if (internal_keys.empty()) {
2565            error = strprintf("tr(): %s", error);
2566            return {};
2567        }
2568        size_t max_providers_len = internal_keys.size();
2569        std::vector<std::vector<std::unique_ptr<DescriptorImpl>>> subscripts; //!< list of multipath expanded script subexpressions
2570        std::vector<int> depths; //!< depth in the tree of each subexpression (same length subscripts)
2571        if (expr.size()) {
2572            if (!Const(",", expr)) {
2573                error = strprintf("tr: expected ',', got '%c'", expr[0]);
2574                return {};
2575            }
2576            /** The path from the top of the tree to what we're currently processing.
2577             * branches[i] == false: left branch in the i'th step from the top; true: right branch.
2578             */
2579            std::vector<bool> branches;
2580            // Loop over all provided scripts. In every iteration exactly one script will be processed.
2581            // Use a do-loop because inside this if-branch we expect at least one script.
2582            do {
2583                // First process all open braces.
2584                while (Const("{", expr)) {
2585                    branches.push_back(false); // new left branch
2586                    if (branches.size() > TAPROOT_CONTROL_MAX_NODE_COUNT) {
2587                        error = strprintf("tr() supports at most %i nesting levels", TAPROOT_CONTROL_MAX_NODE_COUNT);
2588                        return {};
2589                    }
2590                }
2591                // Process the actual script expression.
2592                auto sarg = Expr(expr);
2593                subscripts.emplace_back(ParseScript(key_exp_index, sarg, ParseScriptContext::P2TR, out, error));
2594                if (subscripts.back().empty()) return {};
2595                max_providers_len = std::max(max_providers_len, subscripts.back().size());
2596                depths.push_back(branches.size());
2597                // Process closing braces; one is expected for every right branch we were in.
2598                while (branches.size() && branches.back()) {
2599                    if (!Const("}", expr)) {
2600                        error = strprintf("tr(): expected '}' after script expression");
2601                        return {};
2602                    }
2603                    branches.pop_back(); // move up one level after encountering '}'
2604                }
2605                // If after that, we're at the end of a left branch, expect a comma.
2606                if (branches.size() && !branches.back()) {
2607                    if (!Const(",", expr)) {
2608                        error = strprintf("tr(): expected ',' after script expression");
2609                        return {};
2610                    }
2611                    branches.back() = true; // And now we're in a right branch.
2612                }
2613            } while (branches.size());
2614            // After we've explored a whole tree, we must be at the end of the expression.
2615            if (expr.size()) {
2616                error = strprintf("tr(): expected ')' after script expression");
2617                return {};
2618            }
2619        }
2620        assert(TaprootBuilder::ValidDepths(depths));
2621
2622        // Make sure all vecs are of the same length, or exactly length 1
2623        // For length 1 vectors, clone subdescs until vector is the same length
2624        for (auto& vec : subscripts) {
2625            if (vec.size() == 1) {
2626                for (size_t i = 1; i < max_providers_len; ++i) {
2627                    vec.emplace_back(vec.at(0)->Clone());
2628                }
2629            } else if (vec.size() != max_providers_len) {
2630                error = strprintf("tr(): Multipath subscripts have mismatched lengths");
2631                return {};
2632            }
2633        }
2634
2635        if (internal_keys.size() > 1 && internal_keys.size() != max_providers_len) {
2636            error = strprintf("tr(): Multipath internal key mismatches multipath subscripts lengths");
2637            return {};
2638        }
2639
2640        while (internal_keys.size() < max_providers_len) {
2641            internal_keys.emplace_back(internal_keys.at(0)->Clone());
2642        }
2643
2644        // Build the final descriptors vector
2645        for (size_t i = 0; i < max_providers_len; ++i) {
2646            // Build final subscripts vectors by retrieving the i'th subscript for each vector in subscripts
2647            std::vector<std::unique_ptr<DescriptorImpl>> this_subs;
2648            this_subs.reserve(subscripts.size());
2649            for (auto& subs : subscripts) {
2650                this_subs.emplace_back(std::move(subs.at(i)));
2651            }
2652            ret.emplace_back(std::make_unique<TRDescriptor>(std::move(internal_keys.at(i)), std::move(this_subs), depths));
2653        }
2654        return ret;
2655
2656
2657    } else if (Func("tr", expr)) {
2658        error = "Can only have tr at top level";
2659        return {};
2660    }
2661    if (ctx == ParseScriptContext::TOP && Func("rawtr", expr)) {
2662        auto arg = Expr(expr);
2663        if (expr.size()) {
2664            error = strprintf("rawtr(): only one key expected.");
2665            return {};
2666        }
2667        auto output_keys = ParsePubkey(key_exp_index, arg, ParseScriptContext::P2TR, out, error);
2668        if (output_keys.empty()) {
2669            error = strprintf("rawtr(): %s", error);
2670            return {};
2671        }
2672        for (auto& pubkey : output_keys) {
2673            ret.emplace_back(std::make_unique<RawTRDescriptor>(std::move(pubkey)));
2674        }
2675        return ret;
2676    } else if (Func("rawtr", expr)) {
2677        error = "Can only have rawtr at top level";
2678        return {};
2679    }
2680    if (ctx == ParseScriptContext::TOP && Func("unused", expr)) {
2681        // Check for only one expression, should not find commas, brackets, or parentheses
2682        auto arg = Expr(expr);
2683        if (expr.size()) {
2684            error = strprintf("unused(): only one key expected");
2685            return {};
2686        }
2687        auto keys = ParsePubkey(key_exp_index, arg, ctx, out, error);
2688        if (keys.empty()) return {};
2689        for (auto& pubkey : keys) {
2690            if (pubkey->IsRange()) {
2691                error = "unused(): key cannot be ranged";
2692                return {};
2693            }
2694            ret.emplace_back(std::make_unique<UnusedDescriptor>(std::move(pubkey)));
2695        }
2696        return ret;
2697    } else if (Func("unused", expr)) {
2698        error = "Can only have unused at top level";
2699        return {};
2700    }
2701    if (ctx == ParseScriptContext::TOP && Func("raw", expr)) {
2702        std::string str(expr.begin(), expr.end());
2703        if (!IsHex(str)) {
2704            error = "Raw script is not hex";
2705            return {};
2706        }
2707        auto bytes = ParseHex(str);
2708        ret.emplace_back(std::make_unique<RawDescriptor>(CScript(bytes.begin(), bytes.end())));
2709        return ret;
2710    } else if (Func("raw", expr)) {
2711        error = "Can only have raw() at top level";
2712        return {};
2713    }
2714    // Process miniscript expressions.
2715    {
2716        const auto script_ctx{ctx == ParseScriptContext::P2WSH ? miniscript::MiniscriptContext::P2WSH : miniscript::MiniscriptContext::TAPSCRIPT};
2717        KeyParser parser(/*out = */&out, /* in = */nullptr, /* ctx = */script_ctx, key_exp_index);
2718        auto node = miniscript::FromString(std::string(expr.begin(), expr.end()), parser);
2719        if (parser.m_key_parsing_error != "") {
2720            error = std::move(parser.m_key_parsing_error);
2721            return {};
2722        }
2723        if (node) {
2724            if (ctx != ParseScriptContext::P2WSH && ctx != ParseScriptContext::P2TR) {
2725                error = "Miniscript expressions can only be used in wsh or tr.";
2726                return {};
2727            }
2728            if (!node->IsSane() || node->IsNotSatisfiable()) {
2729                // Try to find the first insane sub for better error reporting.
2730                const auto* insane_node = &node.value();
2731                if (const auto sub = node->FindInsaneSub()) insane_node = sub;
2732                error = *insane_node->ToString(parser);
2733                if (!insane_node->IsValid()) {
2734                    error += " is invalid";
2735                } else if (!node->IsSane()) {
2736                    error += " is not sane";
2737                    if (!insane_node->IsNonMalleable()) {
2738                        error += ": malleable witnesses exist";
2739                    } else if (insane_node == &node.value() && !insane_node->NeedsSignature()) {
2740                        error += ": witnesses without signature exist";
2741                    } else if (!insane_node->CheckTimeLocksMix()) {
2742                        error += ": contains mixes of timelocks expressed in blocks and seconds";
2743                    } else if (!insane_node->CheckDuplicateKey()) {
2744                        error += ": contains duplicate public keys";
2745                    } else if (!insane_node->ValidSatisfactions()) {
2746                        error += ": needs witnesses that may exceed resource limits";
2747                    }
2748                } else {
2749                    error += " is not satisfiable";
2750                }