Describing wallet spending conditions

1251    {
1252        return std::make_unique<PKDescriptor>(m_pubkey_args.at(0)->Clone(), m_xonly);
1253    }
1254};
1255
1256/** A parsed pkh(P) descriptor. */
1257class PKHDescriptor final : public DescriptorImpl
1258{
1259protected:
1260    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript>, FlatSigningProvider&) const override
1261    {
1262        CKeyID id = keys[0].GetID();
1263        return Vector(GetScriptForDestination(PKHash(id)));
1264    }
1265public:
1266    PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "pkh") {}
1267    std::optional<OutputType> GetOutputType() const override { return OutputType::LEGACY; }
1268    bool IsSingleType() const final { return true; }
1269
1270    std::optional<int64_t> ScriptSize() const override { return 1 + 1 + 1 + 20 + 1 + 1; }
1271
1272    std::optional<int64_t> MaxSatSize(bool use_max_sig) const override {
1273        const auto sig_size = use_max_sig ? 72 : 71;
1274        return 1 + sig_size + 1 + m_pubkey_args[0]->GetSize();
1275    }
1276
1277    std::optional<int64_t> MaxSatisfactionWeight(bool use_max_sig) const override {
1278        return *MaxSatSize(use_max_sig) * WITNESS_SCALE_FACTOR;
1279    }
1280
1281    std::optional<int64_t> MaxSatisfactionElems() const override { return 2; }
1282
1283    std::unique_ptr<DescriptorImpl> Clone() const override
1284    {
1285        return std::make_unique<PKHDescriptor>(m_pubkey_args.at(0)->Clone());
1286    }
1287};
1288
1289/** A parsed wpkh(P) descriptor. */
1290class WPKHDescriptor final : public DescriptorImpl
1291{
1292protected:
1293    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript>, FlatSigningProvider&) const override
1294    {
1295        CKeyID id = keys[0].GetID();
1296        return Vector(GetScriptForDestination(WitnessV0KeyHash(id)));
1297    }
1298public:
1299    WPKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "wpkh") {}
1300    std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32; }
1301    bool IsSingleType() const final { return true; }
1302
1303    std::optional<int64_t> ScriptSize() const override { return 1 + 1 + 20; }
1304
1305    std::optional<int64_t> MaxSatSize(bool use_max_sig) const override {
1306        const auto sig_size = use_max_sig ? 72 : 71;
1307        return (1 + sig_size + 1 + 33);
1308    }
1309
1310    std::optional<int64_t> MaxSatisfactionWeight(bool use_max_sig) const override {
1311        return MaxSatSize(use_max_sig);
1312    }
1313
1314    std::optional<int64_t> MaxSatisfactionElems() const override { return 2; }
1315
1316    std::unique_ptr<DescriptorImpl> Clone() const override
1317    {
1318        return std::make_unique<WPKHDescriptor>(m_pubkey_args.at(0)->Clone());
1319    }
1320};
1321
1322/** A parsed combo(P) descriptor. */
1323class ComboDescriptor final : public DescriptorImpl
1324{
1325protected:
1326    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript>, FlatSigningProvider& out) const override
1327    {
1328        std::vector<CScript> ret;
1329        CKeyID id = keys[0].GetID();
1330        ret.emplace_back(GetScriptForRawPubKey(keys[0])); // P2PK
1331        ret.emplace_back(GetScriptForDestination(PKHash(id))); // P2PKH
1332        if (keys[0].IsCompressed()) {
1333            CScript p2wpkh = GetScriptForDestination(WitnessV0KeyHash(id));
1334            out.scripts.emplace(CScriptID(p2wpkh), p2wpkh);
1335            ret.emplace_back(p2wpkh);
1336            ret.emplace_back(GetScriptForDestination(ScriptHash(p2wpkh))); // P2SH-P2WPKH
1337        }
1338        return ret;
1339    }
1340public:
1341    ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "combo") {}
1342    bool IsSingleType() const final { return false; }
1343    std::unique_ptr<DescriptorImpl> Clone() const override
1344    {
1345        return std::make_unique<ComboDescriptor>(m_pubkey_args.at(0)->Clone());
1346    }
1347};
1348
1349/** A parsed multi(...) or sortedmulti(...) descriptor */
1350class MultisigDescriptor final : public DescriptorImpl
1351{
1352    const int m_threshold;
1353    const bool m_sorted;
1354protected:
1355    std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }
1356    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript>, FlatSigningProvider&) const override {
1357        if (m_sorted) {
1358            std::vector<CPubKey> sorted_keys(keys);
1359            std::sort(sorted_keys.begin(), sorted_keys.end());
1360            return Vector(GetScriptForMultisig(m_threshold, sorted_keys));
1361        }
1362        return Vector(GetScriptForMultisig(m_threshold, keys));
1363    }
1364public:
1365    MultisigDescriptor(int threshold, std::vector<std::unique_ptr<PubkeyProvider>> providers, bool sorted = false) : DescriptorImpl(std::move(providers), sorted ? "sortedmulti" : "multi"), m_threshold(threshold), m_sorted(sorted) {}
1366    bool IsSingleType() const final { return true; }
1367
1368    std::optional<int64_t> ScriptSize() const override {
1369        const auto n_keys = m_pubkey_args.size();
1370        auto op = [](int64_t acc, const std::unique_ptr<PubkeyProvider>& pk) { return acc + 1 + pk->GetSize();};
1371        const auto pubkeys_size{std::accumulate(m_pubkey_args.begin(), m_pubkey_args.end(), int64_t{0}, op)};
1372        return 1 + BuildScript(n_keys).size() + BuildScript(m_threshold).size() + pubkeys_size;
1373    }
1374
1375    std::optional<int64_t> MaxSatSize(bool use_max_sig) const override {
1376        const auto sig_size = use_max_sig ? 72 : 71;
1377        return (1 + (1 + sig_size) * m_threshold);
1378    }
1379
1380    std::optional<int64_t> MaxSatisfactionWeight(bool use_max_sig) const override {
1381        return *MaxSatSize(use_max_sig) * WITNESS_SCALE_FACTOR;
1382    }
1383
1384    std::optional<int64_t> MaxSatisfactionElems() const override { return 1 + m_threshold; }
1385
1386    std::unique_ptr<DescriptorImpl> Clone() const override
1387    {
1388        std::vector<std::unique_ptr<PubkeyProvider>> providers;
1389        providers.reserve(m_pubkey_args.size());
1390        std::transform(m_pubkey_args.begin(), m_pubkey_args.end(), std::back_inserter(providers), [](const std::unique_ptr<PubkeyProvider>& p) { return p->Clone(); });
1391        return std::make_unique<MultisigDescriptor>(m_threshold, std::move(providers), m_sorted);
1392    }
1393};
1394
1395/** A parsed (sorted)multi_a(...) descriptor. Always uses x-only pubkeys. */
1396class MultiADescriptor final : public DescriptorImpl
1397{
1398    const int m_threshold;
1399    const bool m_sorted;
1400protected:
1401    std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }
1402    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript>, FlatSigningProvider&) const override {
1403        CScript ret;
1404        std::vector<XOnlyPubKey> xkeys;
1405        xkeys.reserve(keys.size());
1406        for (const auto& key : keys) xkeys.emplace_back(key);
1407        if (m_sorted) std::sort(xkeys.begin(), xkeys.end());
1408        ret << ToByteVector(xkeys[0]) << OP_CHECKSIG;
1409        for (size_t i = 1; i < keys.size(); ++i) {
1410            ret << ToByteVector(xkeys[i]) << OP_CHECKSIGADD;
1411        }
1412        ret << m_threshold << OP_NUMEQUAL;
1413        return Vector(std::move(ret));
1414    }
1415public:
1416    MultiADescriptor(int threshold, std::vector<std::unique_ptr<PubkeyProvider>> providers, bool sorted = false) : DescriptorImpl(std::move(providers), sorted ? "sortedmulti_a" : "multi_a"), m_threshold(threshold), m_sorted(sorted) {}
1417    bool IsSingleType() const final { return true; }
1418
1419    std::optional<int64_t> ScriptSize() const override {
1420        const auto n_keys = m_pubkey_args.size();
1421        return (1 + 32 + 1) * n_keys + BuildScript(m_threshold).size() + 1;
1422    }
1423
1424    std::optional<int64_t> MaxSatSize(bool use_max_sig) const override {
1425        return (1 + 65) * m_threshold + (m_pubkey_args.size() - m_threshold);
1426    }
1427
1428    std::optional<int64_t> MaxSatisfactionElems() const override { return m_pubkey_args.size(); }
1429
1430    std::unique_ptr<DescriptorImpl> Clone() const override
1431    {
1432        std::vector<std::unique_ptr<PubkeyProvider>> providers;
1433        providers.reserve(m_pubkey_args.size());
1434        for (const auto& arg : m_pubkey_args) {
1435            providers.push_back(arg->Clone());
1436        }
1437        return std::make_unique<MultiADescriptor>(m_threshold, std::move(providers), m_sorted);
1438    }
1439};
1440
1441/** A parsed sh(...) descriptor. */
1442class SHDescriptor final : public DescriptorImpl
1443{
1444protected:
1445    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, std::span<const CScript> scripts, FlatSigningProvider& out) const override
1446    {
1447        auto ret = Vector(GetScriptForDestination(ScriptHash(scripts[0])));
1448        if (ret.size()) out.scripts.emplace(CScriptID(scripts[0]), scripts[0]);
1449        return ret;
1450    }
1451
1452    bool IsSegwit() const { return m_subdescriptor_args[0]->GetOutputType() == OutputType::BECH32; }
1453
1454public:
1455    SHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "sh") {}
1456
1457    std::optional<OutputType> GetOutputType() const override
1458    {
1459        assert(m_subdescriptor_args.size() == 1);
1460        if (IsSegwit()) return OutputType::P2SH_SEGWIT;
1461        return OutputType::LEGACY;
1462    }
1463    bool IsSingleType() const final { return true; }
1464
1465    std::optional<int64_t> ScriptSize() const override { return 1 + 1 + 20 + 1; }
1466
1467    std::optional<int64_t> MaxSatisfactionWeight(bool use_max_sig) const override {
1468        if (const auto sat_size = m_subdescriptor_args[0]->MaxSatSize(use_max_sig)) {
1469            if (const auto subscript_size = m_subdescriptor_args[0]->ScriptSize()) {
1470                // The subscript is never witness data.
1471                const auto subscript_weight = (1 + *subscript_size) * WITNESS_SCALE_FACTOR;
1472                // The weight depends on whether the inner descriptor is satisfied using the witness stack.
1473                if (IsSegwit()) return subscript_weight + *sat_size;
1474                return subscript_weight + *sat_size * WITNESS_SCALE_FACTOR;
1475            }
1476        }
1477        return {};
1478    }
1479
1480    std::optional<int64_t> MaxSatisfactionElems() const override {
1481        if (const auto sub_elems = m_subdescriptor_args[0]->MaxSatisfactionElems()) return 1 + *sub_elems;
1482        return {};
1483    }
1484
1485    std::unique_ptr<DescriptorImpl> Clone() const override
1486    {
1487        return std::make_unique<SHDescriptor>(m_subdescriptor_args.at(0)->Clone());
1488    }
1489};
1490
1491/** A parsed wsh(...) descriptor. */
1492class WSHDescriptor final : public DescriptorImpl
1493{
1494protected:
1495    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, std::span<const CScript> scripts, FlatSigningProvider& out) const override
1496    {
1497        auto ret = Vector(GetScriptForDestination(WitnessV0ScriptHash(scripts[0])));
1498        if (ret.size()) out.scripts.emplace(CScriptID(scripts[0]), scripts[0]);
1499        return ret;
1500    }