LCOV - code coverage report
Current view: top level - src/wallet - load.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 0.0 % 114 0
Test Date: 2025-10-10 04:04:55 Functions: 0.0 % 4 0
Branches: 0.0 % 218 0

             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 <wallet/load.h>
       7                 :             : 
       8                 :             : #include <common/args.h>
       9                 :             : #include <interfaces/chain.h>
      10                 :             : #include <scheduler.h>
      11                 :             : #include <util/check.h>
      12                 :             : #include <util/fs.h>
      13                 :             : #include <util/string.h>
      14                 :             : #include <util/translation.h>
      15                 :             : #include <wallet/context.h>
      16                 :             : #include <wallet/spend.h>
      17                 :             : #include <wallet/wallet.h>
      18                 :             : #include <wallet/walletdb.h>
      19                 :             : 
      20                 :             : #include <univalue.h>
      21                 :             : 
      22                 :             : #include <system_error>
      23                 :             : 
      24                 :             : using util::Join;
      25                 :             : 
      26                 :             : namespace wallet {
      27                 :           0 : bool VerifyWallets(WalletContext& context)
      28                 :             : {
      29                 :           0 :     interfaces::Chain& chain = *context.chain;
      30                 :           0 :     ArgsManager& args = *Assert(context.args);
      31                 :             : 
      32   [ #  #  #  # ]:           0 :     if (args.IsArgSet("-walletdir")) {
      33   [ #  #  #  # ]:           0 :         const fs::path wallet_dir{args.GetPathArg("-walletdir")};
      34         [ #  # ]:           0 :         std::error_code error;
      35                 :             :         // The canonical path cleans the path, preventing >1 Berkeley environment instances for the same directory
      36                 :             :         // It also lets the fs::exists and fs::is_directory checks below pass on windows, since they return false
      37                 :             :         // if a path has trailing slashes, and it strips trailing slashes.
      38         [ #  # ]:           0 :         fs::path canonical_wallet_dir = fs::canonical(wallet_dir, error);
      39   [ #  #  #  # ]:           0 :         if (error || !fs::exists(canonical_wallet_dir)) {
      40   [ #  #  #  #  :           0 :             chain.initError(strprintf(_("Specified -walletdir \"%s\" does not exist"), fs::PathToString(wallet_dir)));
                   #  # ]
      41                 :           0 :             return false;
      42   [ #  #  #  # ]:           0 :         } else if (!fs::is_directory(canonical_wallet_dir)) {
      43   [ #  #  #  #  :           0 :             chain.initError(strprintf(_("Specified -walletdir \"%s\" is not a directory"), fs::PathToString(wallet_dir)));
                   #  # ]
      44                 :           0 :             return false;
      45                 :             :         // The canonical path transforms relative paths into absolute ones, so we check the non-canonical version
      46         [ #  # ]:           0 :         } else if (!wallet_dir.is_absolute()) {
      47   [ #  #  #  #  :           0 :             chain.initError(strprintf(_("Specified -walletdir \"%s\" is a relative path"), fs::PathToString(wallet_dir)));
                   #  # ]
      48                 :           0 :             return false;
      49                 :             :         }
      50   [ #  #  #  #  :           0 :         args.ForceSetArg("-walletdir", fs::PathToString(canonical_wallet_dir));
                   #  # ]
      51                 :           0 :     }
      52                 :             : 
      53   [ #  #  #  # ]:           0 :     LogInfo("Using wallet directory %s", fs::PathToString(GetWalletDir()));
      54                 :             :     // Print general DB information
      55                 :           0 :     LogDBInfo();
      56                 :             : 
      57         [ #  # ]:           0 :     chain.initMessage(_("Verifying wallet(s)…"));
      58                 :             : 
      59                 :             :     // For backwards compatibility if an unnamed top level wallet exists in the
      60                 :             :     // wallets directory, include it in the default list of wallets to load.
      61   [ #  #  #  # ]:           0 :     if (!args.IsArgSet("wallet")) {
      62         [ #  # ]:           0 :         DatabaseOptions options;
      63                 :           0 :         DatabaseStatus status;
      64         [ #  # ]:           0 :         ReadDatabaseArgs(args, options);
      65         [ #  # ]:           0 :         bilingual_str error_string;
      66                 :           0 :         options.require_existing = true;
      67                 :           0 :         options.verify = false;
      68   [ #  #  #  #  :           0 :         if (MakeWalletDatabase("", options, status, error_string)) {
                   #  # ]
      69                 :           0 :             common::SettingsValue wallets(common::SettingsValue::VARR);
      70   [ #  #  #  # ]:           0 :             wallets.push_back(""); // Default wallet name is ""
      71                 :             :             // Pass write=false because no need to write file and probably
      72                 :             :             // better not to. If unnamed wallet needs to be added next startup
      73                 :             :             // and the setting is empty, this code will just run again.
      74   [ #  #  #  # ]:           0 :             chain.overwriteRwSetting("wallet", std::move(wallets), interfaces::SettingsAction::SKIP_WRITE);
      75                 :           0 :         }
      76                 :           0 :     }
      77                 :             : 
      78                 :             :     // Keep track of each wallet absolute path to detect duplicates.
      79         [ #  # ]:           0 :     std::set<fs::path> wallet_paths;
      80                 :             : 
      81   [ #  #  #  #  :           0 :     for (const auto& wallet : chain.getSettingsList("wallet")) {
                   #  # ]
      82         [ #  # ]:           0 :         if (!wallet.isStr()) {
      83   [ #  #  #  # ]:           0 :             chain.initError(_("Invalid value detected for '-wallet' or '-nowallet'. "
      84                 :             :                               "'-wallet' requires a string value, while '-nowallet' accepts only '1' to disable all wallets"));
      85                 :           0 :             return false;
      86                 :             :         }
      87         [ #  # ]:           0 :         const auto& wallet_file = wallet.get_str();
      88   [ #  #  #  #  :           0 :         const fs::path path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(wallet_file));
                   #  # ]
      89                 :             : 
      90   [ #  #  #  # ]:           0 :         if (!wallet_paths.insert(path).second) {
      91   [ #  #  #  # ]:           0 :             chain.initWarning(strprintf(_("Ignoring duplicate -wallet %s."), wallet_file));
      92                 :           0 :             continue;
      93                 :             :         }
      94                 :             : 
      95         [ #  # ]:           0 :         DatabaseOptions options;
      96                 :           0 :         DatabaseStatus status;
      97         [ #  # ]:           0 :         ReadDatabaseArgs(args, options);
      98                 :           0 :         options.require_existing = true;
      99                 :           0 :         options.verify = true;
     100         [ #  # ]:           0 :         bilingual_str error_string;
     101   [ #  #  #  # ]:           0 :         if (!MakeWalletDatabase(wallet_file, options, status, error_string)) {
     102         [ #  # ]:           0 :             if (status == DatabaseStatus::FAILED_NOT_FOUND) {
     103   [ #  #  #  #  :           0 :                 chain.initWarning(Untranslated(strprintf("Skipping -wallet path that doesn't exist. %s", error_string.original)));
                   #  # ]
     104         [ #  # ]:           0 :             } else if (status == DatabaseStatus::FAILED_LEGACY_DISABLED) {
     105                 :             :                 // Skipping legacy wallets as they will not be loaded.
     106                 :             :                 // This will be properly communicated to the user during the loading process.
     107                 :           0 :                 continue;
     108                 :             :             } else {
     109         [ #  # ]:           0 :                 chain.initError(error_string);
     110                 :           0 :                 return false;
     111                 :             :             }
     112                 :             :         }
     113                 :           0 :     }
     114                 :             : 
     115                 :           0 :     return true;
     116                 :           0 : }
     117                 :             : 
     118                 :           0 : bool LoadWallets(WalletContext& context)
     119                 :             : {
     120                 :           0 :     interfaces::Chain& chain = *context.chain;
     121                 :           0 :     try {
     122         [ #  # ]:           0 :         std::set<fs::path> wallet_paths;
     123   [ #  #  #  #  :           0 :         for (const auto& wallet : chain.getSettingsList("wallet")) {
                   #  # ]
     124         [ #  # ]:           0 :             if (!wallet.isStr()) {
     125   [ #  #  #  # ]:           0 :                 chain.initError(_("Invalid value detected for '-wallet' or '-nowallet'. "
     126                 :             :                                   "'-wallet' requires a string value, while '-nowallet' accepts only '1' to disable all wallets"));
     127                 :           0 :                 return false;
     128                 :             :             }
     129         [ #  # ]:           0 :             const auto& name = wallet.get_str();
     130   [ #  #  #  #  :           0 :             if (!wallet_paths.insert(fs::PathFromString(name)).second) {
                   #  # ]
     131                 :           0 :                 continue;
     132                 :             :             }
     133         [ #  # ]:           0 :             DatabaseOptions options;
     134                 :           0 :             DatabaseStatus status;
     135         [ #  # ]:           0 :             ReadDatabaseArgs(*context.args, options);
     136                 :           0 :             options.require_existing = true;
     137                 :           0 :             options.verify = false; // No need to verify, assuming verified earlier in VerifyWallets()
     138         [ #  # ]:           0 :             bilingual_str error;
     139                 :           0 :             std::vector<bilingual_str> warnings;
     140         [ #  # ]:           0 :             std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
     141         [ #  # ]:           0 :             if (!database) {
     142         [ #  # ]:           0 :                 if (status == DatabaseStatus::FAILED_NOT_FOUND) continue;
     143         [ #  # ]:           0 :                 if (status == DatabaseStatus::FAILED_LEGACY_DISABLED) {
     144                 :             :                     // Inform user that legacy wallet is not loaded and suggest upgrade options
     145         [ #  # ]:           0 :                     chain.initWarning(error);
     146                 :           0 :                     continue;
     147                 :             :                 }
     148                 :             :             }
     149   [ #  #  #  # ]:           0 :             chain.initMessage(_("Loading wallet…"));
     150   [ #  #  #  # ]:           0 :             std::shared_ptr<CWallet> pwallet = database ? CWallet::Create(context, name, std::move(database), options.create_flags, error, warnings) : nullptr;
     151   [ #  #  #  #  :           0 :             if (!warnings.empty()) chain.initWarning(Join(warnings, Untranslated("\n")));
          #  #  #  #  #  
                      # ]
     152         [ #  # ]:           0 :             if (!pwallet) {
     153         [ #  # ]:           0 :                 chain.initError(error);
     154         [ #  # ]:           0 :                 return false;
     155                 :             :             }
     156                 :             : 
     157         [ #  # ]:           0 :             NotifyWalletLoaded(context, pwallet);
     158         [ #  # ]:           0 :             AddWallet(context, pwallet);
     159                 :           0 :         }
     160                 :           0 :         return true;
     161         [ #  # ]:           0 :     } catch (const std::runtime_error& e) {
     162   [ -  -  -  -  :           0 :         chain.initError(Untranslated(e.what()));
                   -  - ]
     163                 :           0 :         return false;
     164                 :           0 :     }
     165                 :             : }
     166                 :             : 
     167                 :           0 : void StartWallets(WalletContext& context)
     168                 :             : {
     169         [ #  # ]:           0 :     for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
     170         [ #  # ]:           0 :         pwallet->postInitProcess();
     171                 :           0 :     }
     172                 :             : 
     173         [ #  # ]:           0 :     context.scheduler->scheduleEvery([&context] { MaybeResendWalletTxs(context); }, 1min);
     174                 :           0 : }
     175                 :             : 
     176                 :           0 : void UnloadWallets(WalletContext& context)
     177                 :             : {
     178                 :           0 :     auto wallets = GetWallets(context);
     179         [ #  # ]:           0 :     while (!wallets.empty()) {
     180         [ #  # ]:           0 :         auto wallet = wallets.back();
     181                 :           0 :         wallets.pop_back();
     182                 :           0 :         std::vector<bilingual_str> warnings;
     183         [ #  # ]:           0 :         RemoveWallet(context, wallet, /* load_on_start= */ std::nullopt, warnings);
     184         [ #  # ]:           0 :         WaitForDeleteWallet(std::move(wallet));
     185         [ #  # ]:           0 :     }
     186                 :           0 : }
     187                 :             : } // namespace wallet
        

Generated by: LCOV version 2.0-1