1001        throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
1002    }
1003    if (keyFail || !keyPass) {
1004        return false;
1005    }
1006    m_decryption_thoroughly_checked = true;
1007    return true;
1008}
1009
1010bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch)
1011{
1012    LOCK(cs_desc_man);
1013    if (!m_map_crypted_keys.empty()) {
1014        return false;
1015    }
1016
1017    for (const KeyMap::value_type& key_in : m_map_keys)
1018    {
1019        const CKey &key = key_in.second;
1020        CPubKey pubkey = key.GetPubKey();
1021        CKeyingMaterial secret{UCharCast(key.begin()), UCharCast(key.end())};
1022        std::vector<unsigned char> crypted_secret;
1023        if (!EncryptSecret(master_key, secret, pubkey.GetHash(), crypted_secret)) {
1024            return false;
1025        }
1026        m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
1027        batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
1028    }
1029    m_map_keys.clear();
1030    return true;
1031}
1032
1033util::Result<CTxDestination> DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, int64_t& index)
1034{
1035    LOCK(cs_desc_man);
1036    auto op_dest = GetNewDestination(type);
1037    index = m_wallet_descriptor.GetNext() - 1;
1038    return op_dest;
1039}
1040
1041void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal, const CTxDestination& addr)
1042{
1043    LOCK(cs_desc_man);
1044    // Only return when the index was the most recent
1045    if (m_wallet_descriptor.GetNext() - 1 == index) {
1046        DecIndex();
1047    }
1048    WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
1049}
1050
1051std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const
1052{
1053    AssertLockHeld(cs_desc_man);
1054    if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
1055        KeyMap keys;
1056        for (const auto& key_pair : m_map_crypted_keys) {
1057            const CPubKey& pubkey = key_pair.second.first;
1058            const std::vector<unsigned char>& crypted_secret = key_pair.second.second;
1059            CKey key;
1060            m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
1061                return DecryptKey(encryption_key, crypted_secret, pubkey, key);
1062            });
1063            keys[pubkey.GetID()] = key;
1064        }
1065        return keys;
1066    }
1067    return m_map_keys;
1068}
1069
1070bool DescriptorScriptPubKeyMan::HasPrivKey(const CKeyID& keyid) const
1071{
1072    AssertLockHeld(cs_desc_man);
1073    return m_map_keys.contains(keyid) || m_map_crypted_keys.contains(keyid);
1074}
1075
1076std::optional<CKey> DescriptorScriptPubKeyMan::GetKey(const CKeyID& keyid) const
1077{
1078    AssertLockHeld(cs_desc_man);
1079    if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
1080        const auto& it = m_map_crypted_keys.find(keyid);
1081        if (it == m_map_crypted_keys.end()) {
1082            return std::nullopt;
1083        }
1084        const std::vector<unsigned char>& crypted_secret = it->second.second;
1085        CKey key;
1086        if (!Assume(m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
1087            return DecryptKey(encryption_key, crypted_secret, it->second.first, key);
1088        }))) {
1089            return std::nullopt;
1090        }
1091        return key;
1092    }
1093    const auto& it = m_map_keys.find(keyid);
1094    if (it == m_map_keys.end()) {
1095        return std::nullopt;
1096    }
1097    return it->second;
1098}
1099
1100bool DescriptorScriptPubKeyMan::TopUp(unsigned int size)
1101{
1102    WalletBatch batch(m_storage.GetDatabase());
1103    if (!batch.TxnBegin()) return false;
1104    bool res = TopUpWithDB(batch, size);
1105    if (!batch.TxnCommit()) throw std::runtime_error(strprintf("Error during descriptors keypool top up. Cannot commit changes for wallet [%s]", m_storage.LogName()));
1106    return res;
1107}
1108
1109bool DescriptorScriptPubKeyMan::TopUpWithDB(WalletBatch& batch, unsigned int size)
1110{
1111    LOCK(cs_desc_man);
1112    std::set<CScript> new_spks;
1113    unsigned int target_size;
1114    if (size > 0) {
1115        target_size = size;
1116    } else {
1117        target_size = m_keypool_size;
1118    }
1119
1120    // Calculate the new range_end
1121    int32_t new_range_end = std::max(m_wallet_descriptor.GetNext() + (int32_t)target_size, m_wallet_descriptor.GetEnd());
1122
1123    // If the descriptor is not ranged, we actually just want to fill the first cache item
1124    if (!m_wallet_descriptor.descriptor->IsRange()) {
1125        new_range_end = 1;
1126    }
1127
1128    FlatSigningProvider provider;
1129    provider.keys = GetKeys();
1130
1131    uint256 id = GetID();
1132    for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
1133        FlatSigningProvider out_keys;
1134        std::vector<CScript> scripts_temp;
1135        DescriptorCache temp_cache;
1136        // Maybe we have a cached xpub and we can expand from the cache first
1137        if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1138            if (!m_wallet_descriptor.descriptor->Expand(i, provider, scripts_temp, out_keys, &temp_cache)) return false;
1139        }
1140        // Add all of the scriptPubKeys to the scriptPubKey set
1141        new_spks.insert(scripts_temp.begin(), scripts_temp.end());
1142        for (const CScript& script : scripts_temp) {
1143            m_map_script_pub_keys[script] = i;
1144        }
1145        for (const auto& pk_pair : out_keys.pubkeys) {
1146            const CPubKey& pubkey = pk_pair.second;
1147            if (m_map_pubkeys.contains(pubkey)) {
1148                // We don't need to give an error here.
1149                // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and its private key
1150                continue;
1151            }
1152            m_map_pubkeys[pubkey] = i;
1153        }
1154        // Merge and write the cache
1155        DescriptorCache new_items = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
1156        if (!batch.WriteDescriptorCacheItems(id, new_items)) {
1157            throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
1158        }
1159        m_max_cached_index++;
1160    }
1161    SetRangeEnd(new_range_end);
1162    batch.WriteDescriptor(GetID(), m_wallet_descriptor);
1163
1164    // By this point, the cache size should be the size of the entire range
1165    assert(m_wallet_descriptor.GetEnd() - 1 == m_max_cached_index);
1166
1167    m_storage.TopUpCallback(new_spks, this);
1168    return true;
1169}
1170
1171std::vector<WalletDestination> DescriptorScriptPubKeyMan::MarkUnusedAddresses(const CScript& script)
1172{
1173    LOCK(cs_desc_man);
1174    std::vector<WalletDestination> result;
1175    if (IsMine(script)) {
1176        int32_t index = m_map_script_pub_keys[script];
1177        if (index >= m_wallet_descriptor.GetNext()) {
1178            WalletLogPrintf("%s: Detected a used keypool item at index %d, mark all keypool items up to this item as used\n", __func__, index);
1179            auto out_keys = std::make_unique<FlatSigningProvider>();
1180            std::vector<CScript> scripts_temp;
1181            while (index >= m_wallet_descriptor.GetNext()) {
1182                if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.GetNext(), m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
1183                    throw std::runtime_error(std::string(__func__) + ": Unable to expand descriptor from cache");
1184                }
1185                CTxDestination dest;
1186                ExtractDestination(scripts_temp[0], dest);
1187                result.push_back({dest, std::nullopt});
1188                IncIndex();
1189            }
1190        }
1191        if (!TopUp()) {
1192            WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
1193        }
1194    }
1195
1196    return result;
1197}
1198
1199bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch& batch, const CKey& key, const CPubKey &pubkey)
1200{
1201    AssertLockHeld(cs_desc_man);
1202    assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
1203
1204    // Check if provided key already exists
1205    if (m_map_keys.contains(pubkey.GetID()) ||
1206        m_map_crypted_keys.contains(pubkey.GetID())) {
1207        return true;
1208    }
1209
1210    if (m_storage.HasEncryptionKeys()) {
1211        if (m_storage.IsLocked()) {
1212            return false;
1213        }
1214
1215        std::vector<unsigned char> crypted_secret;
1216        CKeyingMaterial secret{UCharCast(key.begin()), UCharCast(key.end())};
1217        if (!m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
1218                return EncryptSecret(encryption_key, secret, pubkey.GetHash(), crypted_secret);
1219            })) {
1220            return false;
1221        }
1222
1223        m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
1224        return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
1225    } else {
1226        m_map_keys[pubkey.GetID()] = key;
1227        return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
1228    }
1229}
1230
1231bool DescriptorScriptPubKeyMan::IsHDEnabled() const
1232{
1233    LOCK(cs_desc_man);
1234    return m_wallet_descriptor.descriptor->IsRange();
1235}
1236
1237bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const
1238{
1239    // We can only give out addresses from descriptors that are single type (not combo), ranged,
1240    // and either have cached keys or can generate more keys (ignoring encryption)
1241    LOCK(cs_desc_man);
1242    return m_wallet_descriptor.descriptor->IsSingleType() &&
1243           m_wallet_descriptor.descriptor->IsRange() &&
1244           (HavePrivateKeys() || m_wallet_descriptor.GetNext() < m_wallet_descriptor.GetEnd() || m_wallet_descriptor.descriptor->CanSelfExpand());
1245}
1246
1247bool DescriptorScriptPubKeyMan::HavePrivateKeys() const
1248{
1249    LOCK(cs_desc_man);
1250    return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;