Describing wallet spending conditions

751        if (IsRangedDerivation()) {
752            out += "/*";
753        }
754        return out;
755    }
756    bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
757    {
758        bool any_privkeys = false;
759        out = "musig(";
760        for (size_t i = 0; i < m_participants.size(); ++i) {
761            const auto& pubkey = m_participants.at(i);
762            if (i) out += ",";
763            std::string tmp;
764            if (pubkey->ToPrivateString(arg, tmp)) {
765                any_privkeys = true;
766            }
767            out += tmp;
768        }
769        out += ")";
770        out += FormatHDKeypath(m_path);
771        if (IsRangedDerivation()) {
772            out += "/*";
773        }
774        return any_privkeys;
775    }
776    bool ToNormalizedString(const SigningProvider& arg, std::string& out, const DescriptorCache* cache = nullptr) const override
777    {
778        out = "musig(";
779        for (size_t i = 0; i < m_participants.size(); ++i) {
780            const auto& pubkey = m_participants.at(i);
781            if (i) out += ",";
782            std::string tmp;
783            if (!pubkey->ToNormalizedString(arg, tmp, cache)) {
784                return false;
785            }
786            out += tmp;
787        }
788        out += ")";
789        out += FormatHDKeypath(m_path);
790        if (IsRangedDerivation()) {
791            out += "/*";
792        }
793        return true;
794    }
795
796    void GetPrivKey(int pos, const SigningProvider& arg, FlatSigningProvider& out) const override
797    {
798        // Get the private keys for any participants that we have
799        // If there is participant derivation, it will be done.
800        // If there is not, then the participant privkeys will be included directly
801        for (const auto& prov : m_participants) {
802            prov->GetPrivKey(pos, arg, out);
803        }
804    }
805
806    bool HavePrivateKeys(const SigningProvider& arg) const override
807    {
808        return std::ranges::all_of(m_participants, [&](const auto& prov) { return prov->HavePrivateKeys(arg); });
809    }
810
811    // Get RootPubKey and GetRootExtPubKey are used to return the single pubkey underlying the pubkey provider
812    // to be presented to the user in gethdkeys. As this is a multisig construction, there is no single underlying
813    // pubkey hence nothing should be returned.
814    // While the aggregate pubkey could be returned as the root (ext)pubkey, it is not a pubkey that anyone should
815    // be using by itself in a descriptor as it is unspendable without knowing its participants.
816    std::optional<CPubKey> GetRootPubKey() const override
817    {
818        return std::nullopt;
819    }
820    std::optional<CExtPubKey> GetRootExtPubKey() const override
821    {
822        return std::nullopt;
823    }
824
825    std::unique_ptr<PubkeyProvider> Clone() const override
826    {
827        std::vector<std::unique_ptr<PubkeyProvider>> providers;
828        providers.reserve(m_participants.size());
829        for (const std::unique_ptr<PubkeyProvider>& p : m_participants) {
830            providers.emplace_back(p->Clone());
831        }
832        return std::make_unique<MuSigPubkeyProvider>(m_expr_index, std::move(providers), m_path, m_derive);
833    }
834    bool IsBIP32() const override
835    {
836        // musig() can only be a BIP 32 key if all participants are bip32 too
837        return std::all_of(m_participants.begin(), m_participants.end(), [](const auto& pubkey) { return pubkey->IsBIP32(); });
838    }
839    size_t GetKeyCount() const override
840    {
841        return 1 + m_participants.size();
842    }
843    bool CanSelfExpand() const override
844    {
845        // Participants must be self expandable for all MuSig expressions to be self expandable; the aggregate pubkey cannot be stored
846        // in the descriptor cache, so even aggregate-then-derive still requires the self expansion of participants prior to aggregation.
847        for (const auto& key : m_participants) {
848            if (!key->CanSelfExpand()) return false;
849        }
850        return true;
851    }
852};
853
854/** Base class for all Descriptor implementations. */
855class DescriptorImpl : public Descriptor
856{
857protected:
858    //! Public key arguments for this descriptor (size 1 for PK, PKH, WPKH; any size for WSH and Multisig).
859    const std::vector<std::unique_ptr<PubkeyProvider>> m_pubkey_args;
860    //! The string name of the descriptor function.
861    const std::string m_name;
862    //! Warnings (not including subdescriptors).
863    std::vector<std::string> m_warnings;
864
865    //! The sub-descriptor arguments (empty for everything but SH and WSH).
866    //! In doc/descriptors.md this is referred to as SCRIPT expressions sh(SCRIPT)
867    //! and wsh(SCRIPT), and distinct from KEY expressions and ADDR expressions.
868    //! Subdescriptors can only ever generate a single script.
869    const std::vector<std::unique_ptr<DescriptorImpl>> m_subdescriptor_args;
870
871    //! Return a serialization of anything except pubkey and script arguments, to be prepended to those.
872    virtual std::string ToStringExtra() const { return ""; }
873
874    /** A helper function to construct the scripts for this descriptor.
875     *
876     *  This function is invoked once by ExpandHelper.
877     *
878     *  @param pubkeys The evaluations of the m_pubkey_args field.
879     *  @param scripts The evaluations of m_subdescriptor_args (one for each m_subdescriptor_args element).
880     *  @param out A FlatSigningProvider to put scripts or public keys in that are necessary to the solver.
881     *             The origin info of the provided pubkeys is automatically added.
882     *  @return A vector with scriptPubKeys for this descriptor.
883     */
884    virtual std::vector<CScript> MakeScripts(const std::vector<CPubKey>& pubkeys, std::span<const CScript> scripts, FlatSigningProvider& out) const = 0;
885
886public:
887    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_name(name), m_subdescriptor_args() {}
888    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, std::unique_ptr<DescriptorImpl> script, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_name(name), m_subdescriptor_args(Vector(std::move(script))) {}
889    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, std::vector<std::unique_ptr<DescriptorImpl>> scripts, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_name(name), m_subdescriptor_args(std::move(scripts)) {}
890
891    enum class StringType
892    {
893        PUBLIC,
894        PRIVATE,
895        NORMALIZED,
896        CANONICAL,
897        COMPAT, // string calculation that mustn't change over time to stay compatible with previous software versions
898    };
899
900    // NOLINTNEXTLINE(misc-no-recursion)
901    bool IsSolvable() const override
902    {
903        for (const auto& arg : m_subdescriptor_args) {
904            if (!arg->IsSolvable()) return false;
905        }
906        return true;
907    }
908
909    // NOLINTNEXTLINE(misc-no-recursion)
910    bool HavePrivateKeys(const SigningProvider& arg) const override
911    {
912        if (m_pubkey_args.empty() && m_subdescriptor_args.empty()) return false;
913
914        for (const auto& sub: m_subdescriptor_args) {
915            if (!sub->HavePrivateKeys(arg)) return false;
916        }
917
918        for (const auto& pubkey : m_pubkey_args) {
919            if (!pubkey->HavePrivateKeys(arg)) return false;
920        }
921
922        return true;
923    }
924
925    // NOLINTNEXTLINE(misc-no-recursion)
926    bool IsRange() const final
927    {
928        for (const auto& pubkey : m_pubkey_args) {
929            if (pubkey->IsRange()) return true;
930        }
931        for (const auto& arg : m_subdescriptor_args) {
932            if (arg->IsRange()) return true;
933        }
934        return false;
935    }
936
937    // NOLINTNEXTLINE(misc-no-recursion)
938    virtual bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, const StringType type, const DescriptorCache* cache = nullptr) const
939    {
940        size_t pos = 0;
941        bool is_private{type == StringType::PRIVATE};
942        // For private string output, track if at least one key has a private key available.
943        // Initialize to true for non-private types.
944        bool any_success{!is_private};
945        for (const auto& scriptarg : m_subdescriptor_args) {
946            if (pos++) ret += ",";
947            std::string tmp;
948            bool subscript_res{scriptarg->ToStringHelper(arg, tmp, type, cache)};
949            if (!is_private && !subscript_res) return false;
950            any_success = any_success || subscript_res;
951            ret += tmp;
952        }
953        return any_success;
954    }
955
956    // NOLINTNEXTLINE(misc-no-recursion)
957    virtual bool ToStringHelper(const SigningProvider* arg, std::string& out, const StringType type, const DescriptorCache* cache = nullptr) const
958    {
959        std::string extra = ToStringExtra();
960        size_t pos = extra.size() > 0 ? 1 : 0;
961        std::string ret = m_name + "(" + extra;
962        bool is_private{type == StringType::PRIVATE};
963        // For private string output, track if at least one key has a private key available.
964        // Initialize to true for non-private types.
965        bool any_success{!is_private};
966
967        for (const auto& pubkey : m_pubkey_args) {
968            if (pos++) ret += ",";
969            std::string tmp;
970            switch (type) {
971                case StringType::NORMALIZED:
972                    if (!pubkey->ToNormalizedString(*arg, tmp, cache)) return false;
973                    break;
974                case StringType::PRIVATE:
975                    any_success = pubkey->ToPrivateString(*arg, tmp) || any_success;
976                    break;
977                case StringType::PUBLIC:
978                    tmp = pubkey->ToString(PubkeyProvider::StringType::PUBLIC);
979                    break;
980                case StringType::COMPAT:
981                    tmp = pubkey->ToString(PubkeyProvider::StringType::COMPAT);
982                    break;
983                case StringType::CANONICAL:
984                    tmp = pubkey->ToString(PubkeyProvider::StringType::CANONICAL);
985                    break;
986            }
987            ret += tmp;
988        }
989        std::string subscript;
990        bool subscript_res{ToStringSubScriptHelper(arg, subscript, type, cache)};
991        if (!is_private && !subscript_res) return false;
992        any_success = any_success || subscript_res;
993        if (pos && subscript.size()) ret += ',';
994        out = std::move(ret) + std::move(subscript) + ")";
995        return any_success;
996    }
997
998    std::string ToString(bool compat_format) const final
999    {
1000        std::string ret;