251    LOCK(cs_KeyStore);
252    std::set<CScriptID> set_script;
253    for (const auto& mi : mapScripts) {
254        set_script.insert(mi.first);
255    }
256    return set_script;
257}
258
259bool FillableSigningProvider::GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const
260{
261    LOCK(cs_KeyStore);
262    ScriptMap::const_iterator mi = mapScripts.find(hash);
263    if (mi != mapScripts.end())
264    {
265        redeemScriptOut = (*mi).second;
266        return true;
267    }
268    return false;
269}
270
271CKeyID GetKeyForDestination(const SigningProvider& store, const CTxDestination& dest)
272{
273    // Only supports destinations which map to single public keys:
274    // P2PKH, P2WPKH, P2SH-P2WPKH, P2TR
275    if (auto id = std::get_if<PKHash>(&dest)) {
276        return ToKeyID(*id);
277    }
278    if (auto witness_id = std::get_if<WitnessV0KeyHash>(&dest)) {
279        return ToKeyID(*witness_id);
280    }
281    if (auto script_hash = std::get_if<ScriptHash>(&dest)) {
282        CScript script;
283        CScriptID script_id = ToScriptID(*script_hash);
284        CTxDestination inner_dest;
285        if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) {
286            if (auto inner_witness_id = std::get_if<WitnessV0KeyHash>(&inner_dest)) {
287                return ToKeyID(*inner_witness_id);
288            }
289        }
290    }
291    if (auto output_key = std::get_if<WitnessV1Taproot>(&dest)) {
292        TaprootSpendData spenddata;
293        CPubKey pub;
294        if (store.GetTaprootSpendData(*output_key, spenddata)
295            && !spenddata.internal_key.IsNull()
296            && spenddata.merkle_root.IsNull()
297            && store.GetPubKeyByXOnly(spenddata.internal_key, pub)) {
298            return pub.GetID();
299        }
300    }
301    return CKeyID();
302}
303
304void MultiSigningProvider::AddProvider(std::unique_ptr<SigningProvider> provider)
305{
306    m_providers.push_back(std::move(provider));
307}
308
309bool MultiSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const
310{
311    for (const auto& provider: m_providers) {
312        if (provider->GetCScript(scriptid, script)) return true;
313    }
314    return false;
315}
316
317bool MultiSigningProvider::GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const
318{
319    for (const auto& provider: m_providers) {
320        if (provider->GetPubKey(keyid, pubkey)) return true;
321    }
322    return false;
323}
324
325
326bool MultiSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
327{
328    for (const auto& provider: m_providers) {
329        if (provider->GetKeyOrigin(keyid, info)) return true;
330    }
331    return false;
332}
333
334bool MultiSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const
335{
336    for (const auto& provider: m_providers) {
337        if (provider->GetKey(keyid, key)) return true;
338    }
339    return false;
340}
341
342bool MultiSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
343{
344    for (const auto& provider: m_providers) {
345        if (provider->GetTaprootSpendData(output_key, spenddata)) return true;
346    }
347    return false;
348}
349
350bool MultiSigningProvider::GetTaprootBuilder(const XOnlyPubKey& output_key, TaprootBuilder& builder) const
351{
352    for (const auto& provider: m_providers) {
353        if (provider->GetTaprootBuilder(output_key, builder)) return true;
354    }
355    return false;
356}
357
358/*static*/ TaprootBuilder::NodeInfo TaprootBuilder::Combine(NodeInfo&& a, NodeInfo&& b)
359{
360    NodeInfo ret;
361    /* Iterate over all tracked leaves in a, add b's hash to their Merkle branch, and move them to ret. */
362    for (auto& leaf : a.leaves) {
363        leaf.merkle_branch.push_back(b.hash);
364        ret.leaves.emplace_back(std::move(leaf));
365    }
366    /* Iterate over all tracked leaves in b, add a's hash to their Merkle branch, and move them to ret. */
367    for (auto& leaf : b.leaves) {
368        leaf.merkle_branch.push_back(a.hash);
369        ret.leaves.emplace_back(std::move(leaf));
370    }
371    ret.hash = ComputeTapbranchHash(a.hash, b.hash);
372    return ret;
373}
374
375void TaprootSpendData::Merge(TaprootSpendData other)
376{
377    // TODO: figure out how to better deal with conflicting information
378    // being merged.
379    if (internal_key.IsNull() && !other.internal_key.IsNull()) {
380        internal_key = other.internal_key;
381    }
382    if (merkle_root.IsNull() && !other.merkle_root.IsNull()) {
383        merkle_root = other.merkle_root;
384    }
385    for (auto& [key, control_blocks] : other.scripts) {
386        scripts[key].merge(std::move(control_blocks));
387    }
388}
389
390void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
391{
392    assert(depth >= 0 && (size_t)depth <= TAPROOT_CONTROL_MAX_NODE_COUNT);
393    /* We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
394     * so would mean the Add() invocations do not correspond to a DFS traversal of a
395     * binary tree. */
396    if ((size_t)depth + 1 < m_branch.size()) {
397        m_valid = false;
398        return;
399    }
400    /* As long as an entry in the branch exists at the specified depth, combine it and propagate up.
401     * The 'node' variable is overwritten here with the newly combined node. */
402    while (m_valid && m_branch.size() > (size_t)depth && m_branch[depth].has_value()) {
403        node = Combine(std::move(node), std::move(*m_branch[depth]));
404        m_branch.pop_back();
405        if (depth == 0) m_valid = false; /* Can't propagate further up than the root */
406        --depth;
407    }
408    if (m_valid) {
409        /* Make sure the branch is big enough to place the new node. */
410        if (m_branch.size() <= (size_t)depth) m_branch.resize((size_t)depth + 1);
411        assert(!m_branch[depth].has_value());
412        m_branch[depth] = std::move(node);
413    }
414}
415
416/*static*/ bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
417{
418    std::vector<bool> branch;
419    for (int depth : depths) {
420        // This inner loop corresponds to effectively the same logic on branch
421        // as what Insert() performs on the m_branch variable. Instead of
422        // storing a NodeInfo object, just remember whether or not there is one
423        // at that depth.
424        if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
425        if ((size_t)depth + 1 < branch.size()) return false;
426        while (branch.size() > (size_t)depth && branch[depth]) {
427            branch.pop_back();
428            if (depth == 0) return false;
429            --depth;
430        }
431        if (branch.size() <= (size_t)depth) branch.resize((size_t)depth + 1);
432        assert(!branch[depth]);
433        branch[depth] = true;
434    }
435    // And this check corresponds to the IsComplete() check on m_branch.
436    return branch.size() == 0 || (branch.size() == 1 && branch[0]);
437}
438
439TaprootBuilder& TaprootBuilder::Add(int depth, std::span<const unsigned char> script, int leaf_version, bool track)
440{
441    assert((leaf_version & ~TAPROOT_LEAF_MASK) == 0);
442    if (!IsValid()) return *this;
443    /* Construct NodeInfo object with leaf hash and (if track is true) also leaf information. */
444    NodeInfo node;
445    node.hash = ComputeTapleafHash(leaf_version, script);
446    if (track) node.leaves.emplace_back(LeafInfo{std::vector<unsigned char>(script.begin(), script.end()), leaf_version, {}});
447    /* Insert into the branch. */
448    Insert(std::move(node), depth);
449    return *this;
450}
451
452TaprootBuilder& TaprootBuilder::AddOmitted(int depth, const uint256& hash)
453{
454    if (!IsValid()) return *this;
455    /* Construct NodeInfo object with the hash directly, and insert it into the branch. */
456    NodeInfo node;
457    node.hash = hash;
458    Insert(std::move(node), depth);
459    return *this;
460}
461
462TaprootBuilder& TaprootBuilder::Finalize(const XOnlyPubKey& internal_key)
463{
464    /* Can only call this function when IsComplete() is true. */
465    assert(IsComplete());
466    m_internal_key = internal_key;
467    auto ret = m_internal_key.CreateTapTweak(m_branch.size() == 0 ? nullptr : &m_branch[0]->hash);
468    assert(ret.has_value());
469    std::tie(m_output_key, m_parity) = *ret;
470    return *this;
471}
472
473WitnessV1Taproot TaprootBuilder::GetOutput() { return WitnessV1Taproot{m_output_key}; }
474
475TaprootSpendData TaprootBuilder::GetSpendData() const
476{
477    assert(IsComplete());
478    assert(m_output_key.IsFullyValid());
479    TaprootSpendData spd;
480    spd.merkle_root = m_branch.size() == 0 ? uint256() : m_branch[0]->hash;
481    spd.internal_key = m_internal_key;
482    if (m_branch.size()) {
483        // If any script paths exist, they have been combined into the root m_branch[0]
484        // by now. Compute the control block for each of its tracked leaves, and put them in
485        // spd.scripts.
486        for (const auto& leaf : m_branch[0]->leaves) {
487            std::vector<unsigned char> control_block;
488            control_block.resize(TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size());
489            control_block[0] = leaf.leaf_version | (m_parity ? 1 : 0);
490            std::copy(m_internal_key.begin(), m_internal_key.end(), control_block.begin() + 1);
491            if (leaf.merkle_branch.size()) {
492                std::copy(leaf.merkle_branch[0].begin(),
493                          leaf.merkle_branch[0].begin() + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size(),
494                          control_block.begin() + TAPROOT_CONTROL_BASE_SIZE);
495            }
496            spd.scripts[{leaf.script, leaf.leaf_version}].insert(std::move(control_block));
497        }
498    }
499    return spd;
500}