Describing wallet spending conditions

1751    {
1752        bool has_priv_key{false};
1753        auto res = m_node.ToString(StringMaker(arg, m_pubkey_args, type, cache), has_priv_key);
1754        if (res) out = *res;
1755        if (type == StringType::PRIVATE) {
1756            Assume(res.has_value());
1757            return has_priv_key;
1758        } else {
1759            return res.has_value();
1760        }
1761    }
1762
1763    bool IsSolvable() const override { return true; }
1764    bool IsSingleType() const final { return true; }
1765
1766    std::optional<int64_t> ScriptSize() const override { return m_node.ScriptSize(); }
1767
1768    std::optional<int64_t> MaxSatSize(bool) const override
1769    {
1770        // For Miniscript we always assume high-R ECDSA signatures.
1771        return m_node.GetWitnessSize();
1772    }
1773
1774    std::optional<int64_t> MaxSatisfactionElems() const override
1775    {
1776        return m_node.GetStackSize();
1777    }
1778
1779    std::unique_ptr<DescriptorImpl> Clone() const override
1780    {
1781        std::vector<std::unique_ptr<PubkeyProvider>> providers;
1782        providers.reserve(m_pubkey_args.size());
1783        for (const auto& arg : m_pubkey_args) {
1784            providers.push_back(arg->Clone());
1785        }
1786        return std::make_unique<MiniscriptDescriptor>(std::move(providers), m_node.Clone());
1787    }
1788};
1789
1790/** A parsed rawtr(...) descriptor. */
1791class RawTRDescriptor final : public DescriptorImpl
1792{
1793protected:
1794    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript> scripts, FlatSigningProvider& out) const override
1795    {
1796        assert(keys.size() == 1);
1797        XOnlyPubKey xpk(keys[0]);
1798        if (!xpk.IsFullyValid()) return {};
1799        WitnessV1Taproot output{xpk};
1800        return Vector(GetScriptForDestination(output));
1801    }
1802public:
1803    RawTRDescriptor(std::unique_ptr<PubkeyProvider> output_key) : DescriptorImpl(Vector(std::move(output_key)), "rawtr") {}
1804    std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32M; }
1805    bool IsSingleType() const final { return true; }
1806
1807    std::optional<int64_t> ScriptSize() const override { return 1 + 1 + 32; }
1808
1809    std::optional<int64_t> MaxSatisfactionWeight(bool) const override {
1810        // We can't know whether there is a script path, so assume key path spend.
1811        return 1 + 65;
1812    }
1813
1814    std::optional<int64_t> MaxSatisfactionElems() const override {
1815        // See above, we assume keypath spend.
1816        return 1;
1817    }
1818
1819    std::unique_ptr<DescriptorImpl> Clone() const override
1820    {
1821        return std::make_unique<RawTRDescriptor>(m_pubkey_args.at(0)->Clone());
1822    }
1823};
1824
1825/** A parsed unused(KEY) descriptor */
1826class UnusedDescriptor final : public DescriptorImpl
1827{
1828protected:
1829    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, std::span<const CScript> scripts, FlatSigningProvider& out) const override { return {}; }
1830public:
1831    UnusedDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "unused") {}
1832    bool IsSingleType() const final { return true; }
1833    bool HasScripts() const override { return false; }
1834
1835    std::unique_ptr<DescriptorImpl> Clone() const override
1836    {
1837        return std::make_unique<UnusedDescriptor>(m_pubkey_args.at(0)->Clone());
1838    }
1839};
1840
1841
1842////////////////////////////////////////////////////////////////////////////
1843// Parser                                                                 //
1844////////////////////////////////////////////////////////////////////////////
1845
1846enum class ParseScriptContext {
1847    TOP,     //!< Top-level context (script goes directly in scriptPubKey)
1848    P2SH,    //!< Inside sh() (script becomes P2SH redeemScript)
1849    P2WPKH,  //!< Inside wpkh() (no script, pubkey only)
1850    P2WSH,   //!< Inside wsh() (script becomes v0 witness script)
1851    P2TR,    //!< Inside tr() (either internal key, or BIP342 script leaf)
1852    MUSIG,   //!< Inside musig() (implies P2TR, cannot have nested musig())
1853};
1854
1855/**
1856 * Parse a key path, being passed a split list of elements (the first element is ignored because it is always the key).
1857 *
1858 * @param[in] split BIP32 path string, using either ' or h for hardened derivation
1859 * @param[out] out Vector of parsed key paths
1860 * @param[out] apostrophe only updated if hardened derivation is found
1861 * @param[out] error parsing error message
1862 * @param[in] allow_multipath Allows the parsed path to use the multipath specifier
1863 * @param[out] has_hardened Records whether the path contains any hardened derivation
1864 * @returns false if parsing failed
1865 **/
1866[[nodiscard]] bool ParseKeyPath(const std::vector<std::span<const char>>& split, std::vector<KeyPath>& out, bool& apostrophe, std::string& error, bool allow_multipath, bool& has_hardened)
1867{
1868    auto parse_elem = [&](std::span<const char> elem) -> std::optional<uint32_t> {
1869        const auto parsed{ParseKeyPathElement(elem)};
1870        if (!parsed) {
1871            error = parsed.error();
1872            return std::nullopt;
1873        }
1874        if (parsed->is_hardened) {
1875            has_hardened = true;
1876            apostrophe = elem.back() == '\'';
1877        }
1878        return parsed->ChildNumber();
1879    };
1880
1881    KeyPath path;
1882    struct MultipathSubstitutes {
1883        size_t placeholder_index;
1884        std::vector<uint32_t> values;
1885    };
1886    std::optional<MultipathSubstitutes> substitutes;
1887    has_hardened = false;
1888
1889    for (size_t i = 1; i < split.size(); ++i) {
1890        const std::span<const char>& elem = split[i];
1891
1892        // Check if element contains multipath specifier
1893        if (!elem.empty() && elem.front() == '<' && elem.back() == '>') {
1894            if (!allow_multipath) {
1895                error = strprintf("Key path value '%s' specifies multipath in a section where multipath is not allowed", std::string(elem.begin(), elem.end()));
1896                return false;
1897            }
1898            if (substitutes) {
1899                error = "Multiple multipath key path specifiers found";
1900                return false;
1901            }
1902
1903            // Parse each possible value
1904            std::vector<std::span<const char>> nums = Split(std::span(elem.begin()+1, elem.end()-1), ";");
1905            if (nums.size() < 2) {
1906                error = "Multipath key path specifiers must have at least two items";
1907                return false;
1908            }
1909
1910            substitutes.emplace();
1911            std::unordered_set<uint32_t> seen_substitutes;
1912            for (const auto& num : nums) {
1913                const auto& op_num = parse_elem(num);
1914                if (!op_num) return false;
1915                auto [_, inserted] = seen_substitutes.insert(*op_num);
1916                if (!inserted) {
1917                    error = strprintf("Duplicated key path value %u in multipath specifier", *op_num);
1918                    return false;
1919                }
1920                substitutes->values.emplace_back(*op_num);
1921            }
1922
1923            path.emplace_back(); // Placeholder for multipath segment
1924            substitutes->placeholder_index = path.size() - 1;
1925        } else {
1926            const auto& op_num = parse_elem(elem);
1927            if (!op_num) return false;
1928            path.emplace_back(*op_num);
1929        }
1930    }
1931
1932    if (!substitutes) {
1933        out.emplace_back(std::move(path));
1934    } else {
1935        // Replace the multipath placeholder with each value while generating paths
1936        for (uint32_t substitute : substitutes->values) {
1937            KeyPath branch_path = path;
1938            branch_path[substitutes->placeholder_index] = substitute;
1939            out.emplace_back(std::move(branch_path));
1940        }
1941    }
1942    return true;
1943}
1944
1945[[nodiscard]] bool ParseKeyPath(const std::vector<std::span<const char>>& split, std::vector<KeyPath>& out, bool& apostrophe, std::string& error, bool allow_multipath)
1946{
1947    bool dummy;
1948    return ParseKeyPath(split, out, apostrophe, error, allow_multipath, /*has_hardened=*/dummy);
1949}
1950
1951static DeriveType ParseDeriveType(std::vector<std::span<const char>>& split, bool& apostrophe)
1952{
1953    DeriveType type = DeriveType::NON_RANGED;
1954    if (std::ranges::equal(split.back(), std::span{"*"}.first(1))) {
1955        split.pop_back();
1956        type = DeriveType::UNHARDENED_RANGED;
1957    } else if (std::ranges::equal(split.back(), std::span{"*'"}.first(2)) || std::ranges::equal(split.back(), std::span{"*h"}.first(2))) {
1958        apostrophe = std::ranges::equal(split.back(), std::span{"*'"}.first(2));
1959        split.pop_back();
1960        type = DeriveType::HARDENED_RANGED;
1961    }
1962    return type;
1963}
1964
1965/** Parse a public key that excludes origin information. */
1966std::vector<std::unique_ptr<PubkeyProvider>> ParsePubkeyInner(uint32_t& key_exp_index, const std::span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, bool& apostrophe, std::string& error)
1967{
1968    std::vector<std::unique_ptr<PubkeyProvider>> ret;
1969    bool permit_uncompressed = ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH;
1970    auto split = Split(sp, '/');
1971    std::string str(split[0].begin(), split[0].end());
1972    if (str.size() == 0) {
1973        error = "No key provided";
1974        return {};
1975    }
1976    if (IsSpace(str.front()) || IsSpace(str.back())) {
1977        error = strprintf("Key '%s' is invalid due to whitespace", str);
1978        return {};
1979    }
1980    if (split.size() == 1) {
1981        if (IsHex(str)) {
1982            std::vector<unsigned char> data = ParseHex(str);
1983            CPubKey pubkey(data);
1984            if (pubkey.IsValid() && !pubkey.IsValidNonHybrid()) {
1985                error = "Hybrid public keys are not allowed";
1986                return {};
1987            }
1988            if (pubkey.IsFullyValid()) {
1989                if (permit_uncompressed || pubkey.IsCompressed()) {
1990                    ret.emplace_back(std::make_unique<ConstPubkeyProvider>(key_exp_index, pubkey, false));
1991                    ++key_exp_index;
1992                    return ret;
1993                } else {
1994                    error = "Uncompressed keys are not allowed";
1995                    return {};
1996                }
1997            } else if (data.size() == 32 && ctx == ParseScriptContext::P2TR) {
1998                unsigned char fullkey[33] = {0x02};
1999                std::copy(data.begin(), data.end(), fullkey + 1);
2000                pubkey.Set(std::begin(fullkey), std::end(fullkey));