Describing wallet spending conditions

501        } else {
502            for (auto entry : m_path) {
503                if (!parent_extkey.Derive(parent_extkey, entry)) return std::nullopt;
504            }
505            final_extkey = parent_extkey;
506            if (m_derive == DeriveType::UNHARDENED_RANGED) der = parent_extkey.Derive(final_extkey, pos);
507            assert(m_derive != DeriveType::HARDENED_RANGED);
508        }
509        if (!der) return std::nullopt;
510
511        out.origins.emplace(final_extkey.pubkey.GetID(), std::make_pair(final_extkey.pubkey, info));
512        out.pubkeys.emplace(final_extkey.pubkey.GetID(), final_extkey.pubkey);
513
514        if (write_cache) {
515            // Only cache parent if there is any unhardened derivation
516            if (m_derive != DeriveType::HARDENED_RANGED) {
517                write_cache->CacheParentExtPubKey(m_expr_index, parent_extkey);
518                // Cache last hardened xpub if we have it
519                if (last_hardened_extkey.pubkey.IsValid()) {
520                    write_cache->CacheLastHardenedExtPubKey(m_expr_index, last_hardened_extkey);
521                }
522            } else if (info.path.size() > 0) {
523                write_cache->CacheDerivedExtPubKey(m_expr_index, pos, final_extkey);
524            }
525        }
526
527        return final_extkey.pubkey;
528    }
529    std::string ToString(StringType type, bool normalized) const
530    {
531        bool use_apostrophe{DetermineApostropheUse(type, normalized, m_apostrophe)};
532        std::string ret = EncodeExtPubKey(m_root_extkey) + FormatHDKeypath(m_path, /*apostrophe=*/use_apostrophe);
533        if (IsRange()) {
534            ret += "/*";
535            if (m_derive == DeriveType::HARDENED_RANGED) ret += use_apostrophe ? '\'' : 'h';
536        }
537        return ret;
538    }
539    std::string ToString(StringType type) const override
540    {
541        return ToString(type, /*normalized=*/false);
542    }
543    bool ToPrivateString(const SigningProvider& arg, std::string& out) const override
544    {
545        CExtKey key;
546        if (!GetExtKey(arg, key)) {
547            out = ToString(StringType::PUBLIC);
548            return false;
549        }
550        out = EncodeExtKey(key) + FormatHDKeypath(m_path, /*apostrophe=*/m_apostrophe);
551        if (IsRange()) {
552            out += "/*";
553            if (m_derive == DeriveType::HARDENED_RANGED) out += m_apostrophe ? '\'' : 'h';
554        }
555        return true;
556    }
557    bool ToNormalizedString(const SigningProvider& arg, std::string& out, const DescriptorCache* cache) const override
558    {
559        if (m_derive == DeriveType::HARDENED_RANGED) {
560            out = ToString(StringType::PUBLIC, /*normalized=*/true);
561
562            return true;
563        }
564        // Step backwards to find the last hardened step in the path
565        int i = (int)m_path.size() - 1;
566        for (; i >= 0; --i) {
567            if (m_path.at(i) >> 31) {
568                break;
569            }
570        }
571        // Either no derivation or all unhardened derivation
572        if (i == -1) {
573            out = ToString(StringType::PUBLIC);
574            return true;
575        }
576        // Get the path to the last hardened stup
577        KeyOriginInfo origin;
578        int k = 0;
579        for (; k <= i; ++k) {
580            // Add to the path
581            origin.path.push_back(m_path.at(k));
582        }
583        // Build the remaining path
584        KeyPath end_path;
585        for (; k < (int)m_path.size(); ++k) {
586            end_path.push_back(m_path.at(k));
587        }
588        origin.fingerprint = m_root_extkey.id_key_fingerprint();
589
590        CExtPubKey xpub;
591        CExtKey lh_xprv;
592        // If we have the cache, just get the parent xpub
593        if (cache != nullptr) {
594            cache->GetCachedLastHardenedExtPubKey(m_expr_index, xpub);
595        }
596        if (!xpub.pubkey.IsValid()) {
597            // Cache miss, or nor cache, or need privkey
598            CExtKey xprv;
599            if (!GetDerivedExtKey(arg, xprv, lh_xprv)) return false;
600            xpub = lh_xprv.Neuter();
601        }
602        assert(xpub.pubkey.IsValid());
603
604        // Build the string
605        std::string origin_str = HexStr(origin.fingerprint) + FormatHDKeypath(origin.path);
606        out = "[" + origin_str + "]" + EncodeExtPubKey(xpub) + FormatHDKeypath(end_path);
607        if (IsRange()) {
608            out += "/*";
609            assert(m_derive == DeriveType::UNHARDENED_RANGED);
610        }
611        return true;
612    }
613    void GetPrivKey(int pos, const SigningProvider& arg, FlatSigningProvider& out) const override
614    {
615        CExtKey extkey;
616        CExtKey dummy;
617        if (!GetDerivedExtKey(arg, extkey, dummy)) return;
618        if (m_derive == DeriveType::UNHARDENED_RANGED && !extkey.Derive(extkey, pos)) return;
619        if (m_derive == DeriveType::HARDENED_RANGED && !extkey.Derive(extkey, pos | BIP32_HARDENED_FLAG)) return;
620        out.keys.emplace(extkey.key.GetPubKey().GetID(), extkey.key);
621    }
622    std::optional<CPubKey> GetRootPubKey() const override
623    {
624        return std::nullopt;
625    }
626    std::optional<CExtPubKey> GetRootExtPubKey() const override
627    {
628        return m_root_extkey;
629    }
630    std::unique_ptr<PubkeyProvider> Clone() const override
631    {
632        return std::make_unique<BIP32PubkeyProvider>(m_expr_index, m_root_extkey, m_path, m_derive, m_apostrophe);
633    }
634    bool CanSelfExpand() const override { return !IsHardened(); }
635};
636
637/** PubkeyProvider for a musig() expression */
638class MuSigPubkeyProvider final : public PubkeyProvider
639{
640private:
641    //! PubkeyProvider for the participants
642    const std::vector<std::unique_ptr<PubkeyProvider>> m_participants;
643    //! Derivation path
644    const KeyPath m_path;
645    //! PubkeyProvider for the aggregate pubkey if it can be cached (i.e. participants are not ranged)
646    mutable std::unique_ptr<PubkeyProvider> m_aggregate_provider;
647    mutable std::optional<CPubKey> m_aggregate_pubkey;
648    const DeriveType m_derive;
649    const bool m_ranged_participants;
650
651    bool IsRangedDerivation() const { return m_derive != DeriveType::NON_RANGED; }
652
653public:
654    MuSigPubkeyProvider(
655        uint32_t exp_index,
656        std::vector<std::unique_ptr<PubkeyProvider>> providers,
657        KeyPath path,
658        DeriveType derive
659    )
660        : PubkeyProvider(exp_index),
661        m_participants(std::move(providers)),
662        m_path(std::move(path)),
663        m_derive(derive),
664        m_ranged_participants(std::any_of(m_participants.begin(), m_participants.end(), [](const auto& pubkey) { return pubkey->IsRange(); }))
665    {
666        if (!Assume(!(m_ranged_participants && IsRangedDerivation()))) {
667            throw std::runtime_error("musig(): Cannot have both ranged participants and ranged derivation");
668        }
669        if (!Assume(m_derive != DeriveType::HARDENED_RANGED)) {
670            throw std::runtime_error("musig(): Cannot have hardened derivation");
671        }
672    }
673
674    std::optional<CPubKey> GetPubKey(int pos, const SigningProvider& arg, FlatSigningProvider& out, const DescriptorCache* read_cache = nullptr, DescriptorCache* write_cache = nullptr) const override
675    {
676        FlatSigningProvider dummy;
677        // If the participants are not ranged, we can compute and cache the aggregate pubkey by creating a PubkeyProvider for it
678        if (!m_aggregate_provider && !m_ranged_participants) {
679            // Retrieve the pubkeys from the providers
680            std::vector<CPubKey> pubkeys;
681            for (const auto& prov : m_participants) {
682                std::optional<CPubKey> pubkey = prov->GetPubKey(0, arg, dummy, read_cache, write_cache);
683                if (!pubkey.has_value()) {
684                    return std::nullopt;
685                }
686                pubkeys.push_back(pubkey.value());
687            }
688            std::sort(pubkeys.begin(), pubkeys.end());
689
690            // Aggregate the pubkey
691            m_aggregate_pubkey = MuSig2AggregatePubkeys(pubkeys);
692            if (!Assume(m_aggregate_pubkey.has_value())) return std::nullopt;
693
694            // Make our pubkey provider
695            if (IsRangedDerivation() || !m_path.empty()) {
696                // Make the synthetic xpub and construct the BIP32PubkeyProvider
697                CExtPubKey extpub = CreateMuSig2SyntheticXpub(m_aggregate_pubkey.value());
698                m_aggregate_provider = std::make_unique<BIP32PubkeyProvider>(m_expr_index, extpub, m_path, m_derive, /*apostrophe=*/false);
699            } else {
700                m_aggregate_provider = std::make_unique<ConstPubkeyProvider>(m_expr_index, m_aggregate_pubkey.value(), /*xonly=*/false);
701            }
702        }
703
704        // Retrieve all participant pubkeys
705        std::vector<CPubKey> pubkeys;
706        for (const auto& prov : m_participants) {
707            std::optional<CPubKey> pub = prov->GetPubKey(pos, arg, out, read_cache, write_cache);
708            if (!pub) return std::nullopt;
709            pubkeys.emplace_back(*pub);
710        }
711        std::sort(pubkeys.begin(), pubkeys.end());
712
713        CPubKey pubout;
714        if (m_aggregate_provider) {
715            // When we have a cached aggregate key, we are either returning it or deriving from it
716            // Either way, we can passthrough to its GetPubKey
717            // Use a dummy signing provider as private keys do not exist for the aggregate pubkey
718            std::optional<CPubKey> pub = m_aggregate_provider->GetPubKey(pos, dummy, out, read_cache, write_cache);
719            if (!pub) return std::nullopt;
720            pubout = *pub;
721            out.aggregate_pubkeys.emplace(m_aggregate_pubkey.value(), pubkeys);
722        } else {
723            if (!Assume(m_ranged_participants) || !Assume(m_path.empty())) return std::nullopt;
724            // Compute aggregate key from derived participants
725            std::optional<CPubKey> aggregate_pubkey = MuSig2AggregatePubkeys(pubkeys);
726            if (!aggregate_pubkey) return std::nullopt;
727            pubout = *aggregate_pubkey;
728
729            std::unique_ptr<ConstPubkeyProvider> this_agg_provider = std::make_unique<ConstPubkeyProvider>(m_expr_index, aggregate_pubkey.value(), /*xonly=*/false);
730            this_agg_provider->GetPubKey(0, dummy, out, read_cache, write_cache);
731            out.aggregate_pubkeys.emplace(pubout, pubkeys);
732        }
733
734        if (!Assume(pubout.IsValid())) return std::nullopt;
735        return pubout;
736    }
737    bool IsRange() const override { return IsRangedDerivation() || m_ranged_participants; }
738    // musig() expressions can only be used in tr() contexts which have 32 byte xonly pubkeys
739    size_t GetSize() const override { return 32; }
740
741    std::string ToString(StringType type) const override
742    {
743        std::string out = "musig(";
744        for (size_t i = 0; i < m_participants.size(); ++i) {
745            const auto& pubkey = m_participants.at(i);
746            if (i) out += ",";
747            out += pubkey->ToString(type);
748        }
749        out += ")";
750        out += FormatHDKeypath(m_path);