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