{

uint8_t c0 = c >> 35;

c = ((c & 0x7ffffffff) << 5) ^ val;

if (c0 & 1) c ^= 0xf5dee51989;

if (c0 & 2) c ^= 0xa9fdca3312;

if (c0 & 4) c ^= 0x1bab10e32d;

if (c0 & 8) c ^= 0x3706b1677a;

if (c0 & 16) c ^= 0x644d626ffd;

return c;

{

/** A character set designed such that:

static std::string INPUT_CHARSET =

"0123456789()[],'/*abcdefgh@:$%{}"

"IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~"

"ijklmnopqrstuvwxyzABCDEFGH`#\"\\ ";

/** The character set for the checksum itself (same as bech32). */

static std::string CHECKSUM_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";

uint64_t c = 1;

int cls = 0;

int clscount = 0;

for (auto ch : span) {

auto pos = INPUT_CHARSET.find(ch);

if (pos == std::string::npos) return "";

c = PolyMod(c, pos & 31); // Emit a symbol for the position inside the group, for every character.

cls = cls * 3 + (pos >> 5); // Accumulate the group numbers

if (++clscount == 3) {

// Emit an extra symbol representing the group numbers, for every 3 characters.

c = PolyMod(c, cls);

cls = 0;

clscount = 0;

}

}

if (clscount > 0) c = PolyMod(c, cls);

for (int j = 0; j < 8; ++j) c = PolyMod(c, 0); // Shift further to determine the checksum.

c ^= 1; // Prevent appending zeroes from not affecting the checksum.

std::string ret(8, ' ');

for (int j = 0; j < 8; ++j) ret[j] = CHECKSUM_CHARSET[(c >> (5 * (7 - j))) & 31];

return ret;

{

//! Index of this key expression in the descriptor

//! E.g. If this PubkeyProvider is key1 in multi(2, key1, key2, key3), then m_expr_index = 0

uint32_t m_expr_index;

explicit PubkeyProvider(uint32_t exp_index) : m_expr_index(exp_index) {}

virtual ~PubkeyProvider() = default;

/** Derive a public key.

virtual bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info, const DescriptorCache* read_cache = nullptr, DescriptorCache* write_cache = nullptr) const = 0;

/** Whether this represent multiple public keys at different positions. */

virtual bool IsRange() const = 0;

/** Get the size of the generated public key(s) in bytes (33 or 65). */

virtual size_t GetSize() const = 0;

/** Get the descriptor string form. */

virtual std::string ToString() const = 0;

/** Get the descriptor string form including private data (if available in arg). */

virtual bool ToPrivateString(const SigningProvider& arg, std::string& out) const = 0;

/** Get the descriptor string form with the xpub at the last hardened derivation */

virtual bool ToNormalizedString(const SigningProvider& arg, std::string& out, const DescriptorCache* cache = nullptr) const = 0;

/** Derive a private key, if private data is available in arg. */

virtual bool GetPrivKey(int pos, const SigningProvider& arg, CKey& key) const = 0;

{

KeyOriginInfo m_origin;

std::unique_ptr<PubkeyProvider> m_provider;

std::string OriginString() const

{

return HexStr(m_origin.fingerprint) + FormatHDKeypath(m_origin.path);

}

OriginPubkeyProvider(uint32_t exp_index, KeyOriginInfo info, std::unique_ptr<PubkeyProvider> provider) : PubkeyProvider(exp_index), m_origin(std::move(info)), m_provider(std::move(provider)) {}

bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info, const DescriptorCache* read_cache = nullptr, DescriptorCache* write_cache = nullptr) const override

{

if (!m_provider->GetPubKey(pos, arg, key, info, read_cache, write_cache)) return false;

std::copy(std::begin(m_origin.fingerprint), std::end(m_origin.fingerprint), info.fingerprint);

info.path.insert(info.path.begin(), m_origin.path.begin(), m_origin.path.end());

return true;

}

bool IsRange() const override { return m_provider->IsRange(); }

size_t GetSize() const override { return m_provider->GetSize(); }

std::string ToString() const override { return "[" + OriginString() + "]" + m_provider->ToString(); }

bool ToPrivateString(const SigningProvider& arg, std::string& ret) const override

{

std::string sub;

if (!m_provider->ToPrivateString(arg, sub)) return false;

ret = "[" + OriginString() + "]" + std::move(sub);

return true;

}

bool ToNormalizedString(const SigningProvider& arg, std::string& ret, const DescriptorCache* cache) const override

{

std::string sub;

if (!m_provider->ToNormalizedString(arg, sub, cache)) return false;

// If m_provider is a BIP32PubkeyProvider, we may get a string formatted like a OriginPubkeyProvider

// In that case, we need to strip out the leading square bracket and fingerprint from the substring,

// and append that to our own origin string.

if (sub[0] == '[') {

sub = sub.substr(9);

ret = "[" + OriginString() + std::move(sub);

} else {

ret = "[" + OriginString() + "]" + std::move(sub);

}

return true;

}

bool GetPrivKey(int pos, const SigningProvider& arg, CKey& key) const override

{

return m_provider->GetPrivKey(pos, arg, key);

}

{

CPubKey m_pubkey;

bool m_xonly;

ConstPubkeyProvider(uint32_t exp_index, const CPubKey& pubkey, bool xonly) : PubkeyProvider(exp_index), m_pubkey(pubkey), m_xonly(xonly) {}

bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info, const DescriptorCache* read_cache = nullptr, DescriptorCache* write_cache = nullptr) const override

{

key = m_pubkey;

info.path.clear();

CKeyID keyid = m_pubkey.GetID();

std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint), info.fingerprint);

return true;

}

bool IsRange() const override { return false; }

size_t GetSize() const override { return m_pubkey.size(); }

std::string ToString() const override { return m_xonly ? HexStr(m_pubkey).substr(2) : HexStr(m_pubkey); }

bool ToPrivateString(const SigningProvider& arg, std::string& ret) const override

{

CKey key;

if (m_xonly) {

for (const auto& keyid : XOnlyPubKey(m_pubkey).GetKeyIDs()) {

arg.GetKey(keyid, key);

if (key.IsValid()) break;

}

} else {

arg.GetKey(m_pubkey.GetID(), key);

}

if (!key.IsValid()) return false;

ret = EncodeSecret(key);

return true;

}

bool ToNormalizedString(const SigningProvider& arg, std::string& ret, const DescriptorCache* cache) const override

{

ret = ToString();

return true;

}

bool GetPrivKey(int pos, const SigningProvider& arg, CKey& key) const override

{

return arg.GetKey(m_pubkey.GetID(), key);

}

NO,

UNHARDENED,

HARDENED,

{

// Root xpub, path, and final derivation step type being used, if any

CExtPubKey m_root_extkey;

KeyPath m_path;

DeriveType m_derive;

bool GetExtKey(const SigningProvider& arg, CExtKey& ret) const

{

CKey key;

if (!arg.GetKey(m_root_extkey.pubkey.GetID(), key)) return false;

ret.nDepth = m_root_extkey.nDepth;

std::copy(m_root_extkey.vchFingerprint, m_root_extkey.vchFingerprint + sizeof(ret.vchFingerprint), ret.vchFingerprint);

ret.nChild = m_root_extkey.nChild;

ret.chaincode = m_root_extkey.chaincode;

ret.key = key;

return true;

}

// Derives the last xprv

bool GetDerivedExtKey(const SigningProvider& arg, CExtKey& xprv, CExtKey& last_hardened) const

{

if (!GetExtKey(arg, xprv)) return false;

for (auto entry : m_path) {

xprv.Derive(xprv, entry);

if (entry >> 31) {

last_hardened = xprv;

}

}

return true;

}

bool IsHardened() const

{

if (m_derive == DeriveType::HARDENED) return true;

for (auto entry : m_path) {

if (entry >> 31) return true;

}

return false;

}

BIP32PubkeyProvider(uint32_t exp_index, const CExtPubKey& extkey, KeyPath path, DeriveType derive) : PubkeyProvider(exp_index), m_root_extkey(extkey), m_path(std::move(path)), m_derive(derive) {}

bool IsRange() const override { return m_derive != DeriveType::NO; }

size_t GetSize() const override { return 33; }

bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key_out, KeyOriginInfo& final_info_out, const DescriptorCache* read_cache = nullptr, DescriptorCache* write_cache = nullptr) const override

{

// Info of parent of the to be derived pubkey

KeyOriginInfo parent_info;

CKeyID keyid = m_root_extkey.pubkey.GetID();

std::copy(keyid.begin(), keyid.begin() + sizeof(parent_info.fingerprint), parent_info.fingerprint);

parent_info.path = m_path;

// Info of the derived key itself which is copied out upon successful completion

KeyOriginInfo final_info_out_tmp = parent_info;

if (m_derive == DeriveType::UNHARDENED) final_info_out_tmp.path.push_back((uint32_t)pos);

if (m_derive == DeriveType::HARDENED) final_info_out_tmp.path.push_back(((uint32_t)pos) | 0x80000000L);

// Derive keys or fetch them from cache

CExtPubKey final_extkey = m_root_extkey;

CExtPubKey parent_extkey = m_root_extkey;

CExtPubKey last_hardened_extkey;

bool der = true;

if (read_cache) {

if (!read_cache->GetCachedDerivedExtPubKey(m_expr_index, pos, final_extkey)) {

if (m_derive == DeriveType::HARDENED) return false;

// Try to get the derivation parent

if (!read_cache->GetCachedParentExtPubKey(m_expr_index, parent_extkey)) return false;

final_extkey = parent_extkey;

if (m_derive == DeriveType::UNHARDENED) der = parent_extkey.Derive(final_extkey, pos);

}

} else if (IsHardened()) {

CExtKey xprv;

CExtKey lh_xprv;

if (!GetDerivedExtKey(arg, xprv, lh_xprv)) return false;

parent_extkey = xprv.Neuter();

if (m_derive == DeriveType::UNHARDENED) der = xprv.Derive(xprv, pos);

if (m_derive == DeriveType::HARDENED) der = xprv.Derive(xprv, pos | 0x80000000UL);

final_extkey = xprv.Neuter();

if (lh_xprv.key.IsValid()) {

last_hardened_extkey = lh_xprv.Neuter();

}

} else {

for (auto entry : m_path) {

der = parent_extkey.Derive(parent_extkey, entry);

assert(der);

}

final_extkey = parent_extkey;

if (m_derive == DeriveType::UNHARDENED) der = parent_extkey.Derive(final_extkey, pos);

assert(m_derive != DeriveType::HARDENED);

}

assert(der);

final_info_out = final_info_out_tmp;

key_out = final_extkey.pubkey;

if (write_cache) {

// Only cache parent if there is any unhardened derivation

if (m_derive != DeriveType::HARDENED) {

write_cache->CacheParentExtPubKey(m_expr_index, parent_extkey);

// Cache last hardened xpub if we have it

if (last_hardened_extkey.pubkey.IsValid()) {

write_cache->CacheLastHardenedExtPubKey(m_expr_index, last_hardened_extkey);

}

} else if (final_info_out.path.size() > 0) {

write_cache->CacheDerivedExtPubKey(m_expr_index, pos, final_extkey);

}

}

return true;

}

std::string ToString() const override

{

std::string ret = EncodeExtPubKey(m_root_extkey) + FormatHDKeypath(m_path);

if (IsRange()) {

ret += "/*";

if (m_derive == DeriveType::HARDENED) ret += '\'';

}

return ret;

}

bool ToPrivateString(const SigningProvider& arg, std::string& out) const override

{

CExtKey key;

if (!GetExtKey(arg, key)) return false;

out = EncodeExtKey(key) + FormatHDKeypath(m_path);

if (IsRange()) {

out += "/*";

if (m_derive == DeriveType::HARDENED) out += '\'';

}

return true;

}

bool ToNormalizedString(const SigningProvider& arg, std::string& out, const DescriptorCache* cache) const override

{

// For hardened derivation type, just return the typical string, nothing to normalize

if (m_derive == DeriveType::HARDENED) {

out = ToString();

return true;

}

// Step backwards to find the last hardened step in the path

int i = (int)m_path.size() - 1;

for (; i >= 0; --i) {

if (m_path.at(i) >> 31) {

break;

}

}

// Either no derivation or all unhardened derivation

if (i == -1) {

out = ToString();

return true;

}

// Get the path to the last hardened stup

KeyOriginInfo origin;

int k = 0;

for (; k <= i; ++k) {

// Add to the path

origin.path.push_back(m_path.at(k));

}

// Build the remaining path

KeyPath end_path;

for (; k < (int)m_path.size(); ++k) {

end_path.push_back(m_path.at(k));

}

// Get the fingerprint

CKeyID id = m_root_extkey.pubkey.GetID();

std::copy(id.begin(), id.begin() + 4, origin.fingerprint);

CExtPubKey xpub;

CExtKey lh_xprv;

// If we have the cache, just get the parent xpub

if (cache != nullptr) {

cache->GetCachedLastHardenedExtPubKey(m_expr_index, xpub);

}

if (!xpub.pubkey.IsValid()) {

// Cache miss, or nor cache, or need privkey

CExtKey xprv;

if (!GetDerivedExtKey(arg, xprv, lh_xprv)) return false;

xpub = lh_xprv.Neuter();

}

assert(xpub.pubkey.IsValid());

// Build the string

std::string origin_str = HexStr(origin.fingerprint) + FormatHDKeypath(origin.path);

out = "[" + origin_str + "]" + EncodeExtPubKey(xpub) + FormatHDKeypath(end_path);

if (IsRange()) {

out += "/*";

assert(m_derive == DeriveType::UNHARDENED);

}

return true;

}

bool GetPrivKey(int pos, const SigningProvider& arg, CKey& key) const override

{

CExtKey extkey;

CExtKey dummy;

if (!GetDerivedExtKey(arg, extkey, dummy)) return false;

if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);

if (m_derive == DeriveType::HARDENED) extkey.Derive(extkey, pos | 0x80000000UL);

key = extkey.key;

return true;

}

