751            out.desc_spkms.push_back(std::move(desc_spk_man));
752        }
753
754        // Remove the scriptPubKeys from our current set
755        for (const CScript& desc_spk : desc_spks) {
756            auto del_it = spks.find(desc_spk);
757            assert(del_it != spks.end());
758            assert(IsMine(desc_spk));
759            it = spks.erase(del_it);
760        }
761    }
762
763    // Make sure that we have accounted for all scriptPubKeys
764    if (!Assume(spks.empty())) {
765        LogError("%s", STR_INTERNAL_BUG("Error: Some output scripts were not migrated."));
766        return std::nullopt;
767    }
768
769    // Legacy wallets can also contain scripts whose P2SH, P2WSH, or P2SH-P2WSH it is not watching for
770    // but can provide script data to a PSBT spending them. These "solvable" output scripts will need to
771    // be put into the separate "solvables" wallet.
772    // These can be detected by going through the entire candidate output scripts, finding the not IsMine scripts,
773    // and checking CanProvide() which will dummy sign.
774    for (const CScript& script : GetCandidateScriptPubKeys()) {
775        // Since we only care about P2SH, P2WSH, and P2SH-P2WSH, filter out any scripts that are not those
776        if (!script.IsPayToScriptHash() && !script.IsPayToWitnessScriptHash()) {
777            continue;
778        }
779        if (IsMine(script)) {
780            continue;
781        }
782        SignatureData dummy_sigdata;
783        if (!CanProvide(script, dummy_sigdata)) {
784            continue;
785        }
786
787        // Get birthdate from script meta
788        uint64_t creation_time = 0;
789        const auto& it = m_script_metadata.find(CScriptID(script));
790        if (it != m_script_metadata.end()) {
791            creation_time = it->second.nCreateTime;
792        }
793
794        // InferDescriptor as that will get us all the solving info if it is there
795        std::unique_ptr<Descriptor> desc = InferDescriptor(script, *GetSolvingProvider(script));
796        if (!desc->IsSolvable()) {
797            // The wallet was able to provide some information, but not enough to make a descriptor that actually
798            // contains anything useful. This is probably because the script itself is actually unsignable (e.g. P2WSH-P2WSH).
799            continue;
800        }
801
802        // Past bugs in InferDescriptor have caused it to create descriptors which cannot be re-parsed
803        // Re-parse the descriptors to detect that, and skip any that do not parse.
804        {
805            std::string desc_str = desc->ToString();
806            FlatSigningProvider parsed_keys;
807            std::string parse_error;
808            std::vector<std::unique_ptr<Descriptor>> parsed_descs = Parse(desc_str, parsed_keys, parse_error, false);
809            if (parsed_descs.empty()) {
810                continue;
811            }
812        }
813
814        out.solvable_descs.emplace_back(desc->ToString(), creation_time);
815    }
816
817    // Finalize transaction
818    if (!batch.TxnCommit()) {
819        LogWarning("Error generating descriptors for migration, cannot commit db transaction");
820        return std::nullopt;
821    }
822
823    return out;
824}
825
826bool LegacyDataSPKM::DeleteRecordsWithDB(WalletBatch& batch)
827{
828    LOCK(cs_KeyStore);
829    return batch.EraseRecords(DBKeys::LEGACY_TYPES);
830}
831
832std::unique_ptr<DescriptorScriptPubKeyMan> DescriptorScriptPubKeyMan::CreateFromImport(WalletStorage& storage, WalletDescriptor& descriptor, int64_t keypool_size, const FlatSigningProvider& provider)
833{
834    auto spkm = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(storage, descriptor, keypool_size));
835    LOCK(spkm->cs_desc_man);
836    WalletBatch batch(storage.GetDatabase());
837    spkm->UpdateWithSigningProvider(batch, provider);
838    return spkm;
839}
840
841std::unique_ptr<DescriptorScriptPubKeyMan> DescriptorScriptPubKeyMan::CreateFromMigration(WalletStorage& storage, WalletBatch& batch, WalletDescriptor& descriptor, int64_t keypool_size, const FlatSigningProvider& provider)
842{
843    auto spkm = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(storage, descriptor, keypool_size));
844    LOCK(spkm->cs_desc_man);
845    spkm->UpdateWithSigningProvider(batch, provider);
846    return spkm;
847}
848
849DescriptorScriptPubKeyMan::DescriptorScriptPubKeyMan(WalletStorage& storage, const uint256& id, WalletDescriptor& descriptor, int64_t keypool_size, const KeyMap& keys, const CryptedKeyMap& ckeys)
850    : ScriptPubKeyMan(storage),
851    m_map_keys(keys),
852    m_map_crypted_keys(ckeys),
853    m_keypool_size(keypool_size),
854    m_id(id),
855    m_wallet_descriptor(descriptor)
856{
857    if (!keys.empty() && !ckeys.empty()) {
858        throw std::runtime_error("Wallet contains both unencrypted and encrypted keys");
859    }
860    Load();
861}
862
863std::unique_ptr<DescriptorScriptPubKeyMan> DescriptorScriptPubKeyMan::LoadFromStorage(WalletStorage& storage, const uint256& id, WalletDescriptor& descriptor, int64_t keypool_size, const KeyMap& keys, const CryptedKeyMap& ckeys)
864{
865    return std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(storage, id, descriptor, keypool_size, keys, ckeys));
866}
867
868std::unique_ptr<DescriptorScriptPubKeyMan> DescriptorScriptPubKeyMan::GenerateNewSingleSig(WalletStorage& storage, WalletBatch& batch, int64_t keypool_size, const CExtKey& master_key, OutputType addr_type, bool internal)
869{
870    WalletDescriptor desc = GenerateWalletDescriptor(master_key.Neuter(), addr_type, internal);
871
872    auto spkm = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(storage, desc, keypool_size));
873
874    LOCK(spkm->cs_desc_man);
875    Assert(spkm->m_storage.IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
876
877    // Store the master private key, and descriptor
878    if (!spkm->AddDescriptorKeyWithDB(batch, master_key.key, master_key.key.GetPubKey())) {
879        throw std::runtime_error(std::string(__func__) + ": writing descriptor master private key failed");
880    }
881    if (!batch.WriteDescriptor(spkm->GetID(), spkm->m_wallet_descriptor)) {
882        throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
883    }
884
885    // Set m_decryption_thoroughly_checked for encrypted wallets
886    if (spkm->m_storage.HasEncryptionKeys()) {
887        spkm->m_decryption_thoroughly_checked = true;
888    }
889
890    // TopUp
891    spkm->TopUpWithDB(batch);
892
893    spkm->m_storage.UnsetBlankWalletFlag(batch);
894    return spkm;
895}
896
897void DescriptorScriptPubKeyMan::IncIndex()
898{
899    AssertLockHeld(cs_desc_man);
900
901    const auto old_can = CanGetAddresses();
902    m_wallet_descriptor.IncNext();
903    const auto new_can = CanGetAddresses();
904    if (old_can != new_can) {
905        NotifyCanGetAddressesChanged();
906    }
907}
908
909void DescriptorScriptPubKeyMan::DecIndex()
910{
911    AssertLockHeld(cs_desc_man);
912
913    const auto old_can = CanGetAddresses();
914    m_wallet_descriptor.DecNext();
915    const auto new_can = CanGetAddresses();
916    if (old_can != new_can) {
917        NotifyCanGetAddressesChanged();
918    }
919}
920
921void DescriptorScriptPubKeyMan::SetRangeEnd(int32_t end)
922{
923    AssertLockHeld(cs_desc_man);
924
925    const auto old_can = CanGetAddresses();
926    m_wallet_descriptor.SetEnd(end);
927    const auto new_can = CanGetAddresses();
928    if (old_can != new_can) {
929        NotifyCanGetAddressesChanged();
930    }
931}
932
933util::Result<CTxDestination> DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type)
934{
935    // Returns true if this descriptor supports getting new addresses. Conditions where we may be unable to fetch them (e.g. locked) are caught later
936    if (!CanGetAddresses()) {
937        return util::Error{_("No addresses available")};
938    }
939    {
940        LOCK(cs_desc_man);
941        assert(m_wallet_descriptor.descriptor->IsSingleType()); // This is a combo descriptor which should not be an active descriptor
942        std::optional<OutputType> desc_addr_type = m_wallet_descriptor.descriptor->GetOutputType();
943        assert(desc_addr_type);
944        if (type != *desc_addr_type) {
945            throw std::runtime_error(std::string(__func__) + ": Types are inconsistent. Stored type does not match type of newly generated address");
946        }
947
948        TopUp();
949
950        // Get the scriptPubKey from the descriptor
951        FlatSigningProvider out_keys;
952        std::vector<CScript> scripts_temp;
953        if (m_wallet_descriptor.GetEnd() <= m_max_cached_index && !TopUp(1)) {
954            // We can't generate anymore keys
955            return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
956        }
957        if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.GetNext(), m_wallet_descriptor.cache, scripts_temp, out_keys)) {
958            // We can't generate anymore keys
959            return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
960        }
961
962        CTxDestination dest;
963        if (!ExtractDestination(scripts_temp[0], dest)) {
964            return util::Error{_("Error: Cannot extract destination from the generated scriptpubkey")}; // shouldn't happen
965        }
966        IncIndex();
967        WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
968        return dest;
969    }
970}
971
972bool DescriptorScriptPubKeyMan::IsMine(const CScript& script) const
973{
974    LOCK(cs_desc_man);
975    return m_map_script_pub_keys.contains(script);
976}
977
978bool DescriptorScriptPubKeyMan::CheckDecryptionKey(const CKeyingMaterial& master_key)
979{
980    LOCK(cs_desc_man);
981    if (!m_map_keys.empty()) {
982        return false;
983    }
984
985    bool keyPass = m_map_crypted_keys.empty(); // Always pass when there are no encrypted keys
986    bool keyFail = false;
987    for (const auto& mi : m_map_crypted_keys) {
988        const CPubKey &pubkey = mi.second.first;
989        const std::vector<unsigned char> &crypted_secret = mi.second.second;
990        CKey key;
991        if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
992            keyFail = true;
993            break;
994        }
995        keyPass = true;
996        if (m_decryption_thoroughly_checked)
997            break;
998    }
999    if (keyPass && keyFail) {
1000        LogWarning("The wallet is probably corrupted: Some keys decrypt but not all.");