mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-19 13:27:35 +02:00
Merge c7dd9ff71b into merged_master (Bitcoin PR bitcoin/bitcoin#22051)
Does the bare minimum to introduce Taproot wallet support with CT; just adds a CPubKey blinding_pubkey to the taproot destination variant and updates some visitors. In future when we define blech32 we will need to make sure we are using that encoding and using the pubkey.
This commit is contained in:
Andrew Poelstra
commit
3ffb9aa14f
17 changed files with 876 additions and 55 deletions
|
|
@ -241,9 +241,10 @@ public:
|
|||
class ConstPubkeyProvider final : public PubkeyProvider
|
||||
{
|
||||
CPubKey m_pubkey;
|
||||
bool m_xonly;
|
||||
|
||||
public:
|
||||
ConstPubkeyProvider(uint32_t exp_index, const CPubKey& pubkey) : PubkeyProvider(exp_index), m_pubkey(pubkey) {}
|
||||
ConstPubkeyProvider(uint32_t exp_index, const CPubKey& pubkey, bool xonly = false) : 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) override
|
||||
{
|
||||
key = m_pubkey;
|
||||
|
|
@ -254,7 +255,7 @@ public:
|
|||
}
|
||||
bool IsRange() const override { return false; }
|
||||
size_t GetSize() const override { return m_pubkey.size(); }
|
||||
std::string ToString() const override { return HexStr(m_pubkey); }
|
||||
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;
|
||||
|
|
@ -505,6 +506,7 @@ protected:
|
|||
public:
|
||||
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)) {}
|
||||
|
||||
bool IsSolvable() const override
|
||||
{
|
||||
|
|
@ -638,6 +640,20 @@ public:
|
|||
std::optional<OutputType> GetOutputType() const override { return std::nullopt; }
|
||||
};
|
||||
|
||||
static std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
|
||||
if (std::holds_alternative<PKHash>(dest) ||
|
||||
std::holds_alternative<ScriptHash>(dest)) {
|
||||
return OutputType::LEGACY;
|
||||
}
|
||||
if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
|
||||
std::holds_alternative<WitnessV0ScriptHash>(dest) ||
|
||||
std::holds_alternative<WitnessV1Taproot>(dest) ||
|
||||
std::holds_alternative<WitnessUnknown>(dest)) {
|
||||
return OutputType::BECH32;
|
||||
}
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
/** A parsed addr(A) descriptor. */
|
||||
class AddressDescriptor final : public DescriptorImpl
|
||||
{
|
||||
|
|
@ -651,15 +667,7 @@ public:
|
|||
|
||||
std::optional<OutputType> GetOutputType() const override
|
||||
{
|
||||
switch (m_destination.index()) {
|
||||
case 1 /* PKHash */:
|
||||
case 2 /* ScriptHash */: return OutputType::LEGACY;
|
||||
case 3 /* WitnessV0ScriptHash */:
|
||||
case 4 /* WitnessV0KeyHash */:
|
||||
case 5 /* WitnessUnknown */: return OutputType::BECH32;
|
||||
case 0 /* CNoDestination */:
|
||||
default: return std::nullopt;
|
||||
}
|
||||
return OutputTypeFromDestination(m_destination);
|
||||
}
|
||||
bool IsSingleType() const final { return true; }
|
||||
};
|
||||
|
|
@ -679,15 +687,7 @@ public:
|
|||
{
|
||||
CTxDestination dest;
|
||||
ExtractDestination(m_script, dest);
|
||||
switch (dest.index()) {
|
||||
case 1 /* PKHash */:
|
||||
case 2 /* ScriptHash */: return OutputType::LEGACY;
|
||||
case 3 /* WitnessV0ScriptHash */:
|
||||
case 4 /* WitnessV0KeyHash */:
|
||||
case 5 /* WitnessUnknown */: return OutputType::BECH32;
|
||||
case 0 /* CNoDestination */:
|
||||
default: return std::nullopt;
|
||||
}
|
||||
return OutputTypeFromDestination(dest);
|
||||
}
|
||||
bool IsSingleType() const final { return true; }
|
||||
};
|
||||
|
|
@ -695,10 +695,20 @@ public:
|
|||
/** A parsed pk(P) descriptor. */
|
||||
class PKDescriptor final : public DescriptorImpl
|
||||
{
|
||||
private:
|
||||
const bool m_xonly;
|
||||
protected:
|
||||
std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider&) const override { return Vector(GetScriptForRawPubKey(keys[0])); }
|
||||
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]));
|
||||
}
|
||||
}
|
||||
public:
|
||||
PKDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Vector(std::move(prov)), "pk") {}
|
||||
PKDescriptor(std::unique_ptr<PubkeyProvider> prov, bool xonly = false) : DescriptorImpl(Vector(std::move(prov)), "pk"), m_xonly(xonly) {}
|
||||
bool IsSingleType() const final { return true; }
|
||||
};
|
||||
|
||||
|
|
@ -816,6 +826,56 @@ public:
|
|||
bool IsSingleType() const final { return true; }
|
||||
};
|
||||
|
||||
/** A parsed tr(...) descriptor. */
|
||||
class TRDescriptor final : public DescriptorImpl
|
||||
{
|
||||
std::vector<int> m_depths;
|
||||
protected:
|
||||
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);
|
||||
return Vector(GetScriptForDestination(builder.GetOutput()));
|
||||
}
|
||||
bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, bool priv, bool normalized) 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, priv, normalized)) 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;
|
||||
}
|
||||
public:
|
||||
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::BECH32; }
|
||||
bool IsSingleType() const final { return true; }
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Parser //
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -825,6 +885,7 @@ enum class ParseScriptContext {
|
|||
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)
|
||||
};
|
||||
|
||||
/** Parse a key path, being passed a split list of elements (the first element is ignored). */
|
||||
|
|
@ -873,6 +934,13 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(uint32_t key_exp_index, const S
|
|||
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;
|
||||
|
|
@ -960,13 +1028,16 @@ std::unique_ptr<DescriptorImpl> ParseScript(uint32_t& key_exp_index, Span<const
|
|||
auto pubkey = ParsePubkey(key_exp_index, expr, ctx, out, error);
|
||||
if (!pubkey) return nullptr;
|
||||
++key_exp_index;
|
||||
return std::make_unique<PKDescriptor>(std::move(pubkey));
|
||||
return std::make_unique<PKDescriptor>(std::move(pubkey), ctx == ParseScriptContext::P2TR);
|
||||
}
|
||||
if (Func("pkh", expr)) {
|
||||
if ((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH) && Func("pkh", expr)) {
|
||||
auto pubkey = ParsePubkey(key_exp_index, expr, ctx, out, error);
|
||||
if (!pubkey) return nullptr;
|
||||
++key_exp_index;
|
||||
return std::make_unique<PKHDescriptor>(std::move(pubkey));
|
||||
} else if (Func("pkh", expr)) {
|
||||
error = "Can only have pkh at top level, in sh(), or in wsh()";
|
||||
return nullptr;
|
||||
}
|
||||
if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
|
||||
auto pubkey = ParsePubkey(key_exp_index, expr, ctx, out, error);
|
||||
|
|
@ -977,7 +1048,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(uint32_t& key_exp_index, Span<const
|
|||
error = "Can only have combo() at top level";
|
||||
return nullptr;
|
||||
}
|
||||
if ((sorted_multi = Func("sortedmulti", expr)) || Func("multi", expr)) {
|
||||
if ((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH || ctx == ParseScriptContext::P2WSH) && ((sorted_multi = Func("sortedmulti", expr)) || Func("multi", expr))) {
|
||||
auto threshold = Expr(expr);
|
||||
uint32_t thres;
|
||||
std::vector<std::unique_ptr<PubkeyProvider>> providers;
|
||||
|
|
@ -1022,6 +1093,9 @@ std::unique_ptr<DescriptorImpl> ParseScript(uint32_t& key_exp_index, Span<const
|
|||
}
|
||||
}
|
||||
return std::make_unique<MultisigDescriptor>(thres, std::move(providers), sorted_multi);
|
||||
} else if (Func("sortedmulti", expr) || Func("multi", expr)) {
|
||||
error = "Can only have multi/sortedmulti at top level, in sh(), or in wsh()";
|
||||
return nullptr;
|
||||
}
|
||||
if ((ctx == ParseScriptContext::TOP || ctx == ParseScriptContext::P2SH) && Func("wpkh", expr)) {
|
||||
auto pubkey = ParsePubkey(key_exp_index, expr, ParseScriptContext::P2WPKH, out, error);
|
||||
|
|
@ -1059,6 +1133,67 @@ std::unique_ptr<DescriptorImpl> ParseScript(uint32_t& key_exp_index, Span<const
|
|||
error = "Can only have addr() at top level";
|
||||
return nullptr;
|
||||
}
|
||||
if (ctx == ParseScriptContext::TOP && Func("tr", expr)) {
|
||||
auto arg = Expr(expr);
|
||||
auto internal_key = ParsePubkey(key_exp_index, arg, ParseScriptContext::P2TR, out, error);
|
||||
if (!internal_key) return nullptr;
|
||||
++key_exp_index;
|
||||
std::vector<std::unique_ptr<DescriptorImpl>> subscripts; //!< list of script subexpressions
|
||||
std::vector<int> depths; //!< depth in the tree of each subexpression (same length subscripts)
|
||||
if (expr.size()) {
|
||||
if (!Const(",", expr)) {
|
||||
error = strprintf("tr: expected ',', got '%c'", expr[0]);
|
||||
return nullptr;
|
||||
}
|
||||
/** The path from the top of the tree to what we're currently processing.
|
||||
* branches[i] == false: left branch in the i'th step from the top; true: right branch.
|
||||
*/
|
||||
std::vector<bool> branches;
|
||||
// Loop over all provided scripts. In every iteration exactly one script will be processed.
|
||||
// Use a do-loop because inside this if-branch we expect at least one script.
|
||||
do {
|
||||
// First process all open braces.
|
||||
while (Const("{", expr)) {
|
||||
branches.push_back(false); // new left branch
|
||||
if (branches.size() > TAPROOT_CONTROL_MAX_NODE_COUNT) {
|
||||
error = strprintf("tr() supports at most %i nesting levels", TAPROOT_CONTROL_MAX_NODE_COUNT);
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
// Process the actual script expression.
|
||||
auto sarg = Expr(expr);
|
||||
subscripts.emplace_back(ParseScript(key_exp_index, sarg, ParseScriptContext::P2TR, out, error));
|
||||
if (!subscripts.back()) return nullptr;
|
||||
depths.push_back(branches.size());
|
||||
// Process closing braces; one is expected for every right branch we were in.
|
||||
while (branches.size() && branches.back()) {
|
||||
if (!Const("}", expr)) {
|
||||
error = strprintf("tr(): expected '}' after script expression");
|
||||
return nullptr;
|
||||
}
|
||||
branches.pop_back(); // move up one level after encountering '}'
|
||||
}
|
||||
// If after that, we're at the end of a left branch, expect a comma.
|
||||
if (branches.size() && !branches.back()) {
|
||||
if (!Const(",", expr)) {
|
||||
error = strprintf("tr(): expected ',' after script expression");
|
||||
return nullptr;
|
||||
}
|
||||
branches.back() = true; // And now we're in a right branch.
|
||||
}
|
||||
} while (branches.size());
|
||||
// After we've explored a whole tree, we must be at the end of the expression.
|
||||
if (expr.size()) {
|
||||
error = strprintf("tr(): expected ')' after script expression");
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
assert(TaprootBuilder::ValidDepths(depths));
|
||||
return std::make_unique<TRDescriptor>(std::move(internal_key), std::move(subscripts), std::move(depths));
|
||||
} else if (Func("tr", expr)) {
|
||||
error = "Can only have tr at top level";
|
||||
return nullptr;
|
||||
}
|
||||
if (ctx == ParseScriptContext::TOP && Func("raw", expr)) {
|
||||
std::string str(expr.begin(), expr.end());
|
||||
if (!IsHex(str)) {
|
||||
|
|
|
|||
|
|
@ -1907,9 +1907,8 @@ template PrecomputedTransactionData::PrecomputedTransactionData(const CTransacti
|
|||
template PrecomputedTransactionData::PrecomputedTransactionData(const CMutableTransaction& txTo);
|
||||
|
||||
static const CHashWriter HASHER_TAPSIGHASH = TaggedHash("TapSighash");
|
||||
static const CHashWriter HASHER_TAPLEAF = TaggedHash("TapLeaf");
|
||||
static const CHashWriter HASHER_TAPBRANCH = TaggedHash("TapBranch");
|
||||
static const CHashWriter HASHER_TAPTWEAK = TaggedHash("TapTweak");
|
||||
const CHashWriter HASHER_TAPLEAF = TaggedHash("TapLeaf");
|
||||
const CHashWriter HASHER_TAPBRANCH = TaggedHash("TapBranch");
|
||||
|
||||
static bool HandleMissingData(MissingDataBehavior mdb)
|
||||
{
|
||||
|
|
@ -2330,10 +2329,8 @@ static bool VerifyTaprootCommitment(const std::vector<unsigned char>& control, c
|
|||
}
|
||||
k = ss_branch.GetSHA256();
|
||||
}
|
||||
// Compute the tweak from the Merkle root and the internal pubkey.
|
||||
k = (CHashWriter(HASHER_TAPTWEAK) << MakeSpan(p) << k).GetSHA256();
|
||||
// Verify that the output pubkey matches the tweaked internal pubkey, after correcting for parity.
|
||||
return q.CheckPayToContract(p, k, control[0] & 1);
|
||||
return q.CheckTapTweak(p, k, control[0] & 1);
|
||||
}
|
||||
|
||||
static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion, const std::vector<unsigned char>& program, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* serror, bool is_p2sh)
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#ifndef BITCOIN_SCRIPT_INTERPRETER_H
|
||||
#define BITCOIN_SCRIPT_INTERPRETER_H
|
||||
|
||||
#include <hash.h>
|
||||
#include <script/script_error.h>
|
||||
#include <span.h>
|
||||
#include <primitives/transaction.h>
|
||||
|
|
@ -232,6 +233,9 @@ static constexpr size_t TAPROOT_CONTROL_NODE_SIZE = 32;
|
|||
static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT = 128;
|
||||
static constexpr size_t TAPROOT_CONTROL_MAX_SIZE = TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
|
||||
|
||||
extern const CHashWriter HASHER_TAPLEAF; //!< Hasher with tag "TapLeaf" pre-fed to it.
|
||||
extern const CHashWriter HASHER_TAPBRANCH; //!< Hasher with tag "TapBranch" pre-fed to it.
|
||||
|
||||
template <class T>
|
||||
uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn, int nHashType, const CConfidentialValue& amount, SigVersion sigversion, unsigned int flags, const PrecomputedTransactionData* cache = nullptr);
|
||||
|
||||
|
|
|
|||
|
|
@ -7,8 +7,11 @@
|
|||
|
||||
#include <chainparams.h>
|
||||
#include <crypto/sha256.h>
|
||||
#include <hash.h>
|
||||
#include <pubkey.h>
|
||||
#include <script/interpreter.h>
|
||||
#include <script/script.h>
|
||||
#include <util/strencodings.h>
|
||||
|
||||
#include <string>
|
||||
|
||||
|
|
@ -178,15 +181,14 @@ TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned c
|
|||
std::vector<unsigned char> witnessprogram;
|
||||
if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
|
||||
if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
|
||||
vSolutionsRet.push_back(witnessprogram);
|
||||
vSolutionsRet.push_back(std::move(witnessprogram));
|
||||
return TxoutType::WITNESS_V0_KEYHASH;
|
||||
}
|
||||
if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
|
||||
vSolutionsRet.push_back(witnessprogram);
|
||||
vSolutionsRet.push_back(std::move(witnessprogram));
|
||||
return TxoutType::WITNESS_V0_SCRIPTHASH;
|
||||
}
|
||||
if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
|
||||
vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
|
||||
vSolutionsRet.push_back(std::move(witnessprogram));
|
||||
return TxoutType::WITNESS_V1_TAPROOT;
|
||||
}
|
||||
|
|
@ -265,8 +267,13 @@ bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
|
|||
addressRet = hash;
|
||||
return true;
|
||||
}
|
||||
case TxoutType::WITNESS_UNKNOWN:
|
||||
case TxoutType::WITNESS_V1_TAPROOT: {
|
||||
WitnessV1Taproot tap;
|
||||
std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
|
||||
addressRet = tap;
|
||||
return true;
|
||||
}
|
||||
case TxoutType::WITNESS_UNKNOWN: {
|
||||
WitnessUnknown unk;
|
||||
unk.version = vSolutions[0][0];
|
||||
std::copy(vSolutions[1].begin(), vSolutions[1].end(), unk.program);
|
||||
|
|
@ -354,6 +361,11 @@ public:
|
|||
return CScript() << OP_0 << ToByteVector(id);
|
||||
}
|
||||
|
||||
CScript operator()(const WitnessV1Taproot& tap) const
|
||||
{
|
||||
return CScript() << OP_1 << ToByteVector(tap);
|
||||
}
|
||||
|
||||
CScript operator()(const WitnessUnknown& id) const
|
||||
{
|
||||
return CScript() << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
|
||||
|
|
@ -395,3 +407,99 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
|
|||
bool IsValidDestination(const CTxDestination& dest) {
|
||||
return dest.index() != 0;
|
||||
}
|
||||
|
||||
/*static*/ TaprootBuilder::NodeInfo TaprootBuilder::Combine(NodeInfo&& a, NodeInfo&& b)
|
||||
{
|
||||
NodeInfo ret;
|
||||
/* Lexicographically sort a and b's hash, and compute parent hash. */
|
||||
if (a.hash < b.hash) {
|
||||
ret.hash = (CHashWriter(HASHER_TAPBRANCH) << a.hash << b.hash).GetSHA256();
|
||||
} else {
|
||||
ret.hash = (CHashWriter(HASHER_TAPBRANCH) << b.hash << a.hash).GetSHA256();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
|
||||
{
|
||||
assert(depth >= 0 && (size_t)depth <= TAPROOT_CONTROL_MAX_NODE_COUNT);
|
||||
/* We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
|
||||
* so would mean the Add() invocations do not correspond to a DFS traversal of a
|
||||
* binary tree. */
|
||||
if ((size_t)depth + 1 < m_branch.size()) {
|
||||
m_valid = false;
|
||||
return;
|
||||
}
|
||||
/* As long as an entry in the branch exists at the specified depth, combine it and propagate up.
|
||||
* The 'node' variable is overwritten here with the newly combined node. */
|
||||
while (m_valid && m_branch.size() > (size_t)depth && m_branch[depth].has_value()) {
|
||||
node = Combine(std::move(node), std::move(*m_branch[depth]));
|
||||
m_branch.pop_back();
|
||||
if (depth == 0) m_valid = false; /* Can't propagate further up than the root */
|
||||
--depth;
|
||||
}
|
||||
if (m_valid) {
|
||||
/* Make sure the branch is big enough to place the new node. */
|
||||
if (m_branch.size() <= (size_t)depth) m_branch.resize((size_t)depth + 1);
|
||||
assert(!m_branch[depth].has_value());
|
||||
m_branch[depth] = std::move(node);
|
||||
}
|
||||
}
|
||||
|
||||
/*static*/ bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
|
||||
{
|
||||
std::vector<bool> branch;
|
||||
for (int depth : depths) {
|
||||
// This inner loop corresponds to effectively the same logic on branch
|
||||
// as what Insert() performs on the m_branch variable. Instead of
|
||||
// storing a NodeInfo object, just remember whether or not there is one
|
||||
// at that depth.
|
||||
if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
|
||||
if ((size_t)depth + 1 < branch.size()) return false;
|
||||
while (branch.size() > (size_t)depth && branch[depth]) {
|
||||
branch.pop_back();
|
||||
if (depth == 0) return false;
|
||||
--depth;
|
||||
}
|
||||
if (branch.size() <= (size_t)depth) branch.resize((size_t)depth + 1);
|
||||
assert(!branch[depth]);
|
||||
branch[depth] = true;
|
||||
}
|
||||
// And this check corresponds to the IsComplete() check on m_branch.
|
||||
return branch.size() == 0 || (branch.size() == 1 && branch[0]);
|
||||
}
|
||||
|
||||
TaprootBuilder& TaprootBuilder::Add(int depth, const CScript& script, int leaf_version)
|
||||
{
|
||||
assert((leaf_version & ~TAPROOT_LEAF_MASK) == 0);
|
||||
if (!IsValid()) return *this;
|
||||
/* Construct NodeInfo object with leaf hash. */
|
||||
NodeInfo node;
|
||||
node.hash = (CHashWriter{HASHER_TAPLEAF} << uint8_t(leaf_version) << script).GetSHA256();
|
||||
/* Insert into the branch. */
|
||||
Insert(std::move(node), depth);
|
||||
return *this;
|
||||
}
|
||||
|
||||
TaprootBuilder& TaprootBuilder::AddOmitted(int depth, const uint256& hash)
|
||||
{
|
||||
if (!IsValid()) return *this;
|
||||
/* Construct NodeInfo object with the hash directly, and insert it into the branch. */
|
||||
NodeInfo node;
|
||||
node.hash = hash;
|
||||
Insert(std::move(node), depth);
|
||||
return *this;
|
||||
}
|
||||
|
||||
TaprootBuilder& TaprootBuilder::Finalize(const XOnlyPubKey& internal_key)
|
||||
{
|
||||
/* Can only call this function when IsComplete() is true. */
|
||||
assert(IsComplete());
|
||||
m_internal_key = internal_key;
|
||||
auto ret = m_internal_key.CreateTapTweak(m_branch.size() == 0 ? nullptr : &m_branch[0]->hash);
|
||||
assert(ret.has_value());
|
||||
std::tie(m_output_key, std::ignore) = *ret;
|
||||
return *this;
|
||||
}
|
||||
|
||||
WitnessV1Taproot TaprootBuilder::GetOutput() { return WitnessV1Taproot{m_output_key}; }
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#ifndef BITCOIN_SCRIPT_STANDARD_H
|
||||
#define BITCOIN_SCRIPT_STANDARD_H
|
||||
|
||||
#include <pubkey.h>
|
||||
#include <script/interpreter.h>
|
||||
#include <uint256.h>
|
||||
#include <util/hash_type.h>
|
||||
|
|
@ -141,6 +142,13 @@ struct WitnessV0KeyHash : public BaseHash<uint160>
|
|||
};
|
||||
CKeyID ToKeyID(const WitnessV0KeyHash& key_hash);
|
||||
|
||||
struct WitnessV1Taproot : public XOnlyPubKey
|
||||
{
|
||||
WitnessV1Taproot() : XOnlyPubKey() {}
|
||||
explicit WitnessV1Taproot(const XOnlyPubKey& xpk) : XOnlyPubKey(xpk) {}
|
||||
CPubKey blinding_pubkey;
|
||||
};
|
||||
|
||||
//! CTxDestination subtype to encode any future Witness version
|
||||
struct WitnessUnknown
|
||||
{
|
||||
|
|
@ -192,6 +200,7 @@ public:
|
|||
void operator()(ScriptHash &dest) const { dest.blinding_pubkey = blinding_pubkey; }
|
||||
void operator()(WitnessV0KeyHash &dest) const { dest.blinding_pubkey = blinding_pubkey; }
|
||||
void operator()(WitnessV0ScriptHash &dest) const { dest.blinding_pubkey = blinding_pubkey; }
|
||||
void operator()(WitnessV1Taproot &dest) const { dest.blinding_pubkey = blinding_pubkey; }
|
||||
void operator()(WitnessUnknown &dest) const { dest.blinding_pubkey = blinding_pubkey; }
|
||||
void operator()(NullData &dest) const { }
|
||||
};
|
||||
|
|
@ -202,12 +211,12 @@ public:
|
|||
* * ScriptHash: TxoutType::SCRIPTHASH destination (P2SH)
|
||||
* * WitnessV0ScriptHash: TxoutType::WITNESS_V0_SCRIPTHASH destination (P2WSH)
|
||||
* * WitnessV0KeyHash: TxoutType::WITNESS_V0_KEYHASH destination (P2WPKH)
|
||||
* * WitnessUnknown: TxoutType::WITNESS_UNKNOWN/WITNESS_V1_TAPROOT destination (P2W???)
|
||||
* (taproot outputs do not require their own type as long as no wallet support exists)
|
||||
* * WitnessV1Taproot: TxoutType::WITNESS_V1_TAPROOT destination (P2TR)
|
||||
* * WitnessUnknown: TxoutType::WITNESS_UNKNOWN destination (P2W???)
|
||||
* * NullData: TxoutType::NULL_DATA destination (OP_RETURN)
|
||||
* A CTxDestination is the internal data type encoded in a bitcoin address
|
||||
*/
|
||||
using CTxDestination = std::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown, NullData>;
|
||||
using CTxDestination = std::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown, NullData>;
|
||||
|
||||
/** Check whether a CTxDestination is a CNoDestination. */
|
||||
bool IsValidDestination(const CTxDestination& dest);
|
||||
|
|
@ -263,4 +272,82 @@ CScript GetScriptForRawPubKey(const CPubKey& pubkey);
|
|||
/** Generate a multisig script. */
|
||||
CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);
|
||||
|
||||
/** Utility class to construct Taproot outputs from internal key and script tree. */
|
||||
class TaprootBuilder
|
||||
{
|
||||
private:
|
||||
/** Information associated with a node in the Merkle tree. */
|
||||
struct NodeInfo
|
||||
{
|
||||
/** Merkle hash of this node. */
|
||||
uint256 hash;
|
||||
};
|
||||
/** Whether the builder is in a valid state so far. */
|
||||
bool m_valid = true;
|
||||
|
||||
/** The current state of the builder.
|
||||
*
|
||||
* For each level in the tree, one NodeInfo object may be present. m_branch[0]
|
||||
* is information about the root; further values are for deeper subtrees being
|
||||
* explored.
|
||||
*
|
||||
* For every right branch taken to reach the position we're currently
|
||||
* working in, there will be a (non-nullopt) entry in m_branch corresponding
|
||||
* to the left branch at that level.
|
||||
*
|
||||
* For example, imagine this tree: - N0 -
|
||||
* / \
|
||||
* N1 N2
|
||||
* / \ / \
|
||||
* A B C N3
|
||||
* / \
|
||||
* D E
|
||||
*
|
||||
* Initially, m_branch is empty. After processing leaf A, it would become
|
||||
* {nullopt, nullopt, A}. When processing leaf B, an entry at level 2 already
|
||||
* exists, and it would thus be combined with it to produce a level 1 one,
|
||||
* resulting in {nullopt, N1}. Adding C and D takes us to {nullopt, N1, C}
|
||||
* and {nullopt, N1, C, D} respectively. When E is processed, it is combined
|
||||
* with D, and then C, and then N1, to produce the root, resulting in {N0}.
|
||||
*
|
||||
* This structure allows processing with just O(log n) overhead if the leaves
|
||||
* are computed on the fly.
|
||||
*
|
||||
* As an invariant, there can never be nullopt entries at the end. There can
|
||||
* also not be more than 128 entries (as that would mean more than 128 levels
|
||||
* in the tree). The depth of newly added entries will always be at least
|
||||
* equal to the current size of m_branch (otherwise it does not correspond
|
||||
* to a depth-first traversal of a tree). m_branch is only empty if no entries
|
||||
* have ever be processed. m_branch having length 1 corresponds to being done.
|
||||
*/
|
||||
std::vector<std::optional<NodeInfo>> m_branch;
|
||||
|
||||
XOnlyPubKey m_internal_key; //!< The internal key, set when finalizing.
|
||||
XOnlyPubKey m_output_key; //!< The output key, computed when finalizing. */
|
||||
|
||||
/** Combine information about a parent Merkle tree node from its child nodes. */
|
||||
static NodeInfo Combine(NodeInfo&& a, NodeInfo&& b);
|
||||
/** Insert information about a node at a certain depth, and propagate information up. */
|
||||
void Insert(NodeInfo&& node, int depth);
|
||||
|
||||
public:
|
||||
/** Add a new script at a certain depth in the tree. Add() operations must be called
|
||||
* in depth-first traversal order of binary tree. */
|
||||
TaprootBuilder& Add(int depth, const CScript& script, int leaf_version);
|
||||
/** Like Add(), but for a Merkle node with a given hash to the tree. */
|
||||
TaprootBuilder& AddOmitted(int depth, const uint256& hash);
|
||||
/** Finalize the construction. Can only be called when IsComplete() is true.
|
||||
internal_key.IsFullyValid() must be true. */
|
||||
TaprootBuilder& Finalize(const XOnlyPubKey& internal_key);
|
||||
|
||||
/** Return true if so far all input was valid. */
|
||||
bool IsValid() const { return m_valid; }
|
||||
/** Return whether there were either no leaves, or the leaves form a Huffman tree. */
|
||||
bool IsComplete() const { return m_valid && (m_branch.size() == 0 || (m_branch.size() == 1 && m_branch[0].has_value())); }
|
||||
/** Compute scriptPubKey (after Finalize()). */
|
||||
WitnessV1Taproot GetOutput();
|
||||
/** Check if a list of depths is legal (will lead to IsComplete()). */
|
||||
static bool ValidDepths(const std::vector<int>& depths);
|
||||
};
|
||||
|
||||
#endif // BITCOIN_SCRIPT_STANDARD_H
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue