Managing descriptor scripts, derivation caches and PSBT data

501    // P2SH, P2WSH, and P2SH-P2WSH as a precaution.
502    for (const auto& script : setWatchOnly) {
503        add_script(script);
504    }
505
506    return candidate_spks;
507}
508
509std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetScriptPubKeys() const
510{
511    // Run IsMine() on each candidate output script. Any script that IsMine is an output
512    // script to return.
513    // This both filters out things that are not watched by the wallet, and things that are invalid.
514    std::unordered_set<CScript, SaltedSipHasher> spks;
515    for (const CScript& script : GetCandidateScriptPubKeys()) {
516        if (IsMine(script)) {
517            spks.insert(script);
518        }
519    }
520
521    return spks;
522}
523
524std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetNotMineScriptPubKeys() const
525{
526    LOCK(cs_KeyStore);
527    std::unordered_set<CScript, SaltedSipHasher> spks;
528    for (const CScript& script : setWatchOnly) {
529        if (!IsMine(script)) spks.insert(script);
530    }
531    return spks;
532}
533
534std::optional<MigrationData> LegacyDataSPKM::MigrateToDescriptor()
535{
536    LOCK(cs_KeyStore);
537    if (m_storage.IsLocked()) {
538        return std::nullopt;
539    }
540
541    MigrationData out;
542
543    std::unordered_set<CScript, SaltedSipHasher> spks{GetScriptPubKeys()};
544
545    // Get all key ids
546    std::set<CKeyID> keyids;
547    for (const auto& key_pair : mapKeys) {
548        keyids.insert(key_pair.first);
549    }
550    for (const auto& key_pair : mapCryptedKeys) {
551        keyids.insert(key_pair.first);
552    }
553
554    // Get key metadata and figure out which keys don't have a seed
555    // Note that we do not ignore the seeds themselves because they are considered IsMine!
556    for (auto keyid_it = keyids.begin(); keyid_it != keyids.end();) {
557        const CKeyID& keyid = *keyid_it;
558        const auto& it = mapKeyMetadata.find(keyid);
559        if (it != mapKeyMetadata.end()) {
560            const CKeyMetadata& meta = it->second;
561            if (meta.hdKeypath == "s" || meta.hdKeypath == "m") {
562                keyid_it++;
563                continue;
564            }
565            if (!meta.hd_seed_id.IsNull() && (m_hd_chain.seed_id == meta.hd_seed_id || m_inactive_hd_chains.contains(meta.hd_seed_id))) {
566                keyid_it = keyids.erase(keyid_it);
567                continue;
568            }
569        }
570        keyid_it++;
571    }
572
573    WalletBatch batch(m_storage.GetDatabase());
574    if (!batch.TxnBegin()) {
575        LogWarning("Error generating descriptors for migration, cannot initialize db transaction");
576        return std::nullopt;
577    }
578
579    // keyids is now all non-HD keys. Each key will have its own combo descriptor
580    for (const CKeyID& keyid : keyids) {
581        CKey key;
582        if (!GetKey(keyid, key)) {
583            assert(false);
584        }
585
586        // Get birthdate from key meta
587        uint64_t creation_time = 0;
588        const auto& it = mapKeyMetadata.find(keyid);
589        if (it != mapKeyMetadata.end()) {
590            creation_time = it->second.nCreateTime;
591        }
592
593        // Get the key origin
594        // Maybe this doesn't matter because floating keys here shouldn't have origins
595        KeyOriginInfo info;
596        bool has_info = GetKeyOrigin(keyid, info);
597        std::string origin_str = has_info ? "[" + HexStr(info.fingerprint) + FormatHDKeypath(info.path) + "]" : "";
598
599        // Construct the combo descriptor
600        std::string desc_str = "combo(" + origin_str + HexStr(key.GetPubKey()) + ")";
601        FlatSigningProvider provider;
602        std::string error;
603        std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, provider, error, false);
604        CHECK_NONFATAL(descs.size() == 1); // It shouldn't be possible to have an invalid or multipath descriptor
605        WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
606
607        // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
608        provider.keys.emplace(key.GetPubKey().GetID(), key);
609        auto desc_spk_man = DescriptorScriptPubKeyMan::CreateFromMigration(m_storage, batch, w_desc, /*keypool_size=*/0, provider);
610        auto desc_spks = desc_spk_man->GetScriptPubKeys();
611
612        // Remove the scriptPubKeys from our current set
613        for (const CScript& spk : desc_spks) {
614            size_t erased = spks.erase(spk);
615            assert(erased == 1);
616            assert(IsMine(spk));
617        }
618
619        out.desc_spkms.push_back(std::move(desc_spk_man));
620    }
621
622    // Handle HD keys by using the CHDChains
623    std::set<CHDChain> chains;
624    chains.insert(m_hd_chain);
625    for (const auto& chain_pair : m_inactive_hd_chains) {
626        chains.insert(chain_pair.second);
627    }
628
629    bool can_support_hd_split_feature = m_hd_chain.nVersion >= CHDChain::VERSION_HD_CHAIN_SPLIT;
630
631    std::set<CExtPubKey> master_xpubs;
632    for (const CHDChain& chain : chains) {
633        if (chain.seed_id.IsNull()) continue;
634
635        // Get the master xprv
636        CKey seed_key;
637        if (!GetKey(chain.seed_id, seed_key)) {
638            assert(false);
639        }
640        CExtKey master_key;
641        master_key.SetSeed(seed_key);
642
643        // Get the xpub and verify that we haven't already seen this xpub before
644        CExtPubKey master_xpub = master_key.Neuter();
645        const auto& [_, inserted] = master_xpubs.insert(master_xpub);
646        if (!inserted) continue;
647
648        for (int i = 0; i < 2; ++i) {
649            // Skip if doing internal chain and split chain is not supported
650            if (i == 1 && !can_support_hd_split_feature) {
651                continue;
652            }
653
654            // Make the combo descriptor
655            std::string xpub = EncodeExtPubKey(master_key.Neuter());
656            std::string desc_str = "combo(" + xpub + "/0h/" + ToString(i) + "h/*h)";
657            FlatSigningProvider provider;
658            std::string error;
659            std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, provider, error, false);
660            CHECK_NONFATAL(descs.size() == 1); // It shouldn't be possible to have an invalid or multipath descriptor
661            uint32_t chain_counter = std::max((i == 1 ? chain.nInternalChainCounter : chain.nExternalChainCounter), (uint32_t)0);
662            WalletDescriptor w_desc(std::move(descs.at(0)), 0, 0, chain_counter, 0);
663
664            // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
665            provider.keys.emplace(master_key.key.GetPubKey().GetID(), master_key.key);
666            auto desc_spk_man = DescriptorScriptPubKeyMan::CreateFromMigration(m_storage, batch, w_desc, /*keypool_size=*/0, provider);
667            auto desc_spks = desc_spk_man->GetScriptPubKeys();
668
669            // Remove the scriptPubKeys from our current set
670            for (const CScript& spk : desc_spks) {
671                size_t erased = spks.erase(spk);
672                assert(erased == 1);
673                assert(IsMine(spk));
674            }
675
676            out.desc_spkms.push_back(std::move(desc_spk_man));
677        }
678    }
679    // Add the current master seed to the migration data
680    if (!m_hd_chain.seed_id.IsNull()) {
681        CKey seed_key;
682        if (!GetKey(m_hd_chain.seed_id, seed_key)) {
683            assert(false);
684        }
685        out.master_key.SetSeed(seed_key);
686    }
687
688    // Handle the rest of the scriptPubKeys which must be imports and may not have all info
689    for (auto it = spks.begin(); it != spks.end();) {
690        const CScript& spk = *it;
691
692        // Get birthdate from script meta
693        uint64_t creation_time = 0;
694        const auto& mit = m_script_metadata.find(CScriptID(spk));
695        if (mit != m_script_metadata.end()) {
696            creation_time = mit->second.nCreateTime;
697        }
698
699        // InferDescriptor as that will get us all the solving info if it is there
700        std::unique_ptr<Descriptor> desc = InferDescriptor(spk, *GetSolvingProvider(spk));
701
702        // Past bugs in InferDescriptor have caused it to create descriptors which cannot be re-parsed.
703        // Re-parse the descriptors to detect that, and skip any that do not parse.
704        {
705            std::string desc_str = desc->ToString();
706            FlatSigningProvider parsed_keys;
707            std::string parse_error;
708            std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str, parsed_keys, parse_error);
709            if (parsed_descs.empty()) {
710                // Remove this scriptPubKey from the set
711                it = spks.erase(it);
712                continue;
713            }
714        }
715
716        // Get the private keys for this descriptor
717        std::vector<CScript> scripts;
718        FlatSigningProvider keys;
719        if (!desc->Expand(0, DUMMY_SIGNING_PROVIDER, scripts, keys)) {
720            assert(false);
721        }
722        std::set<CKeyID> privkeyids;
723        for (const auto& key_orig_pair : keys.origins) {
724            privkeyids.insert(key_orig_pair.first);
725        }
726
727        std::vector<CScript> desc_spks;
728
729        // If we can't provide all private keys for this inferred descriptor,
730        // but this wallet is not watch-only, migrate it to the watch-only wallet.
731        if (!desc->HavePrivateKeys(*this) && !m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
732            out.watch_descs.emplace_back(desc->ToString(), creation_time);
733
734            // Get the scriptPubKeys without writing this to the wallet
735            FlatSigningProvider provider;
736            desc->Expand(0, provider, desc_spks, provider);
737        } else {
738            // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
739            for (const auto& keyid : privkeyids) {
740                CKey key;
741                if (!GetKey(keyid, key)) {
742                    continue;
743                }
744                keys.keys.emplace(key.GetPubKey().GetID(), key);
745            }
746            WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
747            auto desc_spk_man = DescriptorScriptPubKeyMan::CreateFromMigration(m_storage, batch, w_desc, /*keypool_size=*/0, keys);
748            auto desc_spks_set = desc_spk_man->GetScriptPubKeys();
749            desc_spks.insert(desc_spks.end(), desc_spks_set.begin(), desc_spks_set.end());
750