251    std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
252    xpub.Encode(ser_xpub.data());
253    return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id), std::make_pair(key_exp_index, der_index)), ser_xpub);
254}
255
256bool WalletBatch::WriteDescriptorParentCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index)
257{
258    std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
259    xpub.Encode(ser_xpub.data());
260    return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id), key_exp_index), ser_xpub);
261}
262
263bool WalletBatch::WriteDescriptorLastHardenedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index)
264{
265    std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
266    xpub.Encode(ser_xpub.data());
267    return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORLHCACHE, desc_id), key_exp_index), ser_xpub);
268}
269
270bool WalletBatch::WriteDescriptorCacheItems(const uint256& desc_id, const DescriptorCache& cache)
271{
272    for (const auto& parent_xpub_pair : cache.GetCachedParentExtPubKeys()) {
273        if (!WriteDescriptorParentCache(parent_xpub_pair.second, desc_id, parent_xpub_pair.first)) {
274            return false;
275        }
276    }
277    for (const auto& derived_xpub_map_pair : cache.GetCachedDerivedExtPubKeys()) {
278        for (const auto& derived_xpub_pair : derived_xpub_map_pair.second) {
279            if (!WriteDescriptorDerivedCache(derived_xpub_pair.second, desc_id, derived_xpub_map_pair.first, derived_xpub_pair.first)) {
280                return false;
281            }
282        }
283    }
284    for (const auto& lh_xpub_pair : cache.GetCachedLastHardenedExtPubKeys()) {
285        if (!WriteDescriptorLastHardenedCache(lh_xpub_pair.second, desc_id, lh_xpub_pair.first)) {
286            return false;
287        }
288    }
289    return true;
290}
291
292bool WalletBatch::WriteLockedUTXO(const COutPoint& output)
293{
294    return WriteIC(std::make_pair(DBKeys::LOCKED_UTXO, std::make_pair(output.hash, output.n)), uint8_t{'1'});
295}
296
297bool WalletBatch::EraseLockedUTXO(const COutPoint& output)
298{
299    return EraseIC(std::make_pair(DBKeys::LOCKED_UTXO, std::make_pair(output.hash, output.n)));
300}
301
302bool LoadKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
303{
304    LOCK(pwallet->cs_wallet);
305    try {
306        CPubKey vchPubKey;
307        ssKey >> vchPubKey;
308        if (!vchPubKey.IsValid())
309        {
310            strErr = "Error reading wallet database: CPubKey corrupt";
311            return false;
312        }
313        CKey key;
314        CPrivKey pkey;
315        uint256 hash;
316
317        ssValue >> pkey;
318
319        // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey]
320        // ... which was slow for wallets with lots of keys, because the public key is re-derived from the private key
321        // using EC operations as a checksum.
322        // Newer wallets store keys as DBKeys::KEY [pubkey] => [privkey][hash(pubkey,privkey)], which is much faster while
323        // remaining backwards-compatible.
324        try
325        {
326            ssValue >> hash;
327        }
328        catch (const std::ios_base::failure&) {}
329
330        bool fSkipCheck = false;
331
332        if (!hash.IsNull())
333        {
334            // hash pubkey/privkey to accelerate wallet load
335            const auto keypair_hash = Hash(vchPubKey, pkey);
336
337            if (keypair_hash != hash)
338            {
339                strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
340                return false;
341            }
342
343            fSkipCheck = true;
344        }
345
346        if (!key.Load(pkey, vchPubKey, fSkipCheck))
347        {
348            strErr = "Error reading wallet database: CPrivKey corrupt";
349            return false;
350        }
351        if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadKey(key, vchPubKey))
352        {
353            strErr = "Error reading wallet database: LegacyDataSPKM::LoadKey failed";
354            return false;
355        }
356    } catch (const std::exception& e) {
357        if (strErr.empty()) {
358            strErr = e.what();
359        }
360        return false;
361    }
362    return true;
363}
364
365bool LoadCryptedKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
366{
367    LOCK(pwallet->cs_wallet);
368    try {
369        CPubKey vchPubKey;
370        ssKey >> vchPubKey;
371        if (!vchPubKey.IsValid())
372        {
373            strErr = "Error reading wallet database: CPubKey corrupt";
374            return false;
375        }
376        std::vector<unsigned char> vchPrivKey;
377        ssValue >> vchPrivKey;
378
379        // Get the checksum and check it
380        bool checksum_valid = false;
381        if (!ssValue.empty()) {
382            uint256 checksum;
383            ssValue >> checksum;
384            if (!(checksum_valid = Hash(vchPrivKey) == checksum)) {
385                strErr = "Error reading wallet database: Encrypted key corrupt";
386                return false;
387            }
388        }
389
390        if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadCryptedKey(vchPubKey, vchPrivKey, checksum_valid))
391        {
392            strErr = "Error reading wallet database: LegacyDataSPKM::LoadCryptedKey failed";
393            return false;
394        }
395    } catch (const std::exception& e) {
396        if (strErr.empty()) {
397            strErr = e.what();
398        }
399        return false;
400    }
401    return true;
402}
403
404bool LoadEncryptionKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
405{
406    LOCK(pwallet->cs_wallet);
407    try {
408        // Master encryption key is loaded into only the wallet and not any of the ScriptPubKeyMans.
409        unsigned int nID;
410        ssKey >> nID;
411        CMasterKey kMasterKey;
412        ssValue >> kMasterKey;
413        if(pwallet->mapMasterKeys.contains(nID))
414        {
415            strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
416            return false;
417        }
418        pwallet->mapMasterKeys[nID] = kMasterKey;
419        if (pwallet->nMasterKeyMaxID < nID)
420            pwallet->nMasterKeyMaxID = nID;
421
422    } catch (const std::exception& e) {
423        if (strErr.empty()) {
424            strErr = e.what();
425        }
426        return false;
427    }
428    return true;
429}
430
431bool LoadHDChain(CWallet* pwallet, DataStream& ssValue, std::string& strErr)
432{
433    LOCK(pwallet->cs_wallet);
434    try {
435        CHDChain chain;
436        ssValue >> chain;
437        pwallet->GetOrCreateLegacyDataSPKM()->LoadHDChain(chain);
438    } catch (const std::exception& e) {
439        if (strErr.empty()) {
440            strErr = e.what();
441        }
442        return false;
443    }
444    return true;
445}
446
447static DBErrors LoadWalletFlags(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
448{
449    AssertLockHeld(pwallet->cs_wallet);
450    uint64_t flags;
451    if (batch.Read(DBKeys::FLAGS, flags)) {
452        if (!pwallet->LoadWalletFlags(flags)) {
453            pwallet->WalletLogPrintf("Error reading wallet database: Unknown non-tolerable wallet flags found\n");
454            return DBErrors::TOO_NEW;
455        }
456        // All wallets must be descriptor wallets unless opened with a bdb_ro db
457        // bdb_ro is only used for legacy to descriptor migration.
458        if (pwallet->GetDatabase().Format() != "bdb_ro" && !pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
459            return DBErrors::LEGACY_WALLET;
460        }
461    }
462    return DBErrors::LOAD_OK;
463}
464
465struct LoadResult
466{
467    DBErrors m_result{DBErrors::LOAD_OK};
468    int m_records{0};
469};
470
471using LoadFunc = std::function<DBErrors(CWallet* pwallet, DataStream& key, DataStream& value, std::string& err)>;
472static LoadResult LoadRecords(CWallet* pwallet, DatabaseBatch& batch, const std::string& key, DataStream& prefix, LoadFunc load_func)
473{
474    LoadResult result;
475    DataStream ssKey;
476    DataStream ssValue{};
477
478    Assume(!prefix.empty());
479    std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
480    if (!cursor) {
481        pwallet->WalletLogPrintf("Error getting database cursor for '%s' records\n", key);
482        result.m_result = DBErrors::CORRUPT;
483        return result;
484    }
485
486    while (true) {
487        DatabaseCursor::Status status = cursor->Next(ssKey, ssValue);
488        if (status == DatabaseCursor::Status::DONE) {
489            break;
490        } else if (status == DatabaseCursor::Status::FAIL) {
491            pwallet->WalletLogPrintf("Error reading next '%s' record for wallet database\n", key);
492            result.m_result = DBErrors::CORRUPT;
493            return result;
494        }
495        std::string type;
496        ssKey >> type;
497        assert(type == key);
498        std::string error;
499        DBErrors record_res = load_func(pwallet, ssKey, ssValue, error);
500        if (record_res != DBErrors::LOAD_OK) {