Persisting and loading wallet records

751template<typename... Args>
752static DataStream PrefixStream(const Args&... args)
753{
754    DataStream prefix;
755    SerializeMany(prefix, args...);
756    return prefix;
757}
758
759static DBErrors LoadDescriptorWalletRecords(CWallet* pwallet, DatabaseBatch& batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
760{
761    AssertLockHeld(pwallet->cs_wallet);
762
763    // Load descriptor record
764    int num_keys = 0;
765    int num_ckeys= 0;
766    LoadResult desc_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTOR,
767        [&batch, &num_keys, &num_ckeys, &last_client] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
768        DBErrors result = DBErrors::LOAD_OK;
769
770        uint256 id;
771        key >> id;
772        std::optional<WalletDescriptor> desc;
773        try {
774            desc.emplace(WalletDescriptor::FromStream(deserialize, value));
775        } catch (const std::ios_base::failure& e) {
776            strErr = strprintf("Error: Unrecognized descriptor found in wallet %s. ", pwallet->GetName());
777            strErr += (last_client > CLIENT_VERSION) ? "The wallet might have been created on a newer version. " :
778                    "The database might be corrupted or the software version is not compatible with one of your wallet descriptors. ";
779            strErr += "Please try running the latest software version";
780            // Also include error details
781            strErr = strprintf("%s\nDetails: %s", strErr, e.what());
782            return DBErrors::UNKNOWN_DESCRIPTOR;
783        }
784
785        DescriptorCache cache;
786
787        // Get key cache for this descriptor
788        DataStream prefix = PrefixStream(DBKeys::WALLETDESCRIPTORCACHE, id);
789        LoadResult key_cache_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORCACHE, prefix,
790            [&id, &cache] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
791            bool parent = true;
792            uint256 desc_id;
793            uint32_t key_exp_index;
794            uint32_t der_index;
795            key >> desc_id;
796            assert(desc_id == id);
797            key >> key_exp_index;
798
799            // if the der_index exists, it's a derived xpub
800            try
801            {
802                key >> der_index;
803                parent = false;
804            }
805            catch (...) {}
806
807            std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
808            value >> ser_xpub;
809            CExtPubKey xpub;
810            xpub.Decode(ser_xpub.data());
811            if (parent) {
812                cache.CacheParentExtPubKey(key_exp_index, xpub);
813            } else {
814                cache.CacheDerivedExtPubKey(key_exp_index, der_index, xpub);
815            }
816            return DBErrors::LOAD_OK;
817        });
818        result = std::max(result, key_cache_res.m_result);
819
820        // Get last hardened cache for this descriptor
821        prefix = PrefixStream(DBKeys::WALLETDESCRIPTORLHCACHE, id);
822        LoadResult lh_cache_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORLHCACHE, prefix,
823            [&id, &cache] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
824            uint256 desc_id;
825            uint32_t key_exp_index;
826            key >> desc_id;
827            assert(desc_id == id);
828            key >> key_exp_index;
829
830            std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
831            value >> ser_xpub;
832            CExtPubKey xpub;
833            xpub.Decode(ser_xpub.data());
834            cache.CacheLastHardenedExtPubKey(key_exp_index, xpub);
835            return DBErrors::LOAD_OK;
836        });
837        result = std::max(result, lh_cache_res.m_result);
838
839        // Set the cache to the WalletDescriptor
840        desc->cache = cache;
841
842        // Get unencrypted keys
843        KeyMap keys;
844        prefix = PrefixStream(DBKeys::WALLETDESCRIPTORKEY, id);
845        LoadResult key_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORKEY, prefix,
846            [&id, &keys] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
847            uint256 desc_id;
848            CPubKey pubkey;
849            key >> desc_id;
850            assert(desc_id == id);
851            key >> pubkey;
852            if (!pubkey.IsValid())
853            {
854                strErr = "Error reading wallet database: descriptor unencrypted key CPubKey corrupt";
855                return DBErrors::CORRUPT;
856            }
857            CKey privkey;
858            CPrivKey pkey;
859            uint256 hash;
860
861            value >> pkey;
862            value >> hash;
863
864            // hash pubkey/privkey to accelerate wallet load
865            const auto keypair_hash = Hash(pubkey, pkey);
866
867            if (keypair_hash != hash)
868            {
869                strErr = "Error reading wallet database: descriptor unencrypted key CPubKey/CPrivKey corrupt";
870                return DBErrors::CORRUPT;
871            }
872
873            if (!privkey.Load(pkey, pubkey, true))
874            {
875                strErr = "Error reading wallet database: descriptor unencrypted key CPrivKey corrupt";
876                return DBErrors::CORRUPT;
877            }
878            keys[pubkey.GetID()] = privkey;
879            return DBErrors::LOAD_OK;
880        });
881        result = std::max(result, key_res.m_result);
882        num_keys = key_res.m_records;
883
884        // Get encrypted keys
885        CryptedKeyMap ckeys;
886        prefix = PrefixStream(DBKeys::WALLETDESCRIPTORCKEY, id);
887        LoadResult ckey_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORCKEY, prefix,
888            [&id, &ckeys] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
889            uint256 desc_id;
890            CPubKey pubkey;
891            key >> desc_id;
892            assert(desc_id == id);
893            key >> pubkey;
894            if (!pubkey.IsValid())
895            {
896                err = "Error reading wallet database: descriptor encrypted key CPubKey corrupt";
897                return DBErrors::CORRUPT;
898            }
899            std::vector<unsigned char> privkey;
900            value >> privkey;
901
902            ckeys[pubkey.GetID()] = std::make_pair(pubkey, privkey);
903            return DBErrors::LOAD_OK;
904        });
905        result = std::max(result, ckey_res.m_result);
906        num_ckeys = ckey_res.m_records;
907
908        try {
909            pwallet->LoadDescriptorScriptPubKeyMan(id, *desc, keys, ckeys);
910        } catch (std::runtime_error& e) {
911            strErr = e.what();
912            return DBErrors::CORRUPT;
913        }
914
915        return result;
916    });
917
918    if (desc_res.m_result <= DBErrors::NONCRITICAL_ERROR) {
919        // Only log if there are no critical errors
920        pwallet->WalletLogPrintf("Descriptors: %u, Descriptor Keys: %u plaintext, %u encrypted, %u total.\n",
921               desc_res.m_records, num_keys, num_ckeys, num_keys + num_ckeys);
922    }
923
924    return desc_res.m_result;
925}
926
927static DBErrors LoadAddressBookRecords(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
928{
929    AssertLockHeld(pwallet->cs_wallet);
930    DBErrors result = DBErrors::LOAD_OK;
931
932    // Load name record
933    LoadResult name_res = LoadRecords(pwallet, batch, DBKeys::NAME,
934        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
935        std::string strAddress;
936        key >> strAddress;
937        std::string label;
938        value >> label;
939        pwallet->m_address_book[DecodeDestination(strAddress)].SetLabel(label);
940        return DBErrors::LOAD_OK;
941    });
942    result = std::max(result, name_res.m_result);
943
944    // Load purpose record
945    LoadResult purpose_res = LoadRecords(pwallet, batch, DBKeys::PURPOSE,
946        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
947        std::string strAddress;
948        key >> strAddress;
949        std::string purpose_str;
950        value >> purpose_str;
951        std::optional<AddressPurpose> purpose{PurposeFromString(purpose_str)};
952        if (!purpose) {
953            pwallet->WalletLogPrintf("Warning: nonstandard purpose string '%s' for address '%s'\n", purpose_str, strAddress);
954        }
955        pwallet->m_address_book[DecodeDestination(strAddress)].purpose = purpose;
956        return DBErrors::LOAD_OK;
957    });
958    result = std::max(result, purpose_res.m_result);
959
960    // Load destination data record
961    LoadResult dest_res = LoadRecords(pwallet, batch, DBKeys::DESTDATA,
962        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
963        std::string strAddress, strKey, strValue;
964        key >> strAddress;
965        key >> strKey;
966        value >> strValue;
967        const CTxDestination& dest{DecodeDestination(strAddress)};
968        if (strKey.compare("used") == 0) {
969            // Load "used" key indicating if an IsMine address has
970            // previously been spent from with avoid_reuse option enabled.
971            // The strValue is not used for anything currently, but could
972            // hold more information in the future. Current values are just
973            // "1" or "p" for present (which was written prior to
974            // f5ba424cd44619d9b9be88b8593d69a7ba96db26).
975            pwallet->LoadAddressPreviouslySpent(dest);
976        } else if (strKey.starts_with("rr")) {
977            // Load "rr##" keys where ## is a decimal number, and strValue
978            // is a serialized RecentRequestEntry object.
979            pwallet->LoadAddressReceiveRequest(dest, strKey.substr(2), strValue);
980        }
981        return DBErrors::LOAD_OK;
982    });
983    result = std::max(result, dest_res.m_result);
984
985    return result;
986}
987
988static std::map<Wtxid, CTransactionRef> ReadWtxVariants(DatabaseBatch& batch, const Txid& txid)
989{
990    std::map<Wtxid, CTransactionRef> variants;
991
992    DataStream prefix;
993    prefix << DBKeys::WTX_VARIANT << txid;
994    std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
995    if (!cursor) {
996        throw std::runtime_error(strprintf("Error getting database cursor for '%s' records", DBKeys::WTX_VARIANT));
997    }
998
999    DataStream key;
1000    DataStream value;