Describing wallet spending conditions

1001        ToStringHelper(nullptr, ret, compat_format ? StringType::COMPAT : StringType::PUBLIC);
1002        return AddChecksum(ret);
1003    }
1004
1005    std::string ToCanonicalString() const final
1006    {
1007        std::string ret;
1008        ToStringHelper(nullptr, ret, StringType::CANONICAL);
1009        return AddChecksum(ret);
1010    }
1011
1012    bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
1013    {
1014        bool has_priv_key{ToStringHelper(&arg, out, StringType::PRIVATE)};
1015        out = AddChecksum(out);
1016        return has_priv_key;
1017    }
1018
1019    bool ToNormalizedString(const SigningProvider& arg, std::string& out, const DescriptorCache* cache) const override final
1020    {
1021        bool ret = ToStringHelper(&arg, out, StringType::NORMALIZED, cache);
1022        out = AddChecksum(out);
1023        return ret;
1024    }
1025
1026    // NOLINTNEXTLINE(misc-no-recursion)
1027    bool ExpandHelper(int pos, const SigningProvider& arg, const DescriptorCache* read_cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out, DescriptorCache* write_cache) const
1028    {
1029        FlatSigningProvider subprovider;
1030        std::vector<CPubKey> pubkeys;
1031        pubkeys.reserve(m_pubkey_args.size());
1032
1033        // Construct temporary data in `pubkeys`, `subscripts`, and `subprovider` to avoid producing output in case of failure.
1034        for (const auto& p : m_pubkey_args) {
1035            std::optional<CPubKey> pubkey = p->GetPubKey(pos, arg, subprovider, read_cache, write_cache);
1036            if (!pubkey) return false;
1037            pubkeys.push_back(pubkey.value());
1038        }
1039        std::vector<CScript> subscripts;
1040        for (const auto& subarg : m_subdescriptor_args) {
1041            std::vector<CScript> outscripts;
1042            if (!subarg->ExpandHelper(pos, arg, read_cache, outscripts, subprovider, write_cache)) return false;
1043            assert(outscripts.size() == 1);
1044            subscripts.emplace_back(std::move(outscripts[0]));
1045        }
1046        out.Merge(std::move(subprovider));
1047
1048        output_scripts = MakeScripts(pubkeys, std::span{subscripts}, out);
1049        return true;
1050    }
1051
1052    bool Expand(int pos, const SigningProvider& provider, std::vector<CScript>& output_scripts, FlatSigningProvider& out, DescriptorCache* write_cache = nullptr) const final
1053    {
1054        return ExpandHelper(pos, provider, nullptr, output_scripts, out, write_cache);
1055    }
1056
1057    bool ExpandFromCache(int pos, const DescriptorCache& read_cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const final
1058    {
1059        return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &read_cache, output_scripts, out, nullptr);
1060    }
1061
1062    // NOLINTNEXTLINE(misc-no-recursion)
1063    void ExpandPrivate(int pos, const SigningProvider& provider, FlatSigningProvider& out) const final
1064    {
1065        for (const auto& p : m_pubkey_args) {
1066            p->GetPrivKey(pos, provider, out);
1067        }
1068        for (const auto& arg : m_subdescriptor_args) {
1069            arg->ExpandPrivate(pos, provider, out);
1070        }
1071    }
1072
1073    std::optional<OutputType> GetOutputType() const override { return std::nullopt; }
1074
1075    std::optional<int64_t> ScriptSize() const override { return {}; }
1076
1077    /** A helper for MaxSatisfactionWeight.
1078     *
1079     * @param use_max_sig Whether to assume ECDSA signatures will have a high-r.
1080     * @return The maximum size of the satisfaction in raw bytes (with no witness meaning).
1081     */
1082    virtual std::optional<int64_t> MaxSatSize(bool use_max_sig) const { return {}; }
1083
1084    std::optional<int64_t> MaxSatisfactionWeight(bool) const override { return {}; }
1085
1086    std::optional<int64_t> MaxSatisfactionElems() const override { return {}; }
1087
1088    // NOLINTNEXTLINE(misc-no-recursion)
1089    void GetPubKeys(std::set<CPubKey>& pubkeys, std::set<CExtPubKey>& ext_pubs) const override
1090    {
1091        for (const auto& p : m_pubkey_args) {
1092            std::optional<CPubKey> pub = p->GetRootPubKey();
1093            if (pub) pubkeys.insert(*pub);
1094            std::optional<CExtPubKey> ext_pub = p->GetRootExtPubKey();
1095            if (ext_pub) ext_pubs.insert(*ext_pub);
1096        }
1097        for (const auto& arg : m_subdescriptor_args) {
1098            arg->GetPubKeys(pubkeys, ext_pubs);
1099        }
1100    }
1101
1102    virtual std::unique_ptr<DescriptorImpl> Clone() const = 0;
1103
1104    bool HasScripts() const override { return true; }
1105
1106    // NOLINTNEXTLINE(misc-no-recursion)
1107    std::vector<std::string> Warnings() const override {
1108        std::vector<std::string> all = m_warnings;
1109        for (const auto& sub : m_subdescriptor_args) {
1110            auto sub_w = sub->Warnings();
1111            all.insert(all.end(), sub_w.begin(), sub_w.end());
1112        }
1113        return all;
1114    }
1115
1116    uint32_t GetMaxKeyExpr() const final
1117    {
1118        uint32_t max_key_expr{0};
1119        std::vector<const DescriptorImpl*> todo = {this};
1120        while (!todo.empty()) {
1121            const DescriptorImpl* desc = todo.back();
1122            todo.pop_back();
1123            for (const auto& p : desc->m_pubkey_args) {
1124                max_key_expr = std::max(max_key_expr, p->m_expr_index);
1125            }
1126            for (const auto& s : desc->m_subdescriptor_args) {
1127                todo.push_back(s.get());
1128            }
1129        }
1130        return max_key_expr;
1131    }
1132
1133    size_t GetKeyCount() const final
1134    {
1135        size_t count{0};
1136        std::vector<const DescriptorImpl*> todo = {this};
1137        while (!todo.empty()) {
1138            const DescriptorImpl* desc = todo.back();
1139            todo.pop_back();
1140            for (const auto& p : desc->m_pubkey_args) {
1141                count += p->GetKeyCount();
1142            }
1143            for (const auto& s : desc->m_subdescriptor_args) {
1144                todo.push_back(s.get());
1145            }
1146        }
1147        return count;
1148    }
1149
1150    // NOLINTNEXTLINE(misc-no-recursion)
1151    bool CanSelfExpand() const override
1152    {
1153        for (const auto& key : m_pubkey_args) {
1154            if (!key->CanSelfExpand()) return false;
1155        }
1156        for (const auto& sub : m_subdescriptor_args) {
1157            if (!sub->CanSelfExpand()) return false;
1158        }
1159        return true;
1160    }
1161};
1162
1163/** A parsed addr(A) descriptor. */
1164class AddressDescriptor final : public DescriptorImpl
1165{
1166    const CTxDestination m_destination;
1167protected:
1168    std::string ToStringExtra() const override { return EncodeDestination(m_destination); }
1169    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, std::span<const CScript>, FlatSigningProvider&) const override { return Vector(GetScriptForDestination(m_destination)); }
1170public:
1171    AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, "addr"), m_destination(std::move(destination)) {}
1172    bool IsSolvable() const final { return false; }
1173
1174    std::optional<OutputType> GetOutputType() const override
1175    {
1176        return OutputTypeFromDestination(m_destination);
1177    }
1178    bool IsSingleType() const final { return true; }
1179    bool ToPrivateString(const SigningProvider& arg, std::string& out) const final { return false; }
1180
1181    std::optional<int64_t> ScriptSize() const override { return GetScriptForDestination(m_destination).size(); }
1182    std::unique_ptr<DescriptorImpl> Clone() const override
1183    {
1184        return std::make_unique<AddressDescriptor>(m_destination);
1185    }
1186};
1187
1188/** A parsed raw(H) descriptor. */
1189class RawDescriptor final : public DescriptorImpl
1190{
1191    const CScript m_script;
1192protected:
1193    std::string ToStringExtra() const override { return HexStr(m_script); }
1194    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, std::span<const CScript>, FlatSigningProvider&) const override { return Vector(m_script); }
1195public:
1196    RawDescriptor(CScript script) : DescriptorImpl({}, "raw"), m_script(std::move(script)) {}
1197    bool IsSolvable() const final { return false; }
1198
1199    std::optional<OutputType> GetOutputType() const override
1200    {
1201        CTxDestination dest;
1202        ExtractDestination(m_script, dest);
1203        return OutputTypeFromDestination(dest);
1204    }
1205    bool IsSingleType() const final { return true; }
1206    bool ToPrivateString(const SigningProvider& arg, std::string& out) const final { return false; }
1207
1208    std::optional<int64_t> ScriptSize() const override { return m_script.size(); }
1209
1210    std::unique_ptr<DescriptorImpl> Clone() const override
1211    {
1212        return std::make_unique<RawDescriptor>(m_script);
1213    }
1214};
1215
1216/** A parsed pk(P) descriptor. */
1217class PKDescriptor final : public DescriptorImpl
1218{
1219private:
1220    const bool m_xonly;
1221protected:
1222    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript>, FlatSigningProvider&) const override
1223    {
1224        if (m_xonly) {
1225            CScript script = CScript() << ToByteVector(XOnlyPubKey(keys[0])) << OP_CHECKSIG;
1226            return Vector(std::move(script));
1227        } else {
1228            return Vector(GetScriptForRawPubKey(keys[0]));
1229        }
1230    }
1231public:
1232    PKDescriptor(std::unique_ptr<PubkeyProvider> prov, bool xonly = false) : DescriptorImpl(Vector(std::move(prov)), "pk"), m_xonly(xonly) {}
1233    bool IsSingleType() const final { return true; }
1234
1235    std::optional<int64_t> ScriptSize() const override {
1236        return 1 + (m_xonly ? 32 : m_pubkey_args[0]->GetSize()) + 1;
1237    }
1238
1239    std::optional<int64_t> MaxSatSize(bool use_max_sig) const override {
1240        const auto ecdsa_sig_size = use_max_sig ? 72 : 71;
1241        return 1 + (m_xonly ? 65 : ecdsa_sig_size);
1242    }
1243
1244    std::optional<int64_t> MaxSatisfactionWeight(bool use_max_sig) const override {
1245        return *MaxSatSize(use_max_sig) * WITNESS_SCALE_FACTOR;
1246    }
1247
1248    std::optional<int64_t> MaxSatisfactionElems() const override { return 1; }
1249
1250    std::unique_ptr<DescriptorImpl> Clone() const override