Merge #14646: Add expansion cache functions to descriptors (unused for now)
26879509fAdd comments to descriptor tests (Pieter Wuille)82df4c64fAdd descriptor expansion cache (Pieter Wuille)1eda33aab[refactor] Combine the ToString and ToPrivateString implementations (Pieter Wuille)24d3a7b3a[refactor] Use DescriptorImpl internally, permitting access to new methods (Pieter Wuille)6be0fb4b3[refactor] Add a base DescriptorImpl with most common logic (Pieter Wuille) Pull request description: This patch modifies the internal `Descriptor` class to optionally construct and use an "expansion cache". Such a cache is a byte array that encodes all information necessary to expand a `Descriptor` a second time without access to private keys, and without the need to perform expensive BIP32 derivations. For all currently defined descriptors, the cache simply contains a concatenation of all public keys used. This is motivated by the goal of importing a descriptor into the wallet and using it as a replacement for the keypool, where it would be impossible to expand descriptors if they use hardened derivation. Tree-SHA512: f531a0a82ec1eecc30b78ba8a31724d1249826b028cc3543ad32372e1aedd537f137ab03dbffc222c5df444d5865ecd5cec754c1ae1d4989b6e9baeaffade32a
This commit is contained in:
MeshCollider
commit
3fff1ab817
4 changed files with 295 additions and 215 deletions
|
|
@ -40,8 +40,8 @@ struct PubkeyProvider
|
|||
{
|
||||
virtual ~PubkeyProvider() = default;
|
||||
|
||||
/** Derive a public key. */
|
||||
virtual bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const = 0;
|
||||
/** Derive a public key. If key==nullptr, only info is desired. */
|
||||
virtual bool GetPubKey(int pos, const SigningProvider& arg, CPubKey* key, KeyOriginInfo& info) const = 0;
|
||||
|
||||
/** Whether this represent multiple public keys at different positions. */
|
||||
virtual bool IsRange() const = 0;
|
||||
|
|
@ -68,7 +68,7 @@ class OriginPubkeyProvider final : public PubkeyProvider
|
|||
|
||||
public:
|
||||
OriginPubkeyProvider(KeyOriginInfo info, std::unique_ptr<PubkeyProvider> provider) : m_origin(std::move(info)), m_provider(std::move(provider)) {}
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const override
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey* key, KeyOriginInfo& info) const override
|
||||
{
|
||||
if (!m_provider->GetPubKey(pos, arg, key, info)) return false;
|
||||
std::copy(std::begin(m_origin.fingerprint), std::end(m_origin.fingerprint), info.fingerprint);
|
||||
|
|
@ -94,9 +94,9 @@ class ConstPubkeyProvider final : public PubkeyProvider
|
|||
|
||||
public:
|
||||
ConstPubkeyProvider(const CPubKey& pubkey) : m_pubkey(pubkey) {}
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey& key, KeyOriginInfo& info) const override
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey* key, KeyOriginInfo& info) const override
|
||||
{
|
||||
key = m_pubkey;
|
||||
if (key) *key = m_pubkey;
|
||||
info.path.clear();
|
||||
CKeyID keyid = m_pubkey.GetID();
|
||||
std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint), info.fingerprint);
|
||||
|
|
@ -152,26 +152,28 @@ public:
|
|||
BIP32PubkeyProvider(const CExtPubKey& extkey, KeyPath path, DeriveType derive) : m_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, KeyOriginInfo& info) const override
|
||||
bool GetPubKey(int pos, const SigningProvider& arg, CPubKey* key, KeyOriginInfo& info) const override
|
||||
{
|
||||
if (IsHardened()) {
|
||||
CExtKey extkey;
|
||||
if (!GetExtKey(arg, extkey)) return false;
|
||||
for (auto entry : m_path) {
|
||||
extkey.Derive(extkey, entry);
|
||||
if (key) {
|
||||
if (IsHardened()) {
|
||||
CExtKey extkey;
|
||||
if (!GetExtKey(arg, extkey)) return false;
|
||||
for (auto entry : m_path) {
|
||||
extkey.Derive(extkey, entry);
|
||||
}
|
||||
if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
|
||||
if (m_derive == DeriveType::HARDENED) extkey.Derive(extkey, pos | 0x80000000UL);
|
||||
*key = extkey.Neuter().pubkey;
|
||||
} else {
|
||||
// TODO: optimize by caching
|
||||
CExtPubKey extkey = m_extkey;
|
||||
for (auto entry : m_path) {
|
||||
extkey.Derive(extkey, entry);
|
||||
}
|
||||
if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
|
||||
assert(m_derive != DeriveType::HARDENED);
|
||||
*key = extkey.pubkey;
|
||||
}
|
||||
if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
|
||||
if (m_derive == DeriveType::HARDENED) extkey.Derive(extkey, pos | 0x80000000UL);
|
||||
key = extkey.Neuter().pubkey;
|
||||
} else {
|
||||
// TODO: optimize by caching
|
||||
CExtPubKey extkey = m_extkey;
|
||||
for (auto entry : m_path) {
|
||||
extkey.Derive(extkey, entry);
|
||||
}
|
||||
if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
|
||||
assert(m_derive != DeriveType::HARDENED);
|
||||
key = extkey.pubkey;
|
||||
}
|
||||
CKeyID keyid = m_extkey.pubkey.GetID();
|
||||
std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint), info.fingerprint);
|
||||
|
|
@ -202,129 +204,119 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
/** A parsed addr(A) descriptor. */
|
||||
class AddressDescriptor final : public Descriptor
|
||||
/** Base class for all Descriptor implementations. */
|
||||
class DescriptorImpl : public Descriptor
|
||||
{
|
||||
CTxDestination m_destination;
|
||||
//! Public key arguments for this descriptor (size 1 for PK, PKH, WPKH; any size of Multisig).
|
||||
const std::vector<std::unique_ptr<PubkeyProvider>> m_pubkey_args;
|
||||
//! The sub-descriptor argument (nullptr for everything but SH and WSH).
|
||||
const std::unique_ptr<DescriptorImpl> m_script_arg;
|
||||
//! The string name of the descriptor function.
|
||||
const std::string m_name;
|
||||
|
||||
protected:
|
||||
//! 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.
|
||||
*
|
||||
* This function is invoked once for every CScript produced by evaluating
|
||||
* m_script_arg, or just once in case m_script_arg is nullptr.
|
||||
|
||||
* @param pubkeys The evaluations of the m_pubkey_args field.
|
||||
* @param script The evaluation of m_script_arg (or nullptr when m_script_arg is nullptr).
|
||||
* @param out A FlatSigningProvider to put scripts or public keys in that are necessary to the solver.
|
||||
* The script and pubkeys argument to this function are automatically added.
|
||||
* @return A vector with scriptPubKeys for this descriptor.
|
||||
*/
|
||||
virtual std::vector<CScript> MakeScripts(const std::vector<CPubKey>& pubkeys, const CScript* script, FlatSigningProvider& out) const = 0;
|
||||
|
||||
public:
|
||||
AddressDescriptor(CTxDestination destination) : m_destination(std::move(destination)) {}
|
||||
DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, std::unique_ptr<DescriptorImpl> script, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_script_arg(std::move(script)), m_name(name) {}
|
||||
|
||||
bool IsRange() const override { return false; }
|
||||
bool IsSolvable() const override { return false; }
|
||||
std::string ToString() const override { return "addr(" + EncodeDestination(m_destination) + ")"; }
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override { out = ToString(); return true; }
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
bool IsSolvable() const override
|
||||
{
|
||||
output_scripts = std::vector<CScript>{GetScriptForDestination(m_destination)};
|
||||
if (m_script_arg) {
|
||||
if (!m_script_arg->IsSolvable()) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/** A parsed raw(H) descriptor. */
|
||||
class RawDescriptor final : public Descriptor
|
||||
{
|
||||
CScript m_script;
|
||||
|
||||
public:
|
||||
RawDescriptor(CScript script) : m_script(std::move(script)) {}
|
||||
|
||||
bool IsRange() const override { return false; }
|
||||
bool IsSolvable() const override { return false; }
|
||||
std::string ToString() const override { return "raw(" + HexStr(m_script.begin(), m_script.end()) + ")"; }
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override { out = ToString(); return true; }
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
bool IsRange() const final
|
||||
{
|
||||
output_scripts = std::vector<CScript>{m_script};
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/** A parsed pk(P), pkh(P), or wpkh(P) descriptor. */
|
||||
class SingleKeyDescriptor final : public Descriptor
|
||||
{
|
||||
const std::function<CScript(const CPubKey&)> m_script_fn;
|
||||
const std::string m_fn_name;
|
||||
std::unique_ptr<PubkeyProvider> m_provider;
|
||||
|
||||
public:
|
||||
SingleKeyDescriptor(std::unique_ptr<PubkeyProvider> prov, const std::function<CScript(const CPubKey&)>& fn, const std::string& name) : m_script_fn(fn), m_fn_name(name), m_provider(std::move(prov)) {}
|
||||
|
||||
bool IsRange() const override { return m_provider->IsRange(); }
|
||||
bool IsSolvable() const override { return true; }
|
||||
std::string ToString() const override { return m_fn_name + "(" + m_provider->ToString() + ")"; }
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
|
||||
{
|
||||
std::string ret;
|
||||
if (!m_provider->ToPrivateString(arg, ret)) return false;
|
||||
out = m_fn_name + "(" + std::move(ret) + ")";
|
||||
return true;
|
||||
}
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
{
|
||||
CPubKey key;
|
||||
KeyOriginInfo info;
|
||||
if (!m_provider->GetPubKey(pos, arg, key, info)) return false;
|
||||
output_scripts = std::vector<CScript>{m_script_fn(key)};
|
||||
out.origins.emplace(key.GetID(), std::move(info));
|
||||
out.pubkeys.emplace(key.GetID(), key);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
CScript P2PKHGetScript(const CPubKey& pubkey) { return GetScriptForDestination(pubkey.GetID()); }
|
||||
CScript P2PKGetScript(const CPubKey& pubkey) { return GetScriptForRawPubKey(pubkey); }
|
||||
CScript P2WPKHGetScript(const CPubKey& pubkey) { return GetScriptForDestination(WitnessV0KeyHash(pubkey.GetID())); }
|
||||
|
||||
/** A parsed multi(...) descriptor. */
|
||||
class MultisigDescriptor : public Descriptor
|
||||
{
|
||||
int m_threshold;
|
||||
std::vector<std::unique_ptr<PubkeyProvider>> m_providers;
|
||||
|
||||
public:
|
||||
MultisigDescriptor(int threshold, std::vector<std::unique_ptr<PubkeyProvider>> providers) : m_threshold(threshold), m_providers(std::move(providers)) {}
|
||||
|
||||
bool IsRange() const override
|
||||
{
|
||||
for (const auto& p : m_providers) {
|
||||
if (p->IsRange()) return true;
|
||||
for (const auto& pubkey : m_pubkey_args) {
|
||||
if (pubkey->IsRange()) return true;
|
||||
}
|
||||
if (m_script_arg) {
|
||||
if (m_script_arg->IsRange()) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool IsSolvable() const override { return true; }
|
||||
|
||||
std::string ToString() const override
|
||||
bool ToStringHelper(const SigningProvider* arg, std::string& out, bool priv) const
|
||||
{
|
||||
std::string ret = strprintf("multi(%i", m_threshold);
|
||||
for (const auto& p : m_providers) {
|
||||
ret += "," + p->ToString();
|
||||
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;
|
||||
if (priv) {
|
||||
if (!pubkey->ToPrivateString(*arg, tmp)) return false;
|
||||
} else {
|
||||
tmp = pubkey->ToString();
|
||||
}
|
||||
ret += std::move(tmp);
|
||||
}
|
||||
return std::move(ret) + ")";
|
||||
}
|
||||
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
|
||||
{
|
||||
std::string ret = strprintf("multi(%i", m_threshold);
|
||||
for (const auto& p : m_providers) {
|
||||
std::string sub;
|
||||
if (!p->ToPrivateString(arg, sub)) return false;
|
||||
ret += "," + std::move(sub);
|
||||
if (m_script_arg) {
|
||||
if (pos++) ret += ",";
|
||||
std::string tmp;
|
||||
if (!m_script_arg->ToStringHelper(arg, tmp, priv)) return false;
|
||||
ret += std::move(tmp);
|
||||
}
|
||||
out = std::move(ret) + ")";
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
std::string ToString() const final
|
||||
{
|
||||
std::string ret;
|
||||
ToStringHelper(nullptr, ret, false);
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override final { return ToStringHelper(&arg, out, true); }
|
||||
|
||||
bool ExpandHelper(int pos, const SigningProvider& arg, Span<const unsigned char>* cache_read, std::vector<CScript>& output_scripts, FlatSigningProvider& out, std::vector<unsigned char>* cache_write) const
|
||||
{
|
||||
std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;
|
||||
entries.reserve(m_providers.size());
|
||||
// Construct temporary data in `entries`, to avoid producing output in case of failure.
|
||||
for (const auto& p : m_providers) {
|
||||
entries.reserve(m_pubkey_args.size());
|
||||
|
||||
// Construct temporary data in `entries` and `subscripts`, 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)) return false;
|
||||
if (!p->GetPubKey(pos, arg, cache_read ? nullptr : &entries.back().first, entries.back().second)) return false;
|
||||
if (cache_read) {
|
||||
// Cached expanded public key exists, use it.
|
||||
if (cache_read->size() == 0) return false;
|
||||
bool compressed = ((*cache_read)[0] == 0x02 || (*cache_read)[0] == 0x03) && cache_read->size() >= 33;
|
||||
bool uncompressed = ((*cache_read)[0] == 0x04) && cache_read->size() >= 65;
|
||||
if (!(compressed || uncompressed)) return false;
|
||||
CPubKey pubkey(cache_read->begin(), cache_read->begin() + (compressed ? 33 : 65));
|
||||
entries.back().first = pubkey;
|
||||
*cache_read = cache_read->subspan(compressed ? 33 : 65);
|
||||
}
|
||||
if (cache_write) {
|
||||
cache_write->insert(cache_write->end(), entries.back().first.begin(), entries.back().first.end());
|
||||
}
|
||||
}
|
||||
std::vector<CScript> subscripts;
|
||||
if (m_script_arg) {
|
||||
FlatSigningProvider subprovider;
|
||||
if (!m_script_arg->ExpandHelper(pos, arg, cache_read, subscripts, subprovider, cache_write)) return false;
|
||||
out = Merge(out, subprovider);
|
||||
}
|
||||
|
||||
std::vector<CPubKey> pubkeys;
|
||||
pubkeys.reserve(entries.size());
|
||||
for (auto& entry : entries) {
|
||||
|
|
@ -332,89 +324,141 @@ public:
|
|||
out.origins.emplace(entry.first.GetID(), std::move(entry.second));
|
||||
out.pubkeys.emplace(entry.first.GetID(), entry.first);
|
||||
}
|
||||
output_scripts = std::vector<CScript>{GetScriptForMultisig(m_threshold, pubkeys)};
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/** A parsed sh(S) or wsh(S) descriptor. */
|
||||
class ConvertorDescriptor : public Descriptor
|
||||
{
|
||||
const std::function<CScript(const CScript&)> m_convert_fn;
|
||||
const std::string m_fn_name;
|
||||
std::unique_ptr<Descriptor> m_descriptor;
|
||||
|
||||
public:
|
||||
ConvertorDescriptor(std::unique_ptr<Descriptor> descriptor, const std::function<CScript(const CScript&)>& fn, const std::string& name) : m_convert_fn(fn), m_fn_name(name), m_descriptor(std::move(descriptor)) {}
|
||||
|
||||
bool IsRange() const override { return m_descriptor->IsRange(); }
|
||||
bool IsSolvable() const override { return m_descriptor->IsSolvable(); }
|
||||
std::string ToString() const override { return m_fn_name + "(" + m_descriptor->ToString() + ")"; }
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
|
||||
{
|
||||
std::string ret;
|
||||
if (!m_descriptor->ToPrivateString(arg, ret)) return false;
|
||||
out = m_fn_name + "(" + std::move(ret) + ")";
|
||||
return true;
|
||||
}
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
{
|
||||
std::vector<CScript> sub;
|
||||
if (!m_descriptor->Expand(pos, arg, sub, out)) return false;
|
||||
output_scripts.clear();
|
||||
for (const auto& script : sub) {
|
||||
CScriptID id(script);
|
||||
out.scripts.emplace(CScriptID(script), script);
|
||||
output_scripts.push_back(m_convert_fn(script));
|
||||
if (m_script_arg) {
|
||||
for (const auto& subscript : subscripts) {
|
||||
out.scripts.emplace(CScriptID(subscript), subscript);
|
||||
std::vector<CScript> addscripts = MakeScripts(pubkeys, &subscript, out);
|
||||
for (auto& addscript : addscripts) {
|
||||
output_scripts.push_back(std::move(addscript));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
output_scripts = MakeScripts(pubkeys, nullptr, out);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Expand(int pos, const SigningProvider& provider, std::vector<CScript>& output_scripts, FlatSigningProvider& out, std::vector<unsigned char>* cache = nullptr) const final
|
||||
{
|
||||
return ExpandHelper(pos, provider, nullptr, output_scripts, out, cache);
|
||||
}
|
||||
|
||||
bool ExpandFromCache(int pos, const std::vector<unsigned char>& cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const final
|
||||
{
|
||||
Span<const unsigned char> span = MakeSpan(cache);
|
||||
return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &span, output_scripts, out, nullptr) && span.size() == 0;
|
||||
}
|
||||
};
|
||||
|
||||
CScript ConvertP2SH(const CScript& script) { return GetScriptForDestination(CScriptID(script)); }
|
||||
CScript ConvertP2WSH(const CScript& script) { return GetScriptForDestination(WitnessV0ScriptHash(script)); }
|
||||
/** Construct a vector with one element, which is moved into it. */
|
||||
template<typename T>
|
||||
std::vector<T> Singleton(T elem)
|
||||
{
|
||||
std::vector<T> ret;
|
||||
ret.emplace_back(std::move(elem));
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** A parsed addr(A) descriptor. */
|
||||
class AddressDescriptor final : public DescriptorImpl
|
||||
{
|
||||
const CTxDestination m_destination;
|
||||
protected:
|
||||
std::string ToStringExtra() const override { return EncodeDestination(m_destination); }
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(m_destination)); }
|
||||
public:
|
||||
AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, {}, "addr"), m_destination(std::move(destination)) {}
|
||||
bool IsSolvable() const final { return false; }
|
||||
};
|
||||
|
||||
/** A parsed raw(H) descriptor. */
|
||||
class RawDescriptor final : public DescriptorImpl
|
||||
{
|
||||
const CScript m_script;
|
||||
protected:
|
||||
std::string ToStringExtra() const override { return HexStr(m_script.begin(), m_script.end()); }
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript*, FlatSigningProvider&) const override { return Singleton(m_script); }
|
||||
public:
|
||||
RawDescriptor(CScript script) : DescriptorImpl({}, {}, "raw"), m_script(std::move(script)) {}
|
||||
bool IsSolvable() const final { return false; }
|
||||
};
|
||||
|
||||
/** A parsed pk(P) descriptor. */
|
||||
class PKDescriptor final : public DescriptorImpl
|
||||
{
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForRawPubKey(keys[0])); }
|
||||
public:
|
||||
PKDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "pk") {}
|
||||
};
|
||||
|
||||
/** A parsed pkh(P) descriptor. */
|
||||
class PKHDescriptor final : public DescriptorImpl
|
||||
{
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(keys[0].GetID())); }
|
||||
public:
|
||||
PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "pkh") {}
|
||||
};
|
||||
|
||||
/** A parsed wpkh(P) descriptor. */
|
||||
class WPKHDescriptor final : public DescriptorImpl
|
||||
{
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(WitnessV0KeyHash(keys[0].GetID()))); }
|
||||
public:
|
||||
WPKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "wpkh") {}
|
||||
};
|
||||
|
||||
/** A parsed combo(P) descriptor. */
|
||||
class ComboDescriptor final : public Descriptor
|
||||
class ComboDescriptor final : public DescriptorImpl
|
||||
{
|
||||
std::unique_ptr<PubkeyProvider> m_provider;
|
||||
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider& out) const override
|
||||
{
|
||||
std::vector<CScript> ret;
|
||||
CKeyID id = keys[0].GetID();
|
||||
ret.emplace_back(GetScriptForRawPubKey(keys[0])); // P2PK
|
||||
ret.emplace_back(GetScriptForDestination(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(CScriptID(p2wpkh))); // P2SH-P2WPKH
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
public:
|
||||
ComboDescriptor(std::unique_ptr<PubkeyProvider> provider) : m_provider(std::move(provider)) {}
|
||||
ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "combo") {}
|
||||
};
|
||||
|
||||
bool IsRange() const override { return m_provider->IsRange(); }
|
||||
bool IsSolvable() const override { return true; }
|
||||
std::string ToString() const override { return "combo(" + m_provider->ToString() + ")"; }
|
||||
bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
|
||||
{
|
||||
std::string ret;
|
||||
if (!m_provider->ToPrivateString(arg, ret)) return false;
|
||||
out = "combo(" + std::move(ret) + ")";
|
||||
return true;
|
||||
}
|
||||
bool Expand(int pos, const SigningProvider& arg, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const override
|
||||
{
|
||||
CPubKey key;
|
||||
KeyOriginInfo info;
|
||||
if (!m_provider->GetPubKey(pos, arg, key, info)) return false;
|
||||
CKeyID keyid = key.GetID();
|
||||
{
|
||||
CScript p2pk = GetScriptForRawPubKey(key);
|
||||
CScript p2pkh = GetScriptForDestination(keyid);
|
||||
output_scripts = std::vector<CScript>{std::move(p2pk), std::move(p2pkh)};
|
||||
out.pubkeys.emplace(keyid, key);
|
||||
out.origins.emplace(keyid, std::move(info));
|
||||
}
|
||||
if (key.IsCompressed()) {
|
||||
CScript p2wpkh = GetScriptForDestination(WitnessV0KeyHash(keyid));
|
||||
CScriptID p2wpkh_id(p2wpkh);
|
||||
CScript p2sh_p2wpkh = GetScriptForDestination(p2wpkh_id);
|
||||
out.scripts.emplace(p2wpkh_id, p2wpkh);
|
||||
output_scripts.push_back(std::move(p2wpkh));
|
||||
output_scripts.push_back(std::move(p2sh_p2wpkh));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
/** A parsed multi(...) descriptor. */
|
||||
class MultisigDescriptor final : public DescriptorImpl
|
||||
{
|
||||
const int m_threshold;
|
||||
protected:
|
||||
std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForMultisig(m_threshold, keys)); }
|
||||
public:
|
||||
MultisigDescriptor(int threshold, std::vector<std::unique_ptr<PubkeyProvider>> providers) : DescriptorImpl(std::move(providers), {}, "multi"), m_threshold(threshold) {}
|
||||
};
|
||||
|
||||
/** A parsed sh(...) descriptor. */
|
||||
class SHDescriptor final : public DescriptorImpl
|
||||
{
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript* script, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(CScriptID(*script))); }
|
||||
public:
|
||||
SHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "sh") {}
|
||||
};
|
||||
|
||||
/** A parsed wsh(...) descriptor. */
|
||||
class WSHDescriptor final : public DescriptorImpl
|
||||
{
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript* script, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(WitnessV0ScriptHash(*script))); }
|
||||
public:
|
||||
WSHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "wsh") {}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -562,18 +606,18 @@ std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char>& sp, bool per
|
|||
}
|
||||
|
||||
/** Parse a script in a particular context. */
|
||||
std::unique_ptr<Descriptor> ParseScript(Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out)
|
||||
std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out)
|
||||
{
|
||||
auto expr = Expr(sp);
|
||||
if (Func("pk", expr)) {
|
||||
auto pubkey = ParsePubkey(expr, ctx != ParseScriptContext::P2WSH, out);
|
||||
if (!pubkey) return nullptr;
|
||||
return MakeUnique<SingleKeyDescriptor>(std::move(pubkey), P2PKGetScript, "pk");
|
||||
return MakeUnique<PKDescriptor>(std::move(pubkey));
|
||||
}
|
||||
if (Func("pkh", expr)) {
|
||||
auto pubkey = ParsePubkey(expr, ctx != ParseScriptContext::P2WSH, out);
|
||||
if (!pubkey) return nullptr;
|
||||
return MakeUnique<SingleKeyDescriptor>(std::move(pubkey), P2PKHGetScript, "pkh");
|
||||
return MakeUnique<PKHDescriptor>(std::move(pubkey));
|
||||
}
|
||||
if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
|
||||
auto pubkey = ParsePubkey(expr, true, out);
|
||||
|
|
@ -606,17 +650,17 @@ std::unique_ptr<Descriptor> ParseScript(Span<const char>& sp, ParseScriptContext
|
|||
if (ctx != ParseScriptContext::P2WSH && Func("wpkh", expr)) {
|
||||
auto pubkey = ParsePubkey(expr, false, out);
|
||||
if (!pubkey) return nullptr;
|
||||
return MakeUnique<SingleKeyDescriptor>(std::move(pubkey), P2WPKHGetScript, "wpkh");
|
||||
return MakeUnique<WPKHDescriptor>(std::move(pubkey));
|
||||
}
|
||||
if (ctx == ParseScriptContext::TOP && Func("sh", expr)) {
|
||||
auto desc = ParseScript(expr, ParseScriptContext::P2SH, out);
|
||||
if (!desc || expr.size()) return nullptr;
|
||||
return MakeUnique<ConvertorDescriptor>(std::move(desc), ConvertP2SH, "sh");
|
||||
return MakeUnique<SHDescriptor>(std::move(desc));
|
||||
}
|
||||
if (ctx != ParseScriptContext::P2WSH && Func("wsh", expr)) {
|
||||
auto desc = ParseScript(expr, ParseScriptContext::P2WSH, out);
|
||||
if (!desc || expr.size()) return nullptr;
|
||||
return MakeUnique<ConvertorDescriptor>(std::move(desc), ConvertP2WSH, "wsh");
|
||||
return MakeUnique<WSHDescriptor>(std::move(desc));
|
||||
}
|
||||
if (ctx == ParseScriptContext::TOP && Func("addr", expr)) {
|
||||
CTxDestination dest = DecodeDestination(std::string(expr.begin(), expr.end()));
|
||||
|
|
@ -642,7 +686,7 @@ std::unique_ptr<PubkeyProvider> InferPubkey(const CPubKey& pubkey, ParseScriptCo
|
|||
return key_provider;
|
||||
}
|
||||
|
||||
std::unique_ptr<Descriptor> InferScript(const CScript& script, ParseScriptContext ctx, const SigningProvider& provider)
|
||||
std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptContext ctx, const SigningProvider& provider)
|
||||
{
|
||||
std::vector<std::vector<unsigned char>> data;
|
||||
txnouttype txntype = Solver(script, data);
|
||||
|
|
@ -650,7 +694,7 @@ std::unique_ptr<Descriptor> InferScript(const CScript& script, ParseScriptContex
|
|||
if (txntype == TX_PUBKEY) {
|
||||
CPubKey pubkey(data[0].begin(), data[0].end());
|
||||
if (pubkey.IsValid()) {
|
||||
return MakeUnique<SingleKeyDescriptor>(InferPubkey(pubkey, ctx, provider), P2PKGetScript, "pk");
|
||||
return MakeUnique<PKDescriptor>(InferPubkey(pubkey, ctx, provider));
|
||||
}
|
||||
}
|
||||
if (txntype == TX_PUBKEYHASH) {
|
||||
|
|
@ -658,7 +702,7 @@ std::unique_ptr<Descriptor> InferScript(const CScript& script, ParseScriptContex
|
|||
CKeyID keyid(hash);
|
||||
CPubKey pubkey;
|
||||
if (provider.GetPubKey(keyid, pubkey)) {
|
||||
return MakeUnique<SingleKeyDescriptor>(InferPubkey(pubkey, ctx, provider), P2PKHGetScript, "pkh");
|
||||
return MakeUnique<PKHDescriptor>(InferPubkey(pubkey, ctx, provider));
|
||||
}
|
||||
}
|
||||
if (txntype == TX_WITNESS_V0_KEYHASH && ctx != ParseScriptContext::P2WSH) {
|
||||
|
|
@ -666,7 +710,7 @@ std::unique_ptr<Descriptor> InferScript(const CScript& script, ParseScriptContex
|
|||
CKeyID keyid(hash);
|
||||
CPubKey pubkey;
|
||||
if (provider.GetPubKey(keyid, pubkey)) {
|
||||
return MakeUnique<SingleKeyDescriptor>(InferPubkey(pubkey, ctx, provider), P2WPKHGetScript, "wpkh");
|
||||
return MakeUnique<WPKHDescriptor>(InferPubkey(pubkey, ctx, provider));
|
||||
}
|
||||
}
|
||||
if (txntype == TX_MULTISIG) {
|
||||
|
|
@ -683,7 +727,7 @@ std::unique_ptr<Descriptor> InferScript(const CScript& script, ParseScriptContex
|
|||
CScript subscript;
|
||||
if (provider.GetCScript(scriptid, subscript)) {
|
||||
auto sub = InferScript(subscript, ParseScriptContext::P2SH, provider);
|
||||
if (sub) return MakeUnique<ConvertorDescriptor>(std::move(sub), ConvertP2SH, "sh");
|
||||
if (sub) return MakeUnique<SHDescriptor>(std::move(sub));
|
||||
}
|
||||
}
|
||||
if (txntype == TX_WITNESS_V0_SCRIPTHASH && ctx != ParseScriptContext::P2WSH) {
|
||||
|
|
@ -692,7 +736,7 @@ std::unique_ptr<Descriptor> InferScript(const CScript& script, ParseScriptContex
|
|||
CScript subscript;
|
||||
if (provider.GetCScript(scriptid, subscript)) {
|
||||
auto sub = InferScript(subscript, ParseScriptContext::P2WSH, provider);
|
||||
if (sub) return MakeUnique<ConvertorDescriptor>(std::move(sub), ConvertP2WSH, "wsh");
|
||||
if (sub) return MakeUnique<WSHDescriptor>(std::move(sub));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -712,7 +756,7 @@ std::unique_ptr<Descriptor> Parse(const std::string& descriptor, FlatSigningProv
|
|||
{
|
||||
Span<const char> sp(descriptor.data(), descriptor.size());
|
||||
auto ret = ParseScript(sp, ParseScriptContext::TOP, out);
|
||||
if (sp.size() == 0 && ret) return ret;
|
||||
if (sp.size() == 0 && ret) return std::unique_ptr<Descriptor>(std::move(ret));
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -48,8 +48,18 @@ struct Descriptor {
|
|||
* provider: the provider to query for private keys in case of hardened derivation.
|
||||
* output_script: the expanded scriptPubKeys will be put here.
|
||||
* out: scripts and public keys necessary for solving the expanded scriptPubKeys will be put here (may be equal to provider).
|
||||
* cache: vector which will be overwritten with cache data necessary to-evaluate the descriptor at this point without access to private keys.
|
||||
*/
|
||||
virtual bool Expand(int pos, const SigningProvider& provider, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const = 0;
|
||||
virtual bool Expand(int pos, const SigningProvider& provider, std::vector<CScript>& output_scripts, FlatSigningProvider& out, std::vector<unsigned char>* cache = nullptr) const = 0;
|
||||
|
||||
/** Expand a descriptor at a specified position using cached expansion data.
|
||||
*
|
||||
* pos: the position at which to expand the descriptor. If IsRange() is false, this is ignored.
|
||||
* cache: vector from which cached expansion data will be read.
|
||||
* output_script: the expanded scriptPubKeys will be put here.
|
||||
* out: scripts and public keys necessary for solving the expanded scriptPubKeys will be put here (may be equal to provider).
|
||||
*/
|
||||
virtual bool ExpandFromCache(int pos, const std::vector<unsigned char>& cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out) const = 0;
|
||||
};
|
||||
|
||||
/** Parse a descriptor string. Included private keys are put in out. Returns nullptr if parsing fails. */
|
||||
|
|
|
|||
|
|
@ -705,5 +705,7 @@ FlatSigningProvider Merge(const FlatSigningProvider& a, const FlatSigningProvide
|
|||
ret.pubkeys.insert(b.pubkeys.begin(), b.pubkeys.end());
|
||||
ret.keys = a.keys;
|
||||
ret.keys.insert(b.keys.begin(), b.keys.end());
|
||||
ret.origins = a.origins;
|
||||
ret.origins.insert(b.origins.begin(), b.origins.end());
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -79,19 +79,42 @@ void Check(const std::string& prv, const std::string& pub, int flags, const std:
|
|||
BOOST_CHECK_EQUAL(parse_pub->IsRange(), (flags & RANGE) != 0);
|
||||
BOOST_CHECK_EQUAL(parse_priv->IsRange(), (flags & RANGE) != 0);
|
||||
|
||||
|
||||
// Is not ranged descriptor, only a single result is expected.
|
||||
// * For ranged descriptors, the `scripts` parameter is a list of expected result outputs, for subsequent
|
||||
// positions to evaluate the descriptors on (so the first element of `scripts` is for evaluating the
|
||||
// descriptor at 0; the second at 1; and so on). To verify this, we evaluate the descriptors once for
|
||||
// each element in `scripts`.
|
||||
// * For non-ranged descriptors, we evaluate the descriptors at positions 0, 1, and 2, but expect the
|
||||
// same result in each case, namely the first element of `scripts`. Because of that, the size of
|
||||
// `scripts` must be one in that case.
|
||||
if (!(flags & RANGE)) assert(scripts.size() == 1);
|
||||
|
||||
size_t max = (flags & RANGE) ? scripts.size() : 3;
|
||||
|
||||
// Iterate over the position we'll evaluate the descriptors in.
|
||||
for (size_t i = 0; i < max; ++i) {
|
||||
// Call the expected result scripts `ref`.
|
||||
const auto& ref = scripts[(flags & RANGE) ? i : 0];
|
||||
// When t=0, evaluate the `prv` descriptor; when t=1, evaluate the `pub` descriptor.
|
||||
for (int t = 0; t < 2; ++t) {
|
||||
// When the descriptor is hardened, evaluate with access to the private keys inside.
|
||||
const FlatSigningProvider& key_provider = (flags & HARDENED) ? keys_priv : keys_pub;
|
||||
FlatSigningProvider script_provider;
|
||||
std::vector<CScript> spks;
|
||||
BOOST_CHECK((t ? parse_priv : parse_pub)->Expand(i, key_provider, spks, script_provider));
|
||||
|
||||
// Evaluate the descriptor selected by `t` in poisition `i`.
|
||||
FlatSigningProvider script_provider, script_provider_cached;
|
||||
std::vector<CScript> spks, spks_cached;
|
||||
std::vector<unsigned char> cache;
|
||||
BOOST_CHECK((t ? parse_priv : parse_pub)->Expand(i, key_provider, spks, script_provider, &cache));
|
||||
|
||||
// Compare the output with the expected result.
|
||||
BOOST_CHECK_EQUAL(spks.size(), ref.size());
|
||||
|
||||
// Try to expand again using cached data, and compare.
|
||||
BOOST_CHECK(parse_pub->ExpandFromCache(i, cache, spks_cached, script_provider_cached));
|
||||
BOOST_CHECK(spks == spks_cached);
|
||||
BOOST_CHECK(script_provider.pubkeys == script_provider_cached.pubkeys);
|
||||
BOOST_CHECK(script_provider.scripts == script_provider_cached.scripts);
|
||||
BOOST_CHECK(script_provider.origins == script_provider_cached.origins);
|
||||
|
||||
// For each of the produced scripts, verify solvability, and when possible, try to sign a transaction spending it.
|
||||
for (size_t n = 0; n < spks.size(); ++n) {
|
||||
BOOST_CHECK_EQUAL(ref[n], HexStr(spks[n].begin(), spks[n].end()));
|
||||
BOOST_CHECK_EQUAL(IsSolvable(Merge(key_provider, script_provider), spks[n]), (flags & UNSOLVABLE) == 0);
|
||||
|
|
@ -123,6 +146,7 @@ void Check(const std::string& prv, const std::string& pub, int flags, const std:
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Verify no expected paths remain that were not observed.
|
||||
BOOST_CHECK_MESSAGE(left_paths.empty(), "Not all expected key paths found: " + prv);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue