Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <script/keyorigin.h>
7 : : #include <script/interpreter.h>
8 : : #include <script/signingprovider.h>
9 : :
10 : : #include <logging.h>
11 : :
12 : : const SigningProvider& DUMMY_SIGNING_PROVIDER = SigningProvider();
13 : :
14 : : template<typename M, typename K, typename V>
15 : 1293836 : bool LookupHelper(const M& map, const K& key, V& value)
16 : : {
17 [ + + ]: 1293836 : auto it = map.find(key);
18 [ + + ]: 1293836 : if (it != map.end()) {
19 : 918270 : value = it->second;
20 : 918270 : return true;
21 : : }
22 : : return false;
23 : : }
24 : :
25 : 6064 : bool HidingSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const
26 : : {
27 : 6064 : return m_provider->GetCScript(scriptid, script);
28 : : }
29 : :
30 : 6307 : bool HidingSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const
31 : : {
32 : 6307 : return m_provider->GetPubKey(keyid, pubkey);
33 : : }
34 : :
35 : 165210 : bool HidingSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const
36 : : {
37 [ + + ]: 165210 : if (m_hide_secret) return false;
38 : 98449 : return m_provider->GetKey(keyid, key);
39 : : }
40 : :
41 : 136895 : bool HidingSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
42 : : {
43 [ + + ]: 136895 : if (m_hide_origin) return false;
44 : 109636 : return m_provider->GetKeyOrigin(keyid, info);
45 : : }
46 : :
47 : 2800 : bool HidingSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
48 : : {
49 : 2800 : return m_provider->GetTaprootSpendData(output_key, spenddata);
50 : : }
51 : 2800 : bool HidingSigningProvider::GetTaprootBuilder(const XOnlyPubKey& output_key, TaprootBuilder& builder) const
52 : : {
53 : 2800 : return m_provider->GetTaprootBuilder(output_key, builder);
54 : : }
55 : 0 : std::vector<CPubKey> HidingSigningProvider::GetMuSig2ParticipantPubkeys(const CPubKey& pubkey) const
56 : : {
57 [ # # ]: 0 : if (m_hide_origin) return {};
58 : 0 : return m_provider->GetMuSig2ParticipantPubkeys(pubkey);
59 : : }
60 : :
61 : 2800 : std::map<CPubKey, std::vector<CPubKey>> HidingSigningProvider::GetAllMuSig2ParticipantPubkeys() const
62 : : {
63 : 2800 : return m_provider->GetAllMuSig2ParticipantPubkeys();
64 : : }
65 : :
66 : 56 : void HidingSigningProvider::SetMuSig2SecNonce(const uint256& id, MuSig2SecNonce&& nonce) const
67 : : {
68 : 56 : m_provider->SetMuSig2SecNonce(id, std::move(nonce));
69 : 56 : }
70 : :
71 : 94 : std::optional<std::reference_wrapper<MuSig2SecNonce>> HidingSigningProvider::GetMuSig2SecNonce(const uint256& session_id) const
72 : : {
73 : 94 : return m_provider->GetMuSig2SecNonce(session_id);
74 : : }
75 : :
76 : 53 : void HidingSigningProvider::DeleteMuSig2Session(const uint256& session_id) const
77 : : {
78 : 53 : m_provider->DeleteMuSig2Session(session_id);
79 : 53 : }
80 : :
81 : 42802 : bool FlatSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const { return LookupHelper(scripts, scriptid, script); }
82 : 347999 : bool FlatSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const { return LookupHelper(pubkeys, keyid, pubkey); }
83 : 592155 : bool FlatSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
84 : : {
85 [ + - ]: 592155 : std::pair<CPubKey, KeyOriginInfo> out;
86 [ + - ]: 592155 : bool ret = LookupHelper(origins, keyid, out);
87 [ + + ]: 592155 : if (ret) info = std::move(out.second);
88 : 592155 : return ret;
89 : 592155 : }
90 : 833 : bool FlatSigningProvider::HaveKey(const CKeyID &keyid) const
91 : : {
92 : 833 : CKey key;
93 [ + - ]: 833 : return LookupHelper(keys, keyid, key);
94 : 833 : }
95 : 291441 : bool FlatSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const { return LookupHelper(keys, keyid, key); }
96 : 12972 : bool FlatSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
97 : : {
98 [ + - ]: 12972 : TaprootBuilder builder;
99 [ + - + + ]: 12972 : if (LookupHelper(tr_trees, output_key, builder)) {
100 [ + - ]: 7164 : spenddata = builder.GetSpendData();
101 : 7164 : return true;
102 : : }
103 : : return false;
104 : 12972 : }
105 : 5634 : bool FlatSigningProvider::GetTaprootBuilder(const XOnlyPubKey& output_key, TaprootBuilder& builder) const
106 : : {
107 : 5634 : return LookupHelper(tr_trees, output_key, builder);
108 : : }
109 : :
110 : 0 : std::vector<CPubKey> FlatSigningProvider::GetMuSig2ParticipantPubkeys(const CPubKey& pubkey) const
111 : : {
112 : 0 : std::vector<CPubKey> participant_pubkeys;
113 [ # # ]: 0 : LookupHelper(aggregate_pubkeys, pubkey, participant_pubkeys);
114 : 0 : return participant_pubkeys;
115 : 0 : }
116 : :
117 : 5634 : std::map<CPubKey, std::vector<CPubKey>> FlatSigningProvider::GetAllMuSig2ParticipantPubkeys() const
118 : : {
119 : 5634 : return aggregate_pubkeys;
120 : : }
121 : :
122 : 56 : void FlatSigningProvider::SetMuSig2SecNonce(const uint256& session_id, MuSig2SecNonce&& nonce) const
123 : : {
124 [ + - ]: 56 : if (!Assume(musig2_secnonces)) return;
125 : 56 : musig2_secnonces->emplace(session_id, std::move(nonce));
126 : : }
127 : :
128 : 94 : std::optional<std::reference_wrapper<MuSig2SecNonce>> FlatSigningProvider::GetMuSig2SecNonce(const uint256& session_id) const
129 : : {
130 [ - + ]: 94 : if (!Assume(musig2_secnonces)) return std::nullopt;
131 : 94 : const auto& it = musig2_secnonces->find(session_id);
132 [ + + ]: 94 : if (it == musig2_secnonces->end()) return std::nullopt;
133 : 53 : return it->second;
134 : : }
135 : :
136 : 53 : void FlatSigningProvider::DeleteMuSig2Session(const uint256& session_id) const
137 : : {
138 [ + - ]: 53 : if (!Assume(musig2_secnonces)) return;
139 : 53 : musig2_secnonces->erase(session_id);
140 : : }
141 : :
142 : 1040172 : FlatSigningProvider& FlatSigningProvider::Merge(FlatSigningProvider&& b)
143 : : {
144 : 1040172 : scripts.merge(b.scripts);
145 : 1040172 : pubkeys.merge(b.pubkeys);
146 : 1040172 : keys.merge(b.keys);
147 : 1040172 : origins.merge(b.origins);
148 : 1040172 : tr_trees.merge(b.tr_trees);
149 : 1040172 : aggregate_pubkeys.merge(b.aggregate_pubkeys);
150 : : // We shouldn't be merging 2 different sessions, just overwrite with b's sessions.
151 [ + + ]: 1040172 : if (!musig2_secnonces) musig2_secnonces = b.musig2_secnonces;
152 : 1040172 : return *this;
153 : : }
154 : :
155 : 402 : void FillableSigningProvider::ImplicitlyLearnRelatedKeyScripts(const CPubKey& pubkey)
156 : : {
157 : 402 : AssertLockHeld(cs_KeyStore);
158 : 402 : CKeyID key_id = pubkey.GetID();
159 : : // This adds the redeemscripts necessary to detect P2WPKH and P2SH-P2WPKH
160 : : // outputs. Technically P2WPKH outputs don't have a redeemscript to be
161 : : // spent. However, our current IsMine logic requires the corresponding
162 : : // P2SH-P2WPKH redeemscript to be present in the wallet in order to accept
163 : : // payment even to P2WPKH outputs.
164 : : // Also note that having superfluous scripts in the keystore never hurts.
165 : : // They're only used to guide recursion in signing and IsMine logic - if
166 : : // a script is present but we can't do anything with it, it has no effect.
167 : : // "Implicitly" refers to fact that scripts are derived automatically from
168 : : // existing keys, and are present in memory, even without being explicitly
169 : : // loaded (e.g. from a file).
170 [ + + ]: 402 : if (pubkey.IsCompressed()) {
171 [ + - ]: 385 : CScript script = GetScriptForDestination(WitnessV0KeyHash(key_id));
172 : : // This does not use AddCScript, as it may be overridden.
173 [ + - ]: 385 : CScriptID id(script);
174 [ + - ]: 385 : mapScripts[id] = std::move(script);
175 : 385 : }
176 : 402 : }
177 : :
178 : 5686 : bool FillableSigningProvider::GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const
179 : : {
180 : 5686 : CKey key;
181 [ + - + + ]: 5686 : if (!GetKey(address, key)) {
182 : : return false;
183 : : }
184 [ + - ]: 5613 : vchPubKeyOut = key.GetPubKey();
185 : : return true;
186 : 5686 : }
187 : :
188 : 369 : bool FillableSigningProvider::AddKeyPubKey(const CKey& key, const CPubKey &pubkey)
189 : : {
190 : 369 : LOCK(cs_KeyStore);
191 [ + - + - : 369 : mapKeys[pubkey.GetID()] = key;
+ - ]
192 [ + - ]: 369 : ImplicitlyLearnRelatedKeyScripts(pubkey);
193 [ + - ]: 369 : return true;
194 : 369 : }
195 : :
196 : 1924 : bool FillableSigningProvider::HaveKey(const CKeyID &address) const
197 : : {
198 : 1924 : LOCK(cs_KeyStore);
199 [ + - ]: 1924 : return mapKeys.count(address) > 0;
200 : 1924 : }
201 : :
202 : 0 : std::set<CKeyID> FillableSigningProvider::GetKeys() const
203 : : {
204 : 0 : LOCK(cs_KeyStore);
205 : 0 : std::set<CKeyID> set_address;
206 [ # # ]: 0 : for (const auto& mi : mapKeys) {
207 [ # # ]: 0 : set_address.insert(mi.first);
208 : : }
209 [ # # ]: 0 : return set_address;
210 : 0 : }
211 : :
212 : 10686 : bool FillableSigningProvider::GetKey(const CKeyID &address, CKey &keyOut) const
213 : : {
214 : 10686 : LOCK(cs_KeyStore);
215 : 10686 : KeyMap::const_iterator mi = mapKeys.find(address);
216 [ + + ]: 10686 : if (mi != mapKeys.end()) {
217 [ + - ]: 10561 : keyOut = mi->second;
218 : : return true;
219 : : }
220 : : return false;
221 : 10686 : }
222 : :
223 : 117 : bool FillableSigningProvider::AddCScript(const CScript& redeemScript)
224 : : {
225 [ + + - + ]: 117 : if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
226 : 0 : LogError("FillableSigningProvider::AddCScript(): redeemScripts > %i bytes are invalid\n", MAX_SCRIPT_ELEMENT_SIZE);
227 : 0 : return false;
228 : : }
229 : :
230 : 117 : LOCK(cs_KeyStore);
231 [ + - + - ]: 117 : mapScripts[CScriptID(redeemScript)] = redeemScript;
232 [ + - ]: 117 : return true;
233 : 117 : }
234 : :
235 : 1211 : bool FillableSigningProvider::HaveCScript(const CScriptID& hash) const
236 : : {
237 : 1211 : LOCK(cs_KeyStore);
238 [ + - ]: 1211 : return mapScripts.count(hash) > 0;
239 : 1211 : }
240 : :
241 : 0 : std::set<CScriptID> FillableSigningProvider::GetCScripts() const
242 : : {
243 : 0 : LOCK(cs_KeyStore);
244 : 0 : std::set<CScriptID> set_script;
245 [ # # ]: 0 : for (const auto& mi : mapScripts) {
246 [ # # ]: 0 : set_script.insert(mi.first);
247 : : }
248 [ # # ]: 0 : return set_script;
249 : 0 : }
250 : :
251 : 2239 : bool FillableSigningProvider::GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const
252 : : {
253 : 2239 : LOCK(cs_KeyStore);
254 : 2239 : ScriptMap::const_iterator mi = mapScripts.find(hash);
255 [ + + ]: 2239 : if (mi != mapScripts.end())
256 : : {
257 : 1105 : redeemScriptOut = (*mi).second;
258 : 1105 : return true;
259 : : }
260 : : return false;
261 : 2239 : }
262 : :
263 : 657 : CKeyID GetKeyForDestination(const SigningProvider& store, const CTxDestination& dest)
264 : : {
265 : : // Only supports destinations which map to single public keys:
266 : : // P2PKH, P2WPKH, P2SH-P2WPKH, P2TR
267 [ + + ]: 657 : if (auto id = std::get_if<PKHash>(&dest)) {
268 : 96 : return ToKeyID(*id);
269 : : }
270 [ + + ]: 561 : if (auto witness_id = std::get_if<WitnessV0KeyHash>(&dest)) {
271 : 330 : return ToKeyID(*witness_id);
272 : : }
273 [ + + ]: 231 : if (auto script_hash = std::get_if<ScriptHash>(&dest)) {
274 : 107 : CScript script;
275 [ + - ]: 107 : CScriptID script_id = ToScriptID(*script_hash);
276 : 107 : CTxDestination inner_dest;
277 [ + - + - : 107 : if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) {
+ - + - ]
278 [ + + ]: 107 : if (auto inner_witness_id = std::get_if<WitnessV0KeyHash>(&inner_dest)) {
279 [ + - ]: 104 : return ToKeyID(*inner_witness_id);
280 : : }
281 : : }
282 : 107 : }
283 [ + + ]: 127 : if (auto output_key = std::get_if<WitnessV1Taproot>(&dest)) {
284 [ + - ]: 104 : TaprootSpendData spenddata;
285 [ + - ]: 104 : CPubKey pub;
286 [ + - ]: 104 : if (store.GetTaprootSpendData(*output_key, spenddata)
287 [ + - ]: 97 : && !spenddata.internal_key.IsNull()
288 [ + + ]: 97 : && spenddata.merkle_root.IsNull()
289 [ + + + - : 149 : && store.GetPubKeyByXOnly(spenddata.internal_key, pub)) {
- + ]
290 [ + - ]: 45 : return pub.GetID();
291 : : }
292 : 104 : }
293 : 82 : return CKeyID();
294 : : }
295 : :
296 : 52270 : void MultiSigningProvider::AddProvider(std::unique_ptr<SigningProvider> provider)
297 : : {
298 : 52270 : m_providers.push_back(std::move(provider));
299 : 52270 : }
300 : :
301 : 811 : bool MultiSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const
302 : : {
303 [ + + ]: 831 : for (const auto& provider: m_providers) {
304 [ + + ]: 811 : if (provider->GetCScript(scriptid, script)) return true;
305 : : }
306 : : return false;
307 : : }
308 : :
309 : 26255 : bool MultiSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const
310 : : {
311 [ + - ]: 26255 : for (const auto& provider: m_providers) {
312 [ - + ]: 26255 : if (provider->GetPubKey(keyid, pubkey)) return true;
313 : : }
314 : : return false;
315 : : }
316 : :
317 : :
318 : 75886 : bool MultiSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
319 : : {
320 [ + + ]: 78115 : for (const auto& provider: m_providers) {
321 [ + + ]: 76902 : if (provider->GetKeyOrigin(keyid, info)) return true;
322 : : }
323 : : return false;
324 : : }
325 : :
326 : 0 : bool MultiSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const
327 : : {
328 [ # # ]: 0 : for (const auto& provider: m_providers) {
329 [ # # ]: 0 : if (provider->GetKey(keyid, key)) return true;
330 : : }
331 : : return false;
332 : : }
333 : :
334 : 1229 : bool MultiSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
335 : : {
336 [ + + ]: 1344 : for (const auto& provider: m_providers) {
337 [ + + ]: 1283 : if (provider->GetTaprootSpendData(output_key, spenddata)) return true;
338 : : }
339 : : return false;
340 : : }
341 : :
342 : 0 : bool MultiSigningProvider::GetTaprootBuilder(const XOnlyPubKey& output_key, TaprootBuilder& builder) const
343 : : {
344 [ # # ]: 0 : for (const auto& provider: m_providers) {
345 [ # # ]: 0 : if (provider->GetTaprootBuilder(output_key, builder)) return true;
346 : : }
347 : : return false;
348 : : }
349 : :
350 : 22039 : /*static*/ TaprootBuilder::NodeInfo TaprootBuilder::Combine(NodeInfo&& a, NodeInfo&& b)
351 : : {
352 : 22039 : NodeInfo ret;
353 : : /* Iterate over all tracked leaves in a, add b's hash to their Merkle branch, and move them to ret. */
354 [ + + ]: 61954 : for (auto& leaf : a.leaves) {
355 [ + - ]: 39915 : leaf.merkle_branch.push_back(b.hash);
356 [ + - ]: 39915 : ret.leaves.emplace_back(std::move(leaf));
357 : : }
358 : : /* Iterate over all tracked leaves in b, add a's hash to their Merkle branch, and move them to ret. */
359 [ + + ]: 50675 : for (auto& leaf : b.leaves) {
360 [ + - ]: 28636 : leaf.merkle_branch.push_back(a.hash);
361 [ + - ]: 28636 : ret.leaves.emplace_back(std::move(leaf));
362 : : }
363 [ + - ]: 22039 : ret.hash = ComputeTapbranchHash(a.hash, b.hash);
364 : 22039 : return ret;
365 : 0 : }
366 : :
367 : 1367 : void TaprootSpendData::Merge(TaprootSpendData other)
368 : : {
369 : : // TODO: figure out how to better deal with conflicting information
370 : : // being merged.
371 [ + + + - ]: 3539 : if (internal_key.IsNull() && !other.internal_key.IsNull()) {
372 : 805 : internal_key = other.internal_key;
373 : : }
374 [ + + + + ]: 3708 : if (merkle_root.IsNull() && !other.merkle_root.IsNull()) {
375 : 513 : merkle_root = other.merkle_root;
376 : : }
377 [ + + ]: 2764 : for (auto& [key, control_blocks] : other.scripts) {
378 : 1397 : scripts[key].merge(std::move(control_blocks));
379 : : }
380 : 1367 : }
381 : :
382 : 38231 : void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
383 : : {
384 [ - + ]: 38231 : assert(depth >= 0 && (size_t)depth <= TAPROOT_CONTROL_MAX_NODE_COUNT);
385 : : /* We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
386 : : * so would mean the Add() invocations do not correspond to a DFS traversal of a
387 : : * binary tree. */
388 [ - + - + ]: 38231 : if ((size_t)depth + 1 < m_branch.size()) {
389 : 0 : m_valid = false;
390 : 0 : return;
391 : : }
392 : : /* As long as an entry in the branch exists at the specified depth, combine it and propagate up.
393 : : * The 'node' variable is overwritten here with the newly combined node. */
394 [ + - - + : 60270 : while (m_valid && m_branch.size() > (size_t)depth && m_branch[depth].has_value()) {
+ + + + ]
395 : 22039 : node = Combine(std::move(node), std::move(*m_branch[depth]));
396 : 22039 : m_branch.pop_back();
397 [ - + ]: 22039 : if (depth == 0) m_valid = false; /* Can't propagate further up than the root */
398 : 22039 : --depth;
399 : : }
400 [ + - ]: 38231 : if (m_valid) {
401 : : /* Make sure the branch is big enough to place the new node. */
402 [ - + + + ]: 38231 : if (m_branch.size() <= (size_t)depth) m_branch.resize((size_t)depth + 1);
403 [ - + ]: 38231 : assert(!m_branch[depth].has_value());
404 : 38231 : m_branch[depth] = std::move(node);
405 : : }
406 : : }
407 : :
408 : 1904 : /*static*/ bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
409 : : {
410 : 1904 : std::vector<bool> branch;
411 [ + + ]: 3025 : for (int depth : depths) {
412 : : // This inner loop corresponds to effectively the same logic on branch
413 : : // as what Insert() performs on the m_branch variable. Instead of
414 : : // storing a NodeInfo object, just remember whether or not there is one
415 : : // at that depth.
416 [ + + ]: 1146 : if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
417 [ + + ]: 1145 : if ((size_t)depth + 1 < branch.size()) return false;
418 [ + + + + ]: 1853 : while (branch.size() > (size_t)depth && branch[depth]) {
419 [ - + ]: 732 : branch.pop_back();
420 [ + + ]: 732 : if (depth == 0) return false;
421 : 726 : --depth;
422 : : }
423 [ + + + - ]: 1121 : if (branch.size() <= (size_t)depth) branch.resize((size_t)depth + 1);
424 [ - + ]: 1121 : assert(!branch[depth]);
425 : 1121 : branch[depth] = true;
426 : : }
427 : : // And this check corresponds to the IsComplete() check on m_branch.
428 [ + + + + : 1879 : return branch.size() == 0 || (branch.size() == 1 && branch[0]);
+ - ]
429 : 1904 : }
430 : :
431 : 38230 : TaprootBuilder& TaprootBuilder::Add(int depth, std::span<const unsigned char> script, int leaf_version, bool track)
432 : : {
433 [ - + ]: 38230 : assert((leaf_version & ~TAPROOT_LEAF_MASK) == 0);
434 [ + - ]: 38230 : if (!IsValid()) return *this;
435 : : /* Construct NodeInfo object with leaf hash and (if track is true) also leaf information. */
436 : 38230 : NodeInfo node;
437 [ + - ]: 38230 : node.hash = ComputeTapleafHash(leaf_version, script);
438 [ + - + - : 76460 : if (track) node.leaves.emplace_back(LeafInfo{std::vector<unsigned char>(script.begin(), script.end()), leaf_version, {}});
+ - ]
439 : : /* Insert into the branch. */
440 [ + - ]: 38230 : Insert(std::move(node), depth);
441 : 38230 : return *this;
442 : 38230 : }
443 : :
444 : 1 : TaprootBuilder& TaprootBuilder::AddOmitted(int depth, const uint256& hash)
445 : : {
446 [ + - ]: 1 : if (!IsValid()) return *this;
447 : : /* Construct NodeInfo object with the hash directly, and insert it into the branch. */
448 : 1 : NodeInfo node;
449 : 1 : node.hash = hash;
450 [ + - ]: 1 : Insert(std::move(node), depth);
451 : 1 : return *this;
452 : 1 : }
453 : :
454 : 127410 : TaprootBuilder& TaprootBuilder::Finalize(const XOnlyPubKey& internal_key)
455 : : {
456 : : /* Can only call this function when IsComplete() is true. */
457 [ - + ]: 127410 : assert(IsComplete());
458 : 127410 : m_internal_key = internal_key;
459 [ - + + + ]: 127410 : auto ret = m_internal_key.CreateTapTweak(m_branch.size() == 0 ? nullptr : &m_branch[0]->hash);
460 [ - + ]: 127410 : assert(ret.has_value());
461 : 127410 : std::tie(m_output_key, m_parity) = *ret;
462 : 127410 : return *this;
463 : : }
464 : :
465 : 127302 : WitnessV1Taproot TaprootBuilder::GetOutput() { return WitnessV1Taproot{m_output_key}; }
466 : :
467 : 10915 : TaprootSpendData TaprootBuilder::GetSpendData() const
468 : : {
469 [ - + ]: 10915 : assert(IsComplete());
470 [ - + ]: 10915 : assert(m_output_key.IsFullyValid());
471 [ - + ]: 10915 : TaprootSpendData spd;
472 [ - + + + ]: 10915 : spd.merkle_root = m_branch.size() == 0 ? uint256() : m_branch[0]->hash;
473 : 10915 : spd.internal_key = m_internal_key;
474 [ - + + + ]: 10915 : if (m_branch.size()) {
475 : : // If any script paths exist, they have been combined into the root m_branch[0]
476 : : // by now. Compute the control block for each of its tracked leaves, and put them in
477 : : // spd.scripts.
478 [ + + ]: 16687 : for (const auto& leaf : m_branch[0]->leaves) {
479 : 10296 : std::vector<unsigned char> control_block;
480 [ - + + - ]: 10296 : control_block.resize(TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size());
481 [ + + ]: 15734 : control_block[0] = leaf.leaf_version | (m_parity ? 1 : 0);
482 : 10296 : std::copy(m_internal_key.begin(), m_internal_key.end(), control_block.begin() + 1);
483 [ - + + + ]: 10296 : if (leaf.merkle_branch.size()) {
484 : 5388 : std::copy(leaf.merkle_branch[0].begin(),
485 : 5388 : leaf.merkle_branch[0].begin() + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size(),
486 : 5388 : control_block.begin() + TAPROOT_CONTROL_BASE_SIZE);
487 : : }
488 [ + - + - : 20592 : spd.scripts[{leaf.script, leaf.leaf_version}].insert(std::move(control_block));
+ - ]
489 : 10296 : }
490 : : }
491 : 10915 : return spd;
492 : 0 : }
493 : :
494 : 5815 : std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output)
495 : : {
496 : : // Verify that the output matches the assumed Merkle root and internal key.
497 [ + + ]: 11630 : auto tweak = spenddata.internal_key.CreateTapTweak(spenddata.merkle_root.IsNull() ? nullptr : &spenddata.merkle_root);
498 [ + - - + ]: 5815 : if (!tweak || tweak->first != output) return std::nullopt;
499 : : // If the Merkle root is 0, the tree is empty, and we're done.
500 : 5815 : std::vector<std::tuple<int, std::vector<unsigned char>, int>> ret;
501 [ + + ]: 11630 : if (spenddata.merkle_root.IsNull()) return ret;
502 : :
503 : : /** Data structure to represent the nodes of the tree we're going to build. */
504 [ + + - - ]: 5394 : struct TreeNode {
505 : : /** Hash of this node, if known; 0 otherwise. */
506 : : uint256 hash;
507 : : /** The left and right subtrees (note that their order is irrelevant). */
508 : : std::unique_ptr<TreeNode> sub[2];
509 : : /** If this is known to be a leaf node, a pointer to the (script, leaf_ver) pair.
510 : : * nullptr otherwise. */
511 : : const std::pair<std::vector<unsigned char>, int>* leaf = nullptr;
512 : : /** Whether or not this node has been explored (is known to be a leaf, or known to have children). */
513 : : bool explored = false;
514 : : /** Whether or not this node is an inner node (unknown until explored = true). */
515 : : bool inner;
516 : : /** Whether or not we have produced output for this subtree. */
517 : : bool done = false;
518 : : };
519 : :
520 : : // Build tree from the provided branches.
521 : 1798 : TreeNode root;
522 : 1798 : root.hash = spenddata.merkle_root;
523 [ + + ]: 4564 : for (const auto& [key, control_blocks] : spenddata.scripts) {
524 : 2766 : const auto& [script, leaf_ver] = key;
525 [ + + ]: 6304 : for (const auto& control : control_blocks) {
526 : : // Skip script records with nonsensical leaf version.
527 [ + - - + ]: 3538 : if (leaf_ver < 0 || leaf_ver >= 0x100 || leaf_ver & 1) continue;
528 : : // Skip script records with invalid control block sizes.
529 [ - + + - : 3538 : if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE ||
+ - ]
530 [ + - ]: 3538 : ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) continue;
531 : : // Skip script records that don't match the control block.
532 [ - + ]: 3538 : if ((control[0] & TAPROOT_LEAF_MASK) != leaf_ver) continue;
533 : : // Skip script records that don't match the provided Merkle root.
534 [ - + + - ]: 3538 : const uint256 leaf_hash = ComputeTapleafHash(leaf_ver, script);
535 [ - + + - ]: 3538 : const uint256 merkle_root = ComputeTaprootMerkleRoot(control, leaf_hash);
536 [ - + ]: 3538 : if (merkle_root != spenddata.merkle_root) continue;
537 : :
538 : 3538 : TreeNode* node = &root;
539 [ - + ]: 3538 : size_t levels = (control.size() - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE;
540 [ + + ]: 8985 : for (size_t depth = 0; depth < levels; ++depth) {
541 : : // Can't descend into a node which we already know is a leaf.
542 [ + + - + ]: 5447 : if (node->explored && !node->inner) return std::nullopt;
543 : :
544 : : // Extract partner hash from Merkle branch in control block.
545 : 5447 : uint256 hash;
546 : 5447 : std::copy(control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - 1 - depth) * TAPROOT_CONTROL_NODE_SIZE,
547 : 5447 : control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - depth) * TAPROOT_CONTROL_NODE_SIZE,
548 : : hash.begin());
549 : :
550 [ + + ]: 5447 : if (node->sub[0]) {
551 : : // Descend into the existing left or right branch.
552 : 4016 : bool desc = false;
553 [ + - ]: 4016 : for (int i = 0; i < 2; ++i) {
554 [ + + + + : 5162 : if (node->sub[i]->hash == hash || (node->sub[i]->hash.IsNull() && node->sub[1-i]->hash != hash)) {
+ + ]
555 : 3282 : node->sub[i]->hash = hash;
556 : 3282 : node = &*node->sub[1-i];
557 : 3282 : desc = true;
558 : 3282 : break;
559 : : }
560 : : }
561 : 3282 : if (!desc) return std::nullopt; // This probably requires a hash collision to hit.
562 : : } else {
563 : : // We're in an unexplored node. Create subtrees and descend.
564 : 2165 : node->explored = true;
565 : 2165 : node->inner = true;
566 [ + - ]: 2165 : node->sub[0] = std::make_unique<TreeNode>();
567 [ + - ]: 2165 : node->sub[1] = std::make_unique<TreeNode>();
568 : 2165 : node->sub[1]->hash = hash;
569 : 2165 : node = &*node->sub[0];
570 : : }
571 : : }
572 : : // Cannot turn a known inner node into a leaf.
573 [ - + ]: 3538 : if (node->sub[0]) return std::nullopt;
574 : 3538 : node->explored = true;
575 : 3538 : node->inner = false;
576 : 3538 : node->leaf = &key;
577 : 3538 : node->hash = leaf_hash;
578 : : }
579 : : }
580 : :
581 : : // Recursive processing to turn the tree into flattened output. Use an explicit stack here to avoid
582 : : // overflowing the call stack (the tree may be 128 levels deep).
583 [ + - ]: 1798 : std::vector<TreeNode*> stack{&root};
584 : 14033 : while (!stack.empty()) {
585 : 12235 : TreeNode& node = *stack.back();
586 [ - + ]: 12235 : if (!node.explored) {
587 : : // Unexplored node, which means the tree is incomplete.
588 : 0 : return std::nullopt;
589 [ + + ]: 12235 : } else if (!node.inner) {
590 : : // Leaf node; produce output.
591 [ - + + - ]: 4275 : ret.emplace_back(stack.size() - 1, node.leaf->first, node.leaf->second);
592 : 4275 : node.done = true;
593 : 4275 : stack.pop_back();
594 [ + + + + : 8489 : } else if (node.sub[0]->done && !node.sub[1]->done && !node.sub[1]->explored && !node.sub[1]->hash.IsNull() &&
+ + + - ]
595 [ + - - + ]: 529 : ComputeTapbranchHash(node.sub[1]->hash, node.sub[1]->hash) == node.hash) {
596 : : // Whenever there are nodes with two identical subtrees under it, we run into a problem:
597 : : // the control blocks for the leaves underneath those will be identical as well, and thus
598 : : // they will all be matched to the same path in the tree. The result is that at the location
599 : : // where the duplicate occurred, the left child will contain a normal tree that can be explored
600 : : // and processed, but the right one will remain unexplored.
601 : : //
602 : : // This situation can be detected, by encountering an inner node with unexplored right subtree
603 : : // with known hash, and H_TapBranch(hash, hash) is equal to the parent node (this node)'s hash.
604 : : //
605 : : // To deal with this, simply process the left tree a second time (set its done flag to false;
606 : : // noting that the done flag of its children have already been set to false after processing
607 : : // those). To avoid ending up in an infinite loop, set the done flag of the right (unexplored)
608 : : // subtree to true.
609 : 529 : node.sub[0]->done = false;
610 : 529 : node.sub[1]->done = true;
611 [ + + + + ]: 7431 : } else if (node.sub[0]->done && node.sub[1]->done) {
612 : : // An internal node which we're finished with.
613 : 2477 : node.sub[0]->done = false;
614 : 2477 : node.sub[1]->done = false;
615 : 2477 : node.done = true;
616 : 2477 : stack.pop_back();
617 [ + + ]: 4954 : } else if (!node.sub[0]->done) {
618 : : // An internal node whose left branch hasn't been processed yet. Do so first.
619 [ + - ]: 3006 : stack.push_back(&*node.sub[0]);
620 [ + - ]: 1948 : } else if (!node.sub[1]->done) {
621 : : // An internal node whose right branch hasn't been processed yet. Do so first.
622 [ + - + + ]: 15981 : stack.push_back(&*node.sub[1]);
623 : : }
624 : : }
625 : :
626 : 1798 : return ret;
627 : 7613 : }
628 : :
629 : 174 : std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> TaprootBuilder::GetTreeTuples() const
630 : : {
631 [ - + ]: 174 : assert(IsComplete());
632 : 174 : std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> tuples;
633 [ - + + - ]: 174 : if (m_branch.size()) {
634 : 174 : const auto& leaves = m_branch[0]->leaves;
635 [ + + ]: 610 : for (const auto& leaf : leaves) {
636 [ - + - + ]: 436 : assert(leaf.merkle_branch.size() <= TAPROOT_CONTROL_MAX_NODE_COUNT);
637 [ + - ]: 436 : uint8_t depth = (uint8_t)leaf.merkle_branch.size();
638 : 436 : uint8_t leaf_ver = (uint8_t)leaf.leaf_version;
639 [ + - ]: 436 : tuples.emplace_back(depth, leaf_ver, leaf.script);
640 : : }
641 : : }
642 : 174 : return tuples;
643 : 0 : }
|