{

//! Public key arguments for this descriptor (size 1 for PK, PKH, WPKH; any size for Multisig).

const std::vector<std::unique_ptr<PubkeyProvider>> m_pubkey_args;

//! The string name of the descriptor function.

const std::string m_name;

//! The sub-descriptor arguments (empty for everything but SH and WSH).

//! In doc/descriptors.m this is referred to as SCRIPT expressions sh(SCRIPT)

//! and wsh(SCRIPT), and distinct from KEY expressions and ADDR expressions.

//! Subdescriptors can only ever generate a single script.

const std::vector<std::unique_ptr<DescriptorImpl>> m_subdescriptor_args;

//! Return a serialization of anything except pubkey and script arguments, to be prepended to those.

virtual std::string ToStringExtra() const { return ""; }

/** A helper function to construct the scripts for this descriptor.

virtual std::vector<CScript> MakeScripts(const std::vector<CPubKey>& pubkeys, Span<const CScript> scripts, FlatSigningProvider& out) const = 0;

DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_name(name), m_subdescriptor_args() {}

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))) {}

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)) {}

enum class StringType

{

PUBLIC,

PRIVATE,

NORMALIZED,

};

bool IsSolvable() const override

{

for (const auto& arg : m_subdescriptor_args) {

if (!arg->IsSolvable()) return false;

}

return true;

}

bool IsRange() const final

{

for (const auto& pubkey : m_pubkey_args) {

if (pubkey->IsRange()) return true;

}

for (const auto& arg : m_subdescriptor_args) {

if (arg->IsRange()) return true;

}

return false;

}

virtual bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, const StringType type, const DescriptorCache* cache = nullptr) const

{

size_t pos = 0;

for (const auto& scriptarg : m_subdescriptor_args) {

if (pos++) ret += ",";

std::string tmp;

if (!scriptarg->ToStringHelper(arg, tmp, type, cache)) return false;

ret += std::move(tmp);

}

return true;

}

bool ToStringHelper(const SigningProvider* arg, std::string& out, const StringType type, const DescriptorCache* cache = nullptr) const

{

std::string extra = ToStringExtra();

size_t pos = extra.size() > 0 ? 1 : 0;

std::string ret = m_name + "(" + extra;

for (const auto& pubkey : m_pubkey_args) {

if (pos++) ret += ",";

std::string tmp;

switch (type) {

case StringType::NORMALIZED:

if (!pubkey->ToNormalizedString(*arg, tmp, cache)) return false;

break;

case StringType::PRIVATE:

if (!pubkey->ToPrivateString(*arg, tmp)) return false;

break;

case StringType::PUBLIC:

tmp = pubkey->ToString();

break;

}

ret += std::move(tmp);

}

std::string subscript;

if (!ToStringSubScriptHelper(arg, subscript, type, cache)) return false;

if (pos && subscript.size()) ret += ',';

out = std::move(ret) + std::move(subscript) + ")";

return true;

}

std::string ToString() const final

{

std::string ret;

ToStringHelper(nullptr, ret, StringType::PUBLIC);

return AddChecksum(ret);

}

bool ToPrivateString(const SigningProvider& arg, std::string& out) const final

{

bool ret = ToStringHelper(&arg, out, StringType::PRIVATE);

out = AddChecksum(out);

return ret;

}

bool ToNormalizedString(const SigningProvider& arg, std::string& out, const DescriptorCache* cache) const override final

{

bool ret = ToStringHelper(&arg, out, StringType::NORMALIZED, cache);

out = AddChecksum(out);

return ret;

}

bool ExpandHelper(int pos, const SigningProvider& arg, const DescriptorCache* read_cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out, DescriptorCache* write_cache) const

{

std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;

entries.reserve(m_pubkey_args.size());

// Construct temporary data in `entries`, `subscripts`, and `subprovider` to avoid producing output in case of failure.

for (const auto& p : m_pubkey_args) {

entries.emplace_back();

if (!p->GetPubKey(pos, arg, entries.back().first, entries.back().second, read_cache, write_cache)) return false;

}

std::vector<CScript> subscripts;

FlatSigningProvider subprovider;

for (const auto& subarg : m_subdescriptor_args) {

std::vector<CScript> outscripts;

if (!subarg->ExpandHelper(pos, arg, read_cache, outscripts, subprovider, write_cache)) return false;

assert(outscripts.size() == 1);

subscripts.emplace_back(std::move(outscripts[0]));

}

out = Merge(std::move(out), std::move(subprovider));

std::vector<CPubKey> pubkeys;

pubkeys.reserve(entries.size());

for (auto& entry : entries) {

pubkeys.push_back(entry.first);

out.origins.emplace(entry.first.GetID(), std::make_pair<CPubKey, KeyOriginInfo>(CPubKey(entry.first), std::move(entry.second)));

}

output_scripts = MakeScripts(pubkeys, Span{subscripts}, out);

return true;

}

bool Expand(int pos, const SigningProvider& provider, std::vector<CScript>& output_scripts, FlatSigningProvider& out, DescriptorCache* write_cache = nullptr) const final

{

return ExpandHelper(pos, provider, nullptr, output_scripts, out, write_cache);

}

bool ExpandFromCache(int pos, const DescriptorCache& read_cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const final

{

return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &read_cache, output_scripts, out, nullptr);

}

void ExpandPrivate(int pos, const SigningProvider& provider, FlatSigningProvider& out) const final

{

for (const auto& p : m_pubkey_args) {

CKey key;

if (!p->GetPrivKey(pos, provider, key)) continue;

out.keys.emplace(key.GetPubKey().GetID(), key);

}

for (const auto& arg : m_subdescriptor_args) {

arg->ExpandPrivate(pos, provider, out);

}

}

std::optional<OutputType> GetOutputType() const override { return std::nullopt; }

{

const CTxDestination m_destination;

std::string ToStringExtra() const override { return EncodeDestination(m_destination); }

std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, Span<const CScript>, FlatSigningProvider&) const override { return Vector(GetScriptForDestination(m_destination)); }

AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, "addr"), m_destination(std::move(destination)) {}

bool IsSolvable() const final { return false; }

std::optional<OutputType> GetOutputType() const override

{

return OutputTypeFromDestination(m_destination);

}

bool IsSingleType() const final { return true; }

{

const CScript m_script;

std::string ToStringExtra() const override { return HexStr(m_script); }

std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, Span<const CScript>, FlatSigningProvider&) const override { return Vector(m_script); }

RawDescriptor(CScript script) : DescriptorImpl({}, "raw"), m_script(std::move(script)) {}

bool IsSolvable() const final { return false; }

std::optional<OutputType> GetOutputType() const override

{

CTxDestination dest;

ExtractDestination(m_script, dest);

return OutputTypeFromDestination(dest);

}

bool IsSingleType() const final { return true; }

{

const bool m_xonly;

std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider&) const override

{

if (m_xonly) {

CScript script = CScript() << ToByteVector(XOnlyPubKey(keys[0])) << OP_CHECKSIG;

return Vector(std::move(script));

} else {

return Vector(GetScriptForRawPubKey(keys[0]));

}

}

PKDescriptor(std::unique_ptr<PubkeyProvider> prov, bool xonly = false) : DescriptorImpl(Vector(std::move(prov)), "pk"), m_xonly(xonly) {}

bool IsSingleType() const final { return true; }

{

std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider& out) const override

{

CKeyID id = keys[0].GetID();

out.pubkeys.emplace(id, keys[0]);

return Vector(GetScriptForDestination(PKHash(id)));

}

PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "pkh") {}

std::optional<OutputType> GetOutputType() const override { return OutputType::LEGACY; }

bool IsSingleType() const final { return true; }

{

std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider& out) const override

{

CKeyID id = keys[0].GetID();

out.pubkeys.emplace(id, keys[0]);

return Vector(GetScriptForDestination(WitnessV0KeyHash(id)));

}

WPKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "wpkh") {}

std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32; }

bool IsSingleType() const final { return true; }

{

std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider& out) const override

{

std::vector<CScript> ret;

CKeyID id = keys[0].GetID();

out.pubkeys.emplace(id, keys[0]);

ret.emplace_back(GetScriptForRawPubKey(keys[0])); // P2PK

ret.emplace_back(GetScriptForDestination(PKHash(id))); // P2PKH

if (keys[0].IsCompressed()) {

CScript p2wpkh = GetScriptForDestination(WitnessV0KeyHash(id));

out.scripts.emplace(CScriptID(p2wpkh), p2wpkh);

ret.emplace_back(p2wpkh);

ret.emplace_back(GetScriptForDestination(ScriptHash(p2wpkh))); // P2SH-P2WPKH

}

return ret;

}

ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "combo") {}

bool IsSingleType() const final { return false; }

{

const int m_threshold;

const bool m_sorted;

std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }

std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider&) const override {

if (m_sorted) {

std::vector<CPubKey> sorted_keys(keys);

std::sort(sorted_keys.begin(), sorted_keys.end());

return Vector(GetScriptForMultisig(m_threshold, sorted_keys));

}

return Vector(GetScriptForMultisig(m_threshold, keys));

}

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) {}

bool IsSingleType() const final { return true; }

{

std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, Span<const CScript> scripts, FlatSigningProvider& out) const override

{

auto ret = Vector(GetScriptForDestination(ScriptHash(scripts[0])));

if (ret.size()) out.scripts.emplace(CScriptID(scripts[0]), scripts[0]);

return ret;

}

SHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "sh") {}

std::optional<OutputType> GetOutputType() const override

{

assert(m_subdescriptor_args.size() == 1);

if (m_subdescriptor_args[0]->GetOutputType() == OutputType::BECH32) return OutputType::P2SH_SEGWIT;

return OutputType::LEGACY;

}

bool IsSingleType() const final { return true; }

{

std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, Span<const CScript> scripts, FlatSigningProvider& out) const override

{

auto ret = Vector(GetScriptForDestination(WitnessV0ScriptHash(scripts[0])));

if (ret.size()) out.scripts.emplace(CScriptID(scripts[0]), scripts[0]);

return ret;

}

WSHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "wsh") {}

std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32; }

bool IsSingleType() const final { return true; }

{

std::vector<int> m_depths;

std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript> scripts, FlatSigningProvider& out) const override

{

TaprootBuilder builder;

assert(m_depths.size() == scripts.size());

for (size_t pos = 0; pos < m_depths.size(); ++pos) {

builder.Add(m_depths[pos], scripts[pos], TAPROOT_LEAF_TAPSCRIPT);

}

if (!builder.IsComplete()) return {};

assert(keys.size() == 1);

XOnlyPubKey xpk(keys[0]);

if (!xpk.IsFullyValid()) return {};

builder.Finalize(xpk);

WitnessV1Taproot output = builder.GetOutput();

out.tr_spenddata[output].Merge(builder.GetSpendData());

out.pubkeys.emplace(keys[0].GetID(), keys[0]);

return Vector(GetScriptForDestination(output));

}

bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, const StringType type, const DescriptorCache* cache = nullptr) const override

{

if (m_depths.empty()) return true;

std::vector<bool> path;

for (size_t pos = 0; pos < m_depths.size(); ++pos) {

if (pos) ret += ',';

while ((int)path.size() <= m_depths[pos]) {

if (path.size()) ret += '{';

path.push_back(false);

}

std::string tmp;

if (!m_subdescriptor_args[pos]->ToStringHelper(arg, tmp, type, cache)) return false;

ret += std::move(tmp);

while (!path.empty() && path.back()) {

if (path.size() > 1) ret += '}';

path.pop_back();

}

if (!path.empty()) path.back() = true;

}

return true;

}

TRDescriptor(std::unique_ptr<PubkeyProvider> internal_key, std::vector<std::unique_ptr<DescriptorImpl>> descs, std::vector<int> depths) :

DescriptorImpl(Vector(std::move(internal_key)), std::move(descs), "tr"), m_depths(std::move(depths))

{

assert(m_subdescriptor_args.size() == m_depths.size());

}

std::optional<OutputType> GetOutputType() const override { return OutputType::BECH32M; }

bool IsSingleType() const final { return true; }

TOP, //!< Top-level context (script goes directly in scriptPubKey)

P2SH, //!< Inside sh() (script becomes P2SH redeemScript)

P2WPKH, //!< Inside wpkh() (no script, pubkey only)

P2WSH, //!< Inside wsh() (script becomes v0 witness script)

P2TR, //!< Inside tr() (either internal key, or BIP342 script leaf)

{

for (size_t i = 1; i < split.size(); ++i) {

Span<const char> elem = split[i];

bool hardened = false;

if (elem.size() > 0 && (elem[elem.size() - 1] == '\'' || elem[elem.size() - 1] == 'h')) {

elem = elem.first(elem.size() - 1);

hardened = true;

}

uint32_t p;

if (!ParseUInt32(std::string(elem.begin(), elem.end()), &p)) {

error = strprintf("Key path value '%s' is not a valid uint32", std::string(elem.begin(), elem.end()));

return false;

} else if (p > 0x7FFFFFFFUL) {

error = strprintf("Key path value %u is out of range", p);

return false;

}

out.push_back(p | (((uint32_t)hardened) << 31));

}

return true;

{

using namespace spanparsing;

bool permit_uncompressed = ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH;

auto split = Split(sp, '/');

std::string str(split[0].begin(), split[0].end());

if (str.size() == 0) {

error = "No key provided";

return nullptr;

}

if (split.size() == 1) {

if (IsHex(str)) {

std::vector<unsigned char> data = ParseHex(str);

CPubKey pubkey(data);

if (pubkey.IsFullyValid()) {

if (permit_uncompressed || pubkey.IsCompressed()) {

return std::make_unique<ConstPubkeyProvider>(key_exp_index, pubkey, false);

} else {

error = "Uncompressed keys are not allowed";

return nullptr;

}

} else if (data.size() == 32 && ctx == ParseScriptContext::P2TR) {

unsigned char fullkey[33] = {0x02};

std::copy(data.begin(), data.end(), fullkey + 1);

pubkey.Set(std::begin(fullkey), std::end(fullkey));

if (pubkey.IsFullyValid()) {

return std::make_unique<ConstPubkeyProvider>(key_exp_index, pubkey, true);

}

}

error = strprintf("Pubkey '%s' is invalid", str);

return nullptr;

}

CKey key = DecodeSecret(str);

if (key.IsValid()) {

if (permit_uncompressed || key.IsCompressed()) {

CPubKey pubkey = key.GetPubKey();

out.keys.emplace(pubkey.GetID(), key);

return std::make_unique<ConstPubkeyProvider>(key_exp_index, pubkey, ctx == ParseScriptContext::P2TR);

} else {

error = "Uncompressed keys are not allowed";

return nullptr;

}

}

}

CExtKey extkey = DecodeExtKey(str);

CExtPubKey extpubkey = DecodeExtPubKey(str);

if (!extkey.key.IsValid() && !extpubkey.pubkey.IsValid()) {

error = strprintf("key '%s' is not valid", str);

return nullptr;

}

KeyPath path;

DeriveType type = DeriveType::NO;

if (split.back() == Span{"*"}.first(1)) {

split.pop_back();

type = DeriveType::UNHARDENED;

} else if (split.back() == Span{"*'"}.first(2) || split.back() == Span{"*h"}.first(2)) {

split.pop_back();

type = DeriveType::HARDENED;

}

if (!ParseKeyPath(split, path, error)) return nullptr;

if (extkey.key.IsValid()) {

extpubkey = extkey.Neuter();

out.keys.emplace(extpubkey.pubkey.GetID(), extkey.key);

}

return std::make_unique<BIP32PubkeyProvider>(key_exp_index, extpubkey, std::move(path), type);