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  std::vector<CPubKey> HidingSigningProvider::GetMuSig2ParticipantPubkeys(const CPubKey& pubkey) const
 56  {
 57      if (m_hide_origin) return {};
 58      return m_provider->GetMuSig2ParticipantPubkeys(pubkey);
 59  }
 60  
 61  std::map<CPubKey, std::vector<CPubKey>> HidingSigningProvider::GetAllMuSig2ParticipantPubkeys() const
 62  {
 63      return m_provider->GetAllMuSig2ParticipantPubkeys();
 64  }
 65  
 66  void HidingSigningProvider::SetMuSig2SecNonce(const uint256& id, MuSig2SecNonce&& nonce) const
 67  {
 68      m_provider->SetMuSig2SecNonce(id, std::move(nonce));
 69  }
 70  
 71  std::optional<std::reference_wrapper<MuSig2SecNonce>> HidingSigningProvider::GetMuSig2SecNonce(const uint256& session_id) const
 72  {
 73      return m_provider->GetMuSig2SecNonce(session_id);
 74  }
 75  
 76  void HidingSigningProvider::DeleteMuSig2Session(const uint256& session_id) const
 77  {
 78      m_provider->DeleteMuSig2Session(session_id);
 79  }
 80  
 81  bool FlatSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const { return LookupHelper(scripts, scriptid, script); }
 82  bool FlatSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const { return LookupHelper(pubkeys, keyid, pubkey); }
 83  bool FlatSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
 84  {
 85      std::pair<CPubKey, KeyOriginInfo> out;
 86      bool ret = LookupHelper(origins, keyid, out);
 87      if (ret) info = std::move(out.second);
 88      return ret;
 89  }
 90  bool FlatSigningProvider::HaveKey(const CKeyID &keyid) const
 91  {
 92      CKey key;
 93      return LookupHelper(keys, keyid, key);
 94  }
 95  bool FlatSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const { return LookupHelper(keys, keyid, key); }
 96  bool FlatSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
 97  {
 98      TaprootBuilder builder;
 99      if (LookupHelper(tr_trees, output_key, builder)) {
100          spenddata = builder.GetSpendData();
101          return true;
102      }
103      return false;
104  }
105  bool FlatSigningProvider::GetTaprootBuilder(const XOnlyPubKey& output_key, TaprootBuilder& builder) const
106  {
107      return LookupHelper(tr_trees, output_key, builder);
108  }
109  
110  std::vector<CPubKey> FlatSigningProvider::GetMuSig2ParticipantPubkeys(const CPubKey& pubkey) const
111  {
112      std::vector<CPubKey> participant_pubkeys;
113      LookupHelper(aggregate_pubkeys, pubkey, participant_pubkeys);
114      return participant_pubkeys;
115  }
116  
117  std::map<CPubKey, std::vector<CPubKey>> FlatSigningProvider::GetAllMuSig2ParticipantPubkeys() const
118  {
119      return aggregate_pubkeys;
120  }
121  
122  void FlatSigningProvider::SetMuSig2SecNonce(const uint256& session_id, MuSig2SecNonce&& nonce) const
123  {
124      if (!Assume(musig2_secnonces)) return;
125      musig2_secnonces->emplace(session_id, std::move(nonce));
126  }
127  
128  std::optional<std::reference_wrapper<MuSig2SecNonce>> FlatSigningProvider::GetMuSig2SecNonce(const uint256& session_id) const
129  {
130      if (!Assume(musig2_secnonces)) return std::nullopt;
131      const auto& it = musig2_secnonces->find(session_id);
132      if (it == musig2_secnonces->end()) return std::nullopt;
133      return it->second;
134  }
135  
136  void FlatSigningProvider::DeleteMuSig2Session(const uint256& session_id) const
137  {
138      if (!Assume(musig2_secnonces)) return;
139      musig2_secnonces->erase(session_id);
140  }
141  
142  FlatSigningProvider& FlatSigningProvider::Merge(FlatSigningProvider&& b)
143  {
144      scripts.merge(b.scripts);
145      pubkeys.merge(b.pubkeys);
146      keys.merge(b.keys);
147      origins.merge(b.origins);
148      tr_trees.merge(b.tr_trees);
149      aggregate_pubkeys.merge(b.aggregate_pubkeys);
150      // We shouldn't be merging 2 different sessions, just overwrite with b's sessions.
151      if (!musig2_secnonces) musig2_secnonces = b.musig2_secnonces;
152      return *this;
153  }
154  
155  void FillableSigningProvider::ImplicitlyLearnRelatedKeyScripts(const CPubKey& pubkey)
156  {
157      AssertLockHeld(cs_KeyStore);
158      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      if (pubkey.IsCompressed()) {
171          CScript script = GetScriptForDestination(WitnessV0KeyHash(key_id));
172          // This does not use AddCScript, as it may be overridden.
173          CScriptID id(script);
174          mapScripts[id] = std::move(script);
175      }
176  }
177  
178  bool FillableSigningProvider::GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const
179  {
180      CKey key;
181      if (!GetKey(address, key)) {
182          return false;
183      }
184      vchPubKeyOut = key.GetPubKey();
185      return true;
186  }
187  
188  bool FillableSigningProvider::AddKeyPubKey(const CKey& key, const CPubKey &pubkey)
189  {
190      LOCK(cs_KeyStore);
191      mapKeys[pubkey.GetID()] = key;
192      ImplicitlyLearnRelatedKeyScripts(pubkey);
193      return true;
194  }
195  
196  bool FillableSigningProvider::HaveKey(const CKeyID &address) const
197  {
198      LOCK(cs_KeyStore);
199      return mapKeys.count(address) > 0;
200  }
201  
202  std::set<CKeyID> FillableSigningProvider::GetKeys() const
203  {
204      LOCK(cs_KeyStore);
205      std::set<CKeyID> set_address;
206      for (const auto& mi : mapKeys) {
207          set_address.insert(mi.first);
208      }
209      return set_address;
210  }
211  
212  bool FillableSigningProvider::GetKey(const CKeyID &address, CKey &keyOut) const
213  {
214      LOCK(cs_KeyStore);
215      KeyMap::const_iterator mi = mapKeys.find(address);
216      if (mi != mapKeys.end()) {
217          keyOut = mi->second;
218          return true;
219      }
220      return false;
221  }
222  
223  bool FillableSigningProvider::AddCScript(const CScript& redeemScript)
224  {
225      if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
226          LogError("FillableSigningProvider::AddCScript(): redeemScripts > %i bytes are invalid\n", MAX_SCRIPT_ELEMENT_SIZE);
227          return false;
228      }
229  
230      LOCK(cs_KeyStore);
231      mapScripts[CScriptID(redeemScript)] = redeemScript;
232      return true;
233  }
234  
235  bool FillableSigningProvider::HaveCScript(const CScriptID& hash) const
236  {
237      LOCK(cs_KeyStore);
238      return mapScripts.count(hash) > 0;
239  }
240  
241  std::set<CScriptID> FillableSigningProvider::GetCScripts() const
242  {
243      LOCK(cs_KeyStore);
244      std::set<CScriptID> set_script;
245      for (const auto& mi : mapScripts) {
246          set_script.insert(mi.first);
247      }
248      return set_script;
249  }
250  
251  bool FillableSigningProvider::GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const
252  {
253      LOCK(cs_KeyStore);
254      ScriptMap::const_iterator mi = mapScripts.find(hash);
255      if (mi != mapScripts.end())
256      {
257          redeemScriptOut = (*mi).second;
258          return true;
259      }
260      return false;
261  }
262  
263  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      if (auto id = std::get_if<PKHash>(&dest)) {
268          return ToKeyID(*id);
269      }
270      if (auto witness_id = std::get_if<WitnessV0KeyHash>(&dest)) {
271          return ToKeyID(*witness_id);
272      }
273      if (auto script_hash = std::get_if<ScriptHash>(&dest)) {
274          CScript script;
275          CScriptID script_id = ToScriptID(*script_hash);
276          CTxDestination inner_dest;
277          if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) {
278              if (auto inner_witness_id = std::get_if<WitnessV0KeyHash>(&inner_dest)) {
279                  return ToKeyID(*inner_witness_id);
280              }
281          }
282      }
283      if (auto output_key = std::get_if<WitnessV1Taproot>(&dest)) {
284          TaprootSpendData spenddata;
285          CPubKey pub;
286          if (store.GetTaprootSpendData(*output_key, spenddata)
287              && !spenddata.internal_key.IsNull()
288              && spenddata.merkle_root.IsNull()
289              && store.GetPubKeyByXOnly(spenddata.internal_key, pub)) {
290              return pub.GetID();
291          }
292      }
293      return CKeyID();
294  }
295  
296  void MultiSigningProvider::AddProvider(std::unique_ptr<SigningProvider> provider)
297  {
298      m_providers.push_back(std::move(provider));
299  }
300  
301  bool MultiSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const
302  {
303      for (const auto& provider: m_providers) {
304          if (provider->GetCScript(scriptid, script)) return true;
305      }
306      return false;
307  }
308  
309  bool MultiSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const
310  {
311      for (const auto& provider: m_providers) {
312          if (provider->GetPubKey(keyid, pubkey)) return true;
313      }
314      return false;
315  }
316  
317  
318  bool MultiSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
319  {
320      for (const auto& provider: m_providers) {
321          if (provider->GetKeyOrigin(keyid, info)) return true;
322      }
323      return false;
324  }
325  
326  bool MultiSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const
327  {
328      for (const auto& provider: m_providers) {
329          if (provider->GetKey(keyid, key)) return true;
330      }
331      return false;
332  }
333  
334  bool MultiSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
335  {
336      for (const auto& provider: m_providers) {
337          if (provider->GetTaprootSpendData(output_key, spenddata)) return true;
338      }
339      return false;
340  }
341  
342  bool MultiSigningProvider::GetTaprootBuilder(const XOnlyPubKey& output_key, TaprootBuilder& builder) const
343  {
344      for (const auto& provider: m_providers) {
345          if (provider->GetTaprootBuilder(output_key, builder)) return true;
346      }
347      return false;
348  }
349  
350  /*static*/ TaprootBuilder::NodeInfo TaprootBuilder::Combine(NodeInfo&& a, NodeInfo&& b)
351  {
352      NodeInfo ret;
353      /* Iterate over all tracked leaves in a, add b's hash to their Merkle branch, and move them to ret. */
354      for (auto& leaf : a.leaves) {
355          leaf.merkle_branch.push_back(b.hash);
356          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      for (auto& leaf : b.leaves) {
360          leaf.merkle_branch.push_back(a.hash);
361          ret.leaves.emplace_back(std::move(leaf));
362      }
363      ret.hash = ComputeTapbranchHash(a.hash, b.hash);
364      return ret;
365  }
366  
367  void TaprootSpendData::Merge(TaprootSpendData other)
368  {
369      // TODO: figure out how to better deal with conflicting information
370      // being merged.
371      if (internal_key.IsNull() && !other.internal_key.IsNull()) {
372          internal_key = other.internal_key;
373      }
374      if (merkle_root.IsNull() && !other.merkle_root.IsNull()) {
375          merkle_root = other.merkle_root;
376      }
377      for (auto& [key, control_blocks] : other.scripts) {
378          scripts[key].merge(std::move(control_blocks));
379      }
380  }
381  
382  void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
383  {
384      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      if ((size_t)depth + 1 < m_branch.size()) {
389          m_valid = false;
390          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      while (m_valid && m_branch.size() > (size_t)depth && m_branch[depth].has_value()) {
395          node = Combine(std::move(node), std::move(*m_branch[depth]));
396          m_branch.pop_back();
397          if (depth == 0) m_valid = false; /* Can't propagate further up than the root */
398          --depth;
399      }
400      if (m_valid) {
401          /* Make sure the branch is big enough to place the new node. */
402          if (m_branch.size() <= (size_t)depth) m_branch.resize((size_t)depth + 1);
403          assert(!m_branch[depth].has_value());
404          m_branch[depth] = std::move(node);
405      }
406  }
407  
408  /*static*/ bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
409  {
410      std::vector<bool> branch;
411      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          if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
417          if ((size_t)depth + 1 < branch.size()) return false;
418          while (branch.size() > (size_t)depth && branch[depth]) {
419              branch.pop_back();
420              if (depth == 0) return false;
421              --depth;
422          }
423          if (branch.size() <= (size_t)depth) branch.resize((size_t)depth + 1);
424          assert(!branch[depth]);
425          branch[depth] = true;
426      }
427      // And this check corresponds to the IsComplete() check on m_branch.
428      return branch.size() == 0 || (branch.size() == 1 && branch[0]);
429  }
430  
431  TaprootBuilder& TaprootBuilder::Add(int depth, std::span<const unsigned char> script, int leaf_version, bool track)
432  {
433      assert((leaf_version & ~TAPROOT_LEAF_MASK) == 0);
434      if (!IsValid()) return *this;
435      /* Construct NodeInfo object with leaf hash and (if track is true) also leaf information. */
436      NodeInfo node;
437      node.hash = ComputeTapleafHash(leaf_version, script);
438      if (track) node.leaves.emplace_back(LeafInfo{std::vector<unsigned char>(script.begin(), script.end()), leaf_version, {}});
439      /* Insert into the branch. */
440      Insert(std::move(node), depth);
441      return *this;
442  }
443  
444  TaprootBuilder& TaprootBuilder::AddOmitted(int depth, const uint256& hash)
445  {
446      if (!IsValid()) return *this;
447      /* Construct NodeInfo object with the hash directly, and insert it into the branch. */
448      NodeInfo node;
449      node.hash = hash;
450      Insert(std::move(node), depth);
451      return *this;
452  }
453  
454  TaprootBuilder& TaprootBuilder::Finalize(const XOnlyPubKey& internal_key)
455  {
456      /* Can only call this function when IsComplete() is true. */
457      assert(IsComplete());
458      m_internal_key = internal_key;
459      auto ret = m_internal_key.CreateTapTweak(m_branch.size() == 0 ? nullptr : &m_branch[0]->hash);
460      assert(ret.has_value());
461      std::tie(m_output_key, m_parity) = *ret;
462      return *this;
463  }
464  
465  WitnessV1Taproot TaprootBuilder::GetOutput() { return WitnessV1Taproot{m_output_key}; }
466  
467  TaprootSpendData TaprootBuilder::GetSpendData() const
468  {
469      assert(IsComplete());
470      assert(m_output_key.IsFullyValid());
471      TaprootSpendData spd;
472      spd.merkle_root = m_branch.size() == 0 ? uint256() : m_branch[0]->hash;
473      spd.internal_key = m_internal_key;
474      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          for (const auto& leaf : m_branch[0]->leaves) {
479              std::vector<unsigned char> control_block;
480              control_block.resize(TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size());
481              control_block[0] = leaf.leaf_version | (m_parity ? 1 : 0);
482              std::copy(m_internal_key.begin(), m_internal_key.end(), control_block.begin() + 1);
483              if (leaf.merkle_branch.size()) {
484                  std::copy(leaf.merkle_branch[0].begin(),
485                            leaf.merkle_branch[0].begin() + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size(),
486                            control_block.begin() + TAPROOT_CONTROL_BASE_SIZE);
487              }
488              spd.scripts[{leaf.script, leaf.leaf_version}].insert(std::move(control_block));
489          }
490      }
491      return spd;
492  }
493  
494  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      auto tweak = spenddata.internal_key.CreateTapTweak(spenddata.merkle_root.IsNull() ? nullptr : &spenddata.merkle_root);
498      if (!tweak || tweak->first != output) return std::nullopt;
499      // If the Merkle root is 0, the tree is empty, and we're done.
500      std::vector<std::tuple<int, std::vector<unsigned char>, int>> ret;
501      if (spenddata.merkle_root.IsNull()) return ret;
502  
503      /** Data structure to represent the nodes of the tree we're going to build. */
504      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      TreeNode root;
522      root.hash = spenddata.merkle_root;
523      for (const auto& [key, control_blocks] : spenddata.scripts) {
524          const auto& [script, leaf_ver] = key;
525          for (const auto& control : control_blocks) {
526              // Skip script records with nonsensical leaf version.
527              if (leaf_ver < 0 || leaf_ver >= 0x100 || leaf_ver & 1) continue;
528              // Skip script records with invalid control block sizes.
529              if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE ||
530                  ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) continue;
531              // Skip script records that don't match the control block.
532              if ((control[0] & TAPROOT_LEAF_MASK) != leaf_ver) continue;
533              // Skip script records that don't match the provided Merkle root.
534              const uint256 leaf_hash = ComputeTapleafHash(leaf_ver, script);
535              const uint256 merkle_root = ComputeTaprootMerkleRoot(control, leaf_hash);
536              if (merkle_root != spenddata.merkle_root) continue;
537  
538              TreeNode* node = &root;
539              size_t levels = (control.size() - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE;
540              for (size_t depth = 0; depth < levels; ++depth) {
541                  // Can't descend into a node which we already know is a leaf.
542                  if (node->explored && !node->inner) return std::nullopt;
543  
544                  // Extract partner hash from Merkle branch in control block.
545                  uint256 hash;
546                  std::copy(control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - 1 - depth) * TAPROOT_CONTROL_NODE_SIZE,
547                            control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - depth) * TAPROOT_CONTROL_NODE_SIZE,
548                            hash.begin());
549  
550                  if (node->sub[0]) {
551                      // Descend into the existing left or right branch.
552                      bool desc = false;
553                      for (int i = 0; i < 2; ++i) {
554                          if (node->sub[i]->hash == hash || (node->sub[i]->hash.IsNull() && node->sub[1-i]->hash != hash)) {
555                              node->sub[i]->hash = hash;
556                              node = &*node->sub[1-i];
557                              desc = true;
558                              break;
559                          }
560                      }
561                      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                      node->explored = true;
565                      node->inner = true;
566                      node->sub[0] = std::make_unique<TreeNode>();
567                      node->sub[1] = std::make_unique<TreeNode>();
568                      node->sub[1]->hash = hash;
569                      node = &*node->sub[0];
570                  }
571              }
572              // Cannot turn a known inner node into a leaf.
573              if (node->sub[0]) return std::nullopt;
574              node->explored = true;
575              node->inner = false;
576              node->leaf = &key;
577              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      std::vector<TreeNode*> stack{&root};
584      while (!stack.empty()) {
585          TreeNode& node = *stack.back();
586          if (!node.explored) {
587              // Unexplored node, which means the tree is incomplete.
588              return std::nullopt;
589          } else if (!node.inner) {
590              // Leaf node; produce output.
591              ret.emplace_back(stack.size() - 1, node.leaf->first, node.leaf->second);
592              node.done = true;
593              stack.pop_back();
594          } else if (node.sub[0]->done && !node.sub[1]->done && !node.sub[1]->explored && !node.sub[1]->hash.IsNull() &&
595                     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              node.sub[0]->done = false;
610              node.sub[1]->done = true;
611          } else if (node.sub[0]->done && node.sub[1]->done) {
612              // An internal node which we're finished with.
613              node.sub[0]->done = false;
614              node.sub[1]->done = false;
615              node.done = true;
616              stack.pop_back();
617          } else if (!node.sub[0]->done) {
618              // An internal node whose left branch hasn't been processed yet. Do so first.
619              stack.push_back(&*node.sub[0]);
620          } else if (!node.sub[1]->done) {
621              // An internal node whose right branch hasn't been processed yet. Do so first.
622              stack.push_back(&*node.sub[1]);
623          }
624      }
625  
626      return ret;
627  }
628  
629  std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> TaprootBuilder::GetTreeTuples() const
630  {
631      assert(IsComplete());
632      std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> tuples;
633      if (m_branch.size()) {
634          const auto& leaves = m_branch[0]->leaves;
635          for (const auto& leaf : leaves) {
636              assert(leaf.merkle_branch.size() <= TAPROOT_CONTROL_MAX_NODE_COUNT);
637              uint8_t depth = (uint8_t)leaf.merkle_branch.size();
638              uint8_t leaf_ver = (uint8_t)leaf.leaf_version;
639              tuples.emplace_back(depth, leaf_ver, leaf.script);
640          }
641      }
642      return tuples;
643  }