Describing wallet spending conditions

2001                if (pubkey.IsFullyValid()) {
2002                    ret.emplace_back(std::make_unique<ConstPubkeyProvider>(key_exp_index, pubkey, true));
2003                    ++key_exp_index;
2004                    return ret;
2005                }
2006            }
2007            error = strprintf("Pubkey '%s' is invalid", str);
2008            return {};
2009        }
2010        CKey key = DecodeSecret(str);
2011        if (key.IsValid()) {
2012            if (permit_uncompressed || key.IsCompressed()) {
2013                CPubKey pubkey = key.GetPubKey();
2014                out.keys.emplace(pubkey.GetID(), key);
2015                ret.emplace_back(std::make_unique<ConstPubkeyProvider>(key_exp_index, pubkey, ctx == ParseScriptContext::P2TR));
2016                ++key_exp_index;
2017                return ret;
2018            } else {
2019                error = "Uncompressed keys are not allowed";
2020                return {};
2021            }
2022        }
2023    }
2024    CExtKey extkey = DecodeExtKey(str);
2025    CExtPubKey extpubkey = DecodeExtPubKey(str);
2026    if (!extkey.key.IsValid() && !extpubkey.pubkey.IsValid()) {
2027        error = strprintf("key '%s' is not valid", str);
2028        return {};
2029    }
2030    std::vector<KeyPath> paths;
2031    DeriveType type = ParseDeriveType(split, apostrophe);
2032    if (!ParseKeyPath(split, paths, apostrophe, error, /*allow_multipath=*/true)) return {};
2033    if (extkey.key.IsValid()) {
2034        extpubkey = extkey.Neuter();
2035        out.keys.emplace(extpubkey.pubkey.GetID(), extkey.key);
2036    }
2037    for (auto& path : paths) {
2038        ret.emplace_back(std::make_unique<BIP32PubkeyProvider>(key_exp_index, extpubkey, std::move(path), type, apostrophe));
2039    }
2040    ++key_exp_index;
2041    return ret;
2042}
2043
2044/** Parse a public key including origin information (if enabled). */
2045// NOLINTNEXTLINE(misc-no-recursion)
2046std::vector<std::unique_ptr<PubkeyProvider>> ParsePubkey(uint32_t& key_exp_index, const std::span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error)
2047{
2048    std::vector<std::unique_ptr<PubkeyProvider>> ret;
2049
2050    using namespace script;
2051
2052    // musig cannot be nested inside of an origin
2053    std::span<const char> span = sp;
2054    if (Const("musig(", span, /*skip=*/false)) {
2055        if (ctx != ParseScriptContext::P2TR) {
2056            error = "musig() is only allowed in tr() and rawtr()";
2057            return {};
2058        }
2059
2060        // Split the span on the end parentheses. The end parentheses must
2061        // be included in the resulting span so that Expr is happy.
2062        auto split = Split(sp, ')', /*include_sep=*/true);
2063        if (split.size() > 2) {
2064            error = "Too many ')' in musig() expression";
2065            return {};
2066        }
2067        std::span<const char> expr(split.at(0).begin(), split.at(0).end());
2068        if (!Func("musig", expr)) {
2069            error = "Invalid musig() expression";
2070            return {};
2071        }
2072
2073        // Parse the participant pubkeys
2074        bool any_ranged = false;
2075        bool all_bip32 = true;
2076        std::vector<std::vector<std::unique_ptr<PubkeyProvider>>> providers;
2077        bool any_key_parsed = false;
2078        size_t max_multipath_len = 0;
2079        while (expr.size()) {
2080            if (any_key_parsed && !Const(",", expr)) {
2081                error = strprintf("musig(): expected ',', got '%c'", expr[0]);
2082                return {};
2083            }
2084            auto arg = Expr(expr);
2085            auto pk = ParsePubkey(key_exp_index, arg, ParseScriptContext::MUSIG, out, error);
2086            if (pk.empty()) {
2087                error = strprintf("musig(): %s", error);
2088                return {};
2089            }
2090            any_key_parsed = true;
2091
2092            any_ranged = any_ranged || pk.at(0)->IsRange();
2093            all_bip32 = all_bip32 &&  pk.at(0)->IsBIP32();
2094
2095            max_multipath_len = std::max(max_multipath_len, pk.size());
2096
2097            providers.emplace_back(std::move(pk));
2098        }
2099        if (!any_key_parsed) {
2100            error = "musig(): Must contain key expressions";
2101            return {};
2102        }
2103
2104        // Parse any derivation
2105        DeriveType deriv_type = DeriveType::NON_RANGED;
2106        std::vector<KeyPath> derivation_multipaths;
2107        if (split.size() == 2 && Const("/", split.at(1), /*skip=*/false)) {
2108            if (!all_bip32) {
2109                error = "musig(): derivation requires all participants to be xpubs or xprvs";
2110                return {};
2111            }
2112            if (any_ranged) {
2113                error = "musig(): Cannot have ranged participant keys if musig() also has derivation";
2114                return {};
2115            }
2116            bool dummy = false;
2117            auto deriv_split = Split(split.at(1), '/');
2118            deriv_type = ParseDeriveType(deriv_split, dummy);
2119            if (deriv_type == DeriveType::HARDENED_RANGED) {
2120                error = "musig(): Cannot have hardened child derivation";
2121                return {};
2122            }
2123            bool has_hardened = false;
2124            if (!ParseKeyPath(deriv_split, derivation_multipaths, dummy, error, /*allow_multipath=*/true, has_hardened)) {
2125                error = "musig(): " + error;
2126                return {};
2127            }
2128            if (has_hardened) {
2129                error = "musig(): cannot have hardened derivation steps";
2130                return {};
2131            }
2132        } else {
2133            derivation_multipaths.emplace_back();
2134        }
2135
2136        // Makes sure that all providers vectors in providers are the given length, or exactly length 1
2137        // Length 1 vectors have the single provider cloned until it matches the given length.
2138        const auto& clone_providers = [&providers](size_t length) -> bool {
2139            for (auto& multipath_providers : providers) {
2140                if (multipath_providers.size() == 1) {
2141                    for (size_t i = 1; i < length; ++i) {
2142                        multipath_providers.emplace_back(multipath_providers.at(0)->Clone());
2143                    }
2144                } else if (multipath_providers.size() != length) {
2145                    return false;
2146                }
2147            }
2148            return true;
2149        };
2150
2151        // Emplace the final MuSigPubkeyProvider into ret with the pubkey providers from the specified provider vectors index
2152        // and the path from the specified path index
2153        const auto& emplace_final_provider = [&ret, &key_exp_index, &deriv_type, &derivation_multipaths, &providers](size_t vec_idx, size_t path_idx) -> void {
2154            KeyPath& path = derivation_multipaths.at(path_idx);
2155            std::vector<std::unique_ptr<PubkeyProvider>> pubs;
2156            pubs.reserve(providers.size());
2157            for (auto& vec : providers) {
2158                pubs.emplace_back(std::move(vec.at(vec_idx)));
2159            }
2160            ret.emplace_back(std::make_unique<MuSigPubkeyProvider>(key_exp_index, std::move(pubs), path, deriv_type));
2161        };
2162
2163        if (max_multipath_len > 1 && derivation_multipaths.size() > 1) {
2164            error = "musig(): Cannot have multipath participant keys if musig() is also multipath";
2165            return {};
2166        } else if (max_multipath_len > 1) {
2167            if (!clone_providers(max_multipath_len)) {
2168                error = strprintf("musig(): Multipath derivation paths have mismatched lengths");
2169                return {};
2170            }
2171            for (size_t i = 0; i < max_multipath_len; ++i) {
2172                // Final MuSigPubkeyProvider uses participant pubkey providers at each multipath position, and the first (and only) path
2173                emplace_final_provider(i, 0);
2174            }
2175        } else if (derivation_multipaths.size() > 1) {
2176            // All key provider vectors should be length 1. Clone them until they have the same length as paths
2177            if (!Assume(clone_providers(derivation_multipaths.size()))) {
2178                error = "musig(): Multipath derivation path with multipath participants is disallowed"; // This error is unreachable due to earlier check
2179                return {};
2180            }
2181            for (size_t i = 0; i < derivation_multipaths.size(); ++i) {
2182                // Final MuSigPubkeyProvider uses cloned participant pubkey providers, and the multipath derivation paths
2183                emplace_final_provider(i, i);
2184            }
2185        } else {
2186            // No multipath derivation, MuSigPubkeyProvider uses the first (and only) participant pubkey providers, and the first (and only) path
2187            emplace_final_provider(0, 0);
2188        }
2189        ++key_exp_index; // Increment key expression index for the MuSigPubkeyProvider too
2190        return ret;
2191    }
2192
2193    auto origin_split = Split(sp, ']');
2194    if (origin_split.size() > 2) {
2195        error = "Multiple ']' characters found for a single pubkey";
2196        return {};
2197    }
2198    // This is set if either the origin or path suffix contains a hardened derivation.
2199    bool apostrophe = false;
2200    if (origin_split.size() == 1) {
2201        return ParsePubkeyInner(key_exp_index, origin_split[0], ctx, out, apostrophe, error);
2202    }
2203    if (origin_split[0].empty() || origin_split[0][0] != '[') {
2204        error = strprintf("Key origin start '[ character expected but not found, got '%c' instead",
2205                          origin_split[0].empty() ? /** empty, implies split char */ ']' : origin_split[0][0]);
2206        return {};
2207    }
2208    auto slash_split = Split(origin_split[0].subspan(1), '/');
2209    if (slash_split[0].size() != 8) {
2210        error = strprintf("Fingerprint is not 4 bytes (%u characters instead of 8 characters)", slash_split[0].size());
2211        return {};
2212    }
2213    std::string fpr_hex = std::string(slash_split[0].begin(), slash_split[0].end());
2214    if (!IsHex(fpr_hex)) {
2215        error = strprintf("Fingerprint '%s' is not hex", fpr_hex);
2216        return {};
2217    }
2218    auto fpr_bytes = ParseHex(fpr_hex);
2219    KeyOriginInfo info;
2220    static_assert(sizeof(info.fingerprint) == 4, "Fingerprint must be 4 bytes");
2221    assert(fpr_bytes.size() == 4);
2222    std::copy_n(fpr_bytes.begin(), info.fingerprint.size(), info.fingerprint.begin());
2223    std::vector<KeyPath> path;
2224    if (!ParseKeyPath(slash_split, path, apostrophe, error, /*allow_multipath=*/false)) return {};
2225    info.path = path.at(0);
2226    auto providers = ParsePubkeyInner(key_exp_index, origin_split[1], ctx, out, apostrophe, error);
2227    if (providers.empty()) return {};
2228    ret.reserve(providers.size());
2229    for (auto& prov : providers) {
2230        ret.emplace_back(std::make_unique<OriginPubkeyProvider>(prov->m_expr_index, info, std::move(prov), apostrophe));
2231    }
2232    return ret;
2233}
2234
2235std::unique_ptr<PubkeyProvider> InferPubkey(const CPubKey& pubkey, ParseScriptContext ctx, const SigningProvider& provider)
2236{
2237    // Key cannot be hybrid
2238    if (!pubkey.IsValidNonHybrid()) {
2239        return nullptr;
2240    }
2241    // Uncompressed is only allowed in TOP and P2SH contexts
2242    if (ctx != ParseScriptContext::TOP && ctx != ParseScriptContext::P2SH && !pubkey.IsCompressed()) {
2243        return nullptr;
2244    }
2245    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(0, pubkey, false);
2246    KeyOriginInfo info;
2247    if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
2248        return std::make_unique<OriginPubkeyProvider>(0, std::move(info), std::move(key_provider), /*apostrophe=*/false);
2249    }
2250    return key_provider;