Describing wallet spending conditions

1501public:
1502    WSHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "wsh") {}
1503    std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32; }
1504    bool IsSingleType() const final { return true; }
1505
1506    std::optional<int64_t> ScriptSize() const override { return 1 + 1 + 32; }
1507
1508    std::optional<int64_t> MaxSatSize(bool use_max_sig) const override {
1509        if (const auto sat_size = m_subdescriptor_args[0]->MaxSatSize(use_max_sig)) {
1510            if (const auto subscript_size = m_subdescriptor_args[0]->ScriptSize()) {
1511                return GetSizeOfCompactSize(*subscript_size) + *subscript_size + *sat_size;
1512            }
1513        }
1514        return {};
1515    }
1516
1517    std::optional<int64_t> MaxSatisfactionWeight(bool use_max_sig) const override {
1518        return MaxSatSize(use_max_sig);
1519    }
1520
1521    std::optional<int64_t> MaxSatisfactionElems() const override {
1522        if (const auto sub_elems = m_subdescriptor_args[0]->MaxSatisfactionElems()) return 1 + *sub_elems;
1523        return {};
1524    }
1525
1526    std::unique_ptr<DescriptorImpl> Clone() const override
1527    {
1528        return std::make_unique<WSHDescriptor>(m_subdescriptor_args.at(0)->Clone());
1529    }
1530};
1531
1532/** A parsed tr(...) descriptor. */
1533class TRDescriptor final : public DescriptorImpl
1534{
1535    std::vector<int> m_depths;
1536protected:
1537    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript> scripts, FlatSigningProvider& out) const override
1538    {
1539        TaprootBuilder builder;
1540        assert(m_depths.size() == scripts.size());
1541        for (size_t pos = 0; pos < m_depths.size(); ++pos) {
1542            builder.Add(m_depths[pos], scripts[pos], TAPROOT_LEAF_TAPSCRIPT);
1543        }
1544        if (!builder.IsComplete()) return {};
1545        assert(keys.size() == 1);
1546        XOnlyPubKey xpk(keys[0]);
1547        if (!xpk.IsFullyValid()) return {};
1548        builder.Finalize(xpk);
1549        WitnessV1Taproot output = builder.GetOutput();
1550        out.tr_trees[output] = builder;
1551        return Vector(GetScriptForDestination(output));
1552    }
1553    bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, const StringType type, const DescriptorCache* cache = nullptr) const override
1554    {
1555        if (m_depths.empty()) {
1556            // If there are no sub-descriptors and a PRIVATE string
1557            // is requested, return `false` to indicate that the presence
1558            // of a private key depends solely on the internal key (which is checked
1559            // in the caller), not on any sub-descriptor. This ensures correct behavior for
1560            // descriptors like tr(internal_key) when checking for private keys.
1561            return type != StringType::PRIVATE;
1562        }
1563        std::vector<bool> path;
1564        bool is_private{type == StringType::PRIVATE};
1565        // For private string output, track if at least one key has a private key available.
1566        // Initialize to true for non-private types.
1567        bool any_success{!is_private};
1568
1569        for (size_t pos = 0; pos < m_depths.size(); ++pos) {
1570            if (pos) ret += ',';
1571            while ((int)path.size() <= m_depths[pos]) {
1572                if (path.size()) ret += '{';
1573                path.push_back(false);
1574            }
1575            std::string tmp;
1576            bool subscript_res{m_subdescriptor_args[pos]->ToStringHelper(arg, tmp, type, cache)};
1577            if (!is_private && !subscript_res) return false;
1578            any_success = any_success || subscript_res;
1579            ret += tmp;
1580            while (!path.empty() && path.back()) {
1581                if (path.size() > 1) ret += '}';
1582                path.pop_back();
1583            }
1584            if (!path.empty()) path.back() = true;
1585        }
1586        return any_success;
1587    }
1588public:
1589    TRDescriptor(std::unique_ptr<PubkeyProvider> internal_key, std::vector<std::unique_ptr<DescriptorImpl>> descs, std::vector<int> depths) :
1590        DescriptorImpl(Vector(std::move(internal_key)), std::move(descs), "tr"), m_depths(std::move(depths))
1591    {
1592        assert(m_subdescriptor_args.size() == m_depths.size());
1593    }
1594    std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32M; }
1595    bool IsSingleType() const final { return true; }
1596
1597    std::optional<int64_t> ScriptSize() const override { return 1 + 1 + 32; }
1598
1599    std::optional<int64_t> MaxSatisfactionWeight(bool) const override {
1600        // FIXME: We assume keypath spend, which can lead to very large underestimations.
1601        return 1 + 65;
1602    }
1603
1604    std::optional<int64_t> MaxSatisfactionElems() const override {
1605        // FIXME: See above, we assume keypath spend.
1606        return 1;
1607    }
1608
1609    std::unique_ptr<DescriptorImpl> Clone() const override
1610    {
1611        std::vector<std::unique_ptr<DescriptorImpl>> subdescs;
1612        subdescs.reserve(m_subdescriptor_args.size());
1613        std::transform(m_subdescriptor_args.begin(), m_subdescriptor_args.end(), std::back_inserter(subdescs), [](const std::unique_ptr<DescriptorImpl>& d) { return d->Clone(); });
1614        return std::make_unique<TRDescriptor>(m_pubkey_args.at(0)->Clone(), std::move(subdescs), m_depths);
1615    }
1616};
1617
1618/* We instantiate Miniscript here with a simple integer as key type.
1619 * The value of these key integers are an index in the
1620 * DescriptorImpl::m_pubkey_args vector.
1621 */
1622
1623/**
1624 * The context for converting a Miniscript descriptor into a Script.
1625 */
1626class ScriptMaker {
1627    //! Keys contained in the Miniscript (the evaluation of DescriptorImpl::m_pubkey_args).
1628    const std::vector<CPubKey>& m_keys;
1629    //! The script context we're operating within (Tapscript or P2WSH).
1630    const miniscript::MiniscriptContext m_script_ctx;
1631
1632    //! Get the ripemd160(sha256()) hash of this key.
1633    //! Any key that is valid in a descriptor serializes as 32 bytes within a Tapscript context. So we
1634    //! must not hash the sign-bit byte in this case.
1635    uint160 GetHash160(uint32_t key) const {
1636        if (miniscript::IsTapscript(m_script_ctx)) {
1637            return Hash160(XOnlyPubKey{m_keys[key]});
1638        }
1639        return m_keys[key].GetID();
1640    }
1641
1642public:
1643    ScriptMaker(const std::vector<CPubKey>& keys LIFETIMEBOUND, const miniscript::MiniscriptContext script_ctx) : m_keys(keys), m_script_ctx{script_ctx} {}
1644
1645    std::vector<unsigned char> ToPKBytes(uint32_t key) const {
1646        // In Tapscript keys always serialize as x-only, whether an x-only key was used in the descriptor or not.
1647        if (!miniscript::IsTapscript(m_script_ctx)) {
1648            return {m_keys[key].begin(), m_keys[key].end()};
1649        }
1650        const XOnlyPubKey xonly_pubkey{m_keys[key]};
1651        return {xonly_pubkey.begin(), xonly_pubkey.end()};
1652    }
1653
1654    std::vector<unsigned char> ToPKHBytes(uint32_t key) const {
1655        auto id = GetHash160(key);
1656        return {id.begin(), id.end()};
1657    }
1658};
1659
1660/**
1661 * The context for converting a Miniscript descriptor to its textual form.
1662 */
1663class StringMaker {
1664    //! To convert private keys for private descriptors.
1665    const SigningProvider* m_arg;
1666    //! Keys contained in the Miniscript (a reference to DescriptorImpl::m_pubkey_args).
1667    const std::vector<std::unique_ptr<PubkeyProvider>>& m_pubkeys;
1668    //! StringType to serialize keys
1669    const DescriptorImpl::StringType m_type;
1670    const DescriptorCache* m_cache;
1671
1672public:
1673    StringMaker(const SigningProvider* arg LIFETIMEBOUND,
1674                const std::vector<std::unique_ptr<PubkeyProvider>>& pubkeys LIFETIMEBOUND,
1675                DescriptorImpl::StringType type,
1676                const DescriptorCache* cache LIFETIMEBOUND)
1677        : m_arg(arg), m_pubkeys(pubkeys), m_type(type), m_cache(cache) {}
1678
1679    std::optional<std::string> ToString(uint32_t key, bool& has_priv_key) const
1680    {
1681        std::string ret;
1682        has_priv_key = false;
1683        switch (m_type) {
1684        case DescriptorImpl::StringType::PUBLIC:
1685            ret = m_pubkeys[key]->ToString(PubkeyProvider::StringType::PUBLIC);
1686            break;
1687        case DescriptorImpl::StringType::PRIVATE:
1688            has_priv_key = m_pubkeys[key]->ToPrivateString(*m_arg, ret);
1689            break;
1690        case DescriptorImpl::StringType::NORMALIZED:
1691            if (!m_pubkeys[key]->ToNormalizedString(*m_arg, ret, m_cache)) return {};
1692            break;
1693        case DescriptorImpl::StringType::COMPAT:
1694            // For backwards compatibility, we do not pass StringType::COMPAT.
1695            // Prior to 31.0, COMPAT was not provided, so PUBLIC was in use. From this string,
1696            // DescriptorSPKM IDs were computed from this string, so the incorrect behavior
1697            // must be preserved for wallets with Miniscript descriptors to be loaded
1698            ret = m_pubkeys[key]->ToString(PubkeyProvider::StringType::PUBLIC);
1699            break;
1700        case DescriptorImpl::StringType::CANONICAL:
1701            ret = m_pubkeys[key]->ToString(PubkeyProvider::StringType::CANONICAL);
1702            break;
1703        }
1704        return ret;
1705    }
1706};
1707
1708class MiniscriptDescriptor final : public DescriptorImpl
1709{
1710private:
1711    miniscript::Node<uint32_t> m_node;
1712
1713protected:
1714    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript> scripts,
1715                                     FlatSigningProvider& provider) const override
1716    {
1717        const auto script_ctx{m_node.GetMsCtx()};
1718        for (const auto& key : keys) {
1719            if (miniscript::IsTapscript(script_ctx)) {
1720                provider.pubkeys.emplace(Hash160(XOnlyPubKey{key}), key);
1721            } else {
1722                provider.pubkeys.emplace(key.GetID(), key);
1723            }
1724        }
1725        return Vector(m_node.ToScript(ScriptMaker(keys, script_ctx)));
1726    }
1727
1728public:
1729    MiniscriptDescriptor(std::vector<std::unique_ptr<PubkeyProvider>> providers, miniscript::Node<uint32_t>&& node)
1730        : DescriptorImpl(std::move(providers), "?"), m_node(std::move(node))
1731    {
1732        // Traverse miniscript tree for unsafe use of older()
1733        miniscript::ForEachNode(m_node, [&](const miniscript::Node<uint32_t>& node) {
1734            if (node.Fragment() == miniscript::Fragment::OLDER) {
1735                const uint32_t raw = node.K();
1736                const uint32_t value_part = raw & ~CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
1737                if (value_part > CTxIn::SEQUENCE_LOCKTIME_MASK) {
1738                    const bool is_time_based = (raw & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) != 0;
1739                    if (is_time_based) {
1740                        m_warnings.push_back(strprintf("time-based relative locktime: older(%u) > (65535 * 512) seconds is unsafe", raw));
1741                    } else {
1742                        m_warnings.push_back(strprintf("height-based relative locktime: older(%u) > 65535 blocks is unsafe", raw));
1743                    }
1744                }
1745            }
1746        });
1747    }
1748
1749    bool ToStringHelper(const SigningProvider* arg, std::string& out, const StringType type,
1750                        const DescriptorCache* cache = nullptr) const override