LCOV - code coverage report
Current view: top level - src/wallet - walletdb.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 80.3 % 773 621
Test Date: 2025-08-25 05:11:47 Functions: 92.2 % 77 71
Branches: 47.6 % 1062 506

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-2022 The Bitcoin Core developers
       3                 :             : // Distributed under the MIT software license, see the accompanying
       4                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :             : 
       6                 :             : #include <bitcoin-build-config.h> // IWYU pragma: keep
       7                 :             : 
       8                 :             : #include <wallet/walletdb.h>
       9                 :             : 
      10                 :             : #include <common/system.h>
      11                 :             : #include <key_io.h>
      12                 :             : #include <primitives/transaction_identifier.h>
      13                 :             : #include <protocol.h>
      14                 :             : #include <script/script.h>
      15                 :             : #include <serialize.h>
      16                 :             : #include <sync.h>
      17                 :             : #include <util/bip32.h>
      18                 :             : #include <util/check.h>
      19                 :             : #include <util/fs.h>
      20                 :             : #include <util/time.h>
      21                 :             : #include <util/translation.h>
      22                 :             : #include <wallet/migrate.h>
      23                 :             : #include <wallet/sqlite.h>
      24                 :             : #include <wallet/wallet.h>
      25                 :             : 
      26                 :             : #include <atomic>
      27                 :             : #include <optional>
      28                 :             : #include <string>
      29                 :             : 
      30                 :             : namespace wallet {
      31                 :             : namespace DBKeys {
      32                 :             : const std::string ACENTRY{"acentry"};
      33                 :             : const std::string ACTIVEEXTERNALSPK{"activeexternalspk"};
      34                 :             : const std::string ACTIVEINTERNALSPK{"activeinternalspk"};
      35                 :             : const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
      36                 :             : const std::string BESTBLOCK{"bestblock"};
      37                 :             : const std::string CRYPTED_KEY{"ckey"};
      38                 :             : const std::string CSCRIPT{"cscript"};
      39                 :             : const std::string DEFAULTKEY{"defaultkey"};
      40                 :             : const std::string DESTDATA{"destdata"};
      41                 :             : const std::string FLAGS{"flags"};
      42                 :             : const std::string HDCHAIN{"hdchain"};
      43                 :             : const std::string KEYMETA{"keymeta"};
      44                 :             : const std::string KEY{"key"};
      45                 :             : const std::string LOCKED_UTXO{"lockedutxo"};
      46                 :             : const std::string MASTER_KEY{"mkey"};
      47                 :             : const std::string MINVERSION{"minversion"};
      48                 :             : const std::string NAME{"name"};
      49                 :             : const std::string OLD_KEY{"wkey"};
      50                 :             : const std::string ORDERPOSNEXT{"orderposnext"};
      51                 :             : const std::string POOL{"pool"};
      52                 :             : const std::string PURPOSE{"purpose"};
      53                 :             : const std::string SETTINGS{"settings"};
      54                 :             : const std::string TX{"tx"};
      55                 :             : const std::string VERSION{"version"};
      56                 :             : const std::string WALLETDESCRIPTOR{"walletdescriptor"};
      57                 :             : const std::string WALLETDESCRIPTORCACHE{"walletdescriptorcache"};
      58                 :             : const std::string WALLETDESCRIPTORLHCACHE{"walletdescriptorlhcache"};
      59                 :             : const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
      60                 :             : const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
      61                 :             : const std::string WATCHMETA{"watchmeta"};
      62                 :             : const std::string WATCHS{"watchs"};
      63                 :             : const std::unordered_set<std::string> LEGACY_TYPES{CRYPTED_KEY, CSCRIPT, DEFAULTKEY, HDCHAIN, KEYMETA, KEY, OLD_KEY, POOL, WATCHMETA, WATCHS};
      64                 :             : } // namespace DBKeys
      65                 :             : 
      66                 :             : //
      67                 :             : // WalletBatch
      68                 :             : //
      69                 :             : 
      70                 :       29178 : bool WalletBatch::WriteName(const std::string& strAddress, const std::string& strName)
      71                 :             : {
      72         [ +  - ]:       87534 :     return WriteIC(std::make_pair(DBKeys::NAME, strAddress), strName);
      73                 :             : }
      74                 :             : 
      75                 :          26 : bool WalletBatch::EraseName(const std::string& strAddress)
      76                 :             : {
      77                 :             :     // This should only be used for sending addresses, never for receiving addresses,
      78                 :             :     // receiving addresses must always have an address book entry if they're not change return.
      79         [ +  - ]:          78 :     return EraseIC(std::make_pair(DBKeys::NAME, strAddress));
      80                 :             : }
      81                 :             : 
      82                 :       29178 : bool WalletBatch::WritePurpose(const std::string& strAddress, const std::string& strPurpose)
      83                 :             : {
      84         [ +  - ]:       87534 :     return WriteIC(std::make_pair(DBKeys::PURPOSE, strAddress), strPurpose);
      85                 :             : }
      86                 :             : 
      87                 :          26 : bool WalletBatch::ErasePurpose(const std::string& strAddress)
      88                 :             : {
      89         [ +  - ]:          78 :     return EraseIC(std::make_pair(DBKeys::PURPOSE, strAddress));
      90                 :             : }
      91                 :             : 
      92                 :       24056 : bool WalletBatch::WriteTx(const CWalletTx& wtx)
      93                 :             : {
      94         [ +  - ]:       48112 :     return WriteIC(std::make_pair(DBKeys::TX, wtx.GetHash()), wtx);
      95                 :             : }
      96                 :             : 
      97                 :          15 : bool WalletBatch::EraseTx(Txid hash)
      98                 :             : {
      99         [ +  - ]:          30 :     return EraseIC(std::make_pair(DBKeys::TX, hash.ToUint256()));
     100                 :             : }
     101                 :             : 
     102                 :           0 : bool WalletBatch::WriteKeyMetadata(const CKeyMetadata& meta, const CPubKey& pubkey, const bool overwrite)
     103                 :             : {
     104         [ #  # ]:           0 :     return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
     105                 :             : }
     106                 :             : 
     107                 :           0 : bool WalletBatch::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata& keyMeta)
     108                 :             : {
     109         [ #  # ]:           0 :     if (!WriteKeyMetadata(keyMeta, vchPubKey, false)) {
     110                 :             :         return false;
     111                 :             :     }
     112                 :             : 
     113                 :             :     // hash pubkey/privkey to accelerate wallet load
     114                 :           0 :     std::vector<unsigned char> vchKey;
     115   [ #  #  #  # ]:           0 :     vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
     116         [ #  # ]:           0 :     vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
     117         [ #  # ]:           0 :     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
     118                 :             : 
     119   [ #  #  #  #  :           0 :     return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey)), false);
                   #  # ]
     120                 :           0 : }
     121                 :             : 
     122                 :           0 : bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
     123                 :             :                                 const std::vector<unsigned char>& vchCryptedSecret,
     124                 :             :                                 const CKeyMetadata &keyMeta)
     125                 :             : {
     126         [ #  # ]:           0 :     if (!WriteKeyMetadata(keyMeta, vchPubKey, true)) {
     127                 :             :         return false;
     128                 :             :     }
     129                 :             : 
     130                 :             :     // Compute a checksum of the encrypted key
     131                 :           0 :     uint256 checksum = Hash(vchCryptedSecret);
     132                 :             : 
     133                 :           0 :     const auto key = std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey);
     134   [ #  #  #  #  :           0 :     if (!WriteIC(key, std::make_pair(vchCryptedSecret, checksum), false)) {
                   #  # ]
     135                 :             :         // It may already exist, so try writing just the checksum
     136                 :           0 :         std::vector<unsigned char> val;
     137   [ #  #  #  # ]:           0 :         if (!m_batch->Read(key, val)) {
     138                 :             :             return false;
     139                 :             :         }
     140   [ #  #  #  #  :           0 :         if (!WriteIC(key, std::make_pair(val, checksum), true)) {
                   #  # ]
     141                 :             :             return false;
     142                 :             :         }
     143                 :           0 :     }
     144   [ #  #  #  # ]:           0 :     EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
     145                 :           0 :     return true;
     146                 :           0 : }
     147                 :             : 
     148                 :          26 : bool WalletBatch::WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
     149                 :             : {
     150   [ -  +  +  - ]:          78 :     return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
     151                 :             : }
     152                 :             : 
     153                 :           1 : bool WalletBatch::EraseMasterKey(unsigned int id)
     154                 :             : {
     155   [ -  +  +  - ]:           3 :     return EraseIC(std::make_pair(DBKeys::MASTER_KEY, id));
     156                 :             : }
     157                 :             : 
     158                 :           0 : bool WalletBatch::WriteWatchOnly(const CScript &dest, const CKeyMetadata& keyMeta)
     159                 :             : {
     160   [ #  #  #  # ]:           0 :     if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
     161                 :             :         return false;
     162                 :             :     }
     163         [ #  # ]:           0 :     return WriteIC(std::make_pair(DBKeys::WATCHS, dest), uint8_t{'1'});
     164                 :             : }
     165                 :             : 
     166                 :           0 : bool WalletBatch::EraseWatchOnly(const CScript &dest)
     167                 :             : {
     168   [ #  #  #  # ]:           0 :     if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
     169                 :             :         return false;
     170                 :             :     }
     171         [ #  # ]:           0 :     return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
     172                 :             : }
     173                 :             : 
     174                 :       17261 : bool WalletBatch::WriteBestBlock(const CBlockLocator& locator)
     175                 :             : {
     176         [ +  - ]:       17261 :     WriteIC(DBKeys::BESTBLOCK, CBlockLocator()); // Write empty block locator so versions that require a merkle branch automatically rescan
     177                 :       34522 :     return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
     178                 :             : }
     179                 :             : 
     180                 :        1647 : bool WalletBatch::ReadBestBlock(CBlockLocator& locator)
     181                 :             : {
     182   [ +  +  +  - ]:        1647 :     if (m_batch->Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) return true;
     183                 :        1647 :     return m_batch->Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
     184                 :             : }
     185                 :             : 
     186                 :           0 : bool WalletBatch::IsEncrypted()
     187                 :             : {
     188                 :           0 :     DataStream prefix;
     189         [ #  # ]:           0 :     prefix << DBKeys::MASTER_KEY;
     190   [ #  #  #  #  :           0 :     if (auto cursor = m_batch->GetNewPrefixCursor(prefix)) {
                   #  # ]
     191                 :           0 :         DataStream k, v;
     192   [ #  #  #  # ]:           0 :         if (cursor->Next(k, v) == DatabaseCursor::Status::MORE) return true;
     193                 :           0 :     }
     194                 :           0 :     return false;
     195                 :           0 : }
     196                 :             : 
     197                 :       18454 : bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext)
     198                 :             : {
     199                 :       18454 :     return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
     200                 :             : }
     201                 :             : 
     202                 :        3328 : bool WalletBatch::WriteActiveScriptPubKeyMan(uint8_t type, const uint256& id, bool internal)
     203                 :             : {
     204         [ +  + ]:        3328 :     std::string key = internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
     205   [ -  +  +  - ]:        9984 :     return WriteIC(make_pair(key, type), id);
     206                 :        3328 : }
     207                 :             : 
     208                 :           1 : bool WalletBatch::EraseActiveScriptPubKeyMan(uint8_t type, bool internal)
     209                 :             : {
     210         [ -  + ]:           1 :     const std::string key{internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK};
     211   [ -  +  +  - ]:           3 :     return EraseIC(make_pair(key, type));
     212                 :           1 : }
     213                 :             : 
     214                 :        3532 : bool WalletBatch::WriteDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const CPrivKey& privkey)
     215                 :             : {
     216                 :             :     // hash pubkey/privkey to accelerate wallet load
     217                 :        3532 :     std::vector<unsigned char> key;
     218   [ -  +  +  - ]:        3532 :     key.reserve(pubkey.size() + privkey.size());
     219         [ +  - ]:        3532 :     key.insert(key.end(), pubkey.begin(), pubkey.end());
     220         [ +  - ]:        3532 :     key.insert(key.end(), privkey.begin(), privkey.end());
     221                 :             : 
     222   [ +  -  +  -  :       10596 :     return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)), std::make_pair(privkey, Hash(key)), false);
                   +  - ]
     223                 :        3532 : }
     224                 :             : 
     225                 :         265 : bool WalletBatch::WriteCryptedDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const std::vector<unsigned char>& secret)
     226                 :             : {
     227   [ +  -  +  - ]:         530 :     if (!WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORCKEY, std::make_pair(desc_id, pubkey)), secret, false)) {
     228                 :             :         return false;
     229                 :             :     }
     230         [ +  - ]:         265 :     EraseIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)));
     231                 :         265 :     return true;
     232                 :             : }
     233                 :             : 
     234                 :       97104 : bool WalletBatch::WriteDescriptor(const uint256& desc_id, const WalletDescriptor& descriptor)
     235                 :             : {
     236         [ +  - ]:      194208 :     return WriteIC(make_pair(DBKeys::WALLETDESCRIPTOR, desc_id), descriptor);
     237                 :             : }
     238                 :             : 
     239                 :       10010 : bool WalletBatch::WriteDescriptorDerivedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index, uint32_t der_index)
     240                 :             : {
     241                 :       10010 :     std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
     242         [ +  - ]:       10010 :     xpub.Encode(ser_xpub.data());
     243   [ +  -  +  - ]:       20020 :     return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id), std::make_pair(key_exp_index, der_index)), ser_xpub);
     244                 :       10010 : }
     245                 :             : 
     246                 :        3849 : bool WalletBatch::WriteDescriptorParentCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index)
     247                 :             : {
     248                 :        3849 :     std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
     249         [ +  - ]:        3849 :     xpub.Encode(ser_xpub.data());
     250   [ +  -  +  - ]:        7698 :     return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id), key_exp_index), ser_xpub);
     251                 :        3849 : }
     252                 :             : 
     253                 :        3114 : bool WalletBatch::WriteDescriptorLastHardenedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index)
     254                 :             : {
     255                 :        3114 :     std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
     256         [ +  - ]:        3114 :     xpub.Encode(ser_xpub.data());
     257   [ +  -  +  - ]:        6228 :     return WriteIC(std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORLHCACHE, desc_id), key_exp_index), ser_xpub);
     258                 :        3114 : }
     259                 :             : 
     260                 :      423613 : bool WalletBatch::WriteDescriptorCacheItems(const uint256& desc_id, const DescriptorCache& cache)
     261                 :             : {
     262   [ +  +  +  - ]:      427462 :     for (const auto& parent_xpub_pair : cache.GetCachedParentExtPubKeys()) {
     263   [ -  +  +  - ]:        3849 :         if (!WriteDescriptorParentCache(parent_xpub_pair.second, desc_id, parent_xpub_pair.first)) {
     264                 :           0 :             return false;
     265                 :             :         }
     266                 :           0 :     }
     267         [ +  + ]:      433623 :     for (const auto& derived_xpub_map_pair : cache.GetCachedDerivedExtPubKeys()) {
     268   [ +  +  +  - ]:       20020 :         for (const auto& derived_xpub_pair : derived_xpub_map_pair.second) {
     269   [ -  +  +  - ]:       10010 :             if (!WriteDescriptorDerivedCache(derived_xpub_pair.second, desc_id, derived_xpub_map_pair.first, derived_xpub_pair.first)) {
     270                 :           0 :                 return false;
     271                 :             :             }
     272                 :             :         }
     273                 :           0 :     }
     274   [ +  +  +  - ]:      426727 :     for (const auto& lh_xpub_pair : cache.GetCachedLastHardenedExtPubKeys()) {
     275   [ -  +  +  - ]:        3114 :         if (!WriteDescriptorLastHardenedCache(lh_xpub_pair.second, desc_id, lh_xpub_pair.first)) {
     276                 :           0 :             return false;
     277                 :             :         }
     278                 :           0 :     }
     279                 :      423613 :     return true;
     280                 :             : }
     281                 :             : 
     282                 :           1 : bool WalletBatch::WriteLockedUTXO(const COutPoint& output)
     283                 :             : {
     284         [ +  - ]:           2 :     return WriteIC(std::make_pair(DBKeys::LOCKED_UTXO, std::make_pair(output.hash, output.n)), uint8_t{'1'});
     285                 :             : }
     286                 :             : 
     287                 :           1 : bool WalletBatch::EraseLockedUTXO(const COutPoint& output)
     288                 :             : {
     289         [ +  - ]:           2 :     return EraseIC(std::make_pair(DBKeys::LOCKED_UTXO, std::make_pair(output.hash, output.n)));
     290                 :             : }
     291                 :             : 
     292                 :         194 : bool LoadKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
     293                 :             : {
     294                 :         194 :     LOCK(pwallet->cs_wallet);
     295                 :         194 :     try {
     296         [ +  - ]:         194 :         CPubKey vchPubKey;
     297         [ +  - ]:         194 :         ssKey >> vchPubKey;
     298         [ -  + ]:         194 :         if (!vchPubKey.IsValid())
     299                 :             :         {
     300   [ -  -  +  - ]:         194 :             strErr = "Error reading wallet database: CPubKey corrupt";
     301                 :             :             return false;
     302                 :             :         }
     303                 :         194 :         CKey key;
     304                 :         194 :         CPrivKey pkey;
     305                 :         194 :         uint256 hash;
     306                 :             : 
     307         [ +  - ]:         194 :         ssValue >> pkey;
     308                 :             : 
     309                 :             :         // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey]
     310                 :             :         // ... which was slow for wallets with lots of keys, because the public key is re-derived from the private key
     311                 :             :         // using EC operations as a checksum.
     312                 :             :         // Newer wallets store keys as DBKeys::KEY [pubkey] => [privkey][hash(pubkey,privkey)], which is much faster while
     313                 :             :         // remaining backwards-compatible.
     314                 :         194 :         try
     315                 :             :         {
     316         [ +  - ]:         194 :             ssValue >> hash;
     317                 :             :         }
     318         [ -  - ]:           0 :         catch (const std::ios_base::failure&) {}
     319                 :             : 
     320                 :         194 :         bool fSkipCheck = false;
     321                 :             : 
     322         [ +  - ]:         388 :         if (!hash.IsNull())
     323                 :             :         {
     324                 :             :             // hash pubkey/privkey to accelerate wallet load
     325                 :         194 :             std::vector<unsigned char> vchKey;
     326   [ -  +  +  - ]:         194 :             vchKey.reserve(vchPubKey.size() + pkey.size());
     327         [ +  - ]:         194 :             vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
     328         [ +  - ]:         194 :             vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
     329                 :             : 
     330   [ +  -  -  + ]:         194 :             if (Hash(vchKey) != hash)
     331                 :             :             {
     332         [ #  # ]:           0 :                 strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
     333                 :           0 :                 return false;
     334                 :             :             }
     335                 :             : 
     336                 :         194 :             fSkipCheck = true;
     337                 :         194 :         }
     338                 :             : 
     339   [ +  -  -  + ]:         194 :         if (!key.Load(pkey, vchPubKey, fSkipCheck))
     340                 :             :         {
     341         [ #  # ]:           0 :             strErr = "Error reading wallet database: CPrivKey corrupt";
     342                 :             :             return false;
     343                 :             :         }
     344   [ +  -  +  -  :         194 :         if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadKey(key, vchPubKey))
                   -  + ]
     345                 :             :         {
     346         [ #  # ]:           0 :             strErr = "Error reading wallet database: LegacyDataSPKM::LoadKey failed";
     347                 :             :             return false;
     348                 :             :         }
     349         [ -  - ]:         194 :     } catch (const std::exception& e) {
     350         [ -  - ]:           0 :         if (strErr.empty()) {
     351         [ -  - ]:           0 :             strErr = e.what();
     352                 :             :         }
     353                 :           0 :         return false;
     354                 :           0 :     }
     355                 :         194 :     return true;
     356                 :         194 : }
     357                 :             : 
     358                 :          24 : bool LoadCryptedKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
     359                 :             : {
     360                 :          24 :     LOCK(pwallet->cs_wallet);
     361                 :          24 :     try {
     362         [ +  - ]:          24 :         CPubKey vchPubKey;
     363         [ +  - ]:          24 :         ssKey >> vchPubKey;
     364         [ -  + ]:          24 :         if (!vchPubKey.IsValid())
     365                 :             :         {
     366   [ -  -  +  - ]:          24 :             strErr = "Error reading wallet database: CPubKey corrupt";
     367                 :             :             return false;
     368                 :             :         }
     369                 :          24 :         std::vector<unsigned char> vchPrivKey;
     370         [ +  - ]:          24 :         ssValue >> vchPrivKey;
     371                 :             : 
     372                 :             :         // Get the checksum and check it
     373                 :          24 :         bool checksum_valid = false;
     374   [ -  +  +  - ]:          24 :         if (!ssValue.eof()) {
     375                 :          24 :             uint256 checksum;
     376         [ +  - ]:          24 :             ssValue >> checksum;
     377   [ +  -  -  + ]:          24 :             if (!(checksum_valid = Hash(vchPrivKey) == checksum)) {
     378         [ #  # ]:           0 :                 strErr = "Error reading wallet database: Encrypted key corrupt";
     379                 :             :                 return false;
     380                 :             :             }
     381                 :             :         }
     382                 :             : 
     383   [ +  -  +  -  :          24 :         if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadCryptedKey(vchPubKey, vchPrivKey, checksum_valid))
                   -  + ]
     384                 :             :         {
     385         [ #  # ]:           0 :             strErr = "Error reading wallet database: LegacyDataSPKM::LoadCryptedKey failed";
     386                 :             :             return false;
     387                 :             :         }
     388         [ #  # ]:           0 :     } catch (const std::exception& e) {
     389         [ -  - ]:           0 :         if (strErr.empty()) {
     390         [ -  - ]:           0 :             strErr = e.what();
     391                 :             :         }
     392                 :           0 :         return false;
     393                 :           0 :     }
     394                 :          24 :     return true;
     395                 :          24 : }
     396                 :             : 
     397                 :          19 : bool LoadEncryptionKey(CWallet* pwallet, DataStream& ssKey, DataStream& ssValue, std::string& strErr)
     398                 :             : {
     399                 :          19 :     LOCK(pwallet->cs_wallet);
     400                 :          19 :     try {
     401                 :             :         // Master encryption key is loaded into only the wallet and not any of the ScriptPubKeyMans.
     402                 :          19 :         unsigned int nID;
     403         [ +  - ]:          19 :         ssKey >> nID;
     404         [ +  - ]:          19 :         CMasterKey kMasterKey;
     405         [ +  - ]:          19 :         ssValue >> kMasterKey;
     406         [ -  + ]:          19 :         if(pwallet->mapMasterKeys.count(nID) != 0)
     407                 :             :         {
     408         [ #  # ]:           0 :             strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
     409                 :           0 :             return false;
     410                 :             :         }
     411   [ +  -  +  - ]:          19 :         pwallet->mapMasterKeys[nID] = kMasterKey;
     412         [ +  - ]:          19 :         if (pwallet->nMasterKeyMaxID < nID)
     413                 :          19 :             pwallet->nMasterKeyMaxID = nID;
     414                 :             : 
     415         [ #  # ]:           0 :     } catch (const std::exception& e) {
     416         [ -  - ]:           0 :         if (strErr.empty()) {
     417         [ -  - ]:           0 :             strErr = e.what();
     418                 :             :         }
     419                 :           0 :         return false;
     420                 :           0 :     }
     421                 :          19 :     return true;
     422                 :          19 : }
     423                 :             : 
     424                 :          32 : bool LoadHDChain(CWallet* pwallet, DataStream& ssValue, std::string& strErr)
     425                 :             : {
     426                 :          32 :     LOCK(pwallet->cs_wallet);
     427                 :          32 :     try {
     428                 :          32 :         CHDChain chain;
     429         [ +  - ]:          32 :         ssValue >> chain;
     430   [ +  -  +  - ]:          32 :         pwallet->GetOrCreateLegacyDataSPKM()->LoadHDChain(chain);
     431         [ -  - ]:           0 :     } catch (const std::exception& e) {
     432         [ -  - ]:           0 :         if (strErr.empty()) {
     433         [ -  - ]:           0 :             strErr = e.what();
     434                 :             :         }
     435                 :           0 :         return false;
     436                 :           0 :     }
     437                 :             :     return true;
     438                 :          32 : }
     439                 :             : 
     440                 :         926 : static DBErrors LoadWalletFlags(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
     441                 :             : {
     442                 :         926 :     AssertLockHeld(pwallet->cs_wallet);
     443                 :         926 :     uint64_t flags;
     444         [ +  + ]:         926 :     if (batch.Read(DBKeys::FLAGS, flags)) {
     445         [ -  + ]:         345 :         if (!pwallet->LoadWalletFlags(flags)) {
     446                 :           0 :             pwallet->WalletLogPrintf("Error reading wallet database: Unknown non-tolerable wallet flags found\n");
     447                 :           0 :             return DBErrors::TOO_NEW;
     448                 :             :         }
     449                 :             :         // All wallets must be descriptor wallets unless opened with a bdb_ro db
     450                 :             :         // bdb_ro is only used for legacy to descriptor migration.
     451   [ +  +  +  -  :         690 :         if (pwallet->GetDatabase().Format() != "bdb_ro" && !pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
             +  -  -  + ]
     452                 :           0 :             return DBErrors::LEGACY_WALLET;
     453                 :             :         }
     454                 :             :     }
     455                 :             :     return DBErrors::LOAD_OK;
     456                 :             : }
     457                 :             : 
     458                 :             : struct LoadResult
     459                 :             : {
     460                 :             :     DBErrors m_result{DBErrors::LOAD_OK};
     461                 :             :     int m_records{0};
     462                 :             : };
     463                 :             : 
     464                 :             : using LoadFunc = std::function<DBErrors(CWallet* pwallet, DataStream& key, DataStream& value, std::string& err)>;
     465                 :       24892 : static LoadResult LoadRecords(CWallet* pwallet, DatabaseBatch& batch, const std::string& key, DataStream& prefix, LoadFunc load_func)
     466                 :             : {
     467                 :       24892 :     LoadResult result;
     468                 :       24892 :     DataStream ssKey;
     469                 :       24892 :     DataStream ssValue{};
     470                 :             : 
     471         [ -  + ]:       24892 :     Assume(!prefix.empty());
     472         [ +  - ]:       24892 :     std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
     473         [ -  + ]:       24892 :     if (!cursor) {
     474         [ #  # ]:           0 :         pwallet->WalletLogPrintf("Error getting database cursor for '%s' records\n", key);
     475                 :           0 :         result.m_result = DBErrors::CORRUPT;
     476                 :           0 :         return result;
     477                 :             :     }
     478                 :             : 
     479                 :       78024 :     while (true) {
     480         [ +  - ]:       51458 :         DatabaseCursor::Status status = cursor->Next(ssKey, ssValue);
     481         [ +  + ]:       51458 :         if (status == DatabaseCursor::Status::DONE) {
     482                 :             :             break;
     483         [ -  + ]:       26566 :         } else if (status == DatabaseCursor::Status::FAIL) {
     484         [ #  # ]:           0 :             pwallet->WalletLogPrintf("Error reading next '%s' record for wallet database\n", key);
     485                 :           0 :             result.m_result = DBErrors::CORRUPT;
     486                 :           0 :             return result;
     487                 :             :         }
     488         [ +  - ]:       26566 :         std::string type;
     489         [ +  - ]:       26566 :         ssKey >> type;
     490         [ -  + ]:       26566 :         assert(type == key);
     491         [ +  - ]:       26566 :         std::string error;
     492         [ +  - ]:       26566 :         DBErrors record_res = load_func(pwallet, ssKey, ssValue, error);
     493         [ +  + ]:       26566 :         if (record_res != DBErrors::LOAD_OK) {
     494         [ +  - ]:           3 :             pwallet->WalletLogPrintf("%s\n", error);
     495                 :             :         }
     496         [ +  + ]:       26566 :         result.m_result = std::max(result.m_result, record_res);
     497                 :       26566 :         ++result.m_records;
     498                 :       26566 :     }
     499                 :       24892 :     return result;
     500                 :       24892 : }
     501                 :             : 
     502                 :       14840 : static LoadResult LoadRecords(CWallet* pwallet, DatabaseBatch& batch, const std::string& key, LoadFunc load_func)
     503                 :             : {
     504                 :       14840 :     DataStream prefix;
     505         [ +  - ]:       14840 :     prefix << key;
     506   [ +  -  +  - ]:       29680 :     return LoadRecords(pwallet, batch, key, prefix, load_func);
     507                 :       14840 : }
     508                 :             : 
     509                 :          37 : bool HasLegacyRecords(CWallet& wallet)
     510                 :             : {
     511                 :          74 :     const auto& batch = wallet.GetDatabase().MakeBatch();
     512         [ +  - ]:          74 :     return HasLegacyRecords(wallet, *batch);
     513                 :             : }
     514                 :             : 
     515                 :         342 : bool HasLegacyRecords(CWallet& wallet, DatabaseBatch& batch)
     516                 :             : {
     517   [ +  +  +  - ]:        3492 :     for (const auto& type : DBKeys::LEGACY_TYPES) {
     518                 :        3150 :         DataStream key;
     519                 :        3150 :         DataStream value{};
     520                 :        3150 :         DataStream prefix;
     521                 :             : 
     522         [ +  - ]:        3150 :         prefix << type;
     523   [ -  +  +  - ]:        3150 :         std::unique_ptr<DatabaseCursor> cursor = batch.GetNewPrefixCursor(prefix);
     524         [ -  + ]:        3150 :         if (!cursor) {
     525                 :             :             // Could only happen on a closed db, which means there is an error in the code flow.
     526   [ #  #  #  # ]:           0 :             throw std::runtime_error(strprintf("Error getting database cursor for '%s' records", type));
     527                 :             :         }
     528                 :             : 
     529         [ +  - ]:        3150 :         DatabaseCursor::Status status = cursor->Next(key, value);
     530         [ +  + ]:        3150 :         if (status != DatabaseCursor::Status::DONE) {
     531                 :          35 :             return true;
     532                 :             :         }
     533                 :        3150 :     }
     534                 :             :     return false;
     535                 :             : }
     536                 :             : 
     537                 :         926 : static DBErrors LoadLegacyWalletRecords(CWallet* pwallet, DatabaseBatch& batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
     538                 :             : {
     539                 :         926 :     AssertLockHeld(pwallet->cs_wallet);
     540                 :         926 :     DBErrors result = DBErrors::LOAD_OK;
     541                 :             : 
     542                 :             :     // Make sure descriptor wallets don't have any legacy records
     543         [ +  + ]:         926 :     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
     544         [ +  + ]:         305 :         if (HasLegacyRecords(*pwallet, batch)) {
     545                 :           1 :             pwallet->WalletLogPrintf("Error: Unexpected legacy entry found in descriptor wallet %s. The wallet might have been tampered with or created with malicious intent.\n", pwallet->GetName());
     546                 :           1 :             return DBErrors::UNEXPECTED_LEGACY_ENTRY;
     547                 :             :         }
     548                 :             : 
     549                 :             :         return DBErrors::LOAD_OK;
     550                 :             :     }
     551                 :             : 
     552                 :             :     // Load HD Chain
     553                 :             :     // Note: There should only be one HDCHAIN record with no data following the type
     554         [ +  - ]:         621 :     LoadResult hd_chain_res = LoadRecords(pwallet, batch, DBKeys::HDCHAIN,
     555         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     556         [ -  + ]:          32 :         return LoadHDChain(pwallet, value, err) ? DBErrors:: LOAD_OK : DBErrors::CORRUPT;
     557                 :             :     });
     558         [ +  - ]:         621 :     result = std::max(result, hd_chain_res.m_result);
     559                 :             : 
     560                 :             :     // Load unencrypted keys
     561         [ +  - ]:         621 :     LoadResult key_res = LoadRecords(pwallet, batch, DBKeys::KEY,
     562         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     563         [ -  + ]:         194 :         return LoadKey(pwallet, key, value, err) ? DBErrors::LOAD_OK : DBErrors::CORRUPT;
     564                 :             :     });
     565         [ +  - ]:         621 :     result = std::max(result, key_res.m_result);
     566                 :             : 
     567                 :             :     // Load encrypted keys
     568         [ +  - ]:         621 :     LoadResult ckey_res = LoadRecords(pwallet, batch, DBKeys::CRYPTED_KEY,
     569         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     570         [ -  + ]:          24 :         return LoadCryptedKey(pwallet, key, value, err) ? DBErrors::LOAD_OK : DBErrors::CORRUPT;
     571                 :             :     });
     572         [ +  - ]:         621 :     result = std::max(result, ckey_res.m_result);
     573                 :             : 
     574                 :             :     // Load scripts
     575         [ +  - ]:         621 :     LoadResult script_res = LoadRecords(pwallet, batch, DBKeys::CSCRIPT,
     576         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
     577                 :          92 :         uint160 hash;
     578                 :          92 :         key >> hash;
     579                 :          92 :         CScript script;
     580         [ +  - ]:          92 :         value >> script;
     581   [ +  -  +  -  :          92 :         if (!pwallet->GetOrCreateLegacyDataSPKM()->LoadCScript(script))
                   -  + ]
     582                 :             :         {
     583         [ -  - ]:          92 :             strErr = "Error reading wallet database: LegacyDataSPKM::LoadCScript failed";
     584                 :             :             return DBErrors::NONCRITICAL_ERROR;
     585                 :             :         }
     586                 :             :         return DBErrors::LOAD_OK;
     587                 :          92 :     });
     588         [ +  - ]:         621 :     result = std::max(result, script_res.m_result);
     589                 :             : 
     590                 :             :     // Check whether rewrite is needed
     591         [ +  + ]:         621 :     if (ckey_res.m_records > 0) {
     592                 :             :         // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
     593   [ -  +  -  - ]:           4 :         if (last_client == 40000 || last_client == 50000) result = std::max(result, DBErrors::NEED_REWRITE);
     594                 :             :     }
     595                 :             : 
     596                 :             :     // Load keymeta
     597         [ +  - ]:         621 :     std::map<uint160, CHDChain> hd_chains;
     598                 :         621 :     LoadResult keymeta_res = LoadRecords(pwallet, batch, DBKeys::KEYMETA,
     599         [ +  - ]:         621 :         [&hd_chains] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
     600                 :         222 :         CPubKey vchPubKey;
     601                 :         222 :         key >> vchPubKey;
     602                 :         222 :         CKeyMetadata keyMeta;
     603         [ +  - ]:         222 :         value >> keyMeta;
     604   [ +  -  +  -  :         222 :         pwallet->GetOrCreateLegacyDataSPKM()->LoadKeyMetadata(vchPubKey.GetID(), keyMeta);
                   +  - ]
     605                 :             : 
     606                 :             :         // Extract some CHDChain info from this metadata if it has any
     607   [ +  -  +  +  :         657 :         if (keyMeta.nVersion >= CKeyMetadata::VERSION_WITH_HDDATA && !keyMeta.hd_seed_id.IsNull() && keyMeta.hdKeypath.size() > 0) {
                   +  - ]
     608                 :             :             // Get the path from the key origin or from the path string
     609                 :             :             // Not applicable when path is "s" or "m" as those indicate a seed
     610                 :             :             // See https://github.com/bitcoin/bitcoin/pull/12924
     611                 :         213 :             bool internal = false;
     612                 :         213 :             uint32_t index = 0;
     613   [ +  +  +  - ]:         213 :             if (keyMeta.hdKeypath != "s" && keyMeta.hdKeypath != "m") {
     614                 :         175 :                 std::vector<uint32_t> path;
     615         [ +  - ]:         175 :                 if (keyMeta.has_key_origin) {
     616                 :             :                     // We have a key origin, so pull it from its path vector
     617         [ +  - ]:         175 :                     path = keyMeta.key_origin.path;
     618                 :             :                 } else {
     619                 :             :                     // No key origin, have to parse the string
     620   [ #  #  #  # ]:           0 :                     if (!ParseHDKeypath(keyMeta.hdKeypath, path)) {
     621         [ #  # ]:           0 :                         strErr = "Error reading wallet database: keymeta with invalid HD keypath";
     622                 :             :                         return DBErrors::NONCRITICAL_ERROR;
     623                 :             :                     }
     624                 :             :                 }
     625                 :             : 
     626                 :             :                 // Extract the index and internal from the path
     627                 :             :                 // Path string is m/0'/k'/i'
     628                 :             :                 // Path vector is [0', k', i'] (but as ints OR'd with the hardened bit
     629                 :             :                 // k == 0 for external, 1 for internal. i is the index
     630   [ -  +  +  + ]:         175 :                 if (path.size() != 3) {
     631         [ +  - ]:           1 :                     strErr = "Error reading wallet database: keymeta found with unexpected path";
     632                 :             :                     return DBErrors::NONCRITICAL_ERROR;
     633                 :             :                 }
     634         [ -  + ]:         174 :                 if (path[0] != 0x80000000) {
     635         [ #  # ]:           0 :                     strErr = strprintf("Unexpected path index of 0x%08x (expected 0x80000000) for the element at index 0", path[0]);
     636                 :           0 :                     return DBErrors::NONCRITICAL_ERROR;
     637                 :             :                 }
     638   [ +  +  +  - ]:         174 :                 if (path[1] != 0x80000000 && path[1] != (1 | 0x80000000)) {
     639         [ #  # ]:           0 :                     strErr = strprintf("Unexpected path index of 0x%08x (expected 0x80000000 or 0x80000001) for the element at index 1", path[1]);
     640                 :           0 :                     return DBErrors::NONCRITICAL_ERROR;
     641                 :             :                 }
     642         [ -  + ]:         174 :                 if ((path[2] & 0x80000000) == 0) {
     643         [ #  # ]:           0 :                     strErr = strprintf("Unexpected path index of 0x%08x (expected to be greater than or equal to 0x80000000)", path[2]);
     644                 :           0 :                     return DBErrors::NONCRITICAL_ERROR;
     645                 :             :                 }
     646                 :         174 :                 internal = path[1] == (1 | 0x80000000);
     647                 :         174 :                 index = path[2] & ~0x80000000;
     648                 :         175 :             }
     649                 :             : 
     650                 :             :             // Insert a new CHDChain, or get the one that already exists
     651   [ +  -  +  + ]:         212 :             auto [ins, inserted] = hd_chains.emplace(keyMeta.hd_seed_id, CHDChain());
     652         [ +  + ]:         212 :             CHDChain& chain = ins->second;
     653         [ +  + ]:         212 :             if (inserted) {
     654                 :             :                 // For new chains, we want to default to VERSION_HD_BASE until we see an internal
     655                 :          38 :                 chain.nVersion = CHDChain::VERSION_HD_BASE;
     656                 :          38 :                 chain.seed_id = keyMeta.hd_seed_id;
     657                 :             :             }
     658         [ +  + ]:         212 :             if (internal) {
     659                 :          72 :                 chain.nVersion = CHDChain::VERSION_HD_CHAIN_SPLIT;
     660         [ +  + ]:          95 :                 chain.nInternalChainCounter = std::max(chain.nInternalChainCounter, index + 1);
     661                 :             :             } else {
     662         [ +  + ]:         225 :                 chain.nExternalChainCounter = std::max(chain.nExternalChainCounter, index + 1);
     663                 :             :             }
     664                 :             :         }
     665                 :             :         return DBErrors::LOAD_OK;
     666                 :         222 :     });
     667         [ +  + ]:         621 :     result = std::max(result, keymeta_res.m_result);
     668                 :             : 
     669                 :             :     // Set inactive chains
     670         [ +  + ]:         621 :     if (!hd_chains.empty()) {
     671         [ +  - ]:          32 :         LegacyDataSPKM* legacy_spkm = pwallet->GetLegacyDataSPKM();
     672         [ +  - ]:          32 :         if (legacy_spkm) {
     673   [ +  +  +  + ]:          70 :             for (const auto& [hd_seed_id, chain] : hd_chains) {
     674         [ +  + ]:          38 :                 if (hd_seed_id != legacy_spkm->GetHDChain().seed_id) {
     675         [ +  - ]:           6 :                     legacy_spkm->AddInactiveHDChain(chain);
     676                 :             :                 }
     677                 :             :             }
     678                 :             :         } else {
     679         [ #  # ]:           0 :             pwallet->WalletLogPrintf("Inactive HD Chains found but no Legacy ScriptPubKeyMan\n");
     680                 :           0 :             result = DBErrors::CORRUPT;
     681                 :             :         }
     682                 :             :     }
     683                 :             : 
     684                 :             :     // Load watchonly scripts
     685         [ +  - ]:         621 :     LoadResult watch_script_res = LoadRecords(pwallet, batch, DBKeys::WATCHS,
     686         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     687                 :          45 :         CScript script;
     688         [ +  - ]:          45 :         key >> script;
     689                 :          45 :         uint8_t fYes;
     690         [ +  - ]:          45 :         value >> fYes;
     691         [ +  - ]:          45 :         if (fYes == '1') {
     692   [ +  -  +  - ]:          45 :             pwallet->GetOrCreateLegacyDataSPKM()->LoadWatchOnly(script);
     693                 :             :         }
     694                 :          45 :         return DBErrors::LOAD_OK;
     695                 :          45 :     });
     696         [ +  - ]:         621 :     result = std::max(result, watch_script_res.m_result);
     697                 :             : 
     698                 :             :     // Load watchonly meta
     699         [ +  - ]:         621 :     LoadResult watch_meta_res = LoadRecords(pwallet, batch, DBKeys::WATCHMETA,
     700         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     701                 :          45 :         CScript script;
     702         [ +  - ]:          45 :         key >> script;
     703                 :          45 :         CKeyMetadata keyMeta;
     704         [ +  - ]:          45 :         value >> keyMeta;
     705   [ +  -  +  -  :          45 :         pwallet->GetOrCreateLegacyDataSPKM()->LoadScriptMetadata(CScriptID(script), keyMeta);
                   +  - ]
     706                 :          45 :         return DBErrors::LOAD_OK;
     707                 :          45 :     });
     708         [ +  - ]:         621 :     result = std::max(result, watch_meta_res.m_result);
     709                 :             : 
     710                 :             :     // Deal with old "wkey" and "defaultkey" records.
     711                 :             :     // These are not actually loaded, but we need to check for them
     712                 :             : 
     713                 :             :     // We don't want or need the default key, but if there is one set,
     714                 :             :     // we want to make sure that it is valid so that we can detect corruption
     715                 :             :     // Note: There should only be one DEFAULTKEY with nothing trailing the type
     716         [ +  - ]:         621 :     LoadResult default_key_res = LoadRecords(pwallet, batch, DBKeys::DEFAULTKEY,
     717         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     718         [ #  # ]:           0 :         CPubKey default_pubkey;
     719                 :           0 :         try {
     720         [ #  # ]:           0 :             value >> default_pubkey;
     721         [ -  - ]:           0 :         } catch (const std::exception& e) {
     722         [ -  - ]:           0 :             err = e.what();
     723                 :           0 :             return DBErrors::CORRUPT;
     724                 :           0 :         }
     725         [ #  # ]:           0 :         if (!default_pubkey.IsValid()) {
     726                 :           0 :             err = "Error reading wallet database: Default Key corrupt";
     727                 :           0 :             return DBErrors::CORRUPT;
     728                 :             :         }
     729                 :             :         return DBErrors::LOAD_OK;
     730                 :             :     });
     731         [ +  - ]:         621 :     result = std::max(result, default_key_res.m_result);
     732                 :             : 
     733                 :             :     // "wkey" records are unsupported, if we see any, throw an error
     734         [ +  - ]:         621 :     LoadResult wkey_res = LoadRecords(pwallet, batch, DBKeys::OLD_KEY,
     735         [ +  - ]:         621 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     736                 :           0 :         err = "Found unsupported 'wkey' record, try loading with version 0.18";
     737                 :           0 :         return DBErrors::LOAD_FAIL;
     738                 :             :     });
     739         [ +  - ]:         621 :     result = std::max(result, wkey_res.m_result);
     740                 :             : 
     741         [ +  - ]:         621 :     if (result <= DBErrors::NONCRITICAL_ERROR) {
     742                 :             :         // Only do logging and time first key update if there were no critical errors
     743                 :         621 :         pwallet->WalletLogPrintf("Legacy Wallet Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total.\n",
     744         [ +  - ]:         621 :                key_res.m_records, ckey_res.m_records, keymeta_res.m_records, key_res.m_records + ckey_res.m_records);
     745                 :             :     }
     746                 :             : 
     747                 :         621 :     return result;
     748                 :         621 : }
     749                 :             : 
     750                 :             : template<typename... Args>
     751                 :       10052 : static DataStream PrefixStream(const Args&... args)
     752                 :             : {
     753                 :       10052 :     DataStream prefix;
     754         [ +  - ]:       10052 :     SerializeMany(prefix, args...);
     755                 :       10052 :     return prefix;
     756                 :           0 : }
     757                 :             : 
     758                 :         926 : static DBErrors LoadDescriptorWalletRecords(CWallet* pwallet, DatabaseBatch& batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
     759                 :             : {
     760                 :         926 :     AssertLockHeld(pwallet->cs_wallet);
     761                 :             : 
     762                 :             :     // Load descriptor record
     763                 :         926 :     int num_keys = 0;
     764                 :         926 :     int num_ckeys= 0;
     765         [ +  - ]:         926 :     LoadResult desc_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTOR,
     766                 :         926 :         [&batch, &num_keys, &num_ckeys, &last_client] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
     767                 :        2515 :         DBErrors result = DBErrors::LOAD_OK;
     768                 :             : 
     769                 :        2515 :         uint256 id;
     770                 :        2515 :         key >> id;
     771                 :        2515 :         WalletDescriptor desc;
     772                 :        2515 :         try {
     773         [ +  + ]:        2515 :             value >> desc;
     774         [ -  + ]:           1 :         } catch (const std::ios_base::failure& e) {
     775         [ +  - ]:           1 :             strErr = strprintf("Error: Unrecognized descriptor found in wallet %s. ", pwallet->GetName());
     776                 :           1 :             strErr += (last_client > CLIENT_VERSION) ? "The wallet might have been created on a newer version. " :
     777         [ +  - ]:           1 :                     "The database might be corrupted or the software version is not compatible with one of your wallet descriptors. ";
     778         [ +  - ]:           1 :             strErr += "Please try running the latest software version";
     779                 :             :             // Also include error details
     780         [ +  - ]:           1 :             strErr = strprintf("%s\nDetails: %s", strErr, e.what());
     781                 :           1 :             return DBErrors::UNKNOWN_DESCRIPTOR;
     782                 :           1 :         }
     783         [ +  - ]:        2514 :         DescriptorScriptPubKeyMan& spkm = pwallet->LoadDescriptorScriptPubKeyMan(id, desc);
     784                 :             : 
     785                 :             :         // Prior to doing anything with this spkm, verify ID compatibility
     786   [ +  -  +  + ]:        2514 :         if (id != spkm.GetID()) {
     787         [ +  - ]:           1 :             strErr = "The descriptor ID calculated by the wallet differs from the one in DB";
     788                 :             :             return DBErrors::CORRUPT;
     789                 :             :         }
     790                 :             : 
     791                 :        2513 :         DescriptorCache cache;
     792                 :             : 
     793                 :             :         // Get key cache for this descriptor
     794         [ +  - ]:        2513 :         DataStream prefix = PrefixStream(DBKeys::WALLETDESCRIPTORCACHE, id);
     795                 :        2513 :         LoadResult key_cache_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORCACHE, prefix,
     796         [ +  - ]:        2513 :             [&id, &cache] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     797                 :        2394 :             bool parent = true;
     798                 :        2394 :             uint256 desc_id;
     799                 :        2394 :             uint32_t key_exp_index;
     800                 :        2394 :             uint32_t der_index;
     801                 :        2394 :             key >> desc_id;
     802         [ -  + ]:        2394 :             assert(desc_id == id);
     803                 :        2394 :             key >> key_exp_index;
     804                 :             : 
     805                 :             :             // if the der_index exists, it's a derived xpub
     806                 :        2394 :             try
     807                 :             :             {
     808         [ +  + ]:        2394 :                 key >> der_index;
     809                 :             :                 parent = false;
     810                 :             :             }
     811                 :        2209 :             catch (...) {}
     812                 :             : 
     813                 :        2394 :             std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
     814         [ +  - ]:        2394 :             value >> ser_xpub;
     815         [ +  - ]:        2394 :             CExtPubKey xpub;
     816         [ +  - ]:        2394 :             xpub.Decode(ser_xpub.data());
     817         [ +  + ]:        2394 :             if (parent) {
     818         [ +  - ]:        2209 :                 cache.CacheParentExtPubKey(key_exp_index, xpub);
     819                 :             :             } else {
     820         [ +  - ]:         185 :                 cache.CacheDerivedExtPubKey(key_exp_index, der_index, xpub);
     821                 :             :             }
     822                 :        2394 :             return DBErrors::LOAD_OK;
     823                 :        2394 :         });
     824         [ +  - ]:        2513 :         result = std::max(result, key_cache_res.m_result);
     825                 :             : 
     826                 :             :         // Get last hardened cache for this descriptor
     827         [ +  - ]:        5026 :         prefix = PrefixStream(DBKeys::WALLETDESCRIPTORLHCACHE, id);
     828                 :        2513 :         LoadResult lh_cache_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORLHCACHE, prefix,
     829         [ +  - ]:        2513 :             [&id, &cache] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     830                 :        2182 :             uint256 desc_id;
     831                 :        2182 :             uint32_t key_exp_index;
     832                 :        2182 :             key >> desc_id;
     833         [ -  + ]:        2182 :             assert(desc_id == id);
     834                 :        2182 :             key >> key_exp_index;
     835                 :             : 
     836                 :        2182 :             std::vector<unsigned char> ser_xpub(BIP32_EXTKEY_SIZE);
     837         [ +  - ]:        2182 :             value >> ser_xpub;
     838         [ +  - ]:        2182 :             CExtPubKey xpub;
     839         [ +  - ]:        2182 :             xpub.Decode(ser_xpub.data());
     840         [ +  - ]:        2182 :             cache.CacheLastHardenedExtPubKey(key_exp_index, xpub);
     841                 :        2182 :             return DBErrors::LOAD_OK;
     842                 :        2182 :         });
     843         [ +  - ]:        2513 :         result = std::max(result, lh_cache_res.m_result);
     844                 :             : 
     845                 :             :         // Set the cache for this descriptor
     846         [ +  - ]:        2513 :         auto spk_man = (DescriptorScriptPubKeyMan*)pwallet->GetScriptPubKeyMan(id);
     847         [ -  + ]:        2513 :         assert(spk_man);
     848         [ +  - ]:        2513 :         spk_man->SetCache(cache);
     849                 :             : 
     850                 :             :         // Get unencrypted keys
     851         [ +  - ]:        5026 :         prefix = PrefixStream(DBKeys::WALLETDESCRIPTORKEY, id);
     852                 :        2513 :         LoadResult key_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORKEY, prefix,
     853         [ +  - ]:        2513 :             [&id, &spk_man] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
     854                 :        2189 :             uint256 desc_id;
     855                 :        2189 :             CPubKey pubkey;
     856                 :        2189 :             key >> desc_id;
     857         [ -  + ]:        2189 :             assert(desc_id == id);
     858                 :        2189 :             key >> pubkey;
     859         [ -  + ]:        2189 :             if (!pubkey.IsValid())
     860                 :             :             {
     861                 :           0 :                 strErr = "Error reading wallet database: descriptor unencrypted key CPubKey corrupt";
     862                 :           0 :                 return DBErrors::CORRUPT;
     863                 :             :             }
     864                 :        2189 :             CKey privkey;
     865                 :        2189 :             CPrivKey pkey;
     866                 :        2189 :             uint256 hash;
     867                 :             : 
     868         [ +  - ]:        2189 :             value >> pkey;
     869         [ +  - ]:        2189 :             value >> hash;
     870                 :             : 
     871                 :             :             // hash pubkey/privkey to accelerate wallet load
     872                 :        2189 :             std::vector<unsigned char> to_hash;
     873   [ -  +  +  - ]:        2189 :             to_hash.reserve(pubkey.size() + pkey.size());
     874         [ +  - ]:        2189 :             to_hash.insert(to_hash.end(), pubkey.begin(), pubkey.end());
     875         [ +  - ]:        2189 :             to_hash.insert(to_hash.end(), pkey.begin(), pkey.end());
     876                 :             : 
     877   [ +  -  -  + ]:        2189 :             if (Hash(to_hash) != hash)
     878                 :             :             {
     879         [ #  # ]:           0 :                 strErr = "Error reading wallet database: descriptor unencrypted key CPubKey/CPrivKey corrupt";
     880                 :             :                 return DBErrors::CORRUPT;
     881                 :             :             }
     882                 :             : 
     883   [ +  -  -  + ]:        2189 :             if (!privkey.Load(pkey, pubkey, true))
     884                 :             :             {
     885         [ -  - ]:        2189 :                 strErr = "Error reading wallet database: descriptor unencrypted key CPrivKey corrupt";
     886                 :             :                 return DBErrors::CORRUPT;
     887                 :             :             }
     888   [ +  -  +  - ]:        2189 :             spk_man->AddKey(pubkey.GetID(), privkey);
     889                 :             :             return DBErrors::LOAD_OK;
     890                 :        2189 :         });
     891         [ +  - ]:        2513 :         result = std::max(result, key_res.m_result);
     892                 :        2513 :         num_keys = key_res.m_records;
     893                 :             : 
     894                 :             :         // Get encrypted keys
     895         [ +  - ]:        5026 :         prefix = PrefixStream(DBKeys::WALLETDESCRIPTORCKEY, id);
     896                 :        2513 :         LoadResult ckey_res = LoadRecords(pwallet, batch, DBKeys::WALLETDESCRIPTORCKEY, prefix,
     897         [ +  - ]:        2513 :             [&id, &spk_man] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
     898                 :         231 :             uint256 desc_id;
     899                 :         231 :             CPubKey pubkey;
     900                 :         231 :             key >> desc_id;
     901         [ -  + ]:         231 :             assert(desc_id == id);
     902                 :         231 :             key >> pubkey;
     903         [ -  + ]:         231 :             if (!pubkey.IsValid())
     904                 :             :             {
     905                 :           0 :                 err = "Error reading wallet database: descriptor encrypted key CPubKey corrupt";
     906                 :           0 :                 return DBErrors::CORRUPT;
     907                 :             :             }
     908                 :         231 :             std::vector<unsigned char> privkey;
     909         [ +  - ]:         231 :             value >> privkey;
     910                 :             : 
     911   [ +  -  +  - ]:         231 :             spk_man->AddCryptedKey(pubkey.GetID(), pubkey, privkey);
     912                 :         231 :             return DBErrors::LOAD_OK;
     913                 :         231 :         });
     914         [ +  - ]:        2513 :         result = std::max(result, ckey_res.m_result);
     915                 :        2513 :         num_ckeys = ckey_res.m_records;
     916                 :             : 
     917                 :        2513 :         return result;
     918                 :        2515 :     });
     919                 :             : 
     920         [ +  + ]:         926 :     if (desc_res.m_result <= DBErrors::NONCRITICAL_ERROR) {
     921                 :             :         // Only log if there are no critical errors
     922                 :         924 :         pwallet->WalletLogPrintf("Descriptors: %u, Descriptor Keys: %u plaintext, %u encrypted, %u total.\n",
     923                 :         924 :                desc_res.m_records, num_keys, num_ckeys, num_keys + num_ckeys);
     924                 :             :     }
     925                 :             : 
     926                 :         926 :     return desc_res.m_result;
     927                 :             : }
     928                 :             : 
     929                 :         925 : static DBErrors LoadAddressBookRecords(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
     930                 :             : {
     931                 :         925 :     AssertLockHeld(pwallet->cs_wallet);
     932                 :         925 :     DBErrors result = DBErrors::LOAD_OK;
     933                 :             : 
     934                 :             :     // Load name record
     935         [ +  - ]:         925 :     LoadResult name_res = LoadRecords(pwallet, batch, DBKeys::NAME,
     936         [ +  - ]:         925 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     937         [ +  - ]:        2928 :         std::string strAddress;
     938         [ +  - ]:        2928 :         key >> strAddress;
     939         [ +  - ]:        2928 :         std::string label;
     940         [ +  - ]:        2928 :         value >> label;
     941   [ +  -  +  -  :        5856 :         pwallet->m_address_book[DecodeDestination(strAddress)].SetLabel(label);
                   -  + ]
     942                 :        2928 :         return DBErrors::LOAD_OK;
     943                 :        2928 :     });
     944         [ +  - ]:         925 :     result = std::max(result, name_res.m_result);
     945                 :             : 
     946                 :             :     // Load purpose record
     947         [ +  - ]:         925 :     LoadResult purpose_res = LoadRecords(pwallet, batch, DBKeys::PURPOSE,
     948         [ +  - ]:         925 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     949         [ +  - ]:        2928 :         std::string strAddress;
     950         [ +  - ]:        2928 :         key >> strAddress;
     951         [ +  - ]:        2928 :         std::string purpose_str;
     952         [ +  - ]:        2928 :         value >> purpose_str;
     953         [ -  + ]:        2928 :         std::optional<AddressPurpose> purpose{PurposeFromString(purpose_str)};
     954         [ -  + ]:        2928 :         if (!purpose) {
     955         [ #  # ]:           0 :             pwallet->WalletLogPrintf("Warning: nonstandard purpose string '%s' for address '%s'\n", purpose_str, strAddress);
     956                 :             :         }
     957   [ +  -  +  - ]:        2928 :         pwallet->m_address_book[DecodeDestination(strAddress)].purpose = purpose;
     958                 :        2928 :         return DBErrors::LOAD_OK;
     959                 :        2928 :     });
     960         [ +  - ]:         925 :     result = std::max(result, purpose_res.m_result);
     961                 :             : 
     962                 :             :     // Load destination data record
     963         [ +  - ]:         925 :     LoadResult dest_res = LoadRecords(pwallet, batch, DBKeys::DESTDATA,
     964         [ +  - ]:         925 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     965         [ +  - ]:          10 :         std::string strAddress, strKey, strValue;
     966         [ +  - ]:          10 :         key >> strAddress;
     967         [ +  - ]:          10 :         key >> strKey;
     968         [ +  - ]:          10 :         value >> strValue;
     969         [ +  - ]:          10 :         const CTxDestination& dest{DecodeDestination(strAddress)};
     970         [ +  + ]:          10 :         if (strKey.compare("used") == 0) {
     971                 :             :             // Load "used" key indicating if an IsMine address has
     972                 :             :             // previously been spent from with avoid_reuse option enabled.
     973                 :             :             // The strValue is not used for anything currently, but could
     974                 :             :             // hold more information in the future. Current values are just
     975                 :             :             // "1" or "p" for present (which was written prior to
     976                 :             :             // f5ba424cd44619d9b9be88b8593d69a7ba96db26).
     977         [ +  - ]:           7 :             pwallet->LoadAddressPreviouslySpent(dest);
     978   [ -  +  +  - ]:           3 :         } else if (strKey.starts_with("rr")) {
     979                 :             :             // Load "rr##" keys where ## is a decimal number, and strValue
     980                 :             :             // is a serialized RecentRequestEntry object.
     981   [ +  -  +  - ]:           6 :             pwallet->LoadAddressReceiveRequest(dest, strKey.substr(2), strValue);
     982                 :             :         }
     983                 :          10 :         return DBErrors::LOAD_OK;
     984                 :          10 :     });
     985         [ +  - ]:         925 :     result = std::max(result, dest_res.m_result);
     986                 :             : 
     987                 :         925 :     return result;
     988                 :             : }
     989                 :             : 
     990                 :         925 : static DBErrors LoadTxRecords(CWallet* pwallet, DatabaseBatch& batch, bool& any_unordered) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
     991                 :             : {
     992                 :         925 :     AssertLockHeld(pwallet->cs_wallet);
     993                 :         925 :     DBErrors result = DBErrors::LOAD_OK;
     994                 :             : 
     995                 :             :     // Load tx record
     996                 :         925 :     any_unordered = false;
     997                 :         925 :     LoadResult tx_res = LoadRecords(pwallet, batch, DBKeys::TX,
     998         [ +  - ]:         925 :         [&any_unordered] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     999                 :        8227 :         DBErrors result = DBErrors::LOAD_OK;
    1000                 :        8227 :         Txid hash;
    1001                 :        8227 :         key >> hash;
    1002                 :             :         // LoadToWallet call below creates a new CWalletTx that fill_wtx
    1003                 :             :         // callback fills with transaction metadata.
    1004                 :       16454 :         auto fill_wtx = [&](CWalletTx& wtx, bool new_tx) {
    1005         [ -  + ]:        8227 :             if(!new_tx) {
    1006                 :             :                 // There's some corruption here since the tx we just tried to load was already in the wallet.
    1007                 :           0 :                 err = "Error: Corrupt transaction found. This can be fixed by removing transactions from wallet and rescanning.";
    1008                 :           0 :                 result = DBErrors::CORRUPT;
    1009                 :           0 :                 return false;
    1010                 :             :             }
    1011                 :        8227 :             value >> wtx;
    1012         [ +  - ]:        8227 :             if (wtx.GetHash() != hash)
    1013                 :             :                 return false;
    1014                 :             : 
    1015         [ -  + ]:        8227 :             if (wtx.nOrderPos == -1)
    1016                 :           0 :                 any_unordered = true;
    1017                 :             : 
    1018                 :             :             return true;
    1019                 :        8227 :         };
    1020   [ +  -  -  + ]:        8227 :         if (!pwallet->LoadToWallet(hash, fill_wtx)) {
    1021                 :             :             // Use std::max as fill_wtx may have already set result to CORRUPT
    1022         [ #  # ]:           0 :             result = std::max(result, DBErrors::NEED_RESCAN);
    1023                 :             :         }
    1024                 :        8227 :         return result;
    1025                 :             :     });
    1026         [ +  - ]:         925 :     result = std::max(result, tx_res.m_result);
    1027                 :             : 
    1028                 :             :     // Load locked utxo record
    1029         [ +  - ]:         925 :     LoadResult locked_utxo_res = LoadRecords(pwallet, batch, DBKeys::LOCKED_UTXO,
    1030         [ +  - ]:         925 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
    1031                 :           2 :         Txid hash;
    1032                 :           2 :         uint32_t n;
    1033                 :           2 :         key >> hash;
    1034                 :           2 :         key >> n;
    1035                 :           2 :         pwallet->LoadLockedCoin(COutPoint(hash, n), /*persistent=*/true);
    1036                 :           2 :         return DBErrors::LOAD_OK;
    1037                 :             :     });
    1038         [ +  - ]:         925 :     result = std::max(result, locked_utxo_res.m_result);
    1039                 :             : 
    1040                 :             :     // Load orderposnext record
    1041                 :             :     // Note: There should only be one ORDERPOSNEXT record with nothing trailing the type
    1042         [ +  - ]:         925 :     LoadResult order_pos_res = LoadRecords(pwallet, batch, DBKeys::ORDERPOSNEXT,
    1043         [ +  - ]:         925 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
    1044                 :         189 :         try {
    1045         [ +  - ]:         378 :             value >> pwallet->nOrderPosNext;
    1046         [ -  - ]:           0 :         } catch (const std::exception& e) {
    1047         [ -  - ]:           0 :             err = e.what();
    1048                 :           0 :             return DBErrors::NONCRITICAL_ERROR;
    1049                 :           0 :         }
    1050                 :             :         return DBErrors::LOAD_OK;
    1051                 :             :     });
    1052         [ +  - ]:         925 :     result = std::max(result, order_pos_res.m_result);
    1053                 :             : 
    1054                 :             :     // After loading all tx records, abandon any coinbase that is no longer in the active chain.
    1055                 :             :     // This could happen during an external wallet load, or if the user replaced the chain data.
    1056   [ +  +  +  + ]:        9152 :     for (auto& [id, wtx] : pwallet->mapWallet) {
    1057         [ +  + ]:       15426 :         if (wtx.IsCoinBase() && wtx.isInactive()) {
    1058                 :         592 :             pwallet->AbandonTransaction(wtx);
    1059                 :             :         }
    1060                 :             :     }
    1061                 :             : 
    1062                 :         925 :     return result;
    1063                 :             : }
    1064                 :             : 
    1065                 :         925 : static DBErrors LoadActiveSPKMs(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
    1066                 :             : {
    1067                 :         925 :     AssertLockHeld(pwallet->cs_wallet);
    1068                 :         925 :     DBErrors result = DBErrors::LOAD_OK;
    1069                 :             : 
    1070                 :             :     // Load spk records
    1071         [ -  + ]:         925 :     std::set<std::pair<OutputType, bool>> seen_spks;
    1072   [ -  +  -  +  :        6475 :     for (const auto& spk_key : {DBKeys::ACTIVEEXTERNALSPK, DBKeys::ACTIVEINTERNALSPK}) {
             +  +  -  - ]
    1073                 :        1850 :         LoadResult spkm_res = LoadRecords(pwallet, batch, spk_key,
    1074         [ +  - ]:        1850 :             [&seen_spks, &spk_key] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
    1075                 :        2098 :             uint8_t output_type;
    1076                 :        2098 :             key >> output_type;
    1077                 :        2098 :             uint256 id;
    1078                 :        2098 :             value >> id;
    1079                 :             : 
    1080                 :        2098 :             bool internal = spk_key == DBKeys::ACTIVEINTERNALSPK;
    1081         [ -  + ]:        2098 :             auto [it, insert] = seen_spks.emplace(static_cast<OutputType>(output_type), internal);
    1082         [ -  + ]:        2098 :             if (!insert) {
    1083                 :           0 :                 strErr = "Multiple ScriptpubKeyMans specified for a single type";
    1084                 :           0 :                 return DBErrors::CORRUPT;
    1085                 :             :             }
    1086                 :        2098 :             pwallet->LoadActiveScriptPubKeyMan(id, static_cast<OutputType>(output_type), /*internal=*/internal);
    1087                 :        2098 :             return DBErrors::LOAD_OK;
    1088                 :             :         });
    1089         [ +  - ]:        3700 :         result = std::max(result, spkm_res.m_result);
    1090   [ +  +  -  - ]:        2775 :     }
    1091                 :         925 :     return result;
    1092                 :         925 : }
    1093                 :             : 
    1094                 :         925 : static DBErrors LoadDecryptionKeys(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
    1095                 :             : {
    1096                 :         925 :     AssertLockHeld(pwallet->cs_wallet);
    1097                 :             : 
    1098                 :             :     // Load decryption key (mkey) records
    1099         [ +  - ]:         925 :     LoadResult mkey_res = LoadRecords(pwallet, batch, DBKeys::MASTER_KEY,
    1100         [ +  - ]:         925 :         [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
    1101         [ -  + ]:          19 :         if (!LoadEncryptionKey(pwallet, key, value, err)) {
    1102                 :           0 :             return DBErrors::CORRUPT;
    1103                 :             :         }
    1104                 :             :         return DBErrors::LOAD_OK;
    1105                 :             :     });
    1106                 :         925 :     return mkey_res.m_result;
    1107                 :             : }
    1108                 :             : 
    1109                 :         926 : DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
    1110                 :             : {
    1111                 :         926 :     DBErrors result = DBErrors::LOAD_OK;
    1112                 :         926 :     bool any_unordered = false;
    1113                 :             : 
    1114                 :         926 :     LOCK(pwallet->cs_wallet);
    1115                 :             : 
    1116                 :             :     // Last client version to open this wallet
    1117                 :         926 :     int last_client = CLIENT_VERSION;
    1118         [ +  - ]:         926 :     bool has_last_client = m_batch->Read(DBKeys::VERSION, last_client);
    1119   [ +  +  +  - ]:         926 :     if (has_last_client) pwallet->WalletLogPrintf("Last client version = %d\n", last_client);
    1120                 :             : 
    1121                 :         926 :     try {
    1122                 :             :         // Load wallet flags, so they are known when processing other records.
    1123                 :             :         // The FLAGS key is absent during wallet creation.
    1124   [ +  -  +  - ]:         926 :         if ((result = LoadWalletFlags(pwallet, *m_batch)) != DBErrors::LOAD_OK) return result;
    1125                 :             : 
    1126                 :             : #ifndef ENABLE_EXTERNAL_SIGNER
    1127                 :             :         if (pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
    1128                 :             :             pwallet->WalletLogPrintf("Error: External signer wallet being loaded without external signer support compiled\n");
    1129                 :             :             return DBErrors::EXTERNAL_SIGNER_SUPPORT_REQUIRED;
    1130                 :             :         }
    1131                 :             : #endif
    1132                 :             : 
    1133                 :             :         // Load legacy wallet keys
    1134   [ +  -  +  - ]:         926 :         result = std::max(LoadLegacyWalletRecords(pwallet, *m_batch, last_client), result);
    1135                 :             : 
    1136                 :             :         // Load descriptors
    1137   [ +  -  +  + ]:         926 :         result = std::max(LoadDescriptorWalletRecords(pwallet, *m_batch, last_client), result);
    1138                 :             :         // Early return if there are unknown descriptors. Later loading of ACTIVEINTERNALSPK and ACTIVEEXTERNALEXPK
    1139                 :             :         // may reference the unknown descriptor's ID which can result in a misleading corruption error
    1140                 :             :         // when in reality the wallet is simply too new.
    1141         [ +  + ]:         926 :         if (result == DBErrors::UNKNOWN_DESCRIPTOR) return result;
    1142                 :             : 
    1143                 :             :         // Load address book
    1144   [ +  -  +  + ]:         925 :         result = std::max(LoadAddressBookRecords(pwallet, *m_batch), result);
    1145                 :             : 
    1146                 :             :         // Load SPKMs
    1147   [ +  -  +  + ]:         925 :         result = std::max(LoadActiveSPKMs(pwallet, *m_batch), result);
    1148                 :             : 
    1149                 :             :         // Load decryption keys
    1150   [ +  -  +  + ]:         925 :         result = std::max(LoadDecryptionKeys(pwallet, *m_batch), result);
    1151                 :             : 
    1152                 :             :         // Load tx records
    1153   [ +  -  +  + ]:        1847 :         result = std::max(LoadTxRecords(pwallet, *m_batch, any_unordered), result);
    1154         [ -  - ]:           0 :     } catch (std::runtime_error& e) {
    1155                 :             :         // Exceptions that can be ignored or treated as non-critical are handled by the individual loading functions.
    1156                 :             :         // Any uncaught exceptions will be caught here and treated as critical.
    1157                 :             :         // Catch std::runtime_error specifically as many functions throw these and they at least have some message that
    1158                 :             :         // we can log
    1159         [ -  - ]:           0 :         pwallet->WalletLogPrintf("%s\n", e.what());
    1160                 :           0 :         result = DBErrors::CORRUPT;
    1161                 :           0 :     } catch (...) {
    1162                 :             :         // All other exceptions are still problematic, but we can't log them
    1163                 :           0 :         result = DBErrors::CORRUPT;
    1164         [ -  - ]:           0 :     }
    1165                 :             : 
    1166                 :             :     // Any wallet corruption at all: skip any rewriting or
    1167                 :             :     // upgrading, we don't want to make it worse.
    1168         [ +  + ]:         925 :     if (result != DBErrors::LOAD_OK)
    1169                 :             :         return result;
    1170                 :             : 
    1171   [ +  +  +  + ]:         922 :     if (!has_last_client || last_client != CLIENT_VERSION) // Update
    1172         [ +  - ]:         660 :         m_batch->Write(DBKeys::VERSION, CLIENT_VERSION);
    1173                 :             : 
    1174         [ -  + ]:         922 :     if (any_unordered)
    1175         [ #  # ]:           0 :         result = pwallet->ReorderTransactions();
    1176                 :             : 
    1177                 :             :     // Upgrade all of the descriptor caches to cache the last hardened xpub
    1178                 :             :     // This operation is not atomic, but if it fails, only new entries are added so it is backwards compatible
    1179                 :         922 :     try {
    1180         [ +  - ]:         922 :         pwallet->UpgradeDescriptorCache();
    1181                 :           0 :     } catch (...) {
    1182                 :           0 :         result = DBErrors::CORRUPT;
    1183         [ -  - ]:           0 :     }
    1184                 :             : 
    1185                 :             :     // Since it was accidentally possible to "encrypt" a wallet with private keys disabled, we should check if this is
    1186                 :             :     // such a wallet and remove the encryption key records to avoid any future issues.
    1187                 :             :     // Although wallets without private keys should not have *ckey records, we should double check that.
    1188                 :             :     // Removing the mkey records is only safe if there are no *ckey records.
    1189   [ +  -  +  +  :         922 :     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && pwallet->HasEncryptionKeys() && !pwallet->HaveCryptedKeys()) {
          +  -  +  +  +  
                -  +  - ]
    1190         [ +  - ]:           1 :         pwallet->WalletLogPrintf("Detected extraneous encryption keys in this wallet without private keys. Removing extraneous encryption keys.\n");
    1191   [ +  -  +  + ]:           2 :         for (const auto& [id, _] : pwallet->mapMasterKeys) {
    1192   [ +  -  -  + ]:           1 :             if (!EraseMasterKey(id)) {
    1193         [ #  # ]:           0 :                 pwallet->WalletLogPrintf("Error: Unable to remove extraneous encryption key '%u'. Wallet corrupt.\n", id);
    1194                 :             :                 return DBErrors::CORRUPT;
    1195                 :             :             }
    1196                 :             :         }
    1197                 :           1 :         pwallet->mapMasterKeys.clear();
    1198                 :             :     }
    1199                 :             : 
    1200                 :         922 :     return result;
    1201                 :         926 : }
    1202                 :             : 
    1203                 :         393 : static bool RunWithinTxn(WalletBatch& batch, std::string_view process_desc, const std::function<bool(WalletBatch&)>& func)
    1204                 :             : {
    1205         [ -  + ]:         393 :     if (!batch.TxnBegin()) {
    1206         [ #  # ]:           0 :         LogDebug(BCLog::WALLETDB, "Error: cannot create db txn for %s\n", process_desc);
    1207                 :           0 :         return false;
    1208                 :             :     }
    1209                 :             : 
    1210                 :             :     // Run procedure
    1211         [ +  + ]:         393 :     if (!func(batch)) {
    1212         [ +  - ]:           1 :         LogDebug(BCLog::WALLETDB, "Error: %s failed\n", process_desc);
    1213                 :           1 :         batch.TxnAbort();
    1214                 :           1 :         return false;
    1215                 :             :     }
    1216                 :             : 
    1217         [ -  + ]:         392 :     if (!batch.TxnCommit()) {
    1218         [ #  # ]:           0 :         LogDebug(BCLog::WALLETDB, "Error: cannot commit db txn for %s\n", process_desc);
    1219                 :           0 :         return false;
    1220                 :             :     }
    1221                 :             : 
    1222                 :             :     // All good
    1223                 :             :     return true;
    1224                 :             : }
    1225                 :             : 
    1226                 :         393 : bool RunWithinTxn(WalletDatabase& database, std::string_view process_desc, const std::function<bool(WalletBatch&)>& func)
    1227                 :             : {
    1228                 :         393 :     WalletBatch batch(database);
    1229         [ +  - ]:         393 :     return RunWithinTxn(batch, process_desc, func);
    1230                 :         393 : }
    1231                 :             : 
    1232                 :          24 : bool WalletBatch::WriteAddressPreviouslySpent(const CTxDestination& dest, bool previously_spent)
    1233                 :             : {
    1234   [ +  -  +  - ]:          72 :     auto key{std::make_pair(DBKeys::DESTDATA, std::make_pair(EncodeDestination(dest), std::string("used")))};
    1235   [ +  +  +  -  :          48 :     return previously_spent ? WriteIC(key, std::string("1")) : EraseIC(key);
                   +  - ]
    1236                 :          24 : }
    1237                 :             : 
    1238                 :           4 : bool WalletBatch::WriteAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& receive_request)
    1239                 :             : {
    1240   [ +  -  +  -  :          16 :     return WriteIC(std::make_pair(DBKeys::DESTDATA, std::make_pair(EncodeDestination(dest), "rr" + id)), receive_request);
                   +  - ]
    1241                 :             : }
    1242                 :             : 
    1243                 :           1 : bool WalletBatch::EraseAddressReceiveRequest(const CTxDestination& dest, const std::string& id)
    1244                 :             : {
    1245   [ +  -  +  -  :           4 :     return EraseIC(std::make_pair(DBKeys::DESTDATA, std::make_pair(EncodeDestination(dest), "rr" + id)));
                   +  - ]
    1246                 :             : }
    1247                 :             : 
    1248                 :          27 : bool WalletBatch::EraseAddressData(const CTxDestination& dest)
    1249                 :             : {
    1250                 :          27 :     DataStream prefix;
    1251   [ +  -  +  - ]:          54 :     prefix << DBKeys::DESTDATA << EncodeDestination(dest);
    1252   [ -  +  +  - ]:          27 :     return m_batch->ErasePrefix(prefix);
    1253                 :          27 : }
    1254                 :             : 
    1255                 :        3750 : bool WalletBatch::WriteWalletFlags(const uint64_t flags)
    1256                 :             : {
    1257                 :        3750 :     return WriteIC(DBKeys::FLAGS, flags);
    1258                 :             : }
    1259                 :             : 
    1260                 :          32 : bool WalletBatch::EraseRecords(const std::unordered_set<std::string>& types)
    1261                 :             : {
    1262                 :          32 :     return std::all_of(types.begin(), types.end(), [&](const std::string& type) {
    1263   [ +  -  -  +  :         320 :         return m_batch->ErasePrefix(DataStream() << type);
                   +  - ]
    1264                 :          32 :     });
    1265                 :             : }
    1266                 :             : 
    1267                 :       71543 : bool WalletBatch::TxnBegin()
    1268                 :             : {
    1269                 :       71543 :     return m_batch->TxnBegin();
    1270                 :             : }
    1271                 :             : 
    1272                 :       71541 : bool WalletBatch::TxnCommit()
    1273                 :             : {
    1274                 :       71541 :     bool res = m_batch->TxnCommit();
    1275         [ +  - ]:       71541 :     if (res) {
    1276         [ +  + ]:       71551 :         for (const auto& listener : m_txn_listeners) {
    1277                 :          10 :             listener.on_commit();
    1278                 :             :         }
    1279                 :             :         // txn finished, clear listeners
    1280                 :       71541 :         m_txn_listeners.clear();
    1281                 :             :     }
    1282                 :       71541 :     return res;
    1283                 :             : }
    1284                 :             : 
    1285                 :           1 : bool WalletBatch::TxnAbort()
    1286                 :             : {
    1287                 :           1 :     bool res = m_batch->TxnAbort();
    1288         [ +  - ]:           1 :     if (res) {
    1289         [ -  + ]:           1 :         for (const auto& listener : m_txn_listeners) {
    1290                 :           0 :             listener.on_abort();
    1291                 :             :         }
    1292                 :             :         // txn finished, clear listeners
    1293                 :           1 :         m_txn_listeners.clear();
    1294                 :             :     }
    1295                 :           1 :     return res;
    1296                 :             : }
    1297                 :             : 
    1298                 :          10 : void WalletBatch::RegisterTxnListener(const DbTxnListener& l)
    1299                 :             : {
    1300         [ -  + ]:          10 :     assert(m_batch->HasActiveTxn());
    1301                 :          10 :     m_txn_listeners.emplace_back(l);
    1302                 :          10 : }
    1303                 :             : 
    1304                 :        1327 : std::unique_ptr<WalletDatabase> MakeDatabase(const fs::path& path, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error)
    1305                 :             : {
    1306                 :        1327 :     bool exists;
    1307                 :        1327 :     try {
    1308         [ +  - ]:        1327 :         exists = fs::symlink_status(path).type() != fs::file_type::not_found;
    1309         [ -  - ]:           0 :     } catch (const fs::filesystem_error& e) {
    1310   [ -  -  -  -  :           0 :         error = Untranslated(strprintf("Failed to access database path '%s': %s", fs::PathToString(path), e.code().message()));
             -  -  -  - ]
    1311                 :           0 :         status = DatabaseStatus::FAILED_BAD_PATH;
    1312                 :           0 :         return nullptr;
    1313                 :           0 :     }
    1314                 :             : 
    1315                 :        1327 :     std::optional<DatabaseFormat> format;
    1316         [ +  + ]:        1327 :     if (exists) {
    1317   [ +  -  +  + ]:        1584 :         if (IsBDBFile(BDBDataFile(path))) {
    1318                 :          50 :             format = DatabaseFormat::BERKELEY_RO;
    1319                 :             :         }
    1320   [ +  -  +  + ]:        1584 :         if (IsSQLiteFile(SQLiteDataFile(path))) {
    1321         [ -  + ]:         425 :             if (format) {
    1322   [ #  #  #  #  :           0 :                 error = Untranslated(strprintf("Failed to load database path '%s'. Data is in ambiguous format.", fs::PathToString(path)));
                   #  # ]
    1323                 :           0 :                 status = DatabaseStatus::FAILED_BAD_FORMAT;
    1324                 :           0 :                 return nullptr;
    1325                 :             :             }
    1326                 :         425 :             format = DatabaseFormat::SQLITE;
    1327                 :             :         }
    1328         [ +  + ]:         535 :     } else if (options.require_existing) {
    1329   [ -  +  +  -  :           9 :         error = Untranslated(strprintf("Failed to load database path '%s'. Path does not exist.", fs::PathToString(path)));
                   +  - ]
    1330                 :           3 :         status = DatabaseStatus::FAILED_NOT_FOUND;
    1331                 :           3 :         return nullptr;
    1332                 :             :     }
    1333                 :             : 
    1334   [ +  +  +  + ]:        1324 :     if (!format && options.require_existing) {
    1335   [ -  +  +  -  :         825 :         error = Untranslated(strprintf("Failed to load database path '%s'. Data is not in recognized format.", fs::PathToString(path)));
                   +  - ]
    1336                 :         275 :         status = DatabaseStatus::FAILED_BAD_FORMAT;
    1337                 :         275 :         return nullptr;
    1338                 :             :     }
    1339                 :             : 
    1340   [ +  +  +  + ]:        1049 :     if (format && options.require_create) {
    1341   [ -  +  +  -  :          15 :         error = Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(path)));
                   +  - ]
    1342                 :           5 :         status = DatabaseStatus::FAILED_ALREADY_EXISTS;
    1343                 :           5 :         return nullptr;
    1344                 :             :     }
    1345                 :             : 
    1346                 :             :     // BERKELEY_RO can only be opened if require_format was set, which only occurs in migration.
    1347   [ +  +  +  +  :        1044 :     if (format && format == DatabaseFormat::BERKELEY_RO && (!options.require_format || options.require_format != DatabaseFormat::BERKELEY_RO)) {
             +  +  -  + ]
    1348   [ -  +  +  -  :          24 :         error = Untranslated(strprintf("Failed to open database path '%s'. The wallet appears to be a Legacy wallet, please use the wallet migration tool (migratewallet RPC or the GUI option).", fs::PathToString(path)));
                   +  - ]
    1349                 :           8 :         status = DatabaseStatus::FAILED_LEGACY_DISABLED;
    1350                 :           8 :         return nullptr;
    1351                 :             :     }
    1352                 :             : 
    1353                 :             :     // A db already exists so format is set, but options also specifies the format, so make sure they agree
    1354   [ +  +  +  +  :        1036 :     if (format && options.require_format && format != options.require_format) {
                   +  - ]
    1355   [ #  #  #  #  :           0 :         error = Untranslated(strprintf("Failed to load database path '%s'. Data is not in required format.", fs::PathToString(path)));
                   #  # ]
    1356                 :           0 :         status = DatabaseStatus::FAILED_BAD_FORMAT;
    1357                 :           0 :         return nullptr;
    1358                 :             :     }
    1359                 :             : 
    1360                 :             :     // Format is not set when a db doesn't already exist, so use the format specified by the options if it is set.
    1361   [ +  +  +  + ]:        1036 :     if (!format && options.require_format) format = options.require_format;
    1362                 :             : 
    1363         [ +  + ]:        1036 :     if (!format) {
    1364                 :           3 :         format = DatabaseFormat::SQLITE;
    1365                 :             :     }
    1366                 :             : 
    1367         [ +  - ]:        1036 :     if (format == DatabaseFormat::SQLITE) {
    1368                 :         996 :         return MakeSQLiteDatabase(path, options, status, error);
    1369                 :             :     }
    1370                 :             : 
    1371         [ +  - ]:          40 :     if (format == DatabaseFormat::BERKELEY_RO) {
    1372                 :          40 :         return MakeBerkeleyRODatabase(path, options, status, error);
    1373                 :             :     }
    1374                 :             : 
    1375         [ #  # ]:           0 :     error = Untranslated(STR_INTERNAL_BUG("Could not determine wallet format"));
    1376                 :           0 :     status = DatabaseStatus::FAILED_BAD_FORMAT;
    1377                 :           0 :     return nullptr;
    1378                 :             : }
    1379                 :             : } // namespace wallet
        

Generated by: LCOV version 2.0-1