LCOV - code coverage report
Current view: top level - src/wallet - wallet.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 18 2613 0.7 %
Date: 2023-10-05 12:38:51 Functions: 11 208 5.3 %
Branches: 11 4592 0.2 %

           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/wallet.h>
       7                 :            : 
       8                 :            : #if defined(HAVE_CONFIG_H)
       9                 :            : #include <config/bitcoin-config.h>
      10                 :            : #endif
      11                 :            : #include <addresstype.h>
      12                 :            : #include <blockfilter.h>
      13                 :            : #include <chain.h>
      14                 :            : #include <coins.h>
      15                 :            : #include <common/args.h>
      16                 :            : #include <common/settings.h>
      17         [ +  - ]:          2 : #include <common/system.h>
      18         [ +  - ]:          2 : #include <consensus/amount.h>
      19                 :            : #include <consensus/consensus.h>
      20                 :            : #include <consensus/validation.h>
      21                 :            : #include <external_signer.h>
      22                 :            : #include <interfaces/chain.h>
      23                 :            : #include <interfaces/handler.h>
      24                 :            : #include <interfaces/wallet.h>
      25                 :            : #include <kernel/chain.h>
      26                 :            : #include <kernel/mempool_removal_reason.h>
      27                 :          2 : #include <key.h>
      28                 :            : #include <key_io.h>
      29                 :            : #include <logging.h>
      30                 :            : #include <outputtype.h>
      31                 :            : #include <policy/feerate.h>
      32                 :            : #include <primitives/block.h>
      33                 :            : #include <primitives/transaction.h>
      34                 :            : #include <psbt.h>
      35                 :            : #include <pubkey.h>
      36                 :            : #include <random.h>
      37                 :            : #include <script/descriptor.h>
      38                 :            : #include <script/interpreter.h>
      39                 :            : #include <script/script.h>
      40                 :            : #include <script/sign.h>
      41                 :            : #include <script/signingprovider.h>
      42                 :            : #include <script/solver.h>
      43                 :            : #include <serialize.h>
      44                 :            : #include <span.h>
      45                 :            : #include <streams.h>
      46                 :            : #include <support/allocators/secure.h>
      47                 :            : #include <support/allocators/zeroafterfree.h>
      48                 :            : #include <support/cleanse.h>
      49                 :            : #include <sync.h>
      50                 :            : #include <tinyformat.h>
      51                 :            : #include <uint256.h>
      52                 :            : #include <univalue.h>
      53         [ #  # ]:          0 : #include <util/check.h>
      54                 :            : #include <util/error.h>
      55                 :            : #include <util/fs.h>
      56                 :            : #include <util/fs_helpers.h>
      57                 :            : #include <util/message.h>
      58                 :            : #include <util/moneystr.h>
      59                 :            : #include <util/result.h>
      60                 :            : #include <util/string.h>
      61                 :            : #include <util/time.h>
      62                 :            : #include <util/translation.h>
      63                 :            : #include <wallet/coincontrol.h>
      64                 :            : #include <wallet/context.h>
      65                 :            : #include <wallet/crypter.h>
      66                 :            : #include <wallet/db.h>
      67                 :            : #include <wallet/external_signer_scriptpubkeyman.h>
      68                 :            : #include <wallet/scriptpubkeyman.h>
      69                 :            : #include <wallet/transaction.h>
      70                 :            : #include <wallet/types.h>
      71                 :            : #include <wallet/walletdb.h>
      72                 :            : #include <wallet/walletutil.h>
      73                 :            : 
      74                 :          2 : #include <algorithm>
      75                 :            : #include <cassert>
      76                 :            : #include <condition_variable>
      77                 :            : #include <exception>
      78                 :            : #include <optional>
      79                 :            : #include <stdexcept>
      80                 :            : #include <thread>
      81                 :            : #include <tuple>
      82                 :            : #include <variant>
      83                 :            : 
      84                 :            : struct KeyOriginInfo;
      85                 :            : 
      86                 :            : using interfaces::FoundBlock;
      87                 :            : 
      88                 :            : namespace wallet {
      89                 :            : 
      90                 :          0 : bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
      91                 :          2 : {
      92   [ #  #  #  # ]:          0 :     common::SettingsValue setting_value = chain.getRwSetting("wallet");
      93   [ #  #  #  #  :          0 :     if (!setting_value.isArray()) setting_value.setArray();
                   #  # ]
      94   [ #  #  #  # ]:          0 :     for (const common::SettingsValue& value : setting_value.getValues()) {
      95   [ #  #  #  #  :          0 :         if (value.isStr() && value.get_str() == wallet_name) return true;
             #  #  #  # ]
      96                 :            :     }
      97   [ #  #  #  # ]:          0 :     setting_value.push_back(wallet_name);
      98   [ #  #  #  # ]:          0 :     return chain.updateRwSetting("wallet", setting_value);
      99                 :          2 : }
     100                 :            : 
     101                 :          0 : bool RemoveWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
     102                 :            : {
     103   [ #  #  #  # ]:          0 :     common::SettingsValue setting_value = chain.getRwSetting("wallet");
     104   [ #  #  #  # ]:          0 :     if (!setting_value.isArray()) return true;
     105         [ #  # ]:          0 :     common::SettingsValue new_value(common::SettingsValue::VARR);
     106   [ #  #  #  # ]:          0 :     for (const common::SettingsValue& value : setting_value.getValues()) {
     107   [ #  #  #  #  :          0 :         if (!value.isStr() || value.get_str() != wallet_name) new_value.push_back(value);
          #  #  #  #  #  
                #  #  # ]
     108                 :            :     }
     109   [ #  #  #  #  :          0 :     if (new_value.size() == setting_value.size()) return true;
                   #  # ]
     110   [ #  #  #  # ]:          0 :     return chain.updateRwSetting("wallet", new_value);
     111                 :          0 : }
     112                 :            : 
     113                 :          0 : static void UpdateWalletSetting(interfaces::Chain& chain,
     114                 :            :                                 const std::string& wallet_name,
     115                 :            :                                 std::optional<bool> load_on_startup,
     116                 :            :                                 std::vector<bilingual_str>& warnings)
     117                 :            : {
     118         [ #  # ]:          0 :     if (!load_on_startup) return;
     119   [ #  #  #  # ]:          0 :     if (load_on_startup.value() && !AddWalletSetting(chain, wallet_name)) {
     120   [ #  #  #  #  :          0 :         warnings.emplace_back(Untranslated("Wallet load on startup setting could not be updated, so wallet may not be loaded next node startup."));
                   #  # ]
     121   [ #  #  #  # ]:          0 :     } else if (!load_on_startup.value() && !RemoveWalletSetting(chain, wallet_name)) {
     122   [ #  #  #  #  :          0 :         warnings.emplace_back(Untranslated("Wallet load on startup setting could not be updated, so wallet may still be loaded next node startup."));
                   #  # ]
     123                 :          0 :     }
     124                 :          0 : }
     125                 :            : 
     126                 :            : /**
     127                 :            :  * Refresh mempool status so the wallet is in an internally consistent state and
     128                 :            :  * immediately knows the transaction's status: Whether it can be considered
     129                 :            :  * trusted and is eligible to be abandoned ...
     130                 :            :  */
     131                 :          0 : static void RefreshMempoolStatus(CWalletTx& tx, interfaces::Chain& chain)
     132                 :            : {
     133         [ #  # ]:          0 :     if (chain.isInMempool(tx.GetHash())) {
     134                 :          0 :         tx.m_state = TxStateInMempool();
     135         [ #  # ]:          0 :     } else if (tx.state<TxStateInMempool>()) {
     136                 :          0 :         tx.m_state = TxStateInactive();
     137                 :          0 :     }
     138                 :          0 : }
     139                 :            : 
     140                 :          0 : bool AddWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
     141                 :            : {
     142                 :          0 :     LOCK(context.wallets_mutex);
     143   [ #  #  #  # ]:          0 :     assert(wallet);
     144         [ #  # ]:          0 :     std::vector<std::shared_ptr<CWallet>>::const_iterator i = std::find(context.wallets.begin(), context.wallets.end(), wallet);
     145         [ #  # ]:          0 :     if (i != context.wallets.end()) return false;
     146         [ #  # ]:          0 :     context.wallets.push_back(wallet);
     147         [ #  # ]:          0 :     wallet->ConnectScriptPubKeyManNotifiers();
     148         [ #  # ]:          0 :     wallet->NotifyCanGetAddressesChanged();
     149                 :          0 :     return true;
     150                 :          0 : }
     151                 :            : 
     152                 :          0 : bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start, std::vector<bilingual_str>& warnings)
     153                 :            : {
     154         [ #  # ]:          0 :     assert(wallet);
     155                 :            : 
     156                 :          0 :     interfaces::Chain& chain = wallet->chain();
     157                 :          0 :     std::string name = wallet->GetName();
     158                 :            : 
     159                 :            :     // Unregister with the validation interface which also drops shared pointers.
     160                 :          0 :     wallet->m_chain_notifications_handler.reset();
     161   [ #  #  #  # ]:          0 :     LOCK(context.wallets_mutex);
     162         [ #  # ]:          0 :     std::vector<std::shared_ptr<CWallet>>::iterator i = std::find(context.wallets.begin(), context.wallets.end(), wallet);
     163   [ +  -  #  # ]:          2 :     if (i == context.wallets.end()) return false;
     164   [ +  -  #  # ]:          2 :     context.wallets.erase(i);
     165         [ +  - ]:          2 : 
     166         [ +  - ]:          2 :     // Write the wallet setting
     167   [ +  -  #  # ]:          2 :     UpdateWalletSetting(chain, name, load_on_start, warnings);
     168         [ +  - ]:          2 : 
     169         [ +  - ]:          2 :     return true;
     170         [ +  - ]:          2 : }
     171                 :            : 
     172                 :          0 : bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start)
     173                 :            : {
     174                 :          0 :     std::vector<bilingual_str> warnings;
     175         [ #  # ]:          0 :     return RemoveWallet(context, wallet, load_on_start, warnings);
     176                 :          0 : }
     177                 :            : 
     178                 :          0 : std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext& context)
     179                 :            : {
     180                 :          0 :     LOCK(context.wallets_mutex);
     181         [ #  # ]:          0 :     return context.wallets;
     182                 :          0 : }
     183                 :            : 
     184                 :          0 : std::shared_ptr<CWallet> GetDefaultWallet(WalletContext& context, size_t& count)
     185                 :            : {
     186                 :          0 :     LOCK(context.wallets_mutex);
     187                 :          0 :     count = context.wallets.size();
     188         [ #  # ]:          0 :     return count == 1 ? context.wallets[0] : nullptr;
     189                 :          0 : }
     190                 :            : 
     191                 :          0 : std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& name)
     192                 :            : {
     193                 :          0 :     LOCK(context.wallets_mutex);
     194         [ #  # ]:          0 :     for (const std::shared_ptr<CWallet>& wallet : context.wallets) {
     195   [ #  #  #  # ]:          0 :         if (wallet->GetName() == name) return wallet;
     196                 :            :     }
     197                 :          0 :     return nullptr;
     198                 :          0 : }
     199                 :            : 
     200                 :          0 : std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet)
     201                 :            : {
     202                 :          0 :     LOCK(context.wallets_mutex);
     203         [ #  # ]:          0 :     auto it = context.wallet_load_fns.emplace(context.wallet_load_fns.end(), std::move(load_wallet));
     204   [ #  #  #  # ]:          0 :     return interfaces::MakeCleanupHandler([&context, it] { LOCK(context.wallets_mutex); context.wallet_load_fns.erase(it); });
     205                 :          0 : }
     206                 :            : 
     207                 :          0 : void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
     208                 :            : {
     209                 :          0 :     LOCK(context.wallets_mutex);
     210         [ #  # ]:          0 :     for (auto& load_wallet : context.wallet_load_fns) {
     211   [ #  #  #  # ]:          0 :         load_wallet(interfaces::MakeWallet(context, wallet));
     212                 :            :     }
     213                 :          0 : }
     214                 :            : 
     215                 :            : static GlobalMutex g_loading_wallet_mutex;
     216                 :            : static GlobalMutex g_wallet_release_mutex;
     217                 :          2 : static std::condition_variable g_wallet_release_cv;
     218                 :          2 : static std::set<std::string> g_loading_wallet_set GUARDED_BY(g_loading_wallet_mutex);
     219                 :          2 : static std::set<std::string> g_unloading_wallet_set GUARDED_BY(g_wallet_release_mutex);
     220                 :            : 
     221                 :            : // Custom deleter for shared_ptr<CWallet>.
     222                 :          0 : static void ReleaseWallet(CWallet* wallet)
     223                 :            : {
     224                 :          0 :     const std::string name = wallet->GetName();
     225         [ #  # ]:          0 :     wallet->WalletLogPrintf("Releasing wallet\n");
     226         [ #  # ]:          0 :     wallet->Flush();
     227         [ #  # ]:          0 :     delete wallet;
     228                 :            :     // Wallet is now released, notify UnloadWallet, if any.
     229                 :            :     {
     230   [ #  #  #  # ]:          0 :         LOCK(g_wallet_release_mutex);
     231   [ #  #  #  # ]:          0 :         if (g_unloading_wallet_set.erase(name) == 0) {
     232                 :            :             // UnloadWallet was not called for this wallet, all done.
     233                 :          0 :             return;
     234                 :            :         }
     235         [ #  # ]:          0 :     }
     236                 :          0 :     g_wallet_release_cv.notify_all();
     237         [ #  # ]:          0 : }
     238                 :            : 
     239                 :          0 : void UnloadWallet(std::shared_ptr<CWallet>&& wallet)
     240                 :            : {
     241                 :            :     // Mark wallet for unloading.
     242                 :          0 :     const std::string name = wallet->GetName();
     243                 :            :     {
     244   [ #  #  #  # ]:          0 :         LOCK(g_wallet_release_mutex);
     245         [ #  # ]:          0 :         auto it = g_unloading_wallet_set.insert(name);
     246         [ #  # ]:          0 :         assert(it.second);
     247                 :          0 :     }
     248                 :            :     // The wallet can be in use so it's not possible to explicitly unload here.
     249                 :            :     // Notify the unload intent so that all remaining shared pointers are
     250                 :            :     // released.
     251         [ #  # ]:          0 :     wallet->NotifyUnload();
     252                 :            : 
     253                 :            :     // Time to ditch our shared_ptr and wait for ReleaseWallet call.
     254                 :          0 :     wallet.reset();
     255                 :            :     {
     256   [ #  #  #  # ]:          0 :         WAIT_LOCK(g_wallet_release_mutex, lock);
     257   [ #  #  #  # ]:          0 :         while (g_unloading_wallet_set.count(name) == 1) {
     258                 :          0 :             g_wallet_release_cv.wait(lock);
     259                 :            :         }
     260                 :          0 :     }
     261                 :          0 : }
     262                 :            : 
     263                 :            : namespace {
     264         [ +  - ]:          2 : std::shared_ptr<CWallet> LoadWalletInternal(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
     265                 :            : {
     266                 :            :     try {
     267         [ #  # ]:          0 :         std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
     268         [ #  # ]:          0 :         if (!database) {
     269   [ #  #  #  #  :          0 :             error = Untranslated("Wallet file verification failed.") + Untranslated(" ") + error;
          #  #  #  #  #  
                #  #  # ]
     270                 :          0 :             return nullptr;
     271                 :            :         }
     272                 :            : 
     273   [ #  #  #  # ]:          0 :         context.chain->initMessage(_("Loading wallet…").translated);
     274         [ #  # ]:          0 :         std::shared_ptr<CWallet> wallet = CWallet::Create(context, name, std::move(database), options.create_flags, error, warnings);
     275   [ #  #  #  # ]:          0 :         if (!wallet) {
     276   [ #  #  #  #  :          0 :             error = Untranslated("Wallet loading failed.") + Untranslated(" ") + error;
          #  #  #  #  #  
                #  #  # ]
     277                 :          0 :             status = DatabaseStatus::FAILED_LOAD;
     278                 :          0 :             return nullptr;
     279                 :            :         }
     280                 :            : 
     281                 :            :         // Legacy wallets are being deprecated, warn if the loaded wallet is legacy
     282         [ #  # ]:          0 :         if (!wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
     283   [ #  #  #  # ]:          0 :             warnings.push_back(_("Wallet loaded successfully. The legacy wallet type is being deprecated and support for creating and opening legacy wallets will be removed in the future. Legacy wallets can be migrated to a descriptor wallet with migratewallet."));
     284                 :          0 :         }
     285                 :            : 
     286         [ #  # ]:          0 :         NotifyWalletLoaded(context, wallet);
     287         [ #  # ]:          0 :         AddWallet(context, wallet);
     288         [ #  # ]:          0 :         wallet->postInitProcess();
     289                 :            : 
     290                 :            :         // Write the wallet setting
     291         [ #  # ]:          0 :         UpdateWalletSetting(*context.chain, name, load_on_start, warnings);
     292                 :            : 
     293                 :          0 :         return wallet;
     294         [ #  # ]:          0 :     } catch (const std::runtime_error& e) {
     295   [ #  #  #  # ]:          0 :         error = Untranslated(e.what());
     296                 :          0 :         status = DatabaseStatus::FAILED_LOAD;
     297                 :          0 :         return nullptr;
     298         [ #  # ]:          0 :     }
     299                 :          0 : }
     300                 :            : 
     301                 :            : class FastWalletRescanFilter
     302                 :            : {
     303                 :            : public:
     304         [ #  # ]:          0 :     FastWalletRescanFilter(const CWallet& wallet) : m_wallet(wallet)
     305                 :            :     {
     306                 :            :         // fast rescanning via block filters is only supported by descriptor wallets right now
     307   [ #  #  #  # ]:          0 :         assert(!m_wallet.IsLegacy());
     308                 :            : 
     309                 :            :         // create initial filter with scripts from all ScriptPubKeyMans
     310   [ #  #  #  # ]:          0 :         for (auto spkm : m_wallet.GetAllScriptPubKeyMans()) {
     311         [ #  # ]:          0 :             auto desc_spkm{dynamic_cast<DescriptorScriptPubKeyMan*>(spkm)};
     312         [ #  # ]:          0 :             assert(desc_spkm != nullptr);
     313         [ #  # ]:          0 :             AddScriptPubKeys(desc_spkm);
     314                 :            :             // save each range descriptor's end for possible future filter updates
     315   [ #  #  #  # ]:          0 :             if (desc_spkm->IsHDEnabled()) {
     316   [ #  #  #  #  :          0 :                 m_last_range_ends.emplace(desc_spkm->GetID(), desc_spkm->GetEndRange());
                   #  # ]
     317                 :          0 :             }
     318                 :            :         }
     319                 :          0 :     }
     320                 :            : 
     321                 :          0 :     void UpdateIfNeeded()
     322                 :            :     {
     323                 :            :         // repopulate filter with new scripts if top-up has happened since last iteration
     324         [ #  # ]:          0 :         for (const auto& [desc_spkm_id, last_range_end] : m_last_range_ends) {
     325   [ #  #  #  # ]:          0 :             auto desc_spkm{dynamic_cast<DescriptorScriptPubKeyMan*>(m_wallet.GetScriptPubKeyMan(desc_spkm_id))};
     326         [ #  # ]:          0 :             assert(desc_spkm != nullptr);
     327                 :          0 :             int32_t current_range_end{desc_spkm->GetEndRange()};
     328   [ #  #  #  # ]:          0 :             if (current_range_end > last_range_end) {
     329                 :          0 :                 AddScriptPubKeys(desc_spkm, last_range_end);
     330                 :          0 :                 m_last_range_ends.at(desc_spkm->GetID()) = current_range_end;
     331                 :          0 :             }
     332                 :            :         }
     333                 :          0 :     }
     334                 :            : 
     335                 :          0 :     std::optional<bool> MatchesBlock(const uint256& block_hash) const
     336                 :            :     {
     337                 :          0 :         return m_wallet.chain().blockFilterMatchesAny(BlockFilterType::BASIC, block_hash, m_filter_set);
     338                 :            :     }
     339                 :            : 
     340                 :            : private:
     341                 :            :     const CWallet& m_wallet;
     342                 :            :     /** Map for keeping track of each range descriptor's last seen end range.
     343                 :            :       * This information is used to detect whether new addresses were derived
     344                 :            :       * (that is, if the current end range is larger than the saved end range)
     345                 :            :       * after processing a block and hence a filter set update is needed to
     346                 :            :       * take possible keypool top-ups into account.
     347                 :            :       */
     348                 :            :     std::map<uint256, int32_t> m_last_range_ends;
     349                 :            :     GCSFilter::ElementSet m_filter_set;
     350                 :            : 
     351                 :          0 :     void AddScriptPubKeys(const DescriptorScriptPubKeyMan* desc_spkm, int32_t last_range_end = 0)
     352                 :            :     {
     353         [ #  # ]:          0 :         for (const auto& script_pub_key : desc_spkm->GetScriptPubKeys(last_range_end)) {
     354   [ #  #  #  #  :          0 :             m_filter_set.emplace(script_pub_key.begin(), script_pub_key.end());
                   #  # ]
     355                 :            :         }
     356                 :          0 :     }
     357                 :            : };
     358                 :            : } // namespace
     359                 :            : 
     360                 :          0 : std::shared_ptr<CWallet> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
     361                 :            : {
     362         [ #  # ]:          0 :     auto result = WITH_LOCK(g_loading_wallet_mutex, return g_loading_wallet_set.insert(name));
     363         [ #  # ]:          0 :     if (!result.second) {
     364   [ #  #  #  # ]:          0 :         error = Untranslated("Wallet already loading.");
     365                 :          0 :         status = DatabaseStatus::FAILED_LOAD;
     366                 :          0 :         return nullptr;
     367                 :            :     }
     368                 :          0 :     auto wallet = LoadWalletInternal(context, name, load_on_start, options, status, error, warnings);
     369   [ #  #  #  #  :          0 :     WITH_LOCK(g_loading_wallet_mutex, g_loading_wallet_set.erase(result.first));
                   #  # ]
     370                 :          0 :     return wallet;
     371         [ #  # ]:          0 : }
     372                 :            : 
     373                 :          0 : std::shared_ptr<CWallet> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
     374                 :            : {
     375                 :          0 :     uint64_t wallet_creation_flags = options.create_flags;
     376                 :          0 :     const SecureString& passphrase = options.create_passphrase;
     377                 :            : 
     378         [ #  # ]:          0 :     if (wallet_creation_flags & WALLET_FLAG_DESCRIPTORS) options.require_format = DatabaseFormat::SQLITE;
     379                 :            : 
     380                 :            :     // Indicate that the wallet is actually supposed to be blank and not just blank to make it encrypted
     381                 :          0 :     bool create_blank = (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET);
     382                 :            : 
     383                 :            :     // Born encrypted wallets need to be created blank first.
     384         [ #  # ]:          0 :     if (!passphrase.empty()) {
     385                 :          0 :         wallet_creation_flags |= WALLET_FLAG_BLANK_WALLET;
     386                 :          0 :     }
     387                 :            : 
     388                 :            :     // Private keys must be disabled for an external signer wallet
     389   [ #  #  #  # ]:          0 :     if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) && !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
     390   [ #  #  #  # ]:          0 :         error = Untranslated("Private keys must be disabled when using an external signer");
     391                 :          0 :         status = DatabaseStatus::FAILED_CREATE;
     392                 :          0 :         return nullptr;
     393                 :            :     }
     394                 :            : 
     395                 :            :     // Descriptor support must be enabled for an external signer wallet
     396   [ #  #  #  # ]:          0 :     if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) && !(wallet_creation_flags & WALLET_FLAG_DESCRIPTORS)) {
     397   [ #  #  #  # ]:          0 :         error = Untranslated("Descriptor support must be enabled when using an external signer");
     398                 :          0 :         status = DatabaseStatus::FAILED_CREATE;
     399                 :          0 :         return nullptr;
     400                 :            :     }
     401                 :            : 
     402                 :            :     // Do not allow a passphrase when private keys are disabled
     403   [ #  #  #  # ]:          0 :     if (!passphrase.empty() && (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
     404   [ #  #  #  # ]:          0 :         error = Untranslated("Passphrase provided but private keys are disabled. A passphrase is only used to encrypt private keys, so cannot be used for wallets with private keys disabled.");
     405                 :          0 :         status = DatabaseStatus::FAILED_CREATE;
     406                 :          0 :         return nullptr;
     407                 :            :     }
     408                 :            : 
     409                 :            :     // Wallet::Verify will check if we're trying to create a wallet with a duplicate name.
     410                 :          0 :     std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
     411         [ #  # ]:          0 :     if (!database) {
     412   [ #  #  #  #  :          0 :         error = Untranslated("Wallet file verification failed.") + Untranslated(" ") + error;
          #  #  #  #  #  
                #  #  # ]
     413                 :          0 :         status = DatabaseStatus::FAILED_VERIFY;
     414                 :          0 :         return nullptr;
     415                 :            :     }
     416                 :            : 
     417                 :            :     // Make the wallet
     418   [ #  #  #  # ]:          0 :     context.chain->initMessage(_("Loading wallet…").translated);
     419         [ #  # ]:          0 :     std::shared_ptr<CWallet> wallet = CWallet::Create(context, name, std::move(database), wallet_creation_flags, error, warnings);
     420   [ #  #  #  # ]:          0 :     if (!wallet) {
     421   [ #  #  #  #  :          0 :         error = Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
          #  #  #  #  #  
                #  #  # ]
     422                 :          0 :         status = DatabaseStatus::FAILED_CREATE;
     423                 :          0 :         return nullptr;
     424                 :            :     }
     425                 :            : 
     426                 :            :     // Encrypt the wallet
     427   [ #  #  #  # ]:          0 :     if (!passphrase.empty() && !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
     428   [ #  #  #  # ]:          0 :         if (!wallet->EncryptWallet(passphrase)) {
     429   [ #  #  #  # ]:          0 :             error = Untranslated("Error: Wallet created but failed to encrypt.");
     430                 :          0 :             status = DatabaseStatus::FAILED_ENCRYPT;
     431                 :          0 :             return nullptr;
     432                 :            :         }
     433         [ #  # ]:          0 :         if (!create_blank) {
     434                 :            :             // Unlock the wallet
     435   [ #  #  #  # ]:          0 :             if (!wallet->Unlock(passphrase)) {
     436   [ #  #  #  # ]:          0 :                 error = Untranslated("Error: Wallet was encrypted but could not be unlocked");
     437                 :          0 :                 status = DatabaseStatus::FAILED_ENCRYPT;
     438                 :          0 :                 return nullptr;
     439                 :            :             }
     440                 :            : 
     441                 :            :             // Set a seed for the wallet
     442                 :            :             {
     443   [ #  #  #  # ]:          0 :                 LOCK(wallet->cs_wallet);
     444   [ #  #  #  # ]:          0 :                 if (wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
     445         [ #  # ]:          0 :                     wallet->SetupDescriptorScriptPubKeyMans();
     446                 :          0 :                 } else {
     447   [ #  #  #  #  :          0 :                     for (auto spk_man : wallet->GetActiveScriptPubKeyMans()) {
                   #  # ]
     448   [ #  #  #  # ]:          0 :                         if (!spk_man->SetupGeneration()) {
     449   [ #  #  #  # ]:          0 :                             error = Untranslated("Unable to generate initial keys");
     450                 :          0 :                             status = DatabaseStatus::FAILED_CREATE;
     451                 :          0 :                             return nullptr;
     452                 :            :                         }
     453                 :            :                     }
     454                 :            :                 }
     455         [ #  # ]:          0 :             }
     456                 :            : 
     457                 :            :             // Relock the wallet
     458         [ #  # ]:          0 :             wallet->Lock();
     459                 :          0 :         }
     460                 :          0 :     }
     461                 :            : 
     462         [ #  # ]:          0 :     NotifyWalletLoaded(context, wallet);
     463         [ #  # ]:          0 :     AddWallet(context, wallet);
     464         [ #  # ]:          0 :     wallet->postInitProcess();
     465                 :            : 
     466                 :            :     // Write the wallet settings
     467         [ #  # ]:          0 :     UpdateWalletSetting(*context.chain, name, load_on_start, warnings);
     468                 :            : 
     469                 :            :     // Legacy wallets are being deprecated, warn if a newly created wallet is legacy
     470         [ #  # ]:          0 :     if (!(wallet_creation_flags & WALLET_FLAG_DESCRIPTORS)) {
     471   [ #  #  #  # ]:          0 :         warnings.push_back(_("Wallet created successfully. The legacy wallet type is being deprecated and support for creating and opening legacy wallets will be removed in the future."));
     472                 :          0 :     }
     473                 :            : 
     474                 :          0 :     status = DatabaseStatus::SUCCESS;
     475                 :          0 :     return wallet;
     476                 :          0 : }
     477                 :            : 
     478                 :          0 : std::shared_ptr<CWallet> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
     479                 :            : {
     480                 :          0 :     DatabaseOptions options;
     481         [ #  # ]:          0 :     ReadDatabaseArgs(*context.args, options);
     482                 :          0 :     options.require_existing = true;
     483                 :            : 
     484   [ #  #  #  #  :          0 :     const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::u8path(wallet_name));
                   #  # ]
     485   [ #  #  #  # ]:          0 :     auto wallet_file = wallet_path / "wallet.dat";
     486                 :          0 :     std::shared_ptr<CWallet> wallet;
     487                 :            : 
     488                 :            :     try {
     489   [ #  #  #  # ]:          0 :         if (!fs::exists(backup_file)) {
     490   [ #  #  #  # ]:          0 :             error = Untranslated("Backup file does not exist");
     491                 :          0 :             status = DatabaseStatus::FAILED_INVALID_BACKUP_FILE;
     492                 :          0 :             return nullptr;
     493                 :            :         }
     494                 :            : 
     495   [ #  #  #  #  :          0 :         if (fs::exists(wallet_path) || !TryCreateDirectories(wallet_path)) {
             #  #  #  # ]
     496   [ #  #  #  #  :          0 :             error = Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(wallet_path)));
                   #  # ]
     497                 :          0 :             status = DatabaseStatus::FAILED_ALREADY_EXISTS;
     498                 :          0 :             return nullptr;
     499                 :            :         }
     500                 :            : 
     501         [ #  # ]:          0 :         fs::copy_file(backup_file, wallet_file, fs::copy_options::none);
     502                 :            : 
     503         [ #  # ]:          0 :         wallet = LoadWallet(context, wallet_name, load_on_start, options, status, error, warnings);
     504         [ #  # ]:          0 :     } catch (const std::exception& e) {
     505   [ #  #  #  # ]:          0 :         assert(!wallet);
     506   [ #  #  #  #  :          0 :         if (!error.empty()) error += Untranslated("\n");
          #  #  #  #  #  
                      # ]
     507   [ #  #  #  #  :          0 :         error += strprintf(Untranslated("Unexpected exception: %s"), e.what());
             #  #  #  # ]
     508   [ #  #  #  # ]:          0 :     }
     509   [ #  #  #  # ]:          0 :     if (!wallet) {
     510         [ #  # ]:          0 :         fs::remove_all(wallet_path);
     511                 :          0 :     }
     512                 :            : 
     513                 :          0 :     return wallet;
     514                 :          0 : }
     515                 :            : 
     516                 :            : /** @defgroup mapWallet
     517                 :            :  *
     518                 :            :  * @{
     519                 :            :  */
     520                 :            : 
     521                 :          0 : const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
     522                 :            : {
     523                 :          0 :     AssertLockHeld(cs_wallet);
     524                 :          0 :     const auto it = mapWallet.find(hash);
     525         [ #  # ]:          0 :     if (it == mapWallet.end())
     526                 :          0 :         return nullptr;
     527                 :          0 :     return &(it->second);
     528                 :          0 : }
     529                 :            : 
     530                 :          0 : void CWallet::UpgradeKeyMetadata()
     531                 :            : {
     532   [ #  #  #  # ]:          0 :     if (IsLocked() || IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
     533                 :          0 :         return;
     534                 :            :     }
     535                 :            : 
     536                 :          0 :     auto spk_man = GetLegacyScriptPubKeyMan();
     537         [ #  # ]:          0 :     if (!spk_man) {
     538                 :          0 :         return;
     539                 :            :     }
     540                 :            : 
     541                 :          0 :     spk_man->UpgradeKeyMetadata();
     542                 :          0 :     SetWalletFlag(WALLET_FLAG_KEY_ORIGIN_METADATA);
     543                 :          0 : }
     544                 :            : 
     545                 :          0 : void CWallet::UpgradeDescriptorCache()
     546                 :            : {
     547   [ #  #  #  #  :          0 :     if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) || IsLocked() || IsWalletFlagSet(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED)) {
                   #  # ]
     548                 :          0 :         return;
     549                 :            :     }
     550                 :            : 
     551         [ #  # ]:          0 :     for (ScriptPubKeyMan* spkm : GetAllScriptPubKeyMans()) {
     552         [ #  # ]:          0 :         DescriptorScriptPubKeyMan* desc_spkm = dynamic_cast<DescriptorScriptPubKeyMan*>(spkm);
     553         [ #  # ]:          0 :         desc_spkm->UpgradeDescriptorCache();
     554                 :            :     }
     555                 :          0 :     SetWalletFlag(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED);
     556                 :          0 : }
     557                 :            : 
     558                 :          0 : bool CWallet::Unlock(const SecureString& strWalletPassphrase, bool accept_no_keys)
     559                 :            : {
     560                 :          0 :     CCrypter crypter;
     561                 :          0 :     CKeyingMaterial _vMasterKey;
     562                 :            : 
     563                 :            :     {
     564   [ #  #  #  # ]:          0 :         LOCK(cs_wallet);
     565         [ #  # ]:          0 :         for (const MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
     566                 :            :         {
     567   [ #  #  #  # ]:          0 :             if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
     568                 :          0 :                 return false;
     569   [ #  #  #  # ]:          0 :             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
     570                 :          0 :                 continue; // try another master key
     571   [ #  #  #  # ]:          0 :             if (Unlock(_vMasterKey, accept_no_keys)) {
     572                 :            :                 // Now that we've unlocked, upgrade the key metadata
     573         [ #  # ]:          0 :                 UpgradeKeyMetadata();
     574                 :            :                 // Now that we've unlocked, upgrade the descriptor cache
     575         [ #  # ]:          0 :                 UpgradeDescriptorCache();
     576                 :          0 :                 return true;
     577                 :            :             }
     578                 :            :         }
     579         [ #  # ]:          0 :     }
     580                 :          0 :     return false;
     581                 :          0 : }
     582                 :            : 
     583                 :          0 : bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
     584                 :            : {
     585                 :          0 :     bool fWasLocked = IsLocked();
     586                 :            : 
     587                 :            :     {
     588   [ #  #  #  # ]:          0 :         LOCK2(m_relock_mutex, cs_wallet);
     589         [ #  # ]:          0 :         Lock();
     590                 :            : 
     591         [ #  # ]:          0 :         CCrypter crypter;
     592                 :          0 :         CKeyingMaterial _vMasterKey;
     593         [ #  # ]:          0 :         for (MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
     594                 :            :         {
     595   [ #  #  #  # ]:          0 :             if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
     596                 :          0 :                 return false;
     597   [ #  #  #  # ]:          0 :             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
     598                 :          0 :                 return false;
     599   [ #  #  #  # ]:          0 :             if (Unlock(_vMasterKey))
     600                 :            :             {
     601                 :          0 :                 constexpr MillisecondsDouble target{100};
     602                 :          0 :                 auto start{SteadyClock::now()};
     603         [ #  # ]:          0 :                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
     604   [ #  #  #  #  :          0 :                 pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * target / (SteadyClock::now() - start));
                   #  # ]
     605                 :            : 
     606                 :          0 :                 start = SteadyClock::now();
     607         [ #  # ]:          0 :                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
     608   [ #  #  #  #  :          0 :                 pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * target / (SteadyClock::now() - start))) / 2;
                   #  # ]
     609                 :            : 
     610         [ #  # ]:          0 :                 if (pMasterKey.second.nDeriveIterations < 25000)
     611                 :          0 :                     pMasterKey.second.nDeriveIterations = 25000;
     612                 :            : 
     613         [ #  # ]:          0 :                 WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
     614                 :            : 
     615   [ #  #  #  # ]:          0 :                 if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
     616                 :          0 :                     return false;
     617   [ #  #  #  # ]:          0 :                 if (!crypter.Encrypt(_vMasterKey, pMasterKey.second.vchCryptedKey))
     618                 :          0 :                     return false;
     619   [ #  #  #  #  :          0 :                 WalletBatch(GetDatabase()).WriteMasterKey(pMasterKey.first, pMasterKey.second);
                   #  # ]
     620         [ #  # ]:          0 :                 if (fWasLocked)
     621         [ #  # ]:          0 :                     Lock();
     622                 :          0 :                 return true;
     623                 :            :             }
     624                 :            :         }
     625      [ #  #  # ]:          0 :     }
     626                 :            : 
     627                 :          0 :     return false;
     628                 :          0 : }
     629                 :            : 
     630                 :          0 : void CWallet::chainStateFlushed(ChainstateRole role, const CBlockLocator& loc)
     631                 :            : {
     632                 :            :     // Don't update the best block until the chain is attached so that in case of a shutdown,
     633                 :            :     // the rescan will be restarted at next startup.
     634   [ #  #  #  # ]:          0 :     if (m_attaching_chain || role == ChainstateRole::BACKGROUND) {
     635                 :          0 :         return;
     636                 :            :     }
     637                 :          0 :     WalletBatch batch(GetDatabase());
     638         [ #  # ]:          0 :     batch.WriteBestBlock(loc);
     639                 :          0 : }
     640                 :            : 
     641                 :          0 : void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch* batch_in)
     642                 :            : {
     643                 :          0 :     LOCK(cs_wallet);
     644         [ #  # ]:          0 :     if (nWalletVersion >= nVersion)
     645                 :          0 :         return;
     646         [ #  # ]:          0 :     WalletLogPrintf("Setting minversion to %d\n", nVersion);
     647                 :          0 :     nWalletVersion = nVersion;
     648                 :            : 
     649                 :            :     {
     650   [ #  #  #  #  :          0 :         WalletBatch* batch = batch_in ? batch_in : new WalletBatch(GetDatabase());
          #  #  #  #  #  
                      # ]
     651         [ #  # ]:          0 :         if (nWalletVersion > 40000)
     652         [ #  # ]:          0 :             batch->WriteMinVersion(nWalletVersion);
     653         [ #  # ]:          0 :         if (!batch_in)
     654         [ #  # ]:          0 :             delete batch;
     655                 :            :     }
     656         [ #  # ]:          0 : }
     657                 :            : 
     658                 :          0 : std::set<uint256> CWallet::GetConflicts(const uint256& txid) const
     659                 :            : {
     660                 :          0 :     std::set<uint256> result;
     661         [ #  # ]:          0 :     AssertLockHeld(cs_wallet);
     662                 :            : 
     663         [ #  # ]:          0 :     const auto it = mapWallet.find(txid);
     664         [ #  # ]:          0 :     if (it == mapWallet.end())
     665                 :          0 :         return result;
     666                 :          0 :     const CWalletTx& wtx = it->second;
     667                 :            : 
     668         [ #  # ]:          0 :     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
     669                 :            : 
     670         [ #  # ]:          0 :     for (const CTxIn& txin : wtx.tx->vin)
     671                 :            :     {
     672   [ #  #  #  # ]:          0 :         if (mapTxSpends.count(txin.prevout) <= 1)
     673                 :          0 :             continue;  // No conflict if zero or one spends
     674         [ #  # ]:          0 :         range = mapTxSpends.equal_range(txin.prevout);
     675         [ #  # ]:          0 :         for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it)
     676         [ #  # ]:          0 :             result.insert(_it->second);
     677                 :            :     }
     678                 :          0 :     return result;
     679         [ #  # ]:          0 : }
     680                 :            : 
     681                 :          0 : bool CWallet::HasWalletSpend(const CTransactionRef& tx) const
     682                 :            : {
     683                 :          0 :     AssertLockHeld(cs_wallet);
     684                 :          0 :     const uint256& txid = tx->GetHash();
     685         [ #  # ]:          0 :     for (unsigned int i = 0; i < tx->vout.size(); ++i) {
     686         [ #  # ]:          0 :         if (IsSpent(COutPoint(txid, i))) {
     687                 :          0 :             return true;
     688                 :            :         }
     689                 :          0 :     }
     690                 :          0 :     return false;
     691                 :          0 : }
     692                 :            : 
     693                 :          0 : void CWallet::Flush()
     694                 :            : {
     695                 :          0 :     GetDatabase().Flush();
     696                 :          0 : }
     697                 :            : 
     698                 :          0 : void CWallet::Close()
     699                 :            : {
     700                 :          0 :     GetDatabase().Close();
     701                 :          0 : }
     702                 :            : 
     703                 :          0 : void CWallet::SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator> range)
     704                 :            : {
     705                 :            :     // We want all the wallet transactions in range to have the same metadata as
     706                 :            :     // the oldest (smallest nOrderPos).
     707                 :            :     // So: find smallest nOrderPos:
     708                 :            : 
     709                 :          0 :     int nMinOrderPos = std::numeric_limits<int>::max();
     710                 :          0 :     const CWalletTx* copyFrom = nullptr;
     711         [ #  # ]:          0 :     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
     712                 :          0 :         const CWalletTx* wtx = &mapWallet.at(it->second);
     713         [ #  # ]:          0 :         if (wtx->nOrderPos < nMinOrderPos) {
     714                 :          0 :             nMinOrderPos = wtx->nOrderPos;
     715                 :          0 :             copyFrom = wtx;
     716                 :          0 :         }
     717                 :          0 :     }
     718                 :            : 
     719         [ #  # ]:          0 :     if (!copyFrom) {
     720                 :          0 :         return;
     721                 :            :     }
     722                 :            : 
     723                 :            :     // Now copy data from copyFrom to rest:
     724         [ #  # ]:          0 :     for (TxSpends::iterator it = range.first; it != range.second; ++it)
     725                 :            :     {
     726                 :          0 :         const uint256& hash = it->second;
     727                 :          0 :         CWalletTx* copyTo = &mapWallet.at(hash);
     728         [ #  # ]:          0 :         if (copyFrom == copyTo) continue;
     729   [ #  #  #  # ]:          0 :         assert(copyFrom && "Oldest wallet transaction in range assumed to have been found.");
     730         [ #  # ]:          0 :         if (!copyFrom->IsEquivalentTo(*copyTo)) continue;
     731                 :          0 :         copyTo->mapValue = copyFrom->mapValue;
     732                 :          0 :         copyTo->vOrderForm = copyFrom->vOrderForm;
     733                 :            :         // fTimeReceivedIsTxTime not copied on purpose
     734                 :            :         // nTimeReceived not copied on purpose
     735                 :          0 :         copyTo->nTimeSmart = copyFrom->nTimeSmart;
     736                 :          0 :         copyTo->fFromMe = copyFrom->fFromMe;
     737                 :            :         // nOrderPos not copied on purpose
     738                 :            :         // cached members not copied on purpose
     739                 :          0 :     }
     740                 :          0 : }
     741                 :            : 
     742                 :            : /**
     743                 :            :  * Outpoint is spent if any non-conflicted transaction
     744                 :            :  * spends it:
     745                 :            :  */
     746                 :          0 : bool CWallet::IsSpent(const COutPoint& outpoint) const
     747                 :            : {
     748                 :          0 :     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
     749                 :          0 :     range = mapTxSpends.equal_range(outpoint);
     750                 :            : 
     751         [ #  # ]:          0 :     for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
     752                 :          0 :         const uint256& wtxid = it->second;
     753                 :          0 :         const auto mit = mapWallet.find(wtxid);
     754         [ #  # ]:          0 :         if (mit != mapWallet.end()) {
     755                 :          0 :             int depth = GetTxDepthInMainChain(mit->second);
     756   [ #  #  #  #  :          0 :             if (depth > 0  || (depth == 0 && !mit->second.isAbandoned()))
                   #  # ]
     757                 :          0 :                 return true; // Spent
     758                 :          0 :         }
     759                 :          0 :     }
     760                 :          0 :     return false;
     761                 :          0 : }
     762                 :            : 
     763                 :          0 : void CWallet::AddToSpends(const COutPoint& outpoint, const uint256& wtxid, WalletBatch* batch)
     764                 :            : {
     765                 :          0 :     mapTxSpends.insert(std::make_pair(outpoint, wtxid));
     766                 :            : 
     767         [ #  # ]:          0 :     if (batch) {
     768                 :          0 :         UnlockCoin(outpoint, batch);
     769                 :          0 :     } else {
     770                 :          0 :         WalletBatch temp_batch(GetDatabase());
     771         [ #  # ]:          0 :         UnlockCoin(outpoint, &temp_batch);
     772                 :          0 :     }
     773                 :            : 
     774                 :          0 :     std::pair<TxSpends::iterator, TxSpends::iterator> range;
     775                 :          0 :     range = mapTxSpends.equal_range(outpoint);
     776                 :          0 :     SyncMetaData(range);
     777                 :          0 : }
     778                 :            : 
     779                 :            : 
     780                 :          0 : void CWallet::AddToSpends(const CWalletTx& wtx, WalletBatch* batch)
     781                 :            : {
     782         [ #  # ]:          0 :     if (wtx.IsCoinBase()) // Coinbases don't spend anything!
     783                 :          0 :         return;
     784                 :            : 
     785         [ #  # ]:          0 :     for (const CTxIn& txin : wtx.tx->vin)
     786                 :          0 :         AddToSpends(txin.prevout, wtx.GetHash(), batch);
     787                 :          0 : }
     788                 :            : 
     789                 :          0 : bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
     790                 :            : {
     791         [ #  # ]:          0 :     if (IsCrypted())
     792                 :          0 :         return false;
     793                 :            : 
     794                 :          0 :     CKeyingMaterial _vMasterKey;
     795                 :            : 
     796         [ #  # ]:          0 :     _vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
     797         [ #  # ]:          0 :     GetStrongRandBytes(_vMasterKey);
     798                 :            : 
     799         [ #  # ]:          0 :     CMasterKey kMasterKey;
     800                 :            : 
     801         [ #  # ]:          0 :     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
     802         [ #  # ]:          0 :     GetStrongRandBytes(kMasterKey.vchSalt);
     803                 :            : 
     804         [ #  # ]:          0 :     CCrypter crypter;
     805                 :          0 :     constexpr MillisecondsDouble target{100};
     806                 :          0 :     auto start{SteadyClock::now()};
     807         [ #  # ]:          0 :     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
     808   [ #  #  #  #  :          0 :     kMasterKey.nDeriveIterations = static_cast<unsigned int>(25000 * target / (SteadyClock::now() - start));
                   #  # ]
     809                 :            : 
     810                 :          0 :     start = SteadyClock::now();
     811         [ #  # ]:          0 :     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
     812   [ #  #  #  #  :          0 :     kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + static_cast<unsigned int>(kMasterKey.nDeriveIterations * target / (SteadyClock::now() - start))) / 2;
                   #  # ]
     813                 :            : 
     814         [ #  # ]:          0 :     if (kMasterKey.nDeriveIterations < 25000)
     815                 :          0 :         kMasterKey.nDeriveIterations = 25000;
     816                 :            : 
     817         [ #  # ]:          0 :     WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);
     818                 :            : 
     819   [ #  #  #  # ]:          0 :     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
     820                 :          0 :         return false;
     821   [ #  #  #  # ]:          0 :     if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey))
     822                 :          0 :         return false;
     823                 :            : 
     824                 :            :     {
     825   [ #  #  #  #  :          0 :         LOCK2(m_relock_mutex, cs_wallet);
             #  #  #  # ]
     826   [ #  #  #  # ]:          0 :         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
     827   [ #  #  #  #  :          0 :         WalletBatch* encrypted_batch = new WalletBatch(GetDatabase());
                   #  # ]
     828   [ #  #  #  # ]:          0 :         if (!encrypted_batch->TxnBegin()) {
     829         [ #  # ]:          0 :             delete encrypted_batch;
     830                 :          0 :             encrypted_batch = nullptr;
     831                 :          0 :             return false;
     832                 :            :         }
     833         [ #  # ]:          0 :         encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
     834                 :            : 
     835         [ #  # ]:          0 :         for (const auto& spk_man_pair : m_spk_managers) {
     836                 :          0 :             auto spk_man = spk_man_pair.second.get();
     837   [ #  #  #  # ]:          0 :             if (!spk_man->Encrypt(_vMasterKey, encrypted_batch)) {
     838         [ #  # ]:          0 :                 encrypted_batch->TxnAbort();
     839         [ #  # ]:          0 :                 delete encrypted_batch;
     840                 :          0 :                 encrypted_batch = nullptr;
     841                 :            :                 // We now probably have half of our keys encrypted in memory, and half not...
     842                 :            :                 // die and let the user reload the unencrypted wallet.
     843                 :          0 :                 assert(false);
     844                 :            :             }
     845                 :            :         }
     846                 :            : 
     847                 :            :         // Encryption was introduced in version 0.4.0
     848         [ #  # ]:          0 :         SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch);
     849                 :            : 
     850   [ #  #  #  # ]:          0 :         if (!encrypted_batch->TxnCommit()) {
     851         [ #  # ]:          0 :             delete encrypted_batch;
     852                 :          0 :             encrypted_batch = nullptr;
     853                 :            :             // We now have keys encrypted in memory, but not on disk...
     854                 :            :             // die to avoid confusion and let the user reload the unencrypted wallet.
     855                 :          0 :             assert(false);
     856                 :            :         }
     857                 :            : 
     858         [ #  # ]:          0 :         delete encrypted_batch;
     859                 :          0 :         encrypted_batch = nullptr;
     860                 :            : 
     861         [ #  # ]:          0 :         Lock();
     862         [ #  # ]:          0 :         Unlock(strWalletPassphrase);
     863                 :            : 
     864                 :            :         // If we are using descriptors, make new descriptors with a new seed
     865   [ #  #  #  #  :          0 :         if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) && !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET)) {
             #  #  #  # ]
     866         [ #  # ]:          0 :             SetupDescriptorScriptPubKeyMans();
     867   [ #  #  #  # ]:          0 :         } else if (auto spk_man = GetLegacyScriptPubKeyMan()) {
     868                 :            :             // if we are using HD, replace the HD seed with a new one
     869   [ #  #  #  # ]:          0 :             if (spk_man->IsHDEnabled()) {
     870   [ #  #  #  # ]:          0 :                 if (!spk_man->SetupGeneration(true)) {
     871                 :          0 :                     return false;
     872                 :            :                 }
     873                 :          0 :             }
     874                 :          0 :         }
     875         [ #  # ]:          0 :         Lock();
     876                 :            : 
     877                 :            :         // Need to completely rewrite the wallet file; if we don't, bdb might keep
     878                 :            :         // bits of the unencrypted private key in slack space in the database file.
     879   [ #  #  #  # ]:          0 :         GetDatabase().Rewrite();
     880                 :            : 
     881                 :            :         // BDB seems to have a bad habit of writing old data into
     882                 :            :         // slack space in .dat files; that is bad if the old data is
     883                 :            :         // unencrypted private keys. So:
     884   [ #  #  #  # ]:          0 :         GetDatabase().ReloadDbEnv();
     885                 :            : 
     886         [ #  # ]:          0 :     }
     887         [ #  # ]:          0 :     NotifyStatusChanged(this);
     888                 :            : 
     889                 :          0 :     return true;
     890                 :          0 : }
     891                 :            : 
     892                 :          0 : DBErrors CWallet::ReorderTransactions()
     893                 :            : {
     894                 :          0 :     LOCK(cs_wallet);
     895   [ #  #  #  # ]:          0 :     WalletBatch batch(GetDatabase());
     896                 :            : 
     897                 :            :     // Old wallets didn't have any defined order for transactions
     898                 :            :     // Probably a bad idea to change the output of this
     899                 :            : 
     900                 :            :     // First: get all CWalletTx into a sorted-by-time multimap.
     901                 :            :     typedef std::multimap<int64_t, CWalletTx*> TxItems;
     902                 :          0 :     TxItems txByTime;
     903                 :            : 
     904         [ #  # ]:          0 :     for (auto& entry : mapWallet)
     905                 :            :     {
     906                 :          0 :         CWalletTx* wtx = &entry.second;
     907   [ #  #  #  # ]:          0 :         txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
     908                 :            :     }
     909                 :            : 
     910                 :          0 :     nOrderPosNext = 0;
     911                 :          0 :     std::vector<int64_t> nOrderPosOffsets;
     912         [ #  # ]:          0 :     for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
     913                 :            :     {
     914                 :          0 :         CWalletTx *const pwtx = (*it).second;
     915                 :          0 :         int64_t& nOrderPos = pwtx->nOrderPos;
     916                 :            : 
     917         [ #  # ]:          0 :         if (nOrderPos == -1)
     918                 :            :         {
     919                 :          0 :             nOrderPos = nOrderPosNext++;
     920         [ #  # ]:          0 :             nOrderPosOffsets.push_back(nOrderPos);
     921                 :            : 
     922   [ #  #  #  # ]:          0 :             if (!batch.WriteTx(*pwtx))
     923                 :          0 :                 return DBErrors::LOAD_FAIL;
     924                 :          0 :         }
     925                 :            :         else
     926                 :            :         {
     927                 :          0 :             int64_t nOrderPosOff = 0;
     928         [ #  # ]:          0 :             for (const int64_t& nOffsetStart : nOrderPosOffsets)
     929                 :            :             {
     930         [ #  # ]:          0 :                 if (nOrderPos >= nOffsetStart)
     931                 :          0 :                     ++nOrderPosOff;
     932                 :            :             }
     933                 :          0 :             nOrderPos += nOrderPosOff;
     934         [ #  # ]:          0 :             nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
     935                 :            : 
     936         [ #  # ]:          0 :             if (!nOrderPosOff)
     937                 :          0 :                 continue;
     938                 :            : 
     939                 :            :             // Since we're changing the order, write it back
     940   [ #  #  #  # ]:          0 :             if (!batch.WriteTx(*pwtx))
     941                 :          0 :                 return DBErrors::LOAD_FAIL;
     942                 :            :         }
     943                 :          0 :     }
     944         [ #  # ]:          0 :     batch.WriteOrderPosNext(nOrderPosNext);
     945                 :            : 
     946                 :          0 :     return DBErrors::LOAD_OK;
     947                 :          0 : }
     948                 :            : 
     949                 :          0 : int64_t CWallet::IncOrderPosNext(WalletBatch* batch)
     950                 :            : {
     951                 :          0 :     AssertLockHeld(cs_wallet);
     952                 :          0 :     int64_t nRet = nOrderPosNext++;
     953         [ #  # ]:          0 :     if (batch) {
     954                 :          0 :         batch->WriteOrderPosNext(nOrderPosNext);
     955                 :          0 :     } else {
     956         [ #  # ]:          0 :         WalletBatch(GetDatabase()).WriteOrderPosNext(nOrderPosNext);
     957                 :            :     }
     958                 :          0 :     return nRet;
     959                 :          0 : }
     960                 :            : 
     961                 :          0 : void CWallet::MarkDirty()
     962                 :            : {
     963                 :            :     {
     964                 :          0 :         LOCK(cs_wallet);
     965         [ #  # ]:          0 :         for (std::pair<const uint256, CWalletTx>& item : mapWallet)
     966         [ #  # ]:          0 :             item.second.MarkDirty();
     967                 :          0 :     }
     968                 :          0 : }
     969                 :            : 
     970                 :          0 : bool CWallet::MarkReplaced(const uint256& originalHash, const uint256& newHash)
     971                 :            : {
     972                 :          0 :     LOCK(cs_wallet);
     973                 :            : 
     974         [ #  # ]:          0 :     auto mi = mapWallet.find(originalHash);
     975                 :            : 
     976                 :            :     // There is a bug if MarkReplaced is not called on an existing wallet transaction.
     977         [ #  # ]:          0 :     assert(mi != mapWallet.end());
     978                 :            : 
     979                 :          0 :     CWalletTx& wtx = (*mi).second;
     980                 :            : 
     981                 :            :     // Ensure for now that we're not overwriting data
     982   [ #  #  #  #  :          0 :     assert(wtx.mapValue.count("replaced_by_txid") == 0);
                   #  # ]
     983                 :            : 
     984   [ #  #  #  #  :          0 :     wtx.mapValue["replaced_by_txid"] = newHash.ToString();
                   #  # ]
     985                 :            : 
     986                 :            :     // Refresh mempool status without waiting for transactionRemovedFromMempool or transactionAddedToMempool
     987   [ #  #  #  # ]:          0 :     RefreshMempoolStatus(wtx, chain());
     988                 :            : 
     989   [ #  #  #  # ]:          0 :     WalletBatch batch(GetDatabase());
     990                 :            : 
     991                 :          0 :     bool success = true;
     992   [ #  #  #  # ]:          0 :     if (!batch.WriteTx(wtx)) {
     993   [ #  #  #  #  :          0 :         WalletLogPrintf("%s: Updating batch tx %s failed\n", __func__, wtx.GetHash().ToString());
                   #  # ]
     994                 :          0 :         success = false;
     995                 :          0 :     }
     996                 :            : 
     997         [ #  # ]:          0 :     NotifyTransactionChanged(originalHash, CT_UPDATED);
     998                 :            : 
     999                 :          0 :     return success;
    1000                 :          0 : }
    1001                 :            : 
    1002                 :          0 : void CWallet::SetSpentKeyState(WalletBatch& batch, const uint256& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations)
    1003                 :            : {
    1004                 :          0 :     AssertLockHeld(cs_wallet);
    1005                 :          0 :     const CWalletTx* srctx = GetWalletTx(hash);
    1006         [ #  # ]:          0 :     if (!srctx) return;
    1007                 :            : 
    1008                 :          0 :     CTxDestination dst;
    1009   [ #  #  #  # ]:          0 :     if (ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst)) {
    1010   [ #  #  #  # ]:          0 :         if (IsMine(dst)) {
    1011   [ #  #  #  # ]:          0 :             if (used != IsAddressPreviouslySpent(dst)) {
    1012         [ #  # ]:          0 :                 if (used) {
    1013         [ #  # ]:          0 :                     tx_destinations.insert(dst);
    1014                 :          0 :                 }
    1015         [ #  # ]:          0 :                 SetAddressPreviouslySpent(batch, dst, used);
    1016                 :          0 :             }
    1017                 :          0 :         }
    1018                 :          0 :     }
    1019                 :          0 : }
    1020                 :            : 
    1021                 :          0 : bool CWallet::IsSpentKey(const CScript& scriptPubKey) const
    1022                 :            : {
    1023                 :          0 :     AssertLockHeld(cs_wallet);
    1024                 :          0 :     CTxDestination dest;
    1025   [ #  #  #  # ]:          0 :     if (!ExtractDestination(scriptPubKey, dest)) {
    1026                 :          0 :         return false;
    1027                 :            :     }
    1028   [ #  #  #  # ]:          0 :     if (IsAddressPreviouslySpent(dest)) {
    1029                 :          0 :         return true;
    1030                 :            :     }
    1031   [ #  #  #  # ]:          0 :     if (IsLegacy()) {
    1032         [ #  # ]:          0 :         LegacyScriptPubKeyMan* spk_man = GetLegacyScriptPubKeyMan();
    1033         [ #  # ]:          0 :         assert(spk_man != nullptr);
    1034   [ #  #  #  #  :          0 :         for (const auto& keyid : GetAffectedKeys(scriptPubKey, *spk_man)) {
                   #  # ]
    1035         [ #  # ]:          0 :             WitnessV0KeyHash wpkh_dest(keyid);
    1036   [ #  #  #  # ]:          0 :             if (IsAddressPreviouslySpent(wpkh_dest)) {
    1037                 :          0 :                 return true;
    1038                 :            :             }
    1039   [ #  #  #  # ]:          0 :             ScriptHash sh_wpkh_dest(GetScriptForDestination(wpkh_dest));
    1040   [ #  #  #  # ]:          0 :             if (IsAddressPreviouslySpent(sh_wpkh_dest)) {
    1041                 :          0 :                 return true;
    1042                 :            :             }
    1043         [ #  # ]:          0 :             PKHash pkh_dest(keyid);
    1044   [ #  #  #  # ]:          0 :             if (IsAddressPreviouslySpent(pkh_dest)) {
    1045                 :          0 :                 return true;
    1046                 :            :             }
    1047                 :            :         }
    1048                 :          0 :     }
    1049                 :          0 :     return false;
    1050                 :          0 : }
    1051                 :            : 
    1052                 :          0 : CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx, bool fFlushOnClose, bool rescanning_old_block)
    1053                 :            : {
    1054                 :          0 :     LOCK(cs_wallet);
    1055                 :            : 
    1056   [ #  #  #  # ]:          0 :     WalletBatch batch(GetDatabase(), fFlushOnClose);
    1057                 :            : 
    1058         [ #  # ]:          0 :     uint256 hash = tx->GetHash();
    1059                 :            : 
    1060   [ #  #  #  # ]:          0 :     if (IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
    1061                 :            :         // Mark used destinations
    1062                 :          0 :         std::set<CTxDestination> tx_destinations;
    1063                 :            : 
    1064         [ #  # ]:          0 :         for (const CTxIn& txin : tx->vin) {
    1065                 :          0 :             const COutPoint& op = txin.prevout;
    1066         [ #  # ]:          0 :             SetSpentKeyState(batch, op.hash, op.n, true, tx_destinations);
    1067                 :            :         }
    1068                 :            : 
    1069         [ #  # ]:          0 :         MarkDestinationsDirty(tx_destinations);
    1070                 :          0 :     }
    1071                 :            : 
    1072                 :            :     // Inserts only if not already there, returns tx inserted or tx found
    1073         [ #  # ]:          0 :     auto ret = mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(tx, state));
    1074                 :          0 :     CWalletTx& wtx = (*ret.first).second;
    1075                 :          0 :     bool fInsertedNew = ret.second;
    1076   [ #  #  #  # ]:          0 :     bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
    1077         [ #  # ]:          0 :     if (fInsertedNew) {
    1078         [ #  # ]:          0 :         wtx.nTimeReceived = GetTime();
    1079         [ #  # ]:          0 :         wtx.nOrderPos = IncOrderPosNext(&batch);
    1080   [ #  #  #  # ]:          0 :         wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
    1081         [ #  # ]:          0 :         wtx.nTimeSmart = ComputeTimeSmart(wtx, rescanning_old_block);
    1082         [ #  # ]:          0 :         AddToSpends(wtx, &batch);
    1083                 :          0 :     }
    1084                 :            : 
    1085         [ #  # ]:          0 :     if (!fInsertedNew)
    1086                 :            :     {
    1087         [ #  # ]:          0 :         if (state.index() != wtx.m_state.index()) {
    1088                 :          0 :             wtx.m_state = state;
    1089                 :          0 :             fUpdated = true;
    1090                 :          0 :         } else {
    1091   [ #  #  #  #  :          0 :             assert(TxStateSerializedIndex(wtx.m_state) == TxStateSerializedIndex(state));
                   #  # ]
    1092   [ #  #  #  #  :          0 :             assert(TxStateSerializedBlockHash(wtx.m_state) == TxStateSerializedBlockHash(state));
             #  #  #  # ]
    1093                 :            :         }
    1094                 :            :         // If we have a witness-stripped version of this transaction, and we
    1095                 :            :         // see a new version with a witness, then we must be upgrading a pre-segwit
    1096                 :            :         // wallet.  Store the new version of the transaction with the witness,
    1097                 :            :         // as the stripped-version must be invalid.
    1098                 :            :         // TODO: Store all versions of the transaction, instead of just one.
    1099   [ #  #  #  #  :          0 :         if (tx->HasWitness() && !wtx.tx->HasWitness()) {
             #  #  #  # ]
    1100         [ #  # ]:          0 :             wtx.SetTx(tx);
    1101                 :          0 :             fUpdated = true;
    1102                 :          0 :         }
    1103                 :          0 :     }
    1104                 :            : 
    1105                 :            :     // Mark inactive coinbase transactions and their descendants as abandoned
    1106   [ #  #  #  #  :          0 :     if (wtx.IsCoinBase() && wtx.isInactive()) {
             #  #  #  # ]
    1107         [ #  # ]:          0 :         std::vector<CWalletTx*> txs{&wtx};
    1108                 :            : 
    1109         [ #  # ]:          0 :         TxStateInactive inactive_state = TxStateInactive{/*abandoned=*/true};
    1110                 :            : 
    1111         [ #  # ]:          0 :         while (!txs.empty()) {
    1112                 :          0 :             CWalletTx* desc_tx = txs.back();
    1113                 :          0 :             txs.pop_back();
    1114                 :          0 :             desc_tx->m_state = inactive_state;
    1115                 :            :             // Break caches since we have changed the state
    1116         [ #  # ]:          0 :             desc_tx->MarkDirty();
    1117         [ #  # ]:          0 :             batch.WriteTx(*desc_tx);
    1118         [ #  # ]:          0 :             MarkInputsDirty(desc_tx->tx);
    1119         [ #  # ]:          0 :             for (unsigned int i = 0; i < desc_tx->tx->vout.size(); ++i) {
    1120   [ #  #  #  # ]:          0 :                 COutPoint outpoint(desc_tx->GetHash(), i);
    1121   [ #  #  #  # ]:          0 :                 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(outpoint);
    1122         [ #  # ]:          0 :                 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
    1123         [ #  # ]:          0 :                     const auto wit = mapWallet.find(it->second);
    1124         [ #  # ]:          0 :                     if (wit != mapWallet.end()) {
    1125         [ #  # ]:          0 :                         txs.push_back(&wit->second);
    1126                 :          0 :                     }
    1127                 :          0 :                 }
    1128                 :          0 :             }
    1129                 :            :         }
    1130                 :          0 :     }
    1131                 :            : 
    1132                 :            :     //// debug print
    1133   [ #  #  #  # ]:          0 :     WalletLogPrintf("AddToWallet %s  %s%s\n", hash.ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
    1134                 :            : 
    1135                 :            :     // Write to disk
    1136         [ #  # ]:          0 :     if (fInsertedNew || fUpdated)
    1137   [ #  #  #  # ]:          0 :         if (!batch.WriteTx(wtx))
    1138                 :          0 :             return nullptr;
    1139                 :            : 
    1140                 :            :     // Break debit/credit balance caches:
    1141         [ #  # ]:          0 :     wtx.MarkDirty();
    1142                 :            : 
    1143                 :            :     // Notify UI of new or updated transaction
    1144         [ #  # ]:          0 :     NotifyTransactionChanged(hash, fInsertedNew ? CT_NEW : CT_UPDATED);
    1145                 :            : 
    1146                 :            : #if HAVE_SYSTEM
    1147                 :            :     // notify an external script when a wallet transaction comes in or is updated
    1148         [ #  # ]:          0 :     std::string strCmd = m_notify_tx_changed_script;
    1149                 :            : 
    1150         [ #  # ]:          0 :     if (!strCmd.empty())
    1151                 :            :     {
    1152   [ #  #  #  #  :          0 :         ReplaceAll(strCmd, "%s", hash.GetHex());
                   #  # ]
    1153   [ #  #  #  # ]:          0 :         if (auto* conf = wtx.state<TxStateConfirmed>())
    1154                 :            :         {
    1155   [ #  #  #  #  :          0 :             ReplaceAll(strCmd, "%b", conf->confirmed_block_hash.GetHex());
                   #  # ]
    1156   [ #  #  #  #  :          0 :             ReplaceAll(strCmd, "%h", ToString(conf->confirmed_block_height));
                   #  # ]
    1157                 :          0 :         } else {
    1158   [ #  #  #  #  :          0 :             ReplaceAll(strCmd, "%b", "unconfirmed");
                   #  # ]
    1159   [ #  #  #  #  :          0 :             ReplaceAll(strCmd, "%h", "-1");
                   #  # ]
    1160                 :            :         }
    1161                 :            : #ifndef WIN32
    1162                 :            :         // Substituting the wallet name isn't currently supported on windows
    1163                 :            :         // because windows shell escaping has not been implemented yet:
    1164                 :            :         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
    1165                 :            :         // A few ways it could be implemented in the future are described in:
    1166                 :            :         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
    1167   [ #  #  #  #  :          0 :         ReplaceAll(strCmd, "%w", ShellEscape(GetName()));
             #  #  #  # ]
    1168                 :            : #endif
    1169         [ #  # ]:          0 :         std::thread t(runCommand, strCmd);
    1170         [ #  # ]:          0 :         t.detach(); // thread runs free
    1171                 :          0 :     }
    1172                 :            : #endif
    1173                 :            : 
    1174                 :          0 :     return &wtx;
    1175                 :          0 : }
    1176                 :            : 
    1177                 :          0 : bool CWallet::LoadToWallet(const uint256& hash, const UpdateWalletTxFn& fill_wtx)
    1178                 :            : {
    1179                 :          0 :     const auto& ins = mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(nullptr, TxStateInactive{}));
    1180                 :          0 :     CWalletTx& wtx = ins.first->second;
    1181         [ #  # ]:          0 :     if (!fill_wtx(wtx, ins.second)) {
    1182                 :          0 :         return false;
    1183                 :            :     }
    1184                 :            :     // If wallet doesn't have a chain (e.g when using bitcoin-wallet tool),
    1185                 :            :     // don't bother to update txn.
    1186         [ #  # ]:          0 :     if (HaveChain()) {
    1187                 :            :         bool active;
    1188                 :          0 :         auto lookup_block = [&](const uint256& hash, int& height, TxState& state) {
    1189                 :            :             // If tx block (or conflicting block) was reorged out of chain
    1190                 :            :             // while the wallet was shutdown, change tx status to UNCONFIRMED
    1191                 :            :             // and reset block height, hash, and index. ABANDONED tx don't have
    1192                 :            :             // associated blocks and don't need to be updated. The case where a
    1193                 :            :             // transaction was reorged out while online and then reconfirmed
    1194                 :            :             // while offline is covered by the rescan logic.
    1195   [ #  #  #  # ]:          0 :             if (!chain().findBlock(hash, FoundBlock().inActiveChain(active).height(height)) || !active) {
    1196                 :          0 :                 state = TxStateInactive{};
    1197                 :          0 :             }
    1198                 :          0 :         };
    1199         [ #  # ]:          0 :         if (auto* conf = wtx.state<TxStateConfirmed>()) {
    1200                 :          0 :             lookup_block(conf->confirmed_block_hash, conf->confirmed_block_height, wtx.m_state);
    1201         [ #  # ]:          0 :         } else if (auto* conf = wtx.state<TxStateConflicted>()) {
    1202                 :          0 :             lookup_block(conf->conflicting_block_hash, conf->conflicting_block_height, wtx.m_state);
    1203                 :          0 :         }
    1204                 :          0 :     }
    1205         [ #  # ]:          0 :     if (/* insertion took place */ ins.second) {
    1206                 :          0 :         wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
    1207                 :          0 :     }
    1208                 :          0 :     AddToSpends(wtx);
    1209         [ #  # ]:          0 :     for (const CTxIn& txin : wtx.tx->vin) {
    1210                 :          0 :         auto it = mapWallet.find(txin.prevout.hash);
    1211         [ #  # ]:          0 :         if (it != mapWallet.end()) {
    1212                 :          0 :             CWalletTx& prevtx = it->second;
    1213         [ #  # ]:          0 :             if (auto* prev = prevtx.state<TxStateConflicted>()) {
    1214                 :          0 :                 MarkConflicted(prev->conflicting_block_hash, prev->conflicting_block_height, wtx.GetHash());
    1215                 :          0 :             }
    1216                 :          0 :         }
    1217                 :            :     }
    1218                 :          0 :     return true;
    1219                 :          0 : }
    1220                 :            : 
    1221                 :          0 : bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef& ptx, const SyncTxState& state, bool fUpdate, bool rescanning_old_block)
    1222                 :            : {
    1223                 :          0 :     const CTransaction& tx = *ptx;
    1224                 :            :     {
    1225                 :          0 :         AssertLockHeld(cs_wallet);
    1226                 :            : 
    1227         [ #  # ]:          0 :         if (auto* conf = std::get_if<TxStateConfirmed>(&state)) {
    1228         [ #  # ]:          0 :             for (const CTxIn& txin : tx.vin) {
    1229                 :          0 :                 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(txin.prevout);
    1230         [ #  # ]:          0 :                 while (range.first != range.second) {
    1231         [ #  # ]:          0 :                     if (range.first->second != tx.GetHash()) {
    1232   [ #  #  #  #  :          0 :                         WalletLogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)\n", tx.GetHash().ToString(), conf->confirmed_block_hash.ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);
             #  #  #  # ]
    1233                 :          0 :                         MarkConflicted(conf->confirmed_block_hash, conf->confirmed_block_height, range.first->second);
    1234                 :          0 :                     }
    1235                 :          0 :                     range.first++;
    1236                 :            :                 }
    1237                 :            :             }
    1238                 :          0 :         }
    1239                 :            : 
    1240                 :          0 :         bool fExisted = mapWallet.count(tx.GetHash()) != 0;
    1241   [ #  #  #  # ]:          0 :         if (fExisted && !fUpdate) return false;
    1242   [ #  #  #  #  :          0 :         if (fExisted || IsMine(tx) || IsFromMe(tx))
                   #  # ]
    1243                 :            :         {
    1244                 :            :             /* Check if any keys in the wallet keypool that were supposed to be unused
    1245                 :            :              * have appeared in a new transaction. If so, remove those keys from the keypool.
    1246                 :            :              * This can happen when restoring an old wallet backup that does not contain
    1247                 :            :              * the mostly recently created transactions from newer versions of the wallet.
    1248                 :            :              */
    1249                 :            : 
    1250                 :            :             // loop though all outputs
    1251         [ #  # ]:          0 :             for (const CTxOut& txout: tx.vout) {
    1252         [ #  # ]:          0 :                 for (const auto& spk_man : GetScriptPubKeyMans(txout.scriptPubKey)) {
    1253   [ #  #  #  # ]:          0 :                     for (auto &dest : spk_man->MarkUnusedAddresses(txout.scriptPubKey)) {
    1254                 :            :                         // If internal flag is not defined try to infer it from the ScriptPubKeyMan
    1255         [ #  # ]:          0 :                         if (!dest.internal.has_value()) {
    1256         [ #  # ]:          0 :                             dest.internal = IsInternalScriptPubKeyMan(spk_man);
    1257                 :          0 :                         }
    1258                 :            : 
    1259                 :            :                         // skip if can't determine whether it's a receiving address or not
    1260         [ #  # ]:          0 :                         if (!dest.internal.has_value()) continue;
    1261                 :            : 
    1262                 :            :                         // If this is a receiving address and it's not in the address book yet
    1263                 :            :                         // (e.g. it wasn't generated on this node or we're restoring from backup)
    1264                 :            :                         // add it to the address book for proper transaction accounting
    1265   [ #  #  #  #  :          0 :                         if (!*dest.internal && !FindAddressBookEntry(dest.dest, /* allow_change= */ false)) {
             #  #  #  # ]
    1266   [ #  #  #  #  :          0 :                             SetAddressBook(dest.dest, "", AddressPurpose::RECEIVE);
                   #  # ]
    1267                 :          0 :                         }
    1268                 :            :                     }
    1269                 :            :                 }
    1270                 :            :             }
    1271                 :            : 
    1272                 :            :             // Block disconnection override an abandoned tx as unconfirmed
    1273                 :            :             // which means user may have to call abandontransaction again
    1274                 :          0 :             TxState tx_state = std::visit([](auto&& s) -> TxState { return s; }, state);
    1275         [ #  # ]:          0 :             CWalletTx* wtx = AddToWallet(MakeTransactionRef(tx), tx_state, /*update_wtx=*/nullptr, /*fFlushOnClose=*/false, rescanning_old_block);
    1276         [ #  # ]:          0 :             if (!wtx) {
    1277                 :            :                 // Can only be nullptr if there was a db write error (missing db, read-only db or a db engine internal writing error).
    1278                 :            :                 // As we only store arriving transaction in this process, and we don't want an inconsistent state, let's throw an error.
    1279         [ #  # ]:          0 :                 throw std::runtime_error("DB error adding transaction to wallet, write failed");
    1280                 :            :             }
    1281                 :          0 :             return true;
    1282                 :            :         }
    1283                 :            :     }
    1284                 :          0 :     return false;
    1285                 :          0 : }
    1286                 :            : 
    1287                 :          0 : bool CWallet::TransactionCanBeAbandoned(const uint256& hashTx) const
    1288                 :            : {
    1289                 :          0 :     LOCK(cs_wallet);
    1290         [ #  # ]:          0 :     const CWalletTx* wtx = GetWalletTx(hashTx);
    1291   [ #  #  #  #  :          0 :     return wtx && !wtx->isAbandoned() && GetTxDepthInMainChain(*wtx) == 0 && !wtx->InMempool();
          #  #  #  #  #  
                #  #  # ]
    1292                 :          0 : }
    1293                 :            : 
    1294                 :          0 : void CWallet::MarkInputsDirty(const CTransactionRef& tx)
    1295                 :            : {
    1296         [ #  # ]:          0 :     for (const CTxIn& txin : tx->vin) {
    1297                 :          0 :         auto it = mapWallet.find(txin.prevout.hash);
    1298         [ #  # ]:          0 :         if (it != mapWallet.end()) {
    1299                 :          0 :             it->second.MarkDirty();
    1300                 :          0 :         }
    1301                 :            :     }
    1302                 :          0 : }
    1303                 :            : 
    1304                 :          0 : bool CWallet::AbandonTransaction(const uint256& hashTx)
    1305                 :            : {
    1306                 :          0 :     LOCK(cs_wallet);
    1307                 :            : 
    1308                 :            :     // Can't mark abandoned if confirmed or in mempool
    1309         [ #  # ]:          0 :     auto it = mapWallet.find(hashTx);
    1310         [ #  # ]:          0 :     assert(it != mapWallet.end());
    1311                 :          0 :     const CWalletTx& origtx = it->second;
    1312   [ #  #  #  #  :          0 :     if (GetTxDepthInMainChain(origtx) != 0 || origtx.InMempool()) {
             #  #  #  # ]
    1313                 :          0 :         return false;
    1314                 :            :     }
    1315                 :            : 
    1316                 :          0 :     auto try_updating_state = [](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
    1317                 :            :         // If the orig tx was not in block/mempool, none of its spends can be.
    1318         [ #  # ]:          0 :         assert(!wtx.isConfirmed());
    1319         [ #  # ]:          0 :         assert(!wtx.InMempool());
    1320                 :            :         // If already conflicted or abandoned, no need to set abandoned
    1321   [ #  #  #  # ]:          0 :         if (!wtx.isConflicted() && !wtx.isAbandoned()) {
    1322                 :          0 :             wtx.m_state = TxStateInactive{/*abandoned=*/true};
    1323                 :          0 :             return TxUpdate::NOTIFY_CHANGED;
    1324                 :            :         }
    1325                 :          0 :         return TxUpdate::UNCHANGED;
    1326                 :          0 :     };
    1327                 :            : 
    1328                 :            :     // Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too.
    1329                 :            :     // States are not permanent, so these transactions can become unabandoned if they are re-added to the
    1330                 :            :     // mempool, or confirmed in a block, or conflicted.
    1331                 :            :     // Note: If the reorged coinbase is re-added to the main chain, the descendants that have not had their
    1332                 :            :     // states change will remain abandoned and will require manual broadcast if the user wants them.
    1333                 :            : 
    1334   [ #  #  #  # ]:          0 :     RecursiveUpdateTxState(hashTx, try_updating_state);
    1335                 :            : 
    1336                 :          0 :     return true;
    1337                 :          0 : }
    1338                 :            : 
    1339                 :          0 : void CWallet::MarkConflicted(const uint256& hashBlock, int conflicting_height, const uint256& hashTx)
    1340                 :            : {
    1341                 :          0 :     LOCK(cs_wallet);
    1342                 :            : 
    1343                 :            :     // If number of conflict confirms cannot be determined, this means
    1344                 :            :     // that the block is still unknown or not yet part of the main chain,
    1345                 :            :     // for example when loading the wallet during a reindex. Do nothing in that
    1346                 :            :     // case.
    1347   [ #  #  #  # ]:          0 :     if (m_last_block_processed_height < 0 || conflicting_height < 0) {
    1348                 :          0 :         return;
    1349                 :            :     }
    1350                 :          0 :     int conflictconfirms = (m_last_block_processed_height - conflicting_height + 1) * -1;
    1351         [ #  # ]:          0 :     if (conflictconfirms >= 0)
    1352                 :          0 :         return;
    1353                 :            : 
    1354                 :          0 :     auto try_updating_state = [&](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
    1355         [ #  # ]:          0 :         if (conflictconfirms < GetTxDepthInMainChain(wtx)) {
    1356                 :            :             // Block is 'more conflicted' than current confirm; update.
    1357                 :            :             // Mark transaction as conflicted with this block.
    1358                 :          0 :             wtx.m_state = TxStateConflicted{hashBlock, conflicting_height};
    1359                 :          0 :             return TxUpdate::CHANGED;
    1360                 :            :         }
    1361                 :          0 :         return TxUpdate::UNCHANGED;
    1362                 :          0 :     };
    1363                 :            : 
    1364                 :            :     // Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too.
    1365   [ #  #  #  # ]:          0 :     RecursiveUpdateTxState(hashTx, try_updating_state);
    1366                 :            : 
    1367         [ #  # ]:          0 : }
    1368                 :            : 
    1369                 :          0 : void CWallet::RecursiveUpdateTxState(const uint256& tx_hash, const TryUpdatingStateFn& try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
    1370                 :            :     // Do not flush the wallet here for performance reasons
    1371                 :          0 :     WalletBatch batch(GetDatabase(), false);
    1372                 :            : 
    1373                 :          0 :     std::set<uint256> todo;
    1374                 :          0 :     std::set<uint256> done;
    1375                 :            : 
    1376         [ #  # ]:          0 :     todo.insert(tx_hash);
    1377                 :            : 
    1378         [ #  # ]:          0 :     while (!todo.empty()) {
    1379                 :          0 :         uint256 now = *todo.begin();
    1380         [ #  # ]:          0 :         todo.erase(now);
    1381         [ #  # ]:          0 :         done.insert(now);
    1382         [ #  # ]:          0 :         auto it = mapWallet.find(now);
    1383         [ #  # ]:          0 :         assert(it != mapWallet.end());
    1384                 :          0 :         CWalletTx& wtx = it->second;
    1385                 :            : 
    1386         [ #  # ]:          0 :         TxUpdate update_state = try_updating_state(wtx);
    1387         [ #  # ]:          0 :         if (update_state != TxUpdate::UNCHANGED) {
    1388         [ #  # ]:          0 :             wtx.MarkDirty();
    1389         [ #  # ]:          0 :             batch.WriteTx(wtx);
    1390                 :            :             // Iterate over all its outputs, and update those tx states as well (if applicable)
    1391         [ #  # ]:          0 :             for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
    1392   [ #  #  #  #  :          0 :                 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(COutPoint(now, i));
                   #  # ]
    1393         [ #  # ]:          0 :                 for (TxSpends::const_iterator iter = range.first; iter != range.second; ++iter) {
    1394   [ #  #  #  # ]:          0 :                     if (!done.count(iter->second)) {
    1395         [ #  # ]:          0 :                         todo.insert(iter->second);
    1396                 :          0 :                     }
    1397                 :          0 :                 }
    1398                 :          0 :             }
    1399                 :            : 
    1400         [ #  # ]:          0 :             if (update_state == TxUpdate::NOTIFY_CHANGED) {
    1401   [ #  #  #  # ]:          0 :                 NotifyTransactionChanged(wtx.GetHash(), CT_UPDATED);
    1402                 :          0 :             }
    1403                 :            : 
    1404                 :            :             // If a transaction changes its tx state, that usually changes the balance
    1405                 :            :             // available of the outputs it spends. So force those to be recomputed
    1406         [ #  # ]:          0 :             MarkInputsDirty(wtx.tx);
    1407                 :          0 :         }
    1408                 :            :     }
    1409                 :          0 : }
    1410                 :            : 
    1411                 :          0 : void CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& state, bool update_tx, bool rescanning_old_block)
    1412                 :            : {
    1413         [ #  # ]:          0 :     if (!AddToWalletIfInvolvingMe(ptx, state, update_tx, rescanning_old_block))
    1414                 :          0 :         return; // Not one of ours
    1415                 :            : 
    1416                 :            :     // If a transaction changes 'conflicted' state, that changes the balance
    1417                 :            :     // available of the outputs it spends. So force those to be
    1418                 :            :     // recomputed, also:
    1419                 :          0 :     MarkInputsDirty(ptx);
    1420                 :          0 : }
    1421                 :            : 
    1422                 :          0 : void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
    1423                 :          0 :     LOCK(cs_wallet);
    1424         [ #  # ]:          0 :     SyncTransaction(tx, TxStateInMempool{});
    1425                 :            : 
    1426   [ #  #  #  # ]:          0 :     auto it = mapWallet.find(tx->GetHash());
    1427         [ #  # ]:          0 :     if (it != mapWallet.end()) {
    1428   [ #  #  #  # ]:          0 :         RefreshMempoolStatus(it->second, chain());
    1429                 :          0 :     }
    1430                 :          0 : }
    1431                 :            : 
    1432                 :          0 : void CWallet::transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) {
    1433                 :          0 :     LOCK(cs_wallet);
    1434   [ #  #  #  # ]:          0 :     auto it = mapWallet.find(tx->GetHash());
    1435         [ #  # ]:          0 :     if (it != mapWallet.end()) {
    1436   [ #  #  #  # ]:          0 :         RefreshMempoolStatus(it->second, chain());
    1437                 :          0 :     }
    1438                 :            :     // Handle transactions that were removed from the mempool because they
    1439                 :            :     // conflict with transactions in a newly connected block.
    1440         [ #  # ]:          0 :     if (reason == MemPoolRemovalReason::CONFLICT) {
    1441                 :            :         // Trigger external -walletnotify notifications for these transactions.
    1442                 :            :         // Set Status::UNCONFIRMED instead of Status::CONFLICTED for a few reasons:
    1443                 :            :         //
    1444                 :            :         // 1. The transactionRemovedFromMempool callback does not currently
    1445                 :            :         //    provide the conflicting block's hash and height, and for backwards
    1446                 :            :         //    compatibility reasons it may not be not safe to store conflicted
    1447                 :            :         //    wallet transactions with a null block hash. See
    1448                 :            :         //    https://github.com/bitcoin/bitcoin/pull/18600#discussion_r420195993.
    1449                 :            :         // 2. For most of these transactions, the wallet's internal conflict
    1450                 :            :         //    detection in the blockConnected handler will subsequently call
    1451                 :            :         //    MarkConflicted and update them with CONFLICTED status anyway. This
    1452                 :            :         //    applies to any wallet transaction that has inputs spent in the
    1453                 :            :         //    block, or that has ancestors in the wallet with inputs spent by
    1454                 :            :         //    the block.
    1455                 :            :         // 3. Longstanding behavior since the sync implementation in
    1456                 :            :         //    https://github.com/bitcoin/bitcoin/pull/9371 and the prior sync
    1457                 :            :         //    implementation before that was to mark these transactions
    1458                 :            :         //    unconfirmed rather than conflicted.
    1459                 :            :         //
    1460                 :            :         // Nothing described above should be seen as an unchangeable requirement
    1461                 :            :         // when improving this code in the future. The wallet's heuristics for
    1462                 :            :         // distinguishing between conflicted and unconfirmed transactions are
    1463                 :            :         // imperfect, and could be improved in general, see
    1464                 :            :         // https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Transaction-Conflict-Tracking
    1465   [ #  #  #  # ]:          0 :         SyncTransaction(tx, TxStateInactive{});
    1466                 :          0 :     }
    1467                 :          0 : }
    1468                 :            : 
    1469                 :          0 : void CWallet::blockConnected(ChainstateRole role, const interfaces::BlockInfo& block)
    1470                 :            : {
    1471         [ #  # ]:          0 :     if (role == ChainstateRole::BACKGROUND) {
    1472                 :          0 :         return;
    1473                 :            :     }
    1474         [ #  # ]:          0 :     assert(block.data);
    1475                 :          0 :     LOCK(cs_wallet);
    1476                 :            : 
    1477                 :          0 :     m_last_block_processed_height = block.height;
    1478                 :          0 :     m_last_block_processed = block.hash;
    1479                 :            : 
    1480                 :            :     // No need to scan block if it was created before the wallet birthday.
    1481                 :            :     // Uses chain max time and twice the grace period to adjust time for block time variability.
    1482         [ #  # ]:          0 :     if (block.chain_time_max < m_birth_time.load() - (TIMESTAMP_WINDOW * 2)) return;
    1483                 :            : 
    1484                 :            :     // Scan block
    1485         [ #  # ]:          0 :     for (size_t index = 0; index < block.data->vtx.size(); index++) {
    1486   [ #  #  #  # ]:          0 :         SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)});
    1487         [ #  # ]:          0 :         transactionRemovedFromMempool(block.data->vtx[index], MemPoolRemovalReason::BLOCK);
    1488                 :          0 :     }
    1489         [ #  # ]:          0 : }
    1490                 :            : 
    1491                 :          0 : void CWallet::blockDisconnected(const interfaces::BlockInfo& block)
    1492                 :            : {
    1493         [ #  # ]:          0 :     assert(block.data);
    1494                 :          0 :     LOCK(cs_wallet);
    1495                 :            : 
    1496                 :            :     // At block disconnection, this will change an abandoned transaction to
    1497                 :            :     // be unconfirmed, whether or not the transaction is added back to the mempool.
    1498                 :            :     // User may have to call abandontransaction again. It may be addressed in the
    1499                 :            :     // future with a stickier abandoned state or even removing abandontransaction call.
    1500                 :          0 :     m_last_block_processed_height = block.height - 1;
    1501         [ #  # ]:          0 :     m_last_block_processed = *Assert(block.prev_hash);
    1502                 :            : 
    1503                 :          0 :     int disconnect_height = block.height;
    1504                 :            : 
    1505   [ #  #  #  # ]:          0 :     for (const CTransactionRef& ptx : Assert(block.data)->vtx) {
    1506   [ #  #  #  # ]:          0 :         SyncTransaction(ptx, TxStateInactive{});
    1507                 :            : 
    1508         [ #  # ]:          0 :         for (const CTxIn& tx_in : ptx->vin) {
    1509                 :            :             // No other wallet transactions conflicted with this transaction
    1510   [ #  #  #  # ]:          0 :             if (mapTxSpends.count(tx_in.prevout) < 1) continue;
    1511                 :            : 
    1512   [ #  #  #  # ]:          0 :             std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(tx_in.prevout);
    1513                 :            : 
    1514                 :            :             // For all of the spends that conflict with this transaction
    1515         [ #  # ]:          0 :             for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {
    1516         [ #  # ]:          0 :                 CWalletTx& wtx = mapWallet.find(_it->second)->second;
    1517                 :            : 
    1518   [ #  #  #  # ]:          0 :                 if (!wtx.isConflicted()) continue;
    1519                 :            : 
    1520                 :          0 :                 auto try_updating_state = [&](CWalletTx& tx) {
    1521         [ #  # ]:          0 :                     if (!tx.isConflicted()) return TxUpdate::UNCHANGED;
    1522         [ #  # ]:          0 :                     if (tx.state<TxStateConflicted>()->conflicting_block_height >= disconnect_height) {
    1523                 :          0 :                         tx.m_state = TxStateInactive{};
    1524                 :          0 :                         return TxUpdate::CHANGED;
    1525                 :            :                     }
    1526                 :          0 :                     return TxUpdate::UNCHANGED;
    1527                 :          0 :                 };
    1528                 :            : 
    1529   [ #  #  #  #  :          0 :                 RecursiveUpdateTxState(wtx.tx->GetHash(), try_updating_state);
                   #  # ]
    1530                 :          0 :             }
    1531                 :            :         }
    1532                 :            :     }
    1533                 :          0 : }
    1534                 :            : 
    1535                 :          0 : void CWallet::updatedBlockTip()
    1536                 :            : {
    1537                 :          0 :     m_best_block_time = GetTime();
    1538                 :          0 : }
    1539                 :            : 
    1540                 :          0 : void CWallet::BlockUntilSyncedToCurrentChain() const {
    1541                 :          0 :     AssertLockNotHeld(cs_wallet);
    1542                 :            :     // Skip the queue-draining stuff if we know we're caught up with
    1543                 :            :     // chain().Tip(), otherwise put a callback in the validation interface queue and wait
    1544                 :            :     // for the queue to drain enough to execute it (indicating we are caught up
    1545                 :            :     // at least with the time we entered this function).
    1546                 :          0 :     uint256 last_block_hash = WITH_LOCK(cs_wallet, return m_last_block_processed);
    1547                 :          0 :     chain().waitForNotificationsIfTipChanged(last_block_hash);
    1548                 :          0 : }
    1549                 :            : 
    1550                 :            : // Note that this function doesn't distinguish between a 0-valued input,
    1551                 :            : // and a not-"is mine" (according to the filter) input.
    1552                 :          0 : CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
    1553                 :            : {
    1554                 :            :     {
    1555                 :          0 :         LOCK(cs_wallet);
    1556         [ #  # ]:          0 :         const auto mi = mapWallet.find(txin.prevout.hash);
    1557         [ #  # ]:          0 :         if (mi != mapWallet.end())
    1558                 :            :         {
    1559                 :          0 :             const CWalletTx& prev = (*mi).second;
    1560         [ #  # ]:          0 :             if (txin.prevout.n < prev.tx->vout.size())
    1561   [ #  #  #  # ]:          0 :                 if (IsMine(prev.tx->vout[txin.prevout.n]) & filter)
    1562                 :          0 :                     return prev.tx->vout[txin.prevout.n].nValue;
    1563                 :          0 :         }
    1564      [ #  #  # ]:          0 :     }
    1565                 :          0 :     return 0;
    1566                 :          0 : }
    1567                 :            : 
    1568                 :          0 : isminetype CWallet::IsMine(const CTxOut& txout) const
    1569                 :            : {
    1570                 :          0 :     AssertLockHeld(cs_wallet);
    1571                 :          0 :     return IsMine(txout.scriptPubKey);
    1572                 :            : }
    1573                 :            : 
    1574                 :          0 : isminetype CWallet::IsMine(const CTxDestination& dest) const
    1575                 :            : {
    1576                 :          0 :     AssertLockHeld(cs_wallet);
    1577         [ #  # ]:          0 :     return IsMine(GetScriptForDestination(dest));
    1578                 :          0 : }
    1579                 :            : 
    1580                 :          0 : isminetype CWallet::IsMine(const CScript& script) const
    1581                 :            : {
    1582                 :          0 :     AssertLockHeld(cs_wallet);
    1583                 :          0 :     isminetype result = ISMINE_NO;
    1584         [ #  # ]:          0 :     for (const auto& spk_man_pair : m_spk_managers) {
    1585                 :          0 :         result = std::max(result, spk_man_pair.second->IsMine(script));
    1586                 :            :     }
    1587                 :          0 :     return result;
    1588                 :            : }
    1589                 :            : 
    1590                 :          0 : bool CWallet::IsMine(const CTransaction& tx) const
    1591                 :            : {
    1592                 :          0 :     AssertLockHeld(cs_wallet);
    1593         [ #  # ]:          0 :     for (const CTxOut& txout : tx.vout)
    1594         [ #  # ]:          0 :         if (IsMine(txout))
    1595                 :          0 :             return true;
    1596                 :          0 :     return false;
    1597                 :          0 : }
    1598                 :            : 
    1599                 :          0 : isminetype CWallet::IsMine(const COutPoint& outpoint) const
    1600                 :            : {
    1601                 :          0 :     AssertLockHeld(cs_wallet);
    1602                 :          0 :     auto wtx = GetWalletTx(outpoint.hash);
    1603         [ #  # ]:          0 :     if (!wtx) {
    1604                 :          0 :         return ISMINE_NO;
    1605                 :            :     }
    1606         [ #  # ]:          0 :     if (outpoint.n >= wtx->tx->vout.size()) {
    1607                 :          0 :         return ISMINE_NO;
    1608                 :            :     }
    1609                 :          0 :     return IsMine(wtx->tx->vout[outpoint.n]);
    1610                 :          0 : }
    1611                 :            : 
    1612                 :          0 : bool CWallet::IsFromMe(const CTransaction& tx) const
    1613                 :            : {
    1614                 :          0 :     return (GetDebit(tx, ISMINE_ALL) > 0);
    1615                 :            : }
    1616                 :            : 
    1617                 :          0 : CAmount CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
    1618                 :            : {
    1619                 :          0 :     CAmount nDebit = 0;
    1620         [ #  # ]:          0 :     for (const CTxIn& txin : tx.vin)
    1621                 :            :     {
    1622                 :          0 :         nDebit += GetDebit(txin, filter);
    1623         [ #  # ]:          0 :         if (!MoneyRange(nDebit))
    1624   [ #  #  #  #  :          0 :             throw std::runtime_error(std::string(__func__) + ": value out of range");
          #  #  #  #  #  
                      # ]
    1625                 :            :     }
    1626                 :          0 :     return nDebit;
    1627                 :          0 : }
    1628                 :            : 
    1629                 :          0 : bool CWallet::IsHDEnabled() const
    1630                 :            : {
    1631                 :            :     // All Active ScriptPubKeyMans must be HD for this to be true
    1632                 :          0 :     bool result = false;
    1633   [ #  #  #  #  :          0 :     for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
                      # ]
    1634   [ #  #  #  # ]:          0 :         if (!spk_man->IsHDEnabled()) return false;
    1635                 :          0 :         result = true;
    1636                 :            :     }
    1637                 :          0 :     return result;
    1638                 :          0 : }
    1639                 :            : 
    1640                 :          0 : bool CWallet::CanGetAddresses(bool internal) const
    1641                 :            : {
    1642                 :          0 :     LOCK(cs_wallet);
    1643         [ #  # ]:          0 :     if (m_spk_managers.empty()) return false;
    1644         [ #  # ]:          0 :     for (OutputType t : OUTPUT_TYPES) {
    1645         [ #  # ]:          0 :         auto spk_man = GetScriptPubKeyMan(t, internal);
    1646   [ #  #  #  #  :          0 :         if (spk_man && spk_man->CanGetAddresses(internal)) {
                   #  # ]
    1647                 :          0 :             return true;
    1648                 :            :         }
    1649                 :            :     }
    1650                 :          0 :     return false;
    1651                 :          0 : }
    1652                 :            : 
    1653                 :          0 : void CWallet::SetWalletFlag(uint64_t flags)
    1654                 :            : {
    1655                 :          0 :     LOCK(cs_wallet);
    1656                 :          0 :     m_wallet_flags |= flags;
    1657   [ #  #  #  #  :          0 :     if (!WalletBatch(GetDatabase()).WriteWalletFlags(m_wallet_flags))
             #  #  #  # ]
    1658   [ #  #  #  #  :          0 :         throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
          #  #  #  #  #  
                      # ]
    1659                 :          0 : }
    1660                 :            : 
    1661                 :          0 : void CWallet::UnsetWalletFlag(uint64_t flag)
    1662                 :            : {
    1663                 :          0 :     WalletBatch batch(GetDatabase());
    1664         [ #  # ]:          0 :     UnsetWalletFlagWithDB(batch, flag);
    1665                 :          0 : }
    1666                 :            : 
    1667                 :          0 : void CWallet::UnsetWalletFlagWithDB(WalletBatch& batch, uint64_t flag)
    1668                 :            : {
    1669                 :          0 :     LOCK(cs_wallet);
    1670                 :          0 :     m_wallet_flags &= ~flag;
    1671   [ #  #  #  # ]:          0 :     if (!batch.WriteWalletFlags(m_wallet_flags))
    1672   [ #  #  #  #  :          0 :         throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
          #  #  #  #  #  
                      # ]
    1673                 :          0 : }
    1674                 :            : 
    1675                 :          0 : void CWallet::UnsetBlankWalletFlag(WalletBatch& batch)
    1676                 :            : {
    1677                 :          0 :     UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
    1678                 :          0 : }
    1679                 :            : 
    1680                 :          0 : bool CWallet::IsWalletFlagSet(uint64_t flag) const
    1681                 :            : {
    1682                 :          0 :     return (m_wallet_flags & flag);
    1683                 :            : }
    1684                 :            : 
    1685                 :          0 : bool CWallet::LoadWalletFlags(uint64_t flags)
    1686                 :            : {
    1687                 :          0 :     LOCK(cs_wallet);
    1688         [ #  # ]:          0 :     if (((flags & KNOWN_WALLET_FLAGS) >> 32) ^ (flags >> 32)) {
    1689                 :            :         // contains unknown non-tolerable wallet flags
    1690                 :          0 :         return false;
    1691                 :            :     }
    1692                 :          0 :     m_wallet_flags = flags;
    1693                 :            : 
    1694                 :          0 :     return true;
    1695                 :          0 : }
    1696                 :            : 
    1697                 :          0 : void CWallet::InitWalletFlags(uint64_t flags)
    1698                 :            : {
    1699                 :          0 :     LOCK(cs_wallet);
    1700                 :            : 
    1701                 :            :     // We should never be writing unknown non-tolerable wallet flags
    1702         [ #  # ]:          0 :     assert(((flags & KNOWN_WALLET_FLAGS) >> 32) == (flags >> 32));
    1703                 :            :     // This should only be used once, when creating a new wallet - so current flags are expected to be blank
    1704         [ #  # ]:          0 :     assert(m_wallet_flags == 0);
    1705                 :            : 
    1706   [ #  #  #  #  :          0 :     if (!WalletBatch(GetDatabase()).WriteWalletFlags(flags)) {
             #  #  #  # ]
    1707   [ #  #  #  #  :          0 :         throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
          #  #  #  #  #  
                      # ]
    1708                 :            :     }
    1709                 :            : 
    1710   [ #  #  #  # ]:          0 :     if (!LoadWalletFlags(flags)) assert(false);
    1711                 :          0 : }
    1712                 :            : 
    1713                 :          0 : bool CWallet::ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
    1714                 :            : {
    1715                 :          0 :     auto spk_man = GetLegacyScriptPubKeyMan();
    1716         [ #  # ]:          0 :     if (!spk_man) {
    1717                 :          0 :         return false;
    1718                 :            :     }
    1719                 :          0 :     LOCK(spk_man->cs_KeyStore);
    1720   [ #  #  #  # ]:          0 :     return spk_man->ImportScripts(scripts, timestamp);
    1721                 :          0 : }
    1722                 :            : 
    1723                 :          0 : bool CWallet::ImportPrivKeys(const std::map<CKeyID, CKey>& privkey_map, const int64_t timestamp)
    1724                 :            : {
    1725                 :          0 :     auto spk_man = GetLegacyScriptPubKeyMan();
    1726         [ #  # ]:          0 :     if (!spk_man) {
    1727                 :          0 :         return false;
    1728                 :            :     }
    1729                 :          0 :     LOCK(spk_man->cs_KeyStore);
    1730         [ #  # ]:          0 :     return spk_man->ImportPrivKeys(privkey_map, timestamp);
    1731                 :          0 : }
    1732                 :            : 
    1733                 :          0 : bool CWallet::ImportPubKeys(const std::vector<CKeyID>& ordered_pubkeys, const std::map<CKeyID, CPubKey>& pubkey_map, const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& key_origins, const bool add_keypool, const bool internal, const int64_t timestamp)
    1734                 :            : {
    1735                 :          0 :     auto spk_man = GetLegacyScriptPubKeyMan();
    1736         [ #  # ]:          0 :     if (!spk_man) {
    1737                 :          0 :         return false;
    1738                 :            :     }
    1739                 :          0 :     LOCK(spk_man->cs_KeyStore);
    1740         [ #  # ]:          0 :     return spk_man->ImportPubKeys(ordered_pubkeys, pubkey_map, key_origins, add_keypool, internal, timestamp);
    1741                 :          0 : }
    1742                 :            : 
    1743                 :          0 : bool CWallet::ImportScriptPubKeys(const std::string& label, const std::set<CScript>& script_pub_keys, const bool have_solving_data, const bool apply_label, const int64_t timestamp)
    1744                 :            : {
    1745                 :          0 :     auto spk_man = GetLegacyScriptPubKeyMan();
    1746         [ #  # ]:          0 :     if (!spk_man) {
    1747                 :          0 :         return false;
    1748                 :            :     }
    1749                 :          0 :     LOCK(spk_man->cs_KeyStore);
    1750   [ #  #  #  # ]:          0 :     if (!spk_man->ImportScriptPubKeys(script_pub_keys, have_solving_data, timestamp)) {
    1751                 :          0 :         return false;
    1752                 :            :     }
    1753         [ #  # ]:          0 :     if (apply_label) {
    1754   [ #  #  #  # ]:          0 :         WalletBatch batch(GetDatabase());
    1755         [ #  # ]:          0 :         for (const CScript& script : script_pub_keys) {
    1756         [ #  # ]:          0 :             CTxDestination dest;
    1757         [ #  # ]:          0 :             ExtractDestination(script, dest);
    1758   [ #  #  #  # ]:          0 :             if (IsValidDestination(dest)) {
    1759   [ #  #  #  # ]:          0 :                 SetAddressBookWithDB(batch, dest, label, AddressPurpose::RECEIVE);
    1760                 :          0 :             }
    1761                 :          0 :         }
    1762                 :          0 :     }
    1763                 :          0 :     return true;
    1764                 :          0 : }
    1765                 :            : 
    1766                 :          0 : void CWallet::FirstKeyTimeChanged(const ScriptPubKeyMan* spkm, int64_t new_birth_time)
    1767                 :            : {
    1768                 :          0 :     int64_t birthtime = m_birth_time.load();
    1769         [ #  # ]:          0 :     if (new_birth_time < birthtime) {
    1770                 :          0 :         m_birth_time = new_birth_time;
    1771                 :          0 :     }
    1772                 :          0 : }
    1773                 :            : 
    1774                 :            : /**
    1775                 :            :  * Scan active chain for relevant transactions after importing keys. This should
    1776                 :            :  * be called whenever new keys are added to the wallet, with the oldest key
    1777                 :            :  * creation time.
    1778                 :            :  *
    1779                 :            :  * @return Earliest timestamp that could be successfully scanned from. Timestamp
    1780                 :            :  * returned will be higher than startTime if relevant blocks could not be read.
    1781                 :            :  */
    1782                 :          0 : int64_t CWallet::RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver, bool update)
    1783                 :            : {
    1784                 :            :     // Find starting block. May be null if nCreateTime is greater than the
    1785                 :            :     // highest blockchain timestamp, in which case there is nothing that needs
    1786                 :            :     // to be scanned.
    1787                 :          0 :     int start_height = 0;
    1788                 :          0 :     uint256 start_block;
    1789                 :          0 :     bool start = chain().findFirstBlockWithTimeAndHeight(startTime - TIMESTAMP_WINDOW, 0, FoundBlock().hash(start_block).height(start_height));
    1790   [ #  #  #  # ]:          0 :     WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__, start ? WITH_LOCK(cs_wallet, return GetLastBlockHeight()) - start_height + 1 : 0);
    1791                 :            : 
    1792         [ #  # ]:          0 :     if (start) {
    1793                 :            :         // TODO: this should take into account failure by ScanResult::USER_ABORT
    1794                 :          0 :         ScanResult result = ScanForWalletTransactions(start_block, start_height, /*max_height=*/{}, reserver, /*fUpdate=*/update, /*save_progress=*/false);
    1795         [ #  # ]:          0 :         if (result.status == ScanResult::FAILURE) {
    1796                 :            :             int64_t time_max;
    1797                 :          0 :             CHECK_NONFATAL(chain().findBlock(result.last_failed_block, FoundBlock().maxTime(time_max)));
    1798                 :          0 :             return time_max + TIMESTAMP_WINDOW + 1;
    1799                 :            :         }
    1800                 :          0 :     }
    1801                 :          0 :     return startTime;
    1802                 :          0 : }
    1803                 :            : 
    1804                 :            : /**
    1805                 :            :  * Scan the block chain (starting in start_block) for transactions
    1806                 :            :  * from or to us. If fUpdate is true, found transactions that already
    1807                 :            :  * exist in the wallet will be updated. If max_height is not set, the
    1808                 :            :  * mempool will be scanned as well.
    1809                 :            :  *
    1810                 :            :  * @param[in] start_block Scan starting block. If block is not on the active
    1811                 :            :  *                        chain, the scan will return SUCCESS immediately.
    1812                 :            :  * @param[in] start_height Height of start_block
    1813                 :            :  * @param[in] max_height  Optional max scanning height. If unset there is
    1814                 :            :  *                        no maximum and scanning can continue to the tip
    1815                 :            :  *
    1816                 :            :  * @return ScanResult returning scan information and indicating success or
    1817                 :            :  *         failure. Return status will be set to SUCCESS if scan was
    1818                 :            :  *         successful. FAILURE if a complete rescan was not possible (due to
    1819                 :            :  *         pruning or corruption). USER_ABORT if the rescan was aborted before
    1820                 :            :  *         it could complete.
    1821                 :            :  *
    1822                 :            :  * @pre Caller needs to make sure start_block (and the optional stop_block) are on
    1823                 :            :  * the main chain after to the addition of any new keys you want to detect
    1824                 :            :  * transactions for.
    1825                 :            :  */
    1826                 :          0 : CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, bool fUpdate, const bool save_progress)
    1827                 :            : {
    1828                 :          0 :     constexpr auto INTERVAL_TIME{60s};
    1829                 :          0 :     auto current_time{reserver.now()};
    1830                 :          0 :     auto start_time{reserver.now()};
    1831                 :            : 
    1832         [ #  # ]:          0 :     assert(reserver.isReserved());
    1833                 :            : 
    1834                 :          0 :     uint256 block_hash = start_block;
    1835                 :          0 :     ScanResult result;
    1836                 :            : 
    1837                 :          0 :     std::unique_ptr<FastWalletRescanFilter> fast_rescan_filter;
    1838   [ #  #  #  #  :          0 :     if (!IsLegacy() && chain().hasBlockFilterIndex(BlockFilterType::BASIC)) fast_rescan_filter = std::make_unique<FastWalletRescanFilter>(*this);
          #  #  #  #  #  
                #  #  # ]
    1839                 :            : 
    1840   [ #  #  #  # ]:          0 :     WalletLogPrintf("Rescan started from block %s... (%s)\n", start_block.ToString(),
    1841                 :          0 :                     fast_rescan_filter ? "fast variant using block filters" : "slow variant inspecting all blocks");
    1842                 :            : 
    1843                 :          0 :     fAbortRescan = false;
    1844   [ #  #  #  #  :          0 :     ShowProgress(strprintf("%s " + _("Rescanning…").translated, GetDisplayName()), 0); // show rescan progress in GUI as dialog or on splashscreen, if rescan required on startup (e.g. due to corruption)
          #  #  #  #  #  
                      # ]
    1845   [ #  #  #  #  :          0 :     uint256 tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
                   #  # ]
    1846                 :          0 :     uint256 end_hash = tip_hash;
    1847   [ #  #  #  #  :          0 :     if (max_height) chain().findAncestorByHeight(tip_hash, *max_height, FoundBlock().hash(end_hash));
          #  #  #  #  #  
                      # ]
    1848   [ #  #  #  # ]:          0 :     double progress_begin = chain().guessVerificationProgress(block_hash);
    1849   [ #  #  #  # ]:          0 :     double progress_end = chain().guessVerificationProgress(end_hash);
    1850                 :          0 :     double progress_current = progress_begin;
    1851                 :          0 :     int block_height = start_height;
    1852   [ #  #  #  #  :          0 :     while (!fAbortRescan && !chain().shutdownRequested()) {
             #  #  #  # ]
    1853         [ #  # ]:          0 :         if (progress_end - progress_begin > 0.0) {
    1854                 :          0 :             m_scanning_progress = (progress_current - progress_begin) / (progress_end - progress_begin);
    1855                 :          0 :         } else { // avoid divide-by-zero for single block scan range (i.e. start and stop hashes are equal)
    1856                 :          0 :             m_scanning_progress = 0;
    1857                 :            :         }
    1858   [ #  #  #  # ]:          0 :         if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
    1859   [ #  #  #  #  :          0 :             ShowProgress(strprintf("%s " + _("Rescanning…").translated, GetDisplayName()), std::max(1, std::min(99, (int)(m_scanning_progress * 100))));
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1860                 :          0 :         }
    1861                 :            : 
    1862   [ #  #  #  #  :          0 :         bool next_interval = reserver.now() >= current_time + INTERVAL_TIME;
                   #  # ]
    1863         [ #  # ]:          0 :         if (next_interval) {
    1864         [ #  # ]:          0 :             current_time = reserver.now();
    1865         [ #  # ]:          0 :             WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n", block_height, progress_current);
    1866                 :          0 :         }
    1867                 :            : 
    1868                 :          0 :         bool fetch_block{true};
    1869         [ #  # ]:          0 :         if (fast_rescan_filter) {
    1870         [ #  # ]:          0 :             fast_rescan_filter->UpdateIfNeeded();
    1871         [ #  # ]:          0 :             auto matches_block{fast_rescan_filter->MatchesBlock(block_hash)};
    1872         [ #  # ]:          0 :             if (matches_block.has_value()) {
    1873   [ #  #  #  # ]:          0 :                 if (*matches_block) {
    1874   [ #  #  #  #  :          0 :                     LogPrint(BCLog::SCAN, "Fast rescan: inspect block %d [%s] (filter matched)\n", block_height, block_hash.ToString());
          #  #  #  #  #  
                #  #  # ]
    1875                 :          0 :                 } else {
    1876                 :          0 :                     result.last_scanned_block = block_hash;
    1877         [ #  # ]:          0 :                     result.last_scanned_height = block_height;
    1878                 :          0 :                     fetch_block = false;
    1879                 :            :                 }
    1880                 :          0 :             } else {
    1881   [ #  #  #  #  :          0 :                 LogPrint(BCLog::SCAN, "Fast rescan: inspect block %d [%s] (WARNING: block filter not found!)\n", block_height, block_hash.ToString());
          #  #  #  #  #  
                #  #  # ]
    1882                 :            :             }
    1883                 :          0 :         }
    1884                 :            : 
    1885                 :            :         // Find next block separately from reading data above, because reading
    1886                 :            :         // is slow and there might be a reorg while it is read.
    1887                 :          0 :         bool block_still_active = false;
    1888                 :          0 :         bool next_block = false;
    1889         [ #  # ]:          0 :         uint256 next_block_hash;
    1890   [ #  #  #  #  :          0 :         chain().findBlock(block_hash, FoundBlock().inActiveChain(block_still_active).nextBlock(FoundBlock().inActiveChain(next_block).hash(next_block_hash)));
          #  #  #  #  #  
                #  #  # ]
    1891                 :            : 
    1892         [ #  # ]:          0 :         if (fetch_block) {
    1893                 :            :             // Read block data
    1894         [ #  # ]:          0 :             CBlock block;
    1895   [ #  #  #  #  :          0 :             chain().findBlock(block_hash, FoundBlock().data(block));
                   #  # ]
    1896                 :            : 
    1897   [ #  #  #  # ]:          0 :             if (!block.IsNull()) {
    1898   [ #  #  #  # ]:          0 :                 LOCK(cs_wallet);
    1899         [ #  # ]:          0 :                 if (!block_still_active) {
    1900                 :            :                     // Abort scan if current block is no longer active, to prevent
    1901                 :            :                     // marking transactions as coming from the wrong block.
    1902                 :          0 :                     result.last_failed_block = block_hash;
    1903                 :          0 :                     result.status = ScanResult::FAILURE;
    1904                 :          0 :                     break;
    1905                 :            :                 }
    1906         [ #  # ]:          0 :                 for (size_t posInBlock = 0; posInBlock < block.vtx.size(); ++posInBlock) {
    1907   [ #  #  #  # ]:          0 :                     SyncTransaction(block.vtx[posInBlock], TxStateConfirmed{block_hash, block_height, static_cast<int>(posInBlock)}, fUpdate, /*rescanning_old_block=*/true);
    1908                 :          0 :                 }
    1909                 :            :                 // scan succeeded, record block as most recent successfully scanned
    1910                 :          0 :                 result.last_scanned_block = block_hash;
    1911         [ #  # ]:          0 :                 result.last_scanned_height = block_height;
    1912                 :            : 
    1913   [ #  #  #  # ]:          0 :                 if (save_progress && next_interval) {
    1914         [ #  # ]:          0 :                     CBlockLocator loc = m_chain->getActiveChainLocator(block_hash);
    1915                 :            : 
    1916   [ #  #  #  # ]:          0 :                     if (!loc.IsNull()) {
    1917         [ #  # ]:          0 :                         WalletLogPrintf("Saving scan progress %d.\n", block_height);
    1918   [ #  #  #  # ]:          0 :                         WalletBatch batch(GetDatabase());
    1919         [ #  # ]:          0 :                         batch.WriteBestBlock(loc);
    1920                 :          0 :                     }
    1921                 :          0 :                 }
    1922         [ #  # ]:          0 :             } else {
    1923                 :            :                 // could not scan block, keep scanning but record this block as the most recent failure
    1924                 :          0 :                 result.last_failed_block = block_hash;
    1925                 :          0 :                 result.status = ScanResult::FAILURE;
    1926                 :            :             }
    1927      [ #  #  # ]:          0 :         }
    1928   [ #  #  #  #  :          0 :         if (max_height && block_height >= *max_height) {
                   #  # ]
    1929                 :          0 :             break;
    1930                 :            :         }
    1931                 :            :         {
    1932         [ #  # ]:          0 :             if (!next_block) {
    1933                 :            :                 // break successfully when rescan has reached the tip, or
    1934                 :            :                 // previous block is no longer on the chain due to a reorg
    1935                 :          0 :                 break;
    1936                 :            :             }
    1937                 :            : 
    1938                 :            :             // increment block and verification progress
    1939                 :          0 :             block_hash = next_block_hash;
    1940                 :          0 :             ++block_height;
    1941   [ #  #  #  # ]:          0 :             progress_current = chain().guessVerificationProgress(block_hash);
    1942                 :            : 
    1943                 :            :             // handle updated tip hash
    1944                 :          0 :             const uint256 prev_tip_hash = tip_hash;
    1945   [ #  #  #  #  :          0 :             tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
                   #  # ]
    1946   [ #  #  #  #  :          0 :             if (!max_height && prev_tip_hash != tip_hash) {
                   #  # ]
    1947                 :            :                 // in case the tip has changed, update progress max
    1948   [ #  #  #  # ]:          0 :                 progress_end = chain().guessVerificationProgress(tip_hash);
    1949                 :          0 :             }
    1950                 :            :         }
    1951                 :            :     }
    1952         [ #  # ]:          0 :     if (!max_height) {
    1953         [ #  # ]:          0 :         WalletLogPrintf("Scanning current mempool transactions.\n");
    1954   [ #  #  #  #  :          0 :         WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
                   #  # ]
    1955                 :          0 :     }
    1956   [ #  #  #  #  :          0 :     ShowProgress(strprintf("%s " + _("Rescanning…").translated, GetDisplayName()), 100); // hide progress dialog in GUI
          #  #  #  #  #  
                      # ]
    1957   [ #  #  #  # ]:          0 :     if (block_height && fAbortRescan) {
    1958         [ #  # ]:          0 :         WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n", block_height, progress_current);
    1959                 :          0 :         result.status = ScanResult::USER_ABORT;
    1960   [ #  #  #  #  :          0 :     } else if (block_height && chain().shutdownRequested()) {
             #  #  #  # ]
    1961         [ #  # ]:          0 :         WalletLogPrintf("Rescan interrupted by shutdown request at block %d. Progress=%f\n", block_height, progress_current);
    1962                 :          0 :         result.status = ScanResult::USER_ABORT;
    1963                 :          0 :     } else {
    1964   [ #  #  #  #  :          0 :         WalletLogPrintf("Rescan completed in %15dms\n", Ticks<std::chrono::milliseconds>(reserver.now() - start_time));
             #  #  #  # ]
    1965                 :            :     }
    1966                 :            :     return result;
    1967                 :          0 : }
    1968                 :            : 
    1969                 :          0 : bool CWallet::SubmitTxMemoryPoolAndRelay(CWalletTx& wtx, std::string& err_string, bool relay) const
    1970                 :            : {
    1971                 :          0 :     AssertLockHeld(cs_wallet);
    1972                 :            : 
    1973                 :            :     // Can't relay if wallet is not broadcasting
    1974         [ #  # ]:          0 :     if (!GetBroadcastTransactions()) return false;
    1975                 :            :     // Don't relay abandoned transactions
    1976         [ #  # ]:          0 :     if (wtx.isAbandoned()) return false;
    1977                 :            :     // Don't try to submit coinbase transactions. These would fail anyway but would
    1978                 :            :     // cause log spam.
    1979         [ #  # ]:          0 :     if (wtx.IsCoinBase()) return false;
    1980                 :            :     // Don't try to submit conflicted or confirmed transactions.
    1981         [ #  # ]:          0 :     if (GetTxDepthInMainChain(wtx) != 0) return false;
    1982                 :            : 
    1983                 :            :     // Submit transaction to mempool for relay
    1984         [ #  # ]:          0 :     WalletLogPrintf("Submitting wtx %s to mempool for relay\n", wtx.GetHash().ToString());
    1985                 :            :     // We must set TxStateInMempool here. Even though it will also be set later by the
    1986                 :            :     // entered-mempool callback, if we did not there would be a race where a
    1987                 :            :     // user could call sendmoney in a loop and hit spurious out of funds errors
    1988                 :            :     // because we think that this newly generated transaction's change is
    1989                 :            :     // unavailable as we're not yet aware that it is in the mempool.
    1990                 :            :     //
    1991                 :            :     // If broadcast fails for any reason, trying to set wtx.m_state here would be incorrect.
    1992                 :            :     // If transaction was previously in the mempool, it should be updated when
    1993                 :            :     // TransactionRemovedFromMempool fires.
    1994                 :          0 :     bool ret = chain().broadcastTransaction(wtx.tx, m_default_max_tx_fee, relay, err_string);
    1995         [ #  # ]:          0 :     if (ret) wtx.m_state = TxStateInMempool{};
    1996                 :          0 :     return ret;
    1997                 :          0 : }
    1998                 :            : 
    1999                 :          0 : std::set<uint256> CWallet::GetTxConflicts(const CWalletTx& wtx) const
    2000                 :            : {
    2001                 :          0 :     AssertLockHeld(cs_wallet);
    2002                 :            : 
    2003                 :          0 :     const uint256 myHash{wtx.GetHash()};
    2004                 :          0 :     std::set<uint256> result{GetConflicts(myHash)};
    2005         [ #  # ]:          0 :     result.erase(myHash);
    2006                 :          0 :     return result;
    2007         [ #  # ]:          0 : }
    2008                 :            : 
    2009                 :          0 : bool CWallet::ShouldResend() const
    2010                 :            : {
    2011                 :            :     // Don't attempt to resubmit if the wallet is configured to not broadcast
    2012         [ #  # ]:          0 :     if (!fBroadcastTransactions) return false;
    2013                 :            : 
    2014                 :            :     // During reindex, importing and IBD, old wallet transactions become
    2015                 :            :     // unconfirmed. Don't resend them as that would spam other nodes.
    2016                 :            :     // We only allow forcing mempool submission when not relaying to avoid this spam.
    2017         [ #  # ]:          0 :     if (!chain().isReadyToBroadcast()) return false;
    2018                 :            : 
    2019                 :            :     // Do this infrequently and randomly to avoid giving away
    2020                 :            :     // that these are our transactions.
    2021         [ #  # ]:          0 :     if (NodeClock::now() < m_next_resend) return false;
    2022                 :            : 
    2023                 :          0 :     return true;
    2024                 :          0 : }
    2025                 :            : 
    2026   [ #  #  #  #  :          0 : NodeClock::time_point CWallet::GetDefaultNextResend() { return FastRandomContext{}.rand_uniform_delay(NodeClock::now() + 12h, 24h); }
          #  #  #  #  #  
                      # ]
    2027                 :            : 
    2028                 :            : // Resubmit transactions from the wallet to the mempool, optionally asking the
    2029                 :            : // mempool to relay them. On startup, we will do this for all unconfirmed
    2030                 :            : // transactions but will not ask the mempool to relay them. We do this on startup
    2031                 :            : // to ensure that our own mempool is aware of our transactions. There
    2032                 :            : // is a privacy side effect here as not broadcasting on startup also means that we won't
    2033                 :            : // inform the world of our wallet's state, particularly if the wallet (or node) is not
    2034                 :            : // yet synced.
    2035                 :            : //
    2036                 :            : // Otherwise this function is called periodically in order to relay our unconfirmed txs.
    2037                 :            : // We do this on a random timer to slightly obfuscate which transactions
    2038                 :            : // come from our wallet.
    2039                 :            : //
    2040                 :            : // TODO: Ideally, we'd only resend transactions that we think should have been
    2041                 :            : // mined in the most recent block. Any transaction that wasn't in the top
    2042                 :            : // blockweight of transactions in the mempool shouldn't have been mined,
    2043                 :            : // and so is probably just sitting in the mempool waiting to be confirmed.
    2044                 :            : // Rebroadcasting does nothing to speed up confirmation and only damages
    2045                 :            : // privacy.
    2046                 :            : //
    2047                 :            : // The `force` option results in all unconfirmed transactions being submitted to
    2048                 :            : // the mempool. This does not necessarily result in those transactions being relayed,
    2049                 :            : // that depends on the `relay` option. Periodic rebroadcast uses the pattern
    2050                 :            : // relay=true force=false, while loading into the mempool
    2051                 :            : // (on start, or after import) uses relay=false force=true.
    2052                 :          0 : void CWallet::ResubmitWalletTransactions(bool relay, bool force)
    2053                 :            : {
    2054                 :            :     // Don't attempt to resubmit if the wallet is configured to not broadcast,
    2055                 :            :     // even if forcing.
    2056         [ #  # ]:          0 :     if (!fBroadcastTransactions) return;
    2057                 :            : 
    2058                 :          0 :     int submitted_tx_count = 0;
    2059                 :            : 
    2060                 :            :     { // cs_wallet scope
    2061                 :          0 :         LOCK(cs_wallet);
    2062                 :            : 
    2063                 :            :         // First filter for the transactions we want to rebroadcast.
    2064                 :            :         // We use a set with WalletTxOrderComparator so that rebroadcasting occurs in insertion order
    2065                 :          0 :         std::set<CWalletTx*, WalletTxOrderComparator> to_submit;
    2066         [ #  # ]:          0 :         for (auto& [txid, wtx] : mapWallet) {
    2067                 :            :             // Only rebroadcast unconfirmed txs
    2068   [ #  #  #  # ]:          0 :             if (!wtx.isUnconfirmed()) continue;
    2069                 :            : 
    2070                 :            :             // Attempt to rebroadcast all txes more than 5 minutes older than
    2071                 :            :             // the last block, or all txs if forcing.
    2072   [ #  #  #  # ]:          0 :             if (!force && wtx.nTimeReceived > m_best_block_time - 5 * 60) continue;
    2073         [ #  # ]:          0 :             to_submit.insert(&wtx);
    2074                 :            :         }
    2075                 :            :         // Now try submitting the transactions to the memory pool and (optionally) relay them.
    2076         [ #  # ]:          0 :         for (auto wtx : to_submit) {
    2077                 :          0 :             std::string unused_err_string;
    2078   [ #  #  #  # ]:          0 :             if (SubmitTxMemoryPoolAndRelay(*wtx, unused_err_string, relay)) ++submitted_tx_count;
    2079                 :          0 :         }
    2080                 :          0 :     } // cs_wallet
    2081                 :            : 
    2082         [ #  # ]:          0 :     if (submitted_tx_count > 0) {
    2083                 :          0 :         WalletLogPrintf("%s: resubmit %u unconfirmed transactions\n", __func__, submitted_tx_count);
    2084                 :          0 :     }
    2085                 :          0 : }
    2086                 :            : 
    2087                 :            : /** @} */ // end of mapWallet
    2088                 :            : 
    2089                 :          0 : void MaybeResendWalletTxs(WalletContext& context)
    2090                 :            : {
    2091         [ #  # ]:          0 :     for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
    2092   [ #  #  #  # ]:          0 :         if (!pwallet->ShouldResend()) continue;
    2093         [ #  # ]:          0 :         pwallet->ResubmitWalletTransactions(/*relay=*/true, /*force=*/false);
    2094         [ #  # ]:          0 :         pwallet->SetNextResend();
    2095                 :            :     }
    2096                 :          0 : }
    2097                 :            : 
    2098                 :            : 
    2099                 :            : /** @defgroup Actions
    2100                 :            :  *
    2101                 :            :  * @{
    2102                 :            :  */
    2103                 :            : 
    2104                 :          0 : bool CWallet::SignTransaction(CMutableTransaction& tx) const
    2105                 :            : {
    2106                 :          0 :     AssertLockHeld(cs_wallet);
    2107                 :            : 
    2108                 :            :     // Build coins map
    2109                 :          0 :     std::map<COutPoint, Coin> coins;
    2110         [ #  # ]:          0 :     for (auto& input : tx.vin) {
    2111         [ #  # ]:          0 :         const auto mi = mapWallet.find(input.prevout.hash);
    2112   [ #  #  #  # ]:          0 :         if(mi == mapWallet.end() || input.prevout.n >= mi->second.tx->vout.size()) {
    2113                 :          0 :             return false;
    2114                 :            :         }
    2115                 :          0 :         const CWalletTx& wtx = mi->second;
    2116   [ #  #  #  #  :          0 :         int prev_height = wtx.state<TxStateConfirmed>() ? wtx.state<TxStateConfirmed>()->confirmed_block_height : 0;
                   #  # ]
    2117   [ #  #  #  #  :          0 :         coins[input.prevout] = Coin(wtx.tx->vout[input.prevout.n], prev_height, wtx.IsCoinBase());
                   #  # ]
    2118                 :            :     }
    2119                 :          0 :     std::map<int, bilingual_str> input_errors;
    2120         [ #  # ]:          0 :     return SignTransaction(tx, coins, SIGHASH_DEFAULT, input_errors);
    2121                 :          0 : }
    2122                 :            : 
    2123                 :          0 : bool CWallet::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
    2124                 :            : {
    2125                 :            :     // Try to sign with all ScriptPubKeyMans
    2126   [ #  #  #  #  :          0 :     for (ScriptPubKeyMan* spk_man : GetAllScriptPubKeyMans()) {
                      # ]
    2127                 :            :         // spk_man->SignTransaction will return true if the transaction is complete,
    2128                 :            :         // so we can exit early and return true if that happens
    2129   [ #  #  #  # ]:          0 :         if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
    2130                 :          0 :             return true;
    2131                 :            :         }
    2132                 :            :     }
    2133                 :            : 
    2134                 :            :     // At this point, one input was not fully signed otherwise we would have exited already
    2135                 :          0 :     return false;
    2136                 :          0 : }
    2137                 :            : 
    2138                 :          0 : TransactionError CWallet::FillPSBT(PartiallySignedTransaction& psbtx, bool& complete, int sighash_type, bool sign, bool bip32derivs, size_t * n_signed, bool finalize) const
    2139                 :            : {
    2140         [ #  # ]:          0 :     if (n_signed) {
    2141                 :          0 :         *n_signed = 0;
    2142                 :          0 :     }
    2143                 :          0 :     LOCK(cs_wallet);
    2144                 :            :     // Get all of the previous transactions
    2145   [ #  #  #  # ]:          0 :     for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
    2146         [ #  # ]:          0 :         const CTxIn& txin = psbtx.tx->vin[i];
    2147         [ #  # ]:          0 :         PSBTInput& input = psbtx.inputs.at(i);
    2148                 :            : 
    2149   [ #  #  #  # ]:          0 :         if (PSBTInputSigned(input)) {
    2150                 :          0 :             continue;
    2151                 :            :         }
    2152                 :            : 
    2153                 :            :         // If we have no utxo, grab it from the wallet.
    2154   [ #  #  #  # ]:          0 :         if (!input.non_witness_utxo) {
    2155                 :          0 :             const uint256& txhash = txin.prevout.hash;
    2156         [ #  # ]:          0 :             const auto it = mapWallet.find(txhash);
    2157         [ #  # ]:          0 :             if (it != mapWallet.end()) {
    2158                 :          0 :                 const CWalletTx& wtx = it->second;
    2159                 :            :                 // We only need the non_witness_utxo, which is a superset of the witness_utxo.
    2160                 :            :                 //   The signing code will switch to the smaller witness_utxo if this is ok.
    2161                 :          0 :                 input.non_witness_utxo = wtx.tx;
    2162                 :          0 :             }
    2163                 :          0 :         }
    2164                 :          0 :     }
    2165                 :            : 
    2166         [ #  # ]:          0 :     const PrecomputedTransactionData txdata = PrecomputePSBTData(psbtx);
    2167                 :            : 
    2168                 :            :     // Fill in information from ScriptPubKeyMans
    2169   [ #  #  #  #  :          0 :     for (ScriptPubKeyMan* spk_man : GetAllScriptPubKeyMans()) {
                   #  # ]
    2170                 :          0 :         int n_signed_this_spkm = 0;
    2171         [ #  # ]:          0 :         TransactionError res = spk_man->FillPSBT(psbtx, txdata, sighash_type, sign, bip32derivs, &n_signed_this_spkm, finalize);
    2172         [ #  # ]:          0 :         if (res != TransactionError::OK) {
    2173                 :          0 :             return res;
    2174                 :            :         }
    2175                 :            : 
    2176         [ #  # ]:          0 :         if (n_signed) {
    2177                 :          0 :             (*n_signed) += n_signed_this_spkm;
    2178                 :          0 :         }
    2179                 :            :     }
    2180                 :            : 
    2181         [ #  # ]:          0 :     RemoveUnnecessaryTransactions(psbtx, sighash_type);
    2182                 :            : 
    2183                 :            :     // Complete if every input is now signed
    2184                 :          0 :     complete = true;
    2185         [ #  # ]:          0 :     for (const auto& input : psbtx.inputs) {
    2186         [ #  # ]:          0 :         complete &= PSBTInputSigned(input);
    2187                 :            :     }
    2188                 :            : 
    2189                 :          0 :     return TransactionError::OK;
    2190                 :          0 : }
    2191                 :            : 
    2192                 :          0 : SigningResult CWallet::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
    2193                 :            : {
    2194                 :          0 :     SignatureData sigdata;
    2195         [ #  # ]:          0 :     CScript script_pub_key = GetScriptForDestination(pkhash);
    2196         [ #  # ]:          0 :     for (const auto& spk_man_pair : m_spk_managers) {
    2197   [ #  #  #  # ]:          0 :         if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
    2198   [ #  #  #  # ]:          0 :             LOCK(cs_wallet);  // DescriptorScriptPubKeyMan calls IsLocked which can lock cs_wallet in a deadlocking order
    2199         [ #  # ]:          0 :             return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
    2200                 :          0 :         }
    2201                 :            :     }
    2202                 :          0 :     return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
    2203                 :          0 : }
    2204                 :            : 
    2205                 :          0 : OutputType CWallet::TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const
    2206                 :            : {
    2207                 :            :     // If -changetype is specified, always use that change type.
    2208         [ #  # ]:          0 :     if (change_type) {
    2209                 :          0 :         return *change_type;
    2210                 :            :     }
    2211                 :            : 
    2212                 :            :     // if m_default_address_type is legacy, use legacy address as change.
    2213         [ #  # ]:          0 :     if (m_default_address_type == OutputType::LEGACY) {
    2214                 :          0 :         return OutputType::LEGACY;
    2215                 :            :     }
    2216                 :            : 
    2217                 :          0 :     bool any_tr{false};
    2218                 :          0 :     bool any_wpkh{false};
    2219                 :          0 :     bool any_sh{false};
    2220                 :          0 :     bool any_pkh{false};
    2221                 :            : 
    2222         [ #  # ]:          0 :     for (const auto& recipient : vecSend) {
    2223         [ #  # ]:          0 :         if (std::get_if<WitnessV1Taproot>(&recipient.dest)) {
    2224                 :          0 :             any_tr = true;
    2225         [ #  # ]:          0 :         } else if (std::get_if<WitnessV0KeyHash>(&recipient.dest)) {
    2226                 :          0 :             any_wpkh = true;
    2227         [ #  # ]:          0 :         } else if (std::get_if<ScriptHash>(&recipient.dest)) {
    2228                 :          0 :             any_sh = true;
    2229         [ #  # ]:          0 :         } else if (std::get_if<PKHash>(&recipient.dest)) {
    2230                 :          0 :             any_pkh = true;
    2231                 :          0 :         }
    2232                 :            :     }
    2233                 :            : 
    2234                 :          0 :     const bool has_bech32m_spkman(GetScriptPubKeyMan(OutputType::BECH32M, /*internal=*/true));
    2235   [ #  #  #  # ]:          0 :     if (has_bech32m_spkman && any_tr) {
    2236                 :            :         // Currently tr is the only type supported by the BECH32M spkman
    2237                 :          0 :         return OutputType::BECH32M;
    2238                 :            :     }
    2239                 :          0 :     const bool has_bech32_spkman(GetScriptPubKeyMan(OutputType::BECH32, /*internal=*/true));
    2240   [ #  #  #  # ]:          0 :     if (has_bech32_spkman && any_wpkh) {
    2241                 :            :         // Currently wpkh is the only type supported by the BECH32 spkman
    2242                 :          0 :         return OutputType::BECH32;
    2243                 :            :     }
    2244                 :          0 :     const bool has_p2sh_segwit_spkman(GetScriptPubKeyMan(OutputType::P2SH_SEGWIT, /*internal=*/true));
    2245   [ #  #  #  # ]:          0 :     if (has_p2sh_segwit_spkman && any_sh) {
    2246                 :            :         // Currently sh_wpkh is the only type supported by the P2SH_SEGWIT spkman
    2247                 :            :         // As of 2021 about 80% of all SH are wrapping WPKH, so use that
    2248                 :          0 :         return OutputType::P2SH_SEGWIT;
    2249                 :            :     }
    2250                 :          0 :     const bool has_legacy_spkman(GetScriptPubKeyMan(OutputType::LEGACY, /*internal=*/true));
    2251   [ #  #  #  # ]:          0 :     if (has_legacy_spkman && any_pkh) {
    2252                 :            :         // Currently pkh is the only type supported by the LEGACY spkman
    2253                 :          0 :         return OutputType::LEGACY;
    2254                 :            :     }
    2255                 :            : 
    2256         [ #  # ]:          0 :     if (has_bech32m_spkman) {
    2257                 :          0 :         return OutputType::BECH32M;
    2258                 :            :     }
    2259         [ #  # ]:          0 :     if (has_bech32_spkman) {
    2260                 :          0 :         return OutputType::BECH32;
    2261                 :            :     }
    2262                 :            :     // else use m_default_address_type for change
    2263                 :          0 :     return m_default_address_type;
    2264                 :          0 : }
    2265                 :            : 
    2266                 :          0 : void CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm)
    2267                 :            : {
    2268                 :          0 :     LOCK(cs_wallet);
    2269   [ #  #  #  # ]:          0 :     WalletLogPrintf("CommitTransaction:\n%s", tx->ToString()); // NOLINT(bitcoin-unterminated-logprintf)
    2270                 :            : 
    2271                 :            :     // Add tx to wallet, because if it has change it's also ours,
    2272                 :            :     // otherwise just for transaction history.
    2273   [ #  #  #  #  :          0 :     CWalletTx* wtx = AddToWallet(tx, TxStateInactive{}, [&](CWalletTx& wtx, bool new_tx) {
                   #  # ]
    2274                 :          0 :         CHECK_NONFATAL(wtx.mapValue.empty());
    2275                 :          0 :         CHECK_NONFATAL(wtx.vOrderForm.empty());
    2276                 :          0 :         wtx.mapValue = std::move(mapValue);
    2277                 :          0 :         wtx.vOrderForm = std::move(orderForm);
    2278                 :          0 :         wtx.fTimeReceivedIsTxTime = true;
    2279                 :          0 :         wtx.fFromMe = true;
    2280                 :          0 :         return true;
    2281                 :            :     });
    2282                 :            : 
    2283                 :            :     // wtx can only be null if the db write failed.
    2284         [ #  # ]:          0 :     if (!wtx) {
    2285   [ #  #  #  #  :          0 :         throw std::runtime_error(std::string(__func__) + ": Wallet db error, transaction commit failed");
             #  #  #  # ]
    2286                 :            :     }
    2287                 :            : 
    2288                 :            :     // Notify that old coins are spent
    2289         [ #  # ]:          0 :     for (const CTxIn& txin : tx->vin) {
    2290         [ #  # ]:          0 :         CWalletTx &coin = mapWallet.at(txin.prevout.hash);
    2291         [ #  # ]:          0 :         coin.MarkDirty();
    2292   [ #  #  #  # ]:          0 :         NotifyTransactionChanged(coin.GetHash(), CT_UPDATED);
    2293                 :            :     }
    2294                 :            : 
    2295         [ #  # ]:          0 :     if (!fBroadcastTransactions) {
    2296                 :            :         // Don't submit tx to the mempool
    2297                 :          0 :         return;
    2298                 :            :     }
    2299                 :            : 
    2300                 :          0 :     std::string err_string;
    2301   [ #  #  #  # ]:          0 :     if (!SubmitTxMemoryPoolAndRelay(*wtx, err_string, true)) {
    2302   [ #  #  #  # ]:          0 :         WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast immediately, %s\n", err_string);
    2303                 :            :         // TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
    2304                 :          0 :     }
    2305                 :          0 : }
    2306                 :            : 
    2307                 :          0 : DBErrors CWallet::LoadWallet()
    2308                 :            : {
    2309                 :          0 :     LOCK(cs_wallet);
    2310                 :            : 
    2311   [ #  #  #  #  :          0 :     DBErrors nLoadWalletRet = WalletBatch(GetDatabase()).LoadWallet(this);
                   #  # ]
    2312         [ #  # ]:          0 :     if (nLoadWalletRet == DBErrors::NEED_REWRITE)
    2313                 :            :     {
    2314   [ #  #  #  #  :          0 :         if (GetDatabase().Rewrite("\x04pool"))
                   #  # ]
    2315                 :            :         {
    2316         [ #  # ]:          0 :             for (const auto& spk_man_pair : m_spk_managers) {
    2317         [ #  # ]:          0 :                 spk_man_pair.second->RewriteDB();
    2318                 :            :             }
    2319                 :          0 :         }
    2320                 :          0 :     }
    2321                 :            : 
    2322         [ #  # ]:          0 :     if (m_spk_managers.empty()) {
    2323         [ #  # ]:          0 :         assert(m_external_spk_managers.empty());
    2324         [ #  # ]:          0 :         assert(m_internal_spk_managers.empty());
    2325                 :          0 :     }
    2326                 :            : 
    2327                 :          0 :     return nLoadWalletRet;
    2328                 :          0 : }
    2329                 :            : 
    2330                 :          0 : DBErrors CWallet::ZapSelectTx(std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut)
    2331                 :            : {
    2332                 :          0 :     AssertLockHeld(cs_wallet);
    2333         [ #  # ]:          0 :     DBErrors nZapSelectTxRet = WalletBatch(GetDatabase()).ZapSelectTx(vHashIn, vHashOut);
    2334         [ #  # ]:          0 :     for (const uint256& hash : vHashOut) {
    2335                 :          0 :         const auto& it = mapWallet.find(hash);
    2336                 :          0 :         wtxOrdered.erase(it->second.m_it_wtxOrdered);
    2337         [ #  # ]:          0 :         for (const auto& txin : it->second.tx->vin)
    2338                 :          0 :             mapTxSpends.erase(txin.prevout);
    2339                 :          0 :         mapWallet.erase(it);
    2340                 :          0 :         NotifyTransactionChanged(hash, CT_DELETED);
    2341                 :            :     }
    2342                 :            : 
    2343         [ #  # ]:          0 :     if (nZapSelectTxRet == DBErrors::NEED_REWRITE)
    2344                 :            :     {
    2345         [ #  # ]:          0 :         if (GetDatabase().Rewrite("\x04pool"))
    2346                 :            :         {
    2347         [ #  # ]:          0 :             for (const auto& spk_man_pair : m_spk_managers) {
    2348                 :          0 :                 spk_man_pair.second->RewriteDB();
    2349                 :            :             }
    2350                 :          0 :         }
    2351                 :          0 :     }
    2352                 :            : 
    2353         [ #  # ]:          0 :     if (nZapSelectTxRet != DBErrors::LOAD_OK)
    2354                 :          0 :         return nZapSelectTxRet;
    2355                 :            : 
    2356                 :          0 :     MarkDirty();
    2357                 :            : 
    2358                 :          0 :     return DBErrors::LOAD_OK;
    2359                 :          0 : }
    2360                 :            : 
    2361                 :          0 : bool CWallet::SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& new_purpose)
    2362                 :            : {
    2363                 :          0 :     bool fUpdated = false;
    2364                 :            :     bool is_mine;
    2365                 :          0 :     std::optional<AddressPurpose> purpose;
    2366                 :            :     {
    2367                 :          0 :         LOCK(cs_wallet);
    2368         [ #  # ]:          0 :         std::map<CTxDestination, CAddressBookData>::iterator mi = m_address_book.find(address);
    2369   [ #  #  #  # ]:          0 :         fUpdated = (mi != m_address_book.end() && !mi->second.IsChange());
    2370   [ #  #  #  #  :          0 :         m_address_book[address].SetLabel(strName);
                   #  # ]
    2371         [ #  # ]:          0 :         is_mine = IsMine(address) != ISMINE_NO;
    2372         [ #  # ]:          0 :         if (new_purpose) { /* update purpose only if requested */
    2373         [ #  # ]:          0 :             purpose = m_address_book[address].purpose = new_purpose;
    2374                 :          0 :         } else {
    2375         [ #  # ]:          0 :             purpose = m_address_book[address].purpose;
    2376                 :            :         }
    2377                 :          0 :     }
    2378                 :            :     // In very old wallets, address purpose may not be recorded so we derive it from IsMine
    2379                 :          0 :     NotifyAddressBookChanged(address, strName, is_mine,
    2380                 :          0 :                              purpose.value_or(is_mine ? AddressPurpose::RECEIVE : AddressPurpose::SEND),
    2381                 :          0 :                              (fUpdated ? CT_UPDATED : CT_NEW));
    2382   [ #  #  #  #  :          0 :     if (new_purpose && !batch.WritePurpose(EncodeDestination(address), PurposeToString(*new_purpose)))
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    2383                 :          0 :         return false;
    2384         [ #  # ]:          0 :     return batch.WriteName(EncodeDestination(address), strName);
    2385                 :          0 : }
    2386                 :            : 
    2387                 :          0 : bool CWallet::SetAddressBook(const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& purpose)
    2388                 :            : {
    2389                 :          0 :     WalletBatch batch(GetDatabase());
    2390         [ #  # ]:          0 :     return SetAddressBookWithDB(batch, address, strName, purpose);
    2391                 :          0 : }
    2392                 :            : 
    2393                 :          0 : bool CWallet::DelAddressBook(const CTxDestination& address)
    2394                 :            : {
    2395                 :          0 :     WalletBatch batch(GetDatabase());
    2396                 :            :     {
    2397   [ #  #  #  # ]:          0 :         LOCK(cs_wallet);
    2398                 :            :         // If we want to delete receiving addresses, we should avoid calling EraseAddressData because it will delete the previously_spent value. Could instead just erase the label so it becomes a change address, and keep the data.
    2399                 :            :         // NOTE: This isn't a problem for sending addresses because they don't have any data that needs to be kept.
    2400                 :            :         // When adding new address data, it should be considered here whether to retain or delete it.
    2401   [ #  #  #  # ]:          0 :         if (IsMine(address)) {
    2402         [ #  # ]:          0 :             WalletLogPrintf("%s called with IsMine address, NOT SUPPORTED. Please report this bug! %s\n", __func__, PACKAGE_BUGREPORT);
    2403                 :          0 :             return false;
    2404                 :            :         }
    2405                 :            :         // Delete data rows associated with this address
    2406         [ #  # ]:          0 :         batch.EraseAddressData(address);
    2407         [ #  # ]:          0 :         m_address_book.erase(address);
    2408         [ #  # ]:          0 :     }
    2409                 :            : 
    2410   [ #  #  #  # ]:          0 :     NotifyAddressBookChanged(address, "", /*is_mine=*/false, AddressPurpose::SEND, CT_DELETED);
    2411                 :            : 
    2412   [ #  #  #  # ]:          0 :     batch.ErasePurpose(EncodeDestination(address));
    2413   [ #  #  #  # ]:          0 :     return batch.EraseName(EncodeDestination(address));
    2414                 :          0 : }
    2415                 :            : 
    2416                 :          0 : size_t CWallet::KeypoolCountExternalKeys() const
    2417                 :            : {
    2418                 :          0 :     AssertLockHeld(cs_wallet);
    2419                 :            : 
    2420                 :          0 :     auto legacy_spk_man = GetLegacyScriptPubKeyMan();
    2421         [ #  # ]:          0 :     if (legacy_spk_man) {
    2422                 :          0 :         return legacy_spk_man->KeypoolCountExternalKeys();
    2423                 :            :     }
    2424                 :            : 
    2425                 :          0 :     unsigned int count = 0;
    2426         [ #  # ]:          0 :     for (auto spk_man : m_external_spk_managers) {
    2427                 :          0 :         count += spk_man.second->GetKeyPoolSize();
    2428                 :            :     }
    2429                 :            : 
    2430                 :          0 :     return count;
    2431                 :          0 : }
    2432                 :            : 
    2433                 :          0 : unsigned int CWallet::GetKeyPoolSize() const
    2434                 :            : {
    2435                 :          0 :     AssertLockHeld(cs_wallet);
    2436                 :            : 
    2437                 :          0 :     unsigned int count = 0;
    2438         [ #  # ]:          0 :     for (auto spk_man : GetActiveScriptPubKeyMans()) {
    2439         [ #  # ]:          0 :         count += spk_man->GetKeyPoolSize();
    2440                 :            :     }
    2441                 :          0 :     return count;
    2442                 :          0 : }
    2443                 :            : 
    2444                 :          0 : bool CWallet::TopUpKeyPool(unsigned int kpSize)
    2445                 :            : {
    2446                 :          0 :     LOCK(cs_wallet);
    2447                 :          0 :     bool res = true;
    2448   [ #  #  #  # ]:          0 :     for (auto spk_man : GetActiveScriptPubKeyMans()) {
    2449         [ #  # ]:          0 :         res &= spk_man->TopUp(kpSize);
    2450                 :            :     }
    2451                 :          0 :     return res;
    2452                 :          0 : }
    2453                 :            : 
    2454                 :          0 : util::Result<CTxDestination> CWallet::GetNewDestination(const OutputType type, const std::string label)
    2455                 :            : {
    2456                 :          0 :     LOCK(cs_wallet);
    2457         [ #  # ]:          0 :     auto spk_man = GetScriptPubKeyMan(type, /*internal=*/false);
    2458         [ #  # ]:          0 :     if (!spk_man) {
    2459   [ #  #  #  #  :          0 :         return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
             #  #  #  # ]
    2460                 :            :     }
    2461                 :            : 
    2462         [ #  # ]:          0 :     auto op_dest = spk_man->GetNewDestination(type);
    2463         [ #  # ]:          0 :     if (op_dest) {
    2464   [ #  #  #  #  :          0 :         SetAddressBook(*op_dest, label, AddressPurpose::RECEIVE);
                   #  # ]
    2465                 :          0 :     }
    2466                 :            : 
    2467                 :          0 :     return op_dest;
    2468         [ #  # ]:          0 : }
    2469                 :            : 
    2470                 :          0 : util::Result<CTxDestination> CWallet::GetNewChangeDestination(const OutputType type)
    2471                 :            : {
    2472                 :          0 :     LOCK(cs_wallet);
    2473                 :            : 
    2474         [ #  # ]:          0 :     ReserveDestination reservedest(this, type);
    2475         [ #  # ]:          0 :     auto op_dest = reservedest.GetReservedDestination(true);
    2476   [ #  #  #  # ]:          0 :     if (op_dest) reservedest.KeepDestination();
    2477                 :            : 
    2478                 :          0 :     return op_dest;
    2479         [ #  # ]:          0 : }
    2480                 :            : 
    2481                 :          0 : std::optional<int64_t> CWallet::GetOldestKeyPoolTime() const
    2482                 :            : {
    2483                 :          0 :     LOCK(cs_wallet);
    2484         [ #  # ]:          0 :     if (m_spk_managers.empty()) {
    2485                 :          0 :         return std::nullopt;
    2486                 :            :     }
    2487                 :            : 
    2488         [ #  # ]:          0 :     std::optional<int64_t> oldest_key{std::numeric_limits<int64_t>::max()};
    2489         [ #  # ]:          0 :     for (const auto& spk_man_pair : m_spk_managers) {
    2490   [ #  #  #  # ]:          0 :         oldest_key = std::min(oldest_key, spk_man_pair.second->GetOldestKeyPoolTime());
    2491                 :            :     }
    2492                 :          0 :     return oldest_key;
    2493                 :          0 : }
    2494                 :            : 
    2495                 :          0 : void CWallet::MarkDestinationsDirty(const std::set<CTxDestination>& destinations) {
    2496         [ #  # ]:          0 :     for (auto& entry : mapWallet) {
    2497                 :          0 :         CWalletTx& wtx = entry.second;
    2498         [ #  # ]:          0 :         if (wtx.m_is_cache_empty) continue;
    2499         [ #  # ]:          0 :         for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
    2500                 :          0 :             CTxDestination dst;
    2501   [ #  #  #  #  :          0 :             if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) && destinations.count(dst)) {
             #  #  #  # ]
    2502         [ #  # ]:          0 :                 wtx.MarkDirty();
    2503                 :          0 :                 break;
    2504                 :            :             }
    2505      [ #  #  # ]:          0 :         }
    2506                 :            :     }
    2507                 :          0 : }
    2508                 :            : 
    2509                 :          0 : void CWallet::ForEachAddrBookEntry(const ListAddrBookFunc& func) const
    2510                 :            : {
    2511                 :          0 :     AssertLockHeld(cs_wallet);
    2512         [ #  # ]:          0 :     for (const std::pair<const CTxDestination, CAddressBookData>& item : m_address_book) {
    2513                 :          0 :         const auto& entry = item.second;
    2514   [ #  #  #  # ]:          0 :         func(item.first, entry.GetLabel(), entry.IsChange(), entry.purpose);
    2515                 :            :     }
    2516                 :          0 : }
    2517                 :            : 
    2518                 :          0 : std::vector<CTxDestination> CWallet::ListAddrBookAddresses(const std::optional<AddrBookFilter>& _filter) const
    2519                 :            : {
    2520                 :          0 :     AssertLockHeld(cs_wallet);
    2521                 :          0 :     std::vector<CTxDestination> result;
    2522   [ #  #  #  #  :          0 :     AddrBookFilter filter = _filter ? *_filter : AddrBookFilter();
                   #  # ]
    2523   [ #  #  #  # ]:          0 :     ForEachAddrBookEntry([&result, &filter](const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose>& purpose) {
    2524                 :            :         // Filter by change
    2525   [ #  #  #  # ]:          0 :         if (filter.ignore_change && is_change) return;
    2526                 :            :         // Filter by label
    2527   [ #  #  #  # ]:          0 :         if (filter.m_op_label && *filter.m_op_label != label) return;
    2528                 :            :         // All good
    2529                 :          0 :         result.emplace_back(dest);
    2530                 :          0 :     });
    2531                 :          0 :     return result;
    2532         [ #  # ]:          0 : }
    2533                 :            : 
    2534                 :          0 : std::set<std::string> CWallet::ListAddrBookLabels(const std::optional<AddressPurpose> purpose) const
    2535                 :            : {
    2536                 :          0 :     AssertLockHeld(cs_wallet);
    2537                 :          0 :     std::set<std::string> label_set;
    2538   [ #  #  #  # ]:          0 :     ForEachAddrBookEntry([&](const CTxDestination& _dest, const std::string& _label,
    2539                 :            :                              bool _is_change, const std::optional<AddressPurpose>& _purpose) {
    2540         [ #  # ]:          0 :         if (_is_change) return;
    2541   [ #  #  #  # ]:          0 :         if (!purpose || purpose == _purpose) {
    2542                 :          0 :             label_set.insert(_label);
    2543                 :          0 :         }
    2544                 :          0 :     });
    2545                 :          0 :     return label_set;
    2546         [ #  # ]:          0 : }
    2547                 :            : 
    2548                 :          0 : util::Result<CTxDestination> ReserveDestination::GetReservedDestination(bool internal)
    2549                 :            : {
    2550                 :          0 :     m_spk_man = pwallet->GetScriptPubKeyMan(type, internal);
    2551         [ #  # ]:          0 :     if (!m_spk_man) {
    2552   [ #  #  #  #  :          0 :         return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
                   #  # ]
    2553                 :            :     }
    2554                 :            : 
    2555         [ #  # ]:          0 :     if (nIndex == -1) {
    2556                 :          0 :         CKeyPool keypool;
    2557                 :          0 :         auto op_address = m_spk_man->GetReservedDestination(type, internal, nIndex, keypool);
    2558         [ #  # ]:          0 :         if (!op_address) return op_address;
    2559   [ #  #  #  # ]:          0 :         address = *op_address;
    2560                 :          0 :         fInternal = keypool.fInternal;
    2561         [ #  # ]:          0 :     }
    2562         [ #  # ]:          0 :     return address;
    2563                 :          0 : }
    2564                 :            : 
    2565                 :          0 : void ReserveDestination::KeepDestination()
    2566                 :            : {
    2567         [ #  # ]:          0 :     if (nIndex != -1) {
    2568                 :          0 :         m_spk_man->KeepDestination(nIndex, type);
    2569                 :          0 :     }
    2570                 :          0 :     nIndex = -1;
    2571                 :          0 :     address = CNoDestination();
    2572                 :          0 : }
    2573                 :            : 
    2574                 :          0 : void ReserveDestination::ReturnDestination()
    2575                 :            : {
    2576         [ #  # ]:          0 :     if (nIndex != -1) {
    2577                 :          0 :         m_spk_man->ReturnDestination(nIndex, fInternal, address);
    2578                 :          0 :     }
    2579                 :          0 :     nIndex = -1;
    2580                 :          0 :     address = CNoDestination();
    2581                 :          0 : }
    2582                 :            : 
    2583                 :          0 : bool CWallet::DisplayAddress(const CTxDestination& dest)
    2584                 :            : {
    2585                 :          0 :     CScript scriptPubKey = GetScriptForDestination(dest);
    2586   [ #  #  #  #  :          0 :     for (const auto& spk_man : GetScriptPubKeyMans(scriptPubKey)) {
                   #  # ]
    2587         [ #  # ]:          0 :         auto signer_spk_man = dynamic_cast<ExternalSignerScriptPubKeyMan *>(spk_man);
    2588         [ #  # ]:          0 :         if (signer_spk_man == nullptr) {
    2589                 :          0 :             continue;
    2590                 :            :         }
    2591         [ #  # ]:          0 :         ExternalSigner signer = ExternalSignerScriptPubKeyMan::GetExternalSigner();
    2592   [ #  #  #  # ]:          0 :         return signer_spk_man->DisplayAddress(scriptPubKey, signer);
    2593                 :          0 :     }
    2594                 :          0 :     return false;
    2595                 :          0 : }
    2596                 :            : 
    2597                 :          0 : bool CWallet::LockCoin(const COutPoint& output, WalletBatch* batch)
    2598                 :            : {
    2599                 :          0 :     AssertLockHeld(cs_wallet);
    2600                 :          0 :     setLockedCoins.insert(output);
    2601         [ #  # ]:          0 :     if (batch) {
    2602                 :          0 :         return batch->WriteLockedUTXO(output);
    2603                 :            :     }
    2604                 :          0 :     return true;
    2605                 :          0 : }
    2606                 :            : 
    2607                 :          0 : bool CWallet::UnlockCoin(const COutPoint& output, WalletBatch* batch)
    2608                 :            : {
    2609                 :          0 :     AssertLockHeld(cs_wallet);
    2610                 :          0 :     bool was_locked = setLockedCoins.erase(output);
    2611   [ #  #  #  # ]:          0 :     if (batch && was_locked) {
    2612                 :          0 :         return batch->EraseLockedUTXO(output);
    2613                 :            :     }
    2614                 :          0 :     return true;
    2615                 :          0 : }
    2616                 :            : 
    2617                 :          0 : bool CWallet::UnlockAllCoins()
    2618                 :            : {
    2619                 :          0 :     AssertLockHeld(cs_wallet);
    2620                 :          0 :     bool success = true;
    2621                 :          0 :     WalletBatch batch(GetDatabase());
    2622         [ #  # ]:          0 :     for (auto it = setLockedCoins.begin(); it != setLockedCoins.end(); ++it) {
    2623         [ #  # ]:          0 :         success &= batch.EraseLockedUTXO(*it);
    2624                 :          0 :     }
    2625                 :          0 :     setLockedCoins.clear();
    2626                 :          0 :     return success;
    2627                 :          0 : }
    2628                 :            : 
    2629                 :          0 : bool CWallet::IsLockedCoin(const COutPoint& output) const
    2630                 :            : {
    2631                 :          0 :     AssertLockHeld(cs_wallet);
    2632                 :          0 :     return setLockedCoins.count(output) > 0;
    2633                 :            : }
    2634                 :            : 
    2635                 :          0 : void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
    2636                 :            : {
    2637                 :          0 :     AssertLockHeld(cs_wallet);
    2638         [ #  # ]:          0 :     for (std::set<COutPoint>::iterator it = setLockedCoins.begin();
    2639                 :          0 :          it != setLockedCoins.end(); it++) {
    2640                 :          0 :         COutPoint outpt = (*it);
    2641                 :          0 :         vOutpts.push_back(outpt);
    2642                 :          0 :     }
    2643                 :          0 : }
    2644                 :            : 
    2645                 :            : /** @} */ // end of Actions
    2646                 :            : 
    2647                 :          0 : void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t>& mapKeyBirth) const {
    2648                 :          0 :     AssertLockHeld(cs_wallet);
    2649                 :          0 :     mapKeyBirth.clear();
    2650                 :            : 
    2651                 :            :     // map in which we'll infer heights of other keys
    2652                 :          0 :     std::map<CKeyID, const TxStateConfirmed*> mapKeyFirstBlock;
    2653   [ #  #  #  # ]:          0 :     TxStateConfirmed max_confirm{uint256{}, /*height=*/-1, /*index=*/-1};
    2654   [ #  #  #  #  :          0 :     max_confirm.confirmed_block_height = GetLastBlockHeight() > 144 ? GetLastBlockHeight() - 144 : 0; // the tip can be reorganized; use a 144-block safety margin
                   #  # ]
    2655   [ #  #  #  #  :          0 :     CHECK_NONFATAL(chain().findAncestorByHeight(GetLastBlockHash(), max_confirm.confirmed_block_height, FoundBlock().hash(max_confirm.confirmed_block_hash)));
          #  #  #  #  #  
                      # ]
    2656                 :            : 
    2657                 :            :     {
    2658         [ #  # ]:          0 :         LegacyScriptPubKeyMan* spk_man = GetLegacyScriptPubKeyMan();
    2659         [ #  # ]:          0 :         assert(spk_man != nullptr);
    2660   [ #  #  #  # ]:          0 :         LOCK(spk_man->cs_KeyStore);
    2661                 :            : 
    2662                 :            :         // get birth times for keys with metadata
    2663         [ #  # ]:          0 :         for (const auto& entry : spk_man->mapKeyMetadata) {
    2664         [ #  # ]:          0 :             if (entry.second.nCreateTime) {
    2665         [ #  # ]:          0 :                 mapKeyBirth[entry.first] = entry.second.nCreateTime;
    2666                 :          0 :             }
    2667                 :            :         }
    2668                 :            : 
    2669                 :            :         // Prepare to infer birth heights for keys without metadata
    2670   [ #  #  #  # ]:          0 :         for (const CKeyID &keyid : spk_man->GetKeys()) {
    2671   [ #  #  #  # ]:          0 :             if (mapKeyBirth.count(keyid) == 0)
    2672         [ #  # ]:          0 :                 mapKeyFirstBlock[keyid] = &max_confirm;
    2673                 :            :         }
    2674                 :            : 
    2675                 :            :         // if there are no such keys, we're done
    2676         [ #  # ]:          0 :         if (mapKeyFirstBlock.empty())
    2677                 :          0 :             return;
    2678                 :            : 
    2679                 :            :         // find first block that affects those keys, if there are any left
    2680         [ #  # ]:          0 :         for (const auto& entry : mapWallet) {
    2681                 :            :             // iterate over all wallet transactions...
    2682                 :          0 :             const CWalletTx &wtx = entry.second;
    2683   [ #  #  #  # ]:          0 :             if (auto* conf = wtx.state<TxStateConfirmed>()) {
    2684                 :            :                 // ... which are already in a block
    2685         [ #  # ]:          0 :                 for (const CTxOut &txout : wtx.tx->vout) {
    2686                 :            :                     // iterate over all their outputs
    2687   [ #  #  #  # ]:          0 :                     for (const auto &keyid : GetAffectedKeys(txout.scriptPubKey, *spk_man)) {
    2688                 :            :                         // ... and all their affected keys
    2689         [ #  # ]:          0 :                         auto rit = mapKeyFirstBlock.find(keyid);
    2690   [ #  #  #  # ]:          0 :                         if (rit != mapKeyFirstBlock.end() && conf->confirmed_block_height < rit->second->confirmed_block_height) {
    2691                 :          0 :                             rit->second = conf;
    2692                 :          0 :                         }
    2693                 :            :                     }
    2694                 :            :                 }
    2695                 :          0 :             }
    2696                 :            :         }
    2697         [ #  # ]:          0 :     }
    2698                 :            : 
    2699                 :            :     // Extract block timestamps for those keys
    2700         [ #  # ]:          0 :     for (const auto& entry : mapKeyFirstBlock) {
    2701                 :            :         int64_t block_time;
    2702   [ #  #  #  #  :          0 :         CHECK_NONFATAL(chain().findBlock(entry.second->confirmed_block_hash, FoundBlock().time(block_time)));
             #  #  #  # ]
    2703         [ #  # ]:          0 :         mapKeyBirth[entry.first] = block_time - TIMESTAMP_WINDOW; // block times can be 2h off
    2704                 :            :     }
    2705         [ #  # ]:          0 : }
    2706                 :            : 
    2707                 :            : /**
    2708                 :            :  * Compute smart timestamp for a transaction being added to the wallet.
    2709                 :            :  *
    2710                 :            :  * Logic:
    2711                 :            :  * - If sending a transaction, assign its timestamp to the current time.
    2712                 :            :  * - If receiving a transaction outside a block, assign its timestamp to the
    2713                 :            :  *   current time.
    2714                 :            :  * - If receiving a transaction during a rescanning process, assign all its
    2715                 :            :  *   (not already known) transactions' timestamps to the block time.
    2716                 :            :  * - If receiving a block with a future timestamp, assign all its (not already
    2717                 :            :  *   known) transactions' timestamps to the current time.
    2718                 :            :  * - If receiving a block with a past timestamp, before the most recent known
    2719                 :            :  *   transaction (that we care about), assign all its (not already known)
    2720                 :            :  *   transactions' timestamps to the same timestamp as that most-recent-known
    2721                 :            :  *   transaction.
    2722                 :            :  * - If receiving a block with a past timestamp, but after the most recent known
    2723                 :            :  *   transaction, assign all its (not already known) transactions' timestamps to
    2724                 :            :  *   the block time.
    2725                 :            :  *
    2726                 :            :  * For more information see CWalletTx::nTimeSmart,
    2727                 :            :  * https://bitcointalk.org/?topic=54527, or
    2728                 :            :  * https://github.com/bitcoin/bitcoin/pull/1393.
    2729                 :            :  */
    2730                 :          0 : unsigned int CWallet::ComputeTimeSmart(const CWalletTx& wtx, bool rescanning_old_block) const
    2731                 :            : {
    2732                 :          0 :     std::optional<uint256> block_hash;
    2733         [ #  # ]:          0 :     if (auto* conf = wtx.state<TxStateConfirmed>()) {
    2734                 :          0 :         block_hash = conf->confirmed_block_hash;
    2735         [ #  # ]:          0 :     } else if (auto* conf = wtx.state<TxStateConflicted>()) {
    2736                 :          0 :         block_hash = conf->conflicting_block_hash;
    2737                 :          0 :     }
    2738                 :            : 
    2739                 :          0 :     unsigned int nTimeSmart = wtx.nTimeReceived;
    2740         [ #  # ]:          0 :     if (block_hash) {
    2741                 :            :         int64_t blocktime;
    2742                 :            :         int64_t block_max_time;
    2743         [ #  # ]:          0 :         if (chain().findBlock(*block_hash, FoundBlock().time(blocktime).maxTime(block_max_time))) {
    2744         [ #  # ]:          0 :             if (rescanning_old_block) {
    2745                 :          0 :                 nTimeSmart = block_max_time;
    2746                 :          0 :             } else {
    2747                 :          0 :                 int64_t latestNow = wtx.nTimeReceived;
    2748                 :          0 :                 int64_t latestEntry = 0;
    2749                 :            : 
    2750                 :            :                 // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
    2751                 :          0 :                 int64_t latestTolerated = latestNow + 300;
    2752                 :          0 :                 const TxItems& txOrdered = wtxOrdered;
    2753         [ #  # ]:          0 :                 for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
    2754                 :          0 :                     CWalletTx* const pwtx = it->second;
    2755         [ #  # ]:          0 :                     if (pwtx == &wtx) {
    2756                 :          0 :                         continue;
    2757                 :            :                     }
    2758                 :            :                     int64_t nSmartTime;
    2759                 :          0 :                     nSmartTime = pwtx->nTimeSmart;
    2760         [ #  # ]:          0 :                     if (!nSmartTime) {
    2761                 :          0 :                         nSmartTime = pwtx->nTimeReceived;
    2762                 :          0 :                     }
    2763         [ #  # ]:          0 :                     if (nSmartTime <= latestTolerated) {
    2764                 :          0 :                         latestEntry = nSmartTime;
    2765         [ #  # ]:          0 :                         if (nSmartTime > latestNow) {
    2766                 :          0 :                             latestNow = nSmartTime;
    2767                 :          0 :                         }
    2768                 :          0 :                         break;
    2769                 :            :                     }
    2770                 :          0 :                 }
    2771                 :            : 
    2772                 :          0 :                 nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
    2773                 :            :             }
    2774                 :          0 :         } else {
    2775   [ #  #  #  #  :          0 :             WalletLogPrintf("%s: found %s in block %s not in index\n", __func__, wtx.GetHash().ToString(), block_hash->ToString());
                   #  # ]
    2776                 :            :         }
    2777                 :          0 :     }
    2778                 :          0 :     return nTimeSmart;
    2779                 :          0 : }
    2780                 :            : 
    2781                 :          0 : bool CWallet::SetAddressPreviouslySpent(WalletBatch& batch, const CTxDestination& dest, bool used)
    2782                 :            : {
    2783         [ #  # ]:          0 :     if (std::get_if<CNoDestination>(&dest))
    2784                 :          0 :         return false;
    2785                 :            : 
    2786         [ #  # ]:          0 :     if (!used) {
    2787         [ #  # ]:          0 :         if (auto* data{common::FindKey(m_address_book, dest)}) data->previously_spent = false;
    2788                 :          0 :         return batch.WriteAddressPreviouslySpent(dest, false);
    2789                 :            :     }
    2790                 :            : 
    2791                 :          0 :     LoadAddressPreviouslySpent(dest);
    2792                 :          0 :     return batch.WriteAddressPreviouslySpent(dest, true);
    2793                 :          0 : }
    2794                 :            : 
    2795                 :          0 : void CWallet::LoadAddressPreviouslySpent(const CTxDestination& dest)
    2796                 :            : {
    2797                 :          0 :     m_address_book[dest].previously_spent = true;
    2798                 :          0 : }
    2799                 :            : 
    2800                 :          0 : void CWallet::LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request)
    2801                 :            : {
    2802                 :          0 :     m_address_book[dest].receive_requests[id] = request;
    2803                 :          0 : }
    2804                 :            : 
    2805                 :          0 : bool CWallet::IsAddressPreviouslySpent(const CTxDestination& dest) const
    2806                 :            : {
    2807         [ #  # ]:          0 :     if (auto* data{common::FindKey(m_address_book, dest)}) return data->previously_spent;
    2808                 :          0 :     return false;
    2809                 :          0 : }
    2810                 :            : 
    2811                 :          0 : std::vector<std::string> CWallet::GetAddressReceiveRequests() const
    2812                 :            : {
    2813                 :          0 :     std::vector<std::string> values;
    2814         [ #  # ]:          0 :     for (const auto& [dest, entry] : m_address_book) {
    2815         [ #  # ]:          0 :         for (const auto& [id, request] : entry.receive_requests) {
    2816         [ #  # ]:          0 :             values.emplace_back(request);
    2817                 :            :         }
    2818                 :            :     }
    2819                 :          0 :     return values;
    2820         [ #  # ]:          0 : }
    2821                 :            : 
    2822                 :          0 : bool CWallet::SetAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id, const std::string& value)
    2823                 :            : {
    2824         [ #  # ]:          0 :     if (!batch.WriteAddressReceiveRequest(dest, id, value)) return false;
    2825                 :          0 :     m_address_book[dest].receive_requests[id] = value;
    2826                 :          0 :     return true;
    2827                 :          0 : }
    2828                 :            : 
    2829                 :          0 : bool CWallet::EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id)
    2830                 :            : {
    2831         [ #  # ]:          0 :     if (!batch.EraseAddressReceiveRequest(dest, id)) return false;
    2832                 :          0 :     m_address_book[dest].receive_requests.erase(id);
    2833                 :          0 :     return true;
    2834                 :          0 : }
    2835                 :            : 
    2836                 :          0 : std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error_string)
    2837                 :            : {
    2838                 :            :     // Do some checking on wallet path. It should be either a:
    2839                 :            :     //
    2840                 :            :     // 1. Path where a directory can be created.
    2841                 :            :     // 2. Path to an existing directory.
    2842                 :            :     // 3. Path to a symlink to a directory.
    2843                 :            :     // 4. For backwards compatibility, the name of a data file in -walletdir.
    2844   [ #  #  #  # ]:          0 :     const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(name));
    2845         [ #  # ]:          0 :     fs::file_type path_type = fs::symlink_status(wallet_path).type();
    2846   [ #  #  #  #  :          0 :     if (!(path_type == fs::file_type::not_found || path_type == fs::file_type::directory ||
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    2847   [ #  #  #  #  :          0 :           (path_type == fs::file_type::symlink && fs::is_directory(wallet_path)) ||
                   #  # ]
    2848   [ #  #  #  #  :          0 :           (path_type == fs::file_type::regular && fs::PathFromString(name).filename() == fs::PathFromString(name)))) {
             #  #  #  # ]
    2849   [ #  #  #  # ]:          0 :         error_string = Untranslated(strprintf(
    2850                 :            :               "Invalid -wallet path '%s'. -wallet path should point to a directory where wallet.dat and "
    2851                 :            :               "database/log.?????????? files can be stored, a location where such a directory could be created, "
    2852                 :            :               "or (for backwards compatibility) the name of an existing data file in -walletdir (%s)",
    2853   [ #  #  #  #  :          0 :               name, fs::quoted(fs::PathToString(GetWalletDir()))));
                   #  # ]
    2854                 :          0 :         status = DatabaseStatus::FAILED_BAD_PATH;
    2855                 :          0 :         return nullptr;
    2856                 :            :     }
    2857         [ #  # ]:          0 :     return MakeDatabase(wallet_path, options, status, error_string);
    2858                 :          0 : }
    2859                 :            : 
    2860                 :          0 : std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings)
    2861                 :            : {
    2862                 :          0 :     interfaces::Chain* chain = context.chain;
    2863                 :          0 :     ArgsManager& args = *Assert(context.args);
    2864                 :          0 :     const std::string& walletFile = database->Filename();
    2865                 :            : 
    2866                 :          0 :     const auto start{SteadyClock::now()};
    2867                 :            :     // TODO: Can't use std::make_shared because we need a custom deleter but
    2868                 :            :     // should be possible to use std::allocate_shared.
    2869   [ #  #  #  #  :          0 :     std::shared_ptr<CWallet> walletInstance(new CWallet(chain, name, std::move(database)), ReleaseWallet);
             #  #  #  # ]
    2870   [ #  #  #  #  :          0 :     walletInstance->m_keypool_size = std::max(args.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t{1});
                   #  # ]
    2871   [ #  #  #  #  :          0 :     walletInstance->m_notify_tx_changed_script = args.GetArg("-walletnotify", "");
                   #  # ]
    2872                 :            : 
    2873                 :            :     // Load wallet
    2874                 :          0 :     bool rescan_required = false;
    2875         [ #  # ]:          0 :     DBErrors nLoadWalletRet = walletInstance->LoadWallet();
    2876         [ #  # ]:          0 :     if (nLoadWalletRet != DBErrors::LOAD_OK) {
    2877         [ #  # ]:          0 :         if (nLoadWalletRet == DBErrors::CORRUPT) {
    2878   [ #  #  #  # ]:          0 :             error = strprintf(_("Error loading %s: Wallet corrupted"), walletFile);
    2879                 :          0 :             return nullptr;
    2880                 :            :         }
    2881         [ #  # ]:          0 :         else if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR)
    2882                 :            :         {
    2883   [ #  #  #  #  :          0 :             warnings.push_back(strprintf(_("Error reading %s! All keys read correctly, but transaction data"
                   #  # ]
    2884                 :            :                                            " or address metadata may be missing or incorrect."),
    2885                 :          0 :                 walletFile));
    2886                 :          0 :         }
    2887         [ #  # ]:          0 :         else if (nLoadWalletRet == DBErrors::TOO_NEW) {
    2888   [ #  #  #  # ]:          0 :             error = strprintf(_("Error loading %s: Wallet requires newer version of %s"), walletFile, PACKAGE_NAME);
    2889                 :          0 :             return nullptr;
    2890                 :            :         }
    2891         [ #  # ]:          0 :         else if (nLoadWalletRet == DBErrors::EXTERNAL_SIGNER_SUPPORT_REQUIRED) {
    2892   [ #  #  #  # ]:          0 :             error = strprintf(_("Error loading %s: External signer wallet being loaded without external signer support compiled"), walletFile);
    2893                 :          0 :             return nullptr;
    2894                 :            :         }
    2895         [ #  # ]:          0 :         else if (nLoadWalletRet == DBErrors::NEED_REWRITE)
    2896                 :            :         {
    2897   [ #  #  #  # ]:          0 :             error = strprintf(_("Wallet needed to be rewritten: restart %s to complete"), PACKAGE_NAME);
    2898                 :          0 :             return nullptr;
    2899         [ #  # ]:          0 :         } else if (nLoadWalletRet == DBErrors::NEED_RESCAN) {
    2900   [ #  #  #  #  :          0 :             warnings.push_back(strprintf(_("Error reading %s! Transaction data may be missing or incorrect."
                   #  # ]
    2901                 :          0 :                                            " Rescanning wallet."), walletFile));
    2902                 :          0 :             rescan_required = true;
    2903         [ #  # ]:          0 :         } else if (nLoadWalletRet == DBErrors::UNKNOWN_DESCRIPTOR) {
    2904   [ #  #  #  # ]:          0 :             error = strprintf(_("Unrecognized descriptor found. Loading wallet %s\n\n"
    2905                 :            :                                 "The wallet might had been created on a newer version.\n"
    2906                 :          0 :                                 "Please try running the latest software version.\n"), walletFile);
    2907                 :          0 :             return nullptr;
    2908         [ #  # ]:          0 :         } else if (nLoadWalletRet == DBErrors::UNEXPECTED_LEGACY_ENTRY) {
    2909   [ #  #  #  # ]:          0 :             error = strprintf(_("Unexpected legacy entry in descriptor wallet found. Loading wallet %s\n\n"
    2910                 :          0 :                                 "The wallet might have been tampered with or created with malicious intent.\n"), walletFile);
    2911                 :          0 :             return nullptr;
    2912                 :            :         } else {
    2913   [ #  #  #  # ]:          0 :             error = strprintf(_("Error loading %s"), walletFile);
    2914                 :          0 :             return nullptr;
    2915                 :            :         }
    2916                 :          0 :     }
    2917                 :            : 
    2918                 :            :     // This wallet is in its first run if there are no ScriptPubKeyMans and it isn't blank or no privkeys
    2919         [ #  # ]:          0 :     const bool fFirstRun = walletInstance->m_spk_managers.empty() &&
    2920         [ #  # ]:          0 :                      !walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
    2921                 :          0 :                      !walletInstance->IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
    2922         [ #  # ]:          0 :     if (fFirstRun)
    2923                 :            :     {
    2924                 :            :         // ensure this wallet.dat can only be opened by clients supporting HD with chain split and expects no default key
    2925         [ #  # ]:          0 :         walletInstance->SetMinVersion(FEATURE_LATEST);
    2926                 :            : 
    2927         [ #  # ]:          0 :         walletInstance->InitWalletFlags(wallet_creation_flags);
    2928                 :            : 
    2929                 :            :         // Only create LegacyScriptPubKeyMan when not descriptor wallet
    2930         [ #  # ]:          0 :         if (!walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
    2931         [ #  # ]:          0 :             walletInstance->SetupLegacyScriptPubKeyMan();
    2932                 :          0 :         }
    2933                 :            : 
    2934   [ #  #  #  # ]:          0 :         if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) || !(wallet_creation_flags & (WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET))) {
    2935   [ #  #  #  # ]:          0 :             LOCK(walletInstance->cs_wallet);
    2936         [ #  # ]:          0 :             if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
    2937         [ #  # ]:          0 :                 walletInstance->SetupDescriptorScriptPubKeyMans();
    2938                 :            :                 // SetupDescriptorScriptPubKeyMans already calls SetupGeneration for us so we don't need to call SetupGeneration separately
    2939                 :          0 :             } else {
    2940                 :            :                 // Legacy wallets need SetupGeneration here.
    2941   [ #  #  #  #  :          0 :                 for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
                   #  # ]
    2942   [ #  #  #  # ]:          0 :                     if (!spk_man->SetupGeneration()) {
    2943         [ #  # ]:          0 :                         error = _("Unable to generate initial keys");
    2944                 :          0 :                         return nullptr;
    2945                 :            :                     }
    2946                 :            :                 }
    2947                 :            :             }
    2948         [ #  # ]:          0 :         }
    2949                 :            : 
    2950         [ #  # ]:          0 :         if (chain) {
    2951   [ #  #  #  # ]:          0 :             walletInstance->chainStateFlushed(ChainstateRole::NORMAL, chain->getTipLocator());
    2952                 :          0 :         }
    2953         [ #  # ]:          0 :     } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
    2954                 :            :         // Make it impossible to disable private keys after creation
    2955   [ #  #  #  # ]:          0 :         error = strprintf(_("Error loading %s: Private keys can only be disabled during creation"), walletFile);
    2956                 :          0 :         return nullptr;
    2957         [ #  # ]:          0 :     } else if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
    2958   [ #  #  #  # ]:          0 :         for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
    2959   [ #  #  #  # ]:          0 :             if (spk_man->HavePrivateKeys()) {
    2960   [ #  #  #  #  :          0 :                 warnings.push_back(strprintf(_("Warning: Private keys detected in wallet {%s} with disabled private keys"), walletFile));
                   #  # ]
    2961                 :          0 :                 break;
    2962                 :            :             }
    2963                 :            :         }
    2964                 :          0 :     }
    2965                 :            : 
    2966   [ #  #  #  #  :          0 :     if (!args.GetArg("-addresstype", "").empty()) {
             #  #  #  # ]
    2967   [ #  #  #  #  :          0 :         std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-addresstype", ""));
             #  #  #  # ]
    2968         [ #  # ]:          0 :         if (!parsed) {
    2969   [ #  #  #  #  :          0 :             error = strprintf(_("Unknown address type '%s'"), args.GetArg("-addresstype", ""));
          #  #  #  #  #  
                      # ]
    2970                 :          0 :             return nullptr;
    2971                 :            :         }
    2972         [ #  # ]:          0 :         walletInstance->m_default_address_type = parsed.value();
    2973                 :          0 :     }
    2974                 :            : 
    2975   [ #  #  #  #  :          0 :     if (!args.GetArg("-changetype", "").empty()) {
             #  #  #  # ]
    2976   [ #  #  #  #  :          0 :         std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-changetype", ""));
             #  #  #  # ]
    2977         [ #  # ]:          0 :         if (!parsed) {
    2978   [ #  #  #  #  :          0 :             error = strprintf(_("Unknown change type '%s'"), args.GetArg("-changetype", ""));
          #  #  #  #  #  
                      # ]
    2979                 :          0 :             return nullptr;
    2980                 :            :         }
    2981   [ #  #  #  # ]:          0 :         walletInstance->m_default_change_type = parsed.value();
    2982                 :          0 :     }
    2983                 :            : 
    2984   [ #  #  #  #  :          0 :     if (args.IsArgSet("-mintxfee")) {
                   #  # ]
    2985   [ #  #  #  #  :          0 :         std::optional<CAmount> min_tx_fee = ParseMoney(args.GetArg("-mintxfee", ""));
             #  #  #  # ]
    2986         [ #  # ]:          0 :         if (!min_tx_fee) {
    2987   [ #  #  #  #  :          0 :             error = AmountErrMsg("mintxfee", args.GetArg("-mintxfee", ""));
          #  #  #  #  #  
                      # ]
    2988                 :          0 :             return nullptr;
    2989   [ #  #  #  # ]:          0 :         } else if (min_tx_fee.value() > HIGH_TX_FEE_PER_KB) {
    2990   [ #  #  #  #  :          0 :             warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2991         [ #  # ]:          0 :                                _("This is the minimum transaction fee you pay on every transaction."));
    2992                 :          0 :         }
    2993                 :            : 
    2994   [ #  #  #  # ]:          0 :         walletInstance->m_min_fee = CFeeRate{min_tx_fee.value()};
    2995                 :          0 :     }
    2996                 :            : 
    2997   [ #  #  #  #  :          0 :     if (args.IsArgSet("-maxapsfee")) {
                   #  # ]
    2998   [ #  #  #  #  :          0 :         const std::string max_aps_fee{args.GetArg("-maxapsfee", "")};
                   #  # ]
    2999   [ #  #  #  # ]:          0 :         if (max_aps_fee == "-1") {
    3000                 :          0 :             walletInstance->m_max_aps_fee = -1;
    3001   [ #  #  #  # ]:          0 :         } else if (std::optional<CAmount> max_fee = ParseMoney(max_aps_fee)) {
    3002   [ #  #  #  # ]:          0 :             if (max_fee.value() > HIGH_APS_FEE) {
    3003   [ #  #  #  #  :          0 :                 warnings.push_back(AmountHighWarn("-maxapsfee") + Untranslated(" ") +
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3004         [ #  # ]:          0 :                                   _("This is the maximum transaction fee you pay (in addition to the normal fee) to prioritize partial spend avoidance over regular coin selection."));
    3005                 :          0 :             }
    3006         [ #  # ]:          0 :             walletInstance->m_max_aps_fee = max_fee.value();
    3007                 :          0 :         } else {
    3008   [ #  #  #  # ]:          0 :             error = AmountErrMsg("maxapsfee", max_aps_fee);
    3009                 :          0 :             return nullptr;
    3010                 :            :         }
    3011         [ #  # ]:          0 :     }
    3012                 :            : 
    3013   [ #  #  #  #  :          0 :     if (args.IsArgSet("-fallbackfee")) {
                   #  # ]
    3014   [ #  #  #  #  :          0 :         std::optional<CAmount> fallback_fee = ParseMoney(args.GetArg("-fallbackfee", ""));
             #  #  #  # ]
    3015         [ #  # ]:          0 :         if (!fallback_fee) {
    3016   [ #  #  #  #  :          0 :             error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-fallbackfee", args.GetArg("-fallbackfee", ""));
          #  #  #  #  #  
                      # ]
    3017                 :          0 :             return nullptr;
    3018   [ #  #  #  # ]:          0 :         } else if (fallback_fee.value() > HIGH_TX_FEE_PER_KB) {
    3019   [ #  #  #  #  :          0 :             warnings.push_back(AmountHighWarn("-fallbackfee") + Untranslated(" ") +
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3020         [ #  # ]:          0 :                                _("This is the transaction fee you may pay when fee estimates are not available."));
    3021                 :          0 :         }
    3022   [ #  #  #  # ]:          0 :         walletInstance->m_fallback_fee = CFeeRate{fallback_fee.value()};
    3023                 :          0 :     }
    3024                 :            : 
    3025                 :            :     // Disable fallback fee in case value was set to 0, enable if non-null value
    3026         [ #  # ]:          0 :     walletInstance->m_allow_fallback_fee = walletInstance->m_fallback_fee.GetFeePerK() != 0;
    3027                 :            : 
    3028   [ #  #  #  #  :          0 :     if (args.IsArgSet("-discardfee")) {
                   #  # ]
    3029   [ #  #  #  #  :          0 :         std::optional<CAmount> discard_fee = ParseMoney(args.GetArg("-discardfee", ""));
             #  #  #  # ]
    3030         [ #  # ]:          0 :         if (!discard_fee) {
    3031   [ #  #  #  #  :          0 :             error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-discardfee", args.GetArg("-discardfee", ""));
          #  #  #  #  #  
                      # ]
    3032                 :          0 :             return nullptr;
    3033   [ #  #  #  # ]:          0 :         } else if (discard_fee.value() > HIGH_TX_FEE_PER_KB) {
    3034   [ #  #  #  #  :          0 :             warnings.push_back(AmountHighWarn("-discardfee") + Untranslated(" ") +
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3035         [ #  # ]:          0 :                                _("This is the transaction fee you may discard if change is smaller than dust at this level"));
    3036                 :          0 :         }
    3037   [ #  #  #  # ]:          0 :         walletInstance->m_discard_rate = CFeeRate{discard_fee.value()};
    3038                 :          0 :     }
    3039                 :            : 
    3040   [ #  #  #  #  :          0 :     if (args.IsArgSet("-paytxfee")) {
                   #  # ]
    3041   [ #  #  #  #  :          0 :         std::optional<CAmount> pay_tx_fee = ParseMoney(args.GetArg("-paytxfee", ""));
             #  #  #  # ]
    3042         [ #  # ]:          0 :         if (!pay_tx_fee) {
    3043   [ #  #  #  #  :          0 :             error = AmountErrMsg("paytxfee", args.GetArg("-paytxfee", ""));
          #  #  #  #  #  
                      # ]
    3044                 :          0 :             return nullptr;
    3045   [ #  #  #  # ]:          0 :         } else if (pay_tx_fee.value() > HIGH_TX_FEE_PER_KB) {
    3046   [ #  #  #  #  :          0 :             warnings.push_back(AmountHighWarn("-paytxfee") + Untranslated(" ") +
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3047         [ #  # ]:          0 :                                _("This is the transaction fee you will pay if you send a transaction."));
    3048                 :          0 :         }
    3049                 :            : 
    3050   [ #  #  #  # ]:          0 :         walletInstance->m_pay_tx_fee = CFeeRate{pay_tx_fee.value(), 1000};
    3051                 :            : 
    3052   [ #  #  #  #  :          0 :         if (chain && walletInstance->m_pay_tx_fee < chain->relayMinFee()) {
             #  #  #  # ]
    3053   [ #  #  #  # ]:          0 :             error = strprintf(_("Invalid amount for %s=<amount>: '%s' (must be at least %s)"),
    3054   [ #  #  #  #  :          0 :                 "-paytxfee", args.GetArg("-paytxfee", ""), chain->relayMinFee().ToString());
          #  #  #  #  #  
                      # ]
    3055                 :          0 :             return nullptr;
    3056                 :            :         }
    3057                 :          0 :     }
    3058                 :            : 
    3059   [ #  #  #  #  :          0 :     if (args.IsArgSet("-maxtxfee")) {
                   #  # ]
    3060   [ #  #  #  #  :          0 :         std::optional<CAmount> max_fee = ParseMoney(args.GetArg("-maxtxfee", ""));
             #  #  #  # ]
    3061         [ #  # ]:          0 :         if (!max_fee) {
    3062   [ #  #  #  #  :          0 :             error = AmountErrMsg("maxtxfee", args.GetArg("-maxtxfee", ""));
          #  #  #  #  #  
                      # ]
    3063                 :          0 :             return nullptr;
    3064   [ #  #  #  # ]:          0 :         } else if (max_fee.value() > HIGH_MAX_TX_FEE) {
    3065   [ #  #  #  #  :          0 :             warnings.push_back(strprintf(_("%s is set very high! Fees this large could be paid on a single transaction."), "-maxtxfee"));
                   #  # ]
    3066                 :          0 :         }
    3067                 :            : 
    3068   [ #  #  #  #  :          0 :         if (chain && CFeeRate{max_fee.value(), 1000} < chain->relayMinFee()) {
          #  #  #  #  #  
                #  #  # ]
    3069   [ #  #  #  # ]:          0 :             error = strprintf(_("Invalid amount for %s=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions)"),
    3070   [ #  #  #  #  :          0 :                 "-maxtxfee", args.GetArg("-maxtxfee", ""), chain->relayMinFee().ToString());
          #  #  #  #  #  
                      # ]
    3071                 :          0 :             return nullptr;
    3072                 :            :         }
    3073                 :            : 
    3074         [ #  # ]:          0 :         walletInstance->m_default_max_tx_fee = max_fee.value();
    3075                 :          0 :     }
    3076                 :            : 
    3077   [ #  #  #  #  :          0 :     if (args.IsArgSet("-consolidatefeerate")) {
                   #  # ]
    3078   [ #  #  #  #  :          0 :         if (std::optional<CAmount> consolidate_feerate = ParseMoney(args.GetArg("-consolidatefeerate", ""))) {
          #  #  #  #  #  
                      # ]
    3079   [ #  #  #  # ]:          0 :             walletInstance->m_consolidate_feerate = CFeeRate(*consolidate_feerate);
    3080                 :          0 :         } else {
    3081   [ #  #  #  #  :          0 :             error = AmountErrMsg("consolidatefeerate", args.GetArg("-consolidatefeerate", ""));
          #  #  #  #  #  
                      # ]
    3082                 :          0 :             return nullptr;
    3083                 :            :         }
    3084                 :          0 :     }
    3085                 :            : 
    3086   [ #  #  #  #  :          0 :     if (chain && chain->relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
             #  #  #  # ]
    3087   [ #  #  #  #  :          0 :         warnings.push_back(AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    3088         [ #  # ]:          0 :                            _("The wallet will avoid paying less than the minimum relay fee."));
    3089                 :          0 :     }
    3090                 :            : 
    3091   [ #  #  #  # ]:          0 :     walletInstance->m_confirm_target = args.GetIntArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
    3092   [ #  #  #  # ]:          0 :     walletInstance->m_spend_zero_conf_change = args.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
    3093   [ #  #  #  # ]:          0 :     walletInstance->m_signal_rbf = args.GetBoolArg("-walletrbf", DEFAULT_WALLET_RBF);
    3094                 :            : 
    3095   [ #  #  #  #  :          0 :     walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
                   #  # ]
    3096                 :            : 
    3097                 :            :     // Try to top up keypool. No-op if the wallet is locked.
    3098         [ #  # ]:          0 :     walletInstance->TopUpKeyPool();
    3099                 :            : 
    3100                 :            :     // Cache the first key time
    3101                 :          0 :     std::optional<int64_t> time_first_key;
    3102   [ #  #  #  # ]:          0 :     for (auto spk_man : walletInstance->GetAllScriptPubKeyMans()) {
    3103         [ #  # ]:          0 :         int64_t time = spk_man->GetTimeFirstKey();
    3104   [ #  #  #  #  :          0 :         if (!time_first_key || time < *time_first_key) time_first_key = time;
             #  #  #  # ]
    3105                 :            :     }
    3106   [ #  #  #  # ]:          0 :     if (time_first_key) walletInstance->m_birth_time = *time_first_key;
    3107                 :            : 
    3108   [ #  #  #  #  :          0 :     if (chain && !AttachChain(walletInstance, *chain, rescan_required, error, warnings)) {
                   #  # ]
    3109                 :          0 :         return nullptr;
    3110                 :            :     }
    3111                 :            : 
    3112                 :            :     {
    3113   [ #  #  #  # ]:          0 :         LOCK(walletInstance->cs_wallet);
    3114   [ #  #  #  #  :          0 :         walletInstance->SetBroadcastTransactions(args.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
                   #  # ]
    3115   [ #  #  #  # ]:          0 :         walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n",      walletInstance->GetKeyPoolSize());
    3116         [ #  # ]:          0 :         walletInstance->WalletLogPrintf("mapWallet.size() = %u\n",       walletInstance->mapWallet.size());
    3117         [ #  # ]:          0 :         walletInstance->WalletLogPrintf("m_address_book.size() = %u\n",  walletInstance->m_address_book.size());
    3118                 :          0 :     }
    3119                 :            : 
    3120                 :          0 :     return walletInstance;
    3121                 :          0 : }
    3122                 :            : 
    3123                 :          0 : bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interfaces::Chain& chain, const bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings)
    3124                 :            : {
    3125                 :          0 :     LOCK(walletInstance->cs_wallet);
    3126                 :            :     // allow setting the chain if it hasn't been set already but prevent changing it
    3127   [ #  #  #  # ]:          0 :     assert(!walletInstance->m_chain || walletInstance->m_chain == &chain);
    3128                 :          0 :     walletInstance->m_chain = &chain;
    3129                 :            : 
    3130                 :            :     // Unless allowed, ensure wallet files are not reused across chains:
    3131   [ #  #  #  #  :          0 :     if (!gArgs.GetBoolArg("-walletcrosschain", DEFAULT_WALLETCROSSCHAIN)) {
                   #  # ]
    3132   [ #  #  #  # ]:          0 :         WalletBatch batch(walletInstance->GetDatabase());
    3133         [ #  # ]:          0 :         CBlockLocator locator;
    3134   [ #  #  #  #  :          0 :         if (batch.ReadBestBlock(locator) && locator.vHave.size() > 0 && chain.getHeight()) {
          #  #  #  #  #  
                      # ]
    3135                 :            :             // Wallet is assumed to be from another chain, if genesis block in the active
    3136                 :            :             // chain differs from the genesis block known to the wallet.
    3137   [ #  #  #  #  :          0 :             if (chain.getBlockHash(0) != locator.vHave.back()) {
                   #  # ]
    3138   [ #  #  #  # ]:          0 :                 error = Untranslated("Wallet files should not be reused across chains. Restart bitcoind with -walletcrosschain to override.");
    3139                 :          0 :                 return false;
    3140                 :            :             }
    3141                 :          0 :         }
    3142         [ #  # ]:          0 :     }
    3143                 :            : 
    3144                 :            :     // Register wallet with validationinterface. It's done before rescan to avoid
    3145                 :            :     // missing block connections between end of rescan and validation subscribing.
    3146                 :            :     // Because of wallet lock being hold, block connection notifications are going to
    3147                 :            :     // be pending on the validation-side until lock release. It's likely to have
    3148                 :            :     // block processing duplicata (if rescan block range overlaps with notification one)
    3149                 :            :     // but we guarantee at least than wallet state is correct after notifications delivery.
    3150                 :            :     // However, chainStateFlushed notifications are ignored until the rescan is finished
    3151                 :            :     // so that in case of a shutdown event, the rescan will be repeated at the next start.
    3152                 :            :     // This is temporary until rescan and notifications delivery are unified under same
    3153                 :            :     // interface.
    3154                 :          0 :     walletInstance->m_attaching_chain = true; //ignores chainStateFlushed notifications
    3155   [ #  #  #  # ]:          0 :     walletInstance->m_chain_notifications_handler = walletInstance->chain().handleNotifications(walletInstance);
    3156                 :            : 
    3157                 :            :     // If rescan_required = true, rescan_height remains equal to 0
    3158                 :          0 :     int rescan_height = 0;
    3159         [ #  # ]:          0 :     if (!rescan_required)
    3160                 :            :     {
    3161   [ #  #  #  # ]:          0 :         WalletBatch batch(walletInstance->GetDatabase());
    3162         [ #  # ]:          0 :         CBlockLocator locator;
    3163   [ #  #  #  # ]:          0 :         if (batch.ReadBestBlock(locator)) {
    3164   [ #  #  #  # ]:          0 :             if (const std::optional<int> fork_height = chain.findLocatorFork(locator)) {
    3165         [ #  # ]:          0 :                 rescan_height = *fork_height;
    3166                 :          0 :             }
    3167                 :          0 :         }
    3168                 :          0 :     }
    3169                 :            : 
    3170         [ #  # ]:          0 :     const std::optional<int> tip_height = chain.getHeight();
    3171         [ #  # ]:          0 :     if (tip_height) {
    3172   [ #  #  #  # ]:          0 :         walletInstance->m_last_block_processed = chain.getBlockHash(*tip_height);
    3173         [ #  # ]:          0 :         walletInstance->m_last_block_processed_height = *tip_height;
    3174                 :          0 :     } else {
    3175         [ #  # ]:          0 :         walletInstance->m_last_block_processed.SetNull();
    3176                 :          0 :         walletInstance->m_last_block_processed_height = -1;
    3177                 :            :     }
    3178                 :            : 
    3179   [ #  #  #  #  :          0 :     if (tip_height && *tip_height != rescan_height)
                   #  # ]
    3180                 :            :     {
    3181                 :            :         // No need to read and scan block if block was created before
    3182                 :            :         // our wallet birthday (as adjusted for block time variability)
    3183         [ #  # ]:          0 :         std::optional<int64_t> time_first_key = walletInstance->m_birth_time.load();
    3184         [ #  # ]:          0 :         if (time_first_key) {
    3185         [ #  # ]:          0 :             FoundBlock found = FoundBlock().height(rescan_height);
    3186   [ #  #  #  # ]:          0 :             chain.findFirstBlockWithTimeAndHeight(*time_first_key - TIMESTAMP_WINDOW, rescan_height, found);
    3187         [ #  # ]:          0 :             if (!found.found) {
    3188                 :            :                 // We were unable to find a block that had a time more recent than our earliest timestamp
    3189                 :            :                 // or a height higher than the wallet was synced to, indicating that the wallet is newer than the
    3190                 :            :                 // current chain tip. Skip rescanning in this case.
    3191         [ #  # ]:          0 :                 rescan_height = *tip_height;
    3192                 :          0 :             }
    3193                 :          0 :         }
    3194                 :            : 
    3195                 :            :         // Technically we could execute the code below in any case, but performing the
    3196                 :            :         // `while` loop below can make startup very slow, so only check blocks on disk
    3197                 :            :         // if necessary.
    3198   [ #  #  #  #  :          0 :         if (chain.havePruned() || chain.hasAssumedValidChain()) {
                   #  # ]
    3199         [ #  # ]:          0 :             int block_height = *tip_height;
    3200   [ #  #  #  #  :          0 :             while (block_height > 0 && chain.haveBlockOnDisk(block_height - 1) && rescan_height != block_height) {
             #  #  #  # ]
    3201                 :          0 :                 --block_height;
    3202                 :            :             }
    3203                 :            : 
    3204         [ #  # ]:          0 :             if (rescan_height != block_height) {
    3205                 :            :                 // We can't rescan beyond blocks we don't have data for, stop and throw an error.
    3206                 :            :                 // This might happen if a user uses an old wallet within a pruned node
    3207                 :            :                 // or if they ran -disablewallet for a longer time, then decided to re-enable
    3208                 :            :                 // Exit early and print an error.
    3209                 :            :                 // It also may happen if an assumed-valid chain is in use and therefore not
    3210                 :            :                 // all block data is available.
    3211                 :            :                 // If a block is pruned after this check, we will load the wallet,
    3212                 :            :                 // but fail the rescan with a generic error.
    3213                 :            : 
    3214   [ #  #  #  #  :          0 :                 error = chain.havePruned() ?
             #  #  #  # ]
    3215         [ #  # ]:          0 :                      _("Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of pruned node)") :
    3216   [ #  #  #  # ]:          0 :                      strprintf(_(
    3217                 :            :                         "Error loading wallet. Wallet requires blocks to be downloaded, "
    3218                 :            :                         "and software does not currently support loading wallets while "
    3219                 :            :                         "blocks are being downloaded out of order when using assumeutxo "
    3220                 :            :                         "snapshots. Wallet should be able to load successfully after "
    3221                 :            :                         "node sync reaches height %s"), block_height);
    3222                 :          0 :                 return false;
    3223                 :            :             }
    3224                 :          0 :         }
    3225                 :            : 
    3226   [ #  #  #  # ]:          0 :         chain.initMessage(_("Rescanning…").translated);
    3227   [ #  #  #  # ]:          0 :         walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...\n", *tip_height - rescan_height, rescan_height);
    3228                 :            : 
    3229                 :            :         {
    3230         [ #  # ]:          0 :             WalletRescanReserver reserver(*walletInstance);
    3231   [ #  #  #  #  :          0 :             if (!reserver.reserve() || (ScanResult::SUCCESS != walletInstance->ScanForWalletTransactions(chain.getBlockHash(rescan_height), rescan_height, /*max_height=*/{}, reserver, /*fUpdate=*/true, /*save_progress=*/true).status)) {
          #  #  #  #  #  
                      # ]
    3232         [ #  # ]:          0 :                 error = _("Failed to rescan the wallet during initialization");
    3233                 :          0 :                 return false;
    3234                 :            :             }
    3235         [ #  # ]:          0 :         }
    3236                 :          0 :         walletInstance->m_attaching_chain = false;
    3237   [ #  #  #  # ]:          0 :         walletInstance->chainStateFlushed(ChainstateRole::NORMAL, chain.getTipLocator());
    3238   [ #  #  #  # ]:          0 :         walletInstance->GetDatabase().IncrementUpdateCounter();
    3239                 :          0 :     }
    3240                 :          0 :     walletInstance->m_attaching_chain = false;
    3241                 :            : 
    3242                 :          0 :     return true;
    3243                 :          0 : }
    3244                 :            : 
    3245                 :          0 : const CAddressBookData* CWallet::FindAddressBookEntry(const CTxDestination& dest, bool allow_change) const
    3246                 :            : {
    3247                 :          0 :     const auto& address_book_it = m_address_book.find(dest);
    3248         [ #  # ]:          0 :     if (address_book_it == m_address_book.end()) return nullptr;
    3249   [ #  #  #  # ]:          0 :     if ((!allow_change) && address_book_it->second.IsChange()) {
    3250                 :          0 :         return nullptr;
    3251                 :            :     }
    3252                 :          0 :     return &address_book_it->second;
    3253                 :          0 : }
    3254                 :            : 
    3255                 :          0 : bool CWallet::UpgradeWallet(int version, bilingual_str& error)
    3256                 :            : {
    3257                 :          0 :     int prev_version = GetVersion();
    3258         [ #  # ]:          0 :     if (version == 0) {
    3259                 :          0 :         WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
    3260                 :          0 :         version = FEATURE_LATEST;
    3261                 :          0 :     } else {
    3262                 :          0 :         WalletLogPrintf("Allowing wallet upgrade up to %i\n", version);
    3263                 :            :     }
    3264         [ #  # ]:          0 :     if (version < prev_version) {
    3265         [ #  # ]:          0 :         error = strprintf(_("Cannot downgrade wallet from version %i to version %i. Wallet version unchanged."), prev_version, version);
    3266                 :          0 :         return false;
    3267                 :            :     }
    3268                 :            : 
    3269                 :          0 :     LOCK(cs_wallet);
    3270                 :            : 
    3271                 :            :     // Do not upgrade versions to any version between HD_SPLIT and FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
    3272   [ #  #  #  #  :          0 :     if (!CanSupportFeature(FEATURE_HD_SPLIT) && version >= FEATURE_HD_SPLIT && version < FEATURE_PRE_SPLIT_KEYPOOL) {
             #  #  #  # ]
    3273   [ #  #  #  # ]:          0 :         error = strprintf(_("Cannot upgrade a non HD split wallet from version %i to version %i without upgrading to support pre-split keypool. Please use version %i or no version specified."), prev_version, version, FEATURE_PRE_SPLIT_KEYPOOL);
    3274                 :          0 :         return false;
    3275                 :            :     }
    3276                 :            : 
    3277                 :            :     // Permanently upgrade to the version
    3278   [ #  #  #  # ]:          0 :     SetMinVersion(GetClosestWalletFeature(version));
    3279                 :            : 
    3280   [ #  #  #  #  :          0 :     for (auto spk_man : GetActiveScriptPubKeyMans()) {
                   #  # ]
    3281   [ #  #  #  # ]:          0 :         if (!spk_man->Upgrade(prev_version, version, error)) {
    3282                 :          0 :             return false;
    3283                 :            :         }
    3284                 :            :     }
    3285                 :          0 :     return true;
    3286                 :          0 : }
    3287                 :            : 
    3288                 :          0 : void CWallet::postInitProcess()
    3289                 :            : {
    3290                 :            :     // Add wallet transactions that aren't already in a block to mempool
    3291                 :            :     // Do this here as mempool requires genesis block to be loaded
    3292                 :          0 :     ResubmitWalletTransactions(/*relay=*/false, /*force=*/true);
    3293                 :            : 
    3294                 :            :     // Update wallet transactions with current mempool transactions.
    3295         [ #  # ]:          0 :     WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
    3296                 :          0 : }
    3297                 :            : 
    3298                 :          0 : bool CWallet::BackupWallet(const std::string& strDest) const
    3299                 :            : {
    3300                 :          0 :     return GetDatabase().Backup(strDest);
    3301                 :            : }
    3302                 :            : 
    3303                 :          0 : CKeyPool::CKeyPool()
    3304                 :            : {
    3305                 :          0 :     nTime = GetTime();
    3306                 :          0 :     fInternal = false;
    3307                 :          0 :     m_pre_split = false;
    3308                 :          0 : }
    3309                 :            : 
    3310                 :          0 : CKeyPool::CKeyPool(const CPubKey& vchPubKeyIn, bool internalIn)
    3311                 :            : {
    3312                 :          0 :     nTime = GetTime();
    3313                 :          0 :     vchPubKey = vchPubKeyIn;
    3314                 :          0 :     fInternal = internalIn;
    3315                 :          0 :     m_pre_split = false;
    3316                 :          0 : }
    3317                 :            : 
    3318                 :          0 : int CWallet::GetTxDepthInMainChain(const CWalletTx& wtx) const
    3319                 :            : {
    3320                 :          0 :     AssertLockHeld(cs_wallet);
    3321         [ #  # ]:          0 :     if (auto* conf = wtx.state<TxStateConfirmed>()) {
    3322                 :          0 :         return GetLastBlockHeight() - conf->confirmed_block_height + 1;
    3323         [ #  # ]:          0 :     } else if (auto* conf = wtx.state<TxStateConflicted>()) {
    3324                 :          0 :         return -1 * (GetLastBlockHeight() - conf->conflicting_block_height + 1);
    3325                 :            :     } else {
    3326                 :          0 :         return 0;
    3327                 :            :     }
    3328                 :          0 : }
    3329                 :            : 
    3330                 :          0 : int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
    3331                 :            : {
    3332                 :          0 :     AssertLockHeld(cs_wallet);
    3333                 :            : 
    3334         [ #  # ]:          0 :     if (!wtx.IsCoinBase()) {
    3335                 :          0 :         return 0;
    3336                 :            :     }
    3337                 :          0 :     int chain_depth = GetTxDepthInMainChain(wtx);
    3338         [ #  # ]:          0 :     assert(chain_depth >= 0); // coinbase tx should not be conflicted
    3339                 :          0 :     return std::max(0, (COINBASE_MATURITY+1) - chain_depth);
    3340                 :          0 : }
    3341                 :            : 
    3342                 :          0 : bool CWallet::IsTxImmatureCoinBase(const CWalletTx& wtx) const
    3343                 :            : {
    3344                 :          0 :     AssertLockHeld(cs_wallet);
    3345                 :            : 
    3346                 :            :     // note GetBlocksToMaturity is 0 for non-coinbase tx
    3347                 :          0 :     return GetTxBlocksToMaturity(wtx) > 0;
    3348                 :            : }
    3349                 :            : 
    3350                 :          0 : bool CWallet::IsCrypted() const
    3351                 :            : {
    3352                 :          0 :     return HasEncryptionKeys();
    3353                 :            : }
    3354                 :            : 
    3355                 :          0 : bool CWallet::IsLocked() const
    3356                 :            : {
    3357         [ #  # ]:          0 :     if (!IsCrypted()) {
    3358                 :          0 :         return false;
    3359                 :            :     }
    3360                 :          0 :     LOCK(cs_wallet);
    3361                 :          0 :     return vMasterKey.empty();
    3362                 :          0 : }
    3363                 :            : 
    3364                 :          0 : bool CWallet::Lock()
    3365                 :            : {
    3366         [ #  # ]:          0 :     if (!IsCrypted())
    3367                 :          0 :         return false;
    3368                 :            : 
    3369                 :            :     {
    3370   [ #  #  #  # ]:          0 :         LOCK2(m_relock_mutex, cs_wallet);
    3371         [ #  # ]:          0 :         if (!vMasterKey.empty()) {
    3372         [ #  # ]:          0 :             memory_cleanse(vMasterKey.data(), vMasterKey.size() * sizeof(decltype(vMasterKey)::value_type));
    3373                 :          0 :             vMasterKey.clear();
    3374                 :          0 :         }
    3375                 :          0 :     }
    3376                 :            : 
    3377                 :          0 :     NotifyStatusChanged(this);
    3378                 :          0 :     return true;
    3379                 :          0 : }
    3380                 :            : 
    3381                 :          0 : bool CWallet::Unlock(const CKeyingMaterial& vMasterKeyIn, bool accept_no_keys)
    3382                 :            : {
    3383                 :            :     {
    3384                 :          0 :         LOCK(cs_wallet);
    3385         [ #  # ]:          0 :         for (const auto& spk_man_pair : m_spk_managers) {
    3386   [ #  #  #  # ]:          0 :             if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn, accept_no_keys)) {
    3387                 :          0 :                 return false;
    3388                 :            :             }
    3389                 :            :         }
    3390         [ #  # ]:          0 :         vMasterKey = vMasterKeyIn;
    3391      [ #  #  # ]:          0 :     }
    3392                 :          0 :     NotifyStatusChanged(this);
    3393                 :          0 :     return true;
    3394                 :          0 : }
    3395                 :            : 
    3396                 :          0 : std::set<ScriptPubKeyMan*> CWallet::GetActiveScriptPubKeyMans() const
    3397                 :            : {
    3398                 :          0 :     std::set<ScriptPubKeyMan*> spk_mans;
    3399         [ #  # ]:          0 :     for (bool internal : {false, true}) {
    3400         [ #  # ]:          0 :         for (OutputType t : OUTPUT_TYPES) {
    3401         [ #  # ]:          0 :             auto spk_man = GetScriptPubKeyMan(t, internal);
    3402         [ #  # ]:          0 :             if (spk_man) {
    3403         [ #  # ]:          0 :                 spk_mans.insert(spk_man);
    3404                 :          0 :             }
    3405                 :            :         }
    3406                 :            :     }
    3407                 :          0 :     return spk_mans;
    3408         [ #  # ]:          0 : }
    3409                 :            : 
    3410                 :          0 : std::set<ScriptPubKeyMan*> CWallet::GetAllScriptPubKeyMans() const
    3411                 :            : {
    3412                 :          0 :     std::set<ScriptPubKeyMan*> spk_mans;
    3413         [ #  # ]:          0 :     for (const auto& spk_man_pair : m_spk_managers) {
    3414         [ #  # ]:          0 :         spk_mans.insert(spk_man_pair.second.get());
    3415                 :            :     }
    3416                 :          0 :     return spk_mans;
    3417         [ #  # ]:          0 : }
    3418                 :            : 
    3419                 :          0 : ScriptPubKeyMan* CWallet::GetScriptPubKeyMan(const OutputType& type, bool internal) const
    3420                 :            : {
    3421         [ #  # ]:          0 :     const std::map<OutputType, ScriptPubKeyMan*>& spk_managers = internal ? m_internal_spk_managers : m_external_spk_managers;
    3422                 :          0 :     std::map<OutputType, ScriptPubKeyMan*>::const_iterator it = spk_managers.find(type);
    3423         [ #  # ]:          0 :     if (it == spk_managers.end()) {
    3424                 :          0 :         return nullptr;
    3425                 :            :     }
    3426                 :          0 :     return it->second;
    3427                 :          0 : }
    3428                 :            : 
    3429                 :          0 : std::set<ScriptPubKeyMan*> CWallet::GetScriptPubKeyMans(const CScript& script) const
    3430                 :            : {
    3431                 :          0 :     std::set<ScriptPubKeyMan*> spk_mans;
    3432         [ #  # ]:          0 :     SignatureData sigdata;
    3433         [ #  # ]:          0 :     for (const auto& spk_man_pair : m_spk_managers) {
    3434   [ #  #  #  # ]:          0 :         if (spk_man_pair.second->CanProvide(script, sigdata)) {
    3435         [ #  # ]:          0 :             spk_mans.insert(spk_man_pair.second.get());
    3436                 :          0 :         }
    3437                 :            :     }
    3438                 :          0 :     return spk_mans;
    3439         [ #  # ]:          0 : }
    3440                 :            : 
    3441                 :          0 : ScriptPubKeyMan* CWallet::GetScriptPubKeyMan(const uint256& id) const
    3442                 :            : {
    3443         [ #  # ]:          0 :     if (m_spk_managers.count(id) > 0) {
    3444                 :          0 :         return m_spk_managers.at(id).get();
    3445                 :            :     }
    3446                 :          0 :     return nullptr;
    3447                 :          0 : }
    3448                 :            : 
    3449                 :          0 : std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script) const
    3450                 :            : {
    3451                 :          0 :     SignatureData sigdata;
    3452         [ #  # ]:          0 :     return GetSolvingProvider(script, sigdata);
    3453                 :          0 : }
    3454                 :            : 
    3455                 :          0 : std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script, SignatureData& sigdata) const
    3456                 :            : {
    3457         [ #  # ]:          0 :     for (const auto& spk_man_pair : m_spk_managers) {
    3458         [ #  # ]:          0 :         if (spk_man_pair.second->CanProvide(script, sigdata)) {
    3459                 :          0 :             return spk_man_pair.second->GetSolvingProvider(script);
    3460                 :            :         }
    3461                 :            :     }
    3462                 :          0 :     return nullptr;
    3463                 :          0 : }
    3464                 :            : 
    3465                 :          0 : std::vector<WalletDescriptor> CWallet::GetWalletDescriptors(const CScript& script) const
    3466                 :            : {
    3467                 :          0 :     std::vector<WalletDescriptor> descs;
    3468   [ #  #  #  # ]:          0 :     for (const auto spk_man: GetScriptPubKeyMans(script)) {
    3469   [ #  #  #  # ]:          0 :         if (const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man)) {
    3470   [ #  #  #  # ]:          0 :             LOCK(desc_spk_man->cs_desc_man);
    3471   [ #  #  #  # ]:          0 :             descs.push_back(desc_spk_man->GetWalletDescriptor());
    3472                 :          0 :         }
    3473                 :            :     }
    3474                 :          0 :     return descs;
    3475         [ #  # ]:          0 : }
    3476                 :            : 
    3477                 :          0 : LegacyScriptPubKeyMan* CWallet::GetLegacyScriptPubKeyMan() const
    3478                 :            : {
    3479         [ #  # ]:          0 :     if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
    3480                 :          0 :         return nullptr;
    3481                 :            :     }
    3482                 :            :     // Legacy wallets only have one ScriptPubKeyMan which is a LegacyScriptPubKeyMan.
    3483                 :            :     // Everything in m_internal_spk_managers and m_external_spk_managers point to the same legacyScriptPubKeyMan.
    3484                 :          0 :     auto it = m_internal_spk_managers.find(OutputType::LEGACY);
    3485         [ #  # ]:          0 :     if (it == m_internal_spk_managers.end()) return nullptr;
    3486         [ #  # ]:          0 :     return dynamic_cast<LegacyScriptPubKeyMan*>(it->second);
    3487                 :          0 : }
    3488                 :            : 
    3489                 :          0 : LegacyScriptPubKeyMan* CWallet::GetOrCreateLegacyScriptPubKeyMan()
    3490                 :            : {
    3491                 :          0 :     SetupLegacyScriptPubKeyMan();
    3492                 :          0 :     return GetLegacyScriptPubKeyMan();
    3493                 :            : }
    3494                 :            : 
    3495                 :          0 : void CWallet::AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man)
    3496                 :            : {
    3497                 :          0 :     const auto& spkm = m_spk_managers[id] = std::move(spkm_man);
    3498                 :            : 
    3499                 :            :     // Update birth time if needed
    3500                 :          0 :     FirstKeyTimeChanged(spkm.get(), spkm->GetTimeFirstKey());
    3501                 :          0 : }
    3502                 :            : 
    3503                 :          0 : void CWallet::SetupLegacyScriptPubKeyMan()
    3504                 :            : {
    3505   [ #  #  #  #  :          0 :     if (!m_internal_spk_managers.empty() || !m_external_spk_managers.empty() || !m_spk_managers.empty() || IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
             #  #  #  # ]
    3506                 :          0 :         return;
    3507                 :            :     }
    3508                 :            : 
    3509         [ #  # ]:          0 :     auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(new LegacyScriptPubKeyMan(*this, m_keypool_size));
    3510         [ #  # ]:          0 :     for (const auto& type : LEGACY_OUTPUT_TYPES) {
    3511         [ #  # ]:          0 :         m_internal_spk_managers[type] = spk_manager.get();
    3512         [ #  # ]:          0 :         m_external_spk_managers[type] = spk_manager.get();
    3513                 :            :     }
    3514         [ #  # ]:          0 :     uint256 id = spk_manager->GetID();
    3515         [ #  # ]:          0 :     AddScriptPubKeyMan(id, std::move(spk_manager));
    3516                 :          0 : }
    3517                 :            : 
    3518                 :          0 : const CKeyingMaterial& CWallet::GetEncryptionKey() const
    3519                 :            : {
    3520                 :          0 :     return vMasterKey;
    3521                 :            : }
    3522                 :            : 
    3523                 :          0 : bool CWallet::HasEncryptionKeys() const
    3524                 :            : {
    3525                 :          0 :     return !mapMasterKeys.empty();
    3526                 :            : }
    3527                 :            : 
    3528                 :          0 : void CWallet::ConnectScriptPubKeyManNotifiers()
    3529                 :            : {
    3530         [ #  # ]:          0 :     for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
    3531   [ #  #  #  # ]:          0 :         spk_man->NotifyWatchonlyChanged.connect(NotifyWatchonlyChanged);
    3532   [ #  #  #  # ]:          0 :         spk_man->NotifyCanGetAddressesChanged.connect(NotifyCanGetAddressesChanged);
    3533   [ #  #  #  #  :          0 :         spk_man->NotifyFirstKeyTimeChanged.connect(std::bind(&CWallet::FirstKeyTimeChanged, this, std::placeholders::_1, std::placeholders::_2));
                   #  # ]
    3534                 :            :     }
    3535                 :          0 : }
    3536                 :            : 
    3537                 :          0 : void CWallet::LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor& desc)
    3538                 :            : {
    3539         [ #  # ]:          0 :     if (IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
    3540         [ #  # ]:          0 :         auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(new ExternalSignerScriptPubKeyMan(*this, desc, m_keypool_size));
    3541         [ #  # ]:          0 :         AddScriptPubKeyMan(id, std::move(spk_manager));
    3542                 :          0 :     } else {
    3543         [ #  # ]:          0 :         auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(new DescriptorScriptPubKeyMan(*this, desc, m_keypool_size));
    3544         [ #  # ]:          0 :         AddScriptPubKeyMan(id, std::move(spk_manager));
    3545                 :          0 :     }
    3546                 :          0 : }
    3547                 :            : 
    3548                 :          0 : void CWallet::SetupDescriptorScriptPubKeyMans(const CExtKey& master_key)
    3549                 :            : {
    3550                 :          0 :     AssertLockHeld(cs_wallet);
    3551                 :            : 
    3552         [ #  # ]:          0 :     for (bool internal : {false, true}) {
    3553         [ #  # ]:          0 :         for (OutputType t : OUTPUT_TYPES) {
    3554         [ #  # ]:          0 :             auto spk_manager = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(*this, m_keypool_size));
    3555   [ #  #  #  # ]:          0 :             if (IsCrypted()) {
    3556   [ #  #  #  # ]:          0 :                 if (IsLocked()) {
    3557   [ #  #  #  #  :          0 :                     throw std::runtime_error(std::string(__func__) + ": Wallet is locked, cannot setup new descriptors");
             #  #  #  # ]
    3558                 :            :                 }
    3559   [ #  #  #  #  :          0 :                 if (!spk_manager->CheckDecryptionKey(vMasterKey) && !spk_manager->Encrypt(vMasterKey, nullptr)) {
             #  #  #  # ]
    3560   [ #  #  #  #  :          0 :                     throw std::runtime_error(std::string(__func__) + ": Could not encrypt new descriptors");
             #  #  #  # ]
    3561                 :            :                 }
    3562                 :          0 :             }
    3563         [ #  # ]:          0 :             spk_manager->SetupDescriptorGeneration(master_key, t, internal);
    3564         [ #  # ]:          0 :             uint256 id = spk_manager->GetID();
    3565         [ #  # ]:          0 :             AddScriptPubKeyMan(id, std::move(spk_manager));
    3566         [ #  # ]:          0 :             AddActiveScriptPubKeyMan(id, t, internal);
    3567                 :          0 :         }
    3568                 :            :     }
    3569                 :          0 : }
    3570                 :            : 
    3571                 :          0 : void CWallet::SetupDescriptorScriptPubKeyMans()
    3572                 :            : {
    3573                 :          0 :     AssertLockHeld(cs_wallet);
    3574                 :            : 
    3575         [ #  # ]:          0 :     if (!IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
    3576                 :            :         // Make a seed
    3577                 :          0 :         CKey seed_key;
    3578         [ #  # ]:          0 :         seed_key.MakeNewKey(true);
    3579         [ #  # ]:          0 :         CPubKey seed = seed_key.GetPubKey();
    3580   [ #  #  #  # ]:          0 :         assert(seed_key.VerifyPubKey(seed));
    3581                 :            : 
    3582                 :            :         // Get the extended key
    3583         [ #  # ]:          0 :         CExtKey master_key;
    3584   [ #  #  #  # ]:          0 :         master_key.SetSeed(seed_key);
    3585                 :            : 
    3586         [ #  # ]:          0 :         SetupDescriptorScriptPubKeyMans(master_key);
    3587                 :          0 :     } else {
    3588                 :          0 :         ExternalSigner signer = ExternalSignerScriptPubKeyMan::GetExternalSigner();
    3589                 :            : 
    3590                 :            :         // TODO: add account parameter
    3591                 :          0 :         int account = 0;
    3592         [ #  # ]:          0 :         UniValue signer_res = signer.GetDescriptors(account);
    3593                 :            : 
    3594   [ #  #  #  #  :          0 :         if (!signer_res.isObject()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
          #  #  #  #  #  
                #  #  # ]
    3595         [ #  # ]:          0 :         for (bool internal : {false, true}) {
    3596         [ #  # ]:          0 :             const UniValue& descriptor_vals = signer_res.find_value(internal ? "internal" : "receive");
    3597   [ #  #  #  #  :          0 :             if (!descriptor_vals.isArray()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
          #  #  #  #  #  
                #  #  # ]
    3598   [ #  #  #  #  :          0 :             for (const UniValue& desc_val : descriptor_vals.get_array().getValues()) {
                   #  # ]
    3599         [ #  # ]:          0 :                 const std::string& desc_str = desc_val.getValStr();
    3600                 :          0 :                 FlatSigningProvider keys;
    3601                 :          0 :                 std::string desc_error;
    3602         [ #  # ]:          0 :                 std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, desc_error, false);
    3603         [ #  # ]:          0 :                 if (desc == nullptr) {
    3604   [ #  #  #  #  :          0 :                     throw std::runtime_error(std::string(__func__) + ": Invalid descriptor \"" + desc_str + "\" (" + desc_error + ")");
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    3605                 :            :                 }
    3606   [ #  #  #  # ]:          0 :                 if (!desc->GetOutputType()) {
    3607                 :          0 :                     continue;
    3608                 :            :                 }
    3609   [ #  #  #  # ]:          0 :                 OutputType t =  *desc->GetOutputType();
    3610   [ #  #  #  # ]:          0 :                 auto spk_manager = std::unique_ptr<ExternalSignerScriptPubKeyMan>(new ExternalSignerScriptPubKeyMan(*this, m_keypool_size));
    3611         [ #  # ]:          0 :                 spk_manager->SetupDescriptor(std::move(desc));
    3612         [ #  # ]:          0 :                 uint256 id = spk_manager->GetID();
    3613         [ #  # ]:          0 :                 AddScriptPubKeyMan(id, std::move(spk_manager));
    3614         [ #  # ]:          0 :                 AddActiveScriptPubKeyMan(id, t, internal);
    3615         [ #  # ]:          0 :             }
    3616                 :            :         }
    3617                 :          0 :     }
    3618                 :          0 : }
    3619                 :            : 
    3620                 :          0 : void CWallet::AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
    3621                 :            : {
    3622                 :          0 :     WalletBatch batch(GetDatabase());
    3623   [ #  #  #  # ]:          0 :     if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id, internal)) {
    3624   [ #  #  #  #  :          0 :         throw std::runtime_error(std::string(__func__) + ": writing active ScriptPubKeyMan id failed");
          #  #  #  #  #  
                      # ]
    3625                 :            :     }
    3626         [ #  # ]:          0 :     LoadActiveScriptPubKeyMan(id, type, internal);
    3627                 :          0 : }
    3628                 :            : 
    3629                 :          0 : void CWallet::LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
    3630                 :            : {
    3631                 :            :     // Activating ScriptPubKeyManager for a given output and change type is incompatible with legacy wallets.
    3632                 :            :     // Legacy wallets have only one ScriptPubKeyManager and it's active for all output and change types.
    3633                 :          0 :     Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
    3634                 :            : 
    3635   [ #  #  #  #  :          0 :     WalletLogPrintf("Setting spkMan to active: id = %s, type = %s, internal = %s\n", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
                   #  # ]
    3636         [ #  # ]:          0 :     auto& spk_mans = internal ? m_internal_spk_managers : m_external_spk_managers;
    3637         [ #  # ]:          0 :     auto& spk_mans_other = internal ? m_external_spk_managers : m_internal_spk_managers;
    3638                 :          0 :     auto spk_man = m_spk_managers.at(id).get();
    3639                 :          0 :     spk_mans[type] = spk_man;
    3640                 :            : 
    3641                 :          0 :     const auto it = spk_mans_other.find(type);
    3642   [ #  #  #  # ]:          0 :     if (it != spk_mans_other.end() && it->second == spk_man) {
    3643                 :          0 :         spk_mans_other.erase(type);
    3644                 :          0 :     }
    3645                 :            : 
    3646                 :          0 :     NotifyCanGetAddressesChanged();
    3647                 :          0 : }
    3648                 :            : 
    3649                 :          0 : void CWallet::DeactivateScriptPubKeyMan(uint256 id, OutputType type, bool internal)
    3650                 :            : {
    3651                 :          0 :     auto spk_man = GetScriptPubKeyMan(type, internal);
    3652   [ #  #  #  # ]:          0 :     if (spk_man != nullptr && spk_man->GetID() == id) {
    3653   [ #  #  #  #  :          0 :         WalletLogPrintf("Deactivate spkMan: id = %s, type = %s, internal = %s\n", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
                   #  # ]
    3654                 :          0 :         WalletBatch batch(GetDatabase());
    3655   [ #  #  #  # ]:          0 :         if (!batch.EraseActiveScriptPubKeyMan(static_cast<uint8_t>(type), internal)) {
    3656   [ #  #  #  #  :          0 :             throw std::runtime_error(std::string(__func__) + ": erasing active ScriptPubKeyMan id failed");
          #  #  #  #  #  
                      # ]
    3657                 :            :         }
    3658                 :            : 
    3659         [ #  # ]:          0 :         auto& spk_mans = internal ? m_internal_spk_managers : m_external_spk_managers;
    3660         [ #  # ]:          0 :         spk_mans.erase(type);
    3661                 :          0 :     }
    3662                 :            : 
    3663                 :          0 :     NotifyCanGetAddressesChanged();
    3664                 :          0 : }
    3665                 :            : 
    3666                 :          0 : bool CWallet::IsLegacy() const
    3667                 :            : {
    3668         [ #  # ]:          0 :     if (m_internal_spk_managers.count(OutputType::LEGACY) == 0) {
    3669                 :          0 :         return false;
    3670                 :            :     }
    3671         [ #  # ]:          0 :     auto spk_man = dynamic_cast<LegacyScriptPubKeyMan*>(m_internal_spk_managers.at(OutputType::LEGACY));
    3672                 :          0 :     return spk_man != nullptr;
    3673                 :          0 : }
    3674                 :            : 
    3675                 :          0 : DescriptorScriptPubKeyMan* CWallet::GetDescriptorScriptPubKeyMan(const WalletDescriptor& desc) const
    3676                 :            : {
    3677         [ #  # ]:          0 :     for (auto& spk_man_pair : m_spk_managers) {
    3678                 :            :         // Try to downcast to DescriptorScriptPubKeyMan then check if the descriptors match
    3679         [ #  # ]:          0 :         DescriptorScriptPubKeyMan* spk_manager = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man_pair.second.get());
    3680   [ #  #  #  # ]:          0 :         if (spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc)) {
    3681                 :          0 :             return spk_manager;
    3682                 :            :         }
    3683                 :            :     }
    3684                 :            : 
    3685                 :          0 :     return nullptr;
    3686                 :          0 : }
    3687                 :            : 
    3688                 :          0 : std::optional<bool> CWallet::IsInternalScriptPubKeyMan(ScriptPubKeyMan* spk_man) const
    3689                 :            : {
    3690                 :            :     // Legacy script pubkey man can't be either external or internal
    3691         [ #  # ]:          0 :     if (IsLegacy()) {
    3692                 :          0 :         return std::nullopt;
    3693                 :            :     }
    3694                 :            : 
    3695                 :            :     // only active ScriptPubKeyMan can be internal
    3696   [ #  #  #  # ]:          0 :     if (!GetActiveScriptPubKeyMans().count(spk_man)) {
    3697                 :          0 :         return std::nullopt;
    3698                 :            :     }
    3699                 :            : 
    3700         [ #  # ]:          0 :     const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
    3701         [ #  # ]:          0 :     if (!desc_spk_man) {
    3702   [ #  #  #  #  :          0 :         throw std::runtime_error(std::string(__func__) + ": unexpected ScriptPubKeyMan type.");
          #  #  #  #  #  
                      # ]
    3703                 :            :     }
    3704                 :            : 
    3705                 :          0 :     LOCK(desc_spk_man->cs_desc_man);
    3706   [ #  #  #  # ]:          0 :     const auto& type = desc_spk_man->GetWalletDescriptor().descriptor->GetOutputType();
    3707         [ #  # ]:          0 :     assert(type.has_value());
    3708                 :            : 
    3709   [ #  #  #  #  :          0 :     return GetScriptPubKeyMan(*type, /* internal= */ true) == desc_spk_man;
                   #  # ]
    3710                 :          0 : }
    3711                 :            : 
    3712                 :          0 : ScriptPubKeyMan* CWallet::AddWalletDescriptor(WalletDescriptor& desc, const FlatSigningProvider& signing_provider, const std::string& label, bool internal)
    3713                 :            : {
    3714                 :          0 :     AssertLockHeld(cs_wallet);
    3715                 :            : 
    3716         [ #  # ]:          0 :     if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
    3717                 :          0 :         WalletLogPrintf("Cannot add WalletDescriptor to a non-descriptor wallet\n");
    3718                 :          0 :         return nullptr;
    3719                 :            :     }
    3720                 :            : 
    3721                 :          0 :     auto spk_man = GetDescriptorScriptPubKeyMan(desc);
    3722         [ #  # ]:          0 :     if (spk_man) {
    3723         [ #  # ]:          0 :         WalletLogPrintf("Update existing descriptor: %s\n", desc.descriptor->ToString());
    3724                 :          0 :         spk_man->UpdateWalletDescriptor(desc);
    3725                 :          0 :     } else {
    3726         [ #  # ]:          0 :         auto new_spk_man = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(*this, desc, m_keypool_size));
    3727                 :          0 :         spk_man = new_spk_man.get();
    3728                 :            : 
    3729                 :            :         // Save the descriptor to memory
    3730         [ #  # ]:          0 :         uint256 id = new_spk_man->GetID();
    3731         [ #  # ]:          0 :         AddScriptPubKeyMan(id, std::move(new_spk_man));
    3732                 :          0 :     }
    3733                 :            : 
    3734                 :            :     // Add the private keys to the descriptor
    3735         [ #  # ]:          0 :     for (const auto& entry : signing_provider.keys) {
    3736                 :          0 :         const CKey& key = entry.second;
    3737                 :          0 :         spk_man->AddDescriptorKey(key, key.GetPubKey());
    3738                 :            :     }
    3739                 :            : 
    3740                 :            :     // Top up key pool, the manager will generate new scriptPubKeys internally
    3741         [ #  # ]:          0 :     if (!spk_man->TopUp()) {
    3742                 :          0 :         WalletLogPrintf("Could not top up scriptPubKeys\n");
    3743                 :          0 :         return nullptr;
    3744                 :            :     }
    3745                 :            : 
    3746                 :            :     // Apply the label if necessary
    3747                 :            :     // Note: we disable labels for ranged descriptors
    3748         [ #  # ]:          0 :     if (!desc.descriptor->IsRange()) {
    3749                 :          0 :         auto script_pub_keys = spk_man->GetScriptPubKeys();
    3750         [ #  # ]:          0 :         if (script_pub_keys.empty()) {
    3751         [ #  # ]:          0 :             WalletLogPrintf("Could not generate scriptPubKeys (cache is empty)\n");
    3752                 :          0 :             return nullptr;
    3753                 :            :         }
    3754                 :            : 
    3755         [ #  # ]:          0 :         if (!internal) {
    3756         [ #  # ]:          0 :             for (const auto& script : script_pub_keys) {
    3757         [ #  # ]:          0 :                 CTxDestination dest;
    3758   [ #  #  #  # ]:          0 :                 if (ExtractDestination(script, dest)) {
    3759   [ #  #  #  # ]:          0 :                     SetAddressBook(dest, label, AddressPurpose::RECEIVE);
    3760                 :          0 :                 }
    3761                 :          0 :             }
    3762                 :          0 :         }
    3763      [ #  #  # ]:          0 :     }
    3764                 :            : 
    3765                 :            :     // Save the descriptor to DB
    3766                 :          0 :     spk_man->WriteDescriptor();
    3767                 :            : 
    3768                 :          0 :     return spk_man;
    3769                 :          0 : }
    3770                 :            : 
    3771                 :          0 : bool CWallet::MigrateToSQLite(bilingual_str& error)
    3772                 :            : {
    3773                 :          0 :     AssertLockHeld(cs_wallet);
    3774                 :            : 
    3775                 :          0 :     WalletLogPrintf("Migrating wallet storage database from BerkeleyDB to SQLite.\n");
    3776                 :            : 
    3777   [ #  #  #  # ]:          0 :     if (m_database->Format() == "sqlite") {
    3778                 :          0 :         error = _("Error: This wallet already uses SQLite");
    3779                 :          0 :         return false;
    3780                 :            :     }
    3781                 :            : 
    3782                 :            :     // Get all of the records for DB type migration
    3783                 :          0 :     std::unique_ptr<DatabaseBatch> batch = m_database->MakeBatch();
    3784         [ #  # ]:          0 :     std::unique_ptr<DatabaseCursor> cursor = batch->GetNewCursor();
    3785                 :          0 :     std::vector<std::pair<SerializeData, SerializeData>> records;
    3786         [ #  # ]:          0 :     if (!cursor) {
    3787         [ #  # ]:          0 :         error = _("Error: Unable to begin reading all records in the database");
    3788                 :          0 :         return false;
    3789                 :            :     }
    3790                 :          0 :     DatabaseCursor::Status status = DatabaseCursor::Status::FAIL;
    3791                 :          0 :     while (true) {
    3792         [ #  # ]:          0 :         DataStream ss_key{};
    3793         [ #  # ]:          0 :         DataStream ss_value{};
    3794         [ #  # ]:          0 :         status = cursor->Next(ss_key, ss_value);
    3795         [ #  # ]:          0 :         if (status != DatabaseCursor::Status::MORE) {
    3796                 :          0 :             break;
    3797                 :            :         }
    3798   [ #  #  #  #  :          0 :         SerializeData key(ss_key.begin(), ss_key.end());
                   #  # ]
    3799   [ #  #  #  #  :          0 :         SerializeData value(ss_value.begin(), ss_value.end());
                   #  # ]
    3800         [ #  # ]:          0 :         records.emplace_back(key, value);
    3801      [ #  #  # ]:          0 :     }
    3802                 :          0 :     cursor.reset();
    3803                 :          0 :     batch.reset();
    3804         [ #  # ]:          0 :     if (status != DatabaseCursor::Status::DONE) {
    3805         [ #  # ]:          0 :         error = _("Error: Unable to read all records in the database");
    3806                 :          0 :         return false;
    3807                 :            :     }
    3808                 :            : 
    3809                 :            :     // Close this database and delete the file
    3810   [ #  #  #  # ]:          0 :     fs::path db_path = fs::PathFromString(m_database->Filename());
    3811         [ #  # ]:          0 :     m_database->Close();
    3812         [ #  # ]:          0 :     fs::remove(db_path);
    3813                 :            : 
    3814                 :            :     // Generate the path for the location of the migrated wallet
    3815                 :            :     // Wallets that are plain files rather than wallet directories will be migrated to be wallet directories.
    3816   [ #  #  #  #  :          0 :     const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(m_name));
                   #  # ]
    3817                 :            : 
    3818                 :            :     // Make new DB
    3819                 :          0 :     DatabaseOptions opts;
    3820                 :          0 :     opts.require_create = true;
    3821         [ #  # ]:          0 :     opts.require_format = DatabaseFormat::SQLITE;
    3822                 :            :     DatabaseStatus db_status;
    3823         [ #  # ]:          0 :     std::unique_ptr<WalletDatabase> new_db = MakeDatabase(wallet_path, opts, db_status, error);
    3824         [ #  # ]:          0 :     assert(new_db); // This is to prevent doing anything further with this wallet. The original file was deleted, but a backup exists.
    3825                 :          0 :     m_database.reset();
    3826                 :          0 :     m_database = std::move(new_db);
    3827                 :            : 
    3828                 :            :     // Write existing records into the new DB
    3829         [ #  # ]:          0 :     batch = m_database->MakeBatch();
    3830         [ #  # ]:          0 :     bool began = batch->TxnBegin();
    3831         [ #  # ]:          0 :     assert(began); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
    3832         [ #  # ]:          0 :     for (const auto& [key, value] : records) {
    3833   [ #  #  #  #  :          0 :         if (!batch->Write(Span{key}, Span{value})) {
          #  #  #  #  #  
                      # ]
    3834         [ #  # ]:          0 :             batch->TxnAbort();
    3835         [ #  # ]:          0 :             m_database->Close();
    3836   [ #  #  #  #  :          0 :             fs::remove(m_database->Filename());
                   #  # ]
    3837                 :          0 :             assert(false); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
    3838                 :            :         }
    3839                 :            :     }
    3840         [ #  # ]:          0 :     bool committed = batch->TxnCommit();
    3841         [ #  # ]:          0 :     assert(committed); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
    3842                 :          0 :     return true;
    3843                 :          0 : }
    3844                 :            : 
    3845                 :          0 : std::optional<MigrationData> CWallet::GetDescriptorsForLegacy(bilingual_str& error) const
    3846                 :            : {
    3847                 :          0 :     AssertLockHeld(cs_wallet);
    3848                 :            : 
    3849                 :          0 :     LegacyScriptPubKeyMan* legacy_spkm = GetLegacyScriptPubKeyMan();
    3850         [ #  # ]:          0 :     assert(legacy_spkm);
    3851                 :            : 
    3852                 :          0 :     std::optional<MigrationData> res = legacy_spkm->MigrateToDescriptor();
    3853         [ #  # ]:          0 :     if (res == std::nullopt) {
    3854         [ #  # ]:          0 :         error = _("Error: Unable to produce descriptors for this legacy wallet. Make sure to provide the wallet's passphrase if it is encrypted.");
    3855                 :          0 :         return std::nullopt;
    3856                 :            :     }
    3857                 :          0 :     return res;
    3858                 :          0 : }
    3859                 :            : 
    3860                 :          0 : bool CWallet::ApplyMigrationData(MigrationData& data, bilingual_str& error)
    3861                 :            : {
    3862                 :          0 :     AssertLockHeld(cs_wallet);
    3863                 :            : 
    3864                 :          0 :     LegacyScriptPubKeyMan* legacy_spkm = GetLegacyScriptPubKeyMan();
    3865         [ #  # ]:          0 :     if (!legacy_spkm) {
    3866                 :          0 :         error = _("Error: This wallet is already a descriptor wallet");
    3867                 :          0 :         return false;
    3868                 :            :     }
    3869                 :            : 
    3870                 :            :     // Get all invalid or non-watched scripts that will not be migrated
    3871                 :          0 :     std::set<CTxDestination> not_migrated_dests;
    3872   [ #  #  #  # ]:          0 :     for (const auto& script : legacy_spkm->GetNotMineScriptPubKeys()) {
    3873         [ #  # ]:          0 :         CTxDestination dest;
    3874   [ #  #  #  #  :          0 :         if (ExtractDestination(script, dest)) not_migrated_dests.emplace(dest);
                   #  # ]
    3875                 :          0 :     }
    3876                 :            : 
    3877         [ #  # ]:          0 :     for (auto& desc_spkm : data.desc_spkms) {
    3878   [ #  #  #  #  :          0 :         if (m_spk_managers.count(desc_spkm->GetID()) > 0) {
                   #  # ]
    3879         [ #  # ]:          0 :             error = _("Error: Duplicate descriptors created during migration. Your wallet may be corrupted.");
    3880                 :          0 :             return false;
    3881                 :            :         }
    3882         [ #  # ]:          0 :         uint256 id = desc_spkm->GetID();
    3883         [ #  # ]:          0 :         AddScriptPubKeyMan(id, std::move(desc_spkm));
    3884                 :            :     }
    3885                 :            : 
    3886                 :            :     // Remove the LegacyScriptPubKeyMan from disk
    3887   [ #  #  #  # ]:          0 :     if (!legacy_spkm->DeleteRecords()) {
    3888                 :          0 :         return false;
    3889                 :            :     }
    3890                 :            : 
    3891                 :            :     // Remove the LegacyScriptPubKeyMan from memory
    3892   [ #  #  #  # ]:          0 :     m_spk_managers.erase(legacy_spkm->GetID());
    3893                 :          0 :     m_external_spk_managers.clear();
    3894                 :          0 :     m_internal_spk_managers.clear();
    3895                 :            : 
    3896                 :            :     // Setup new descriptors
    3897         [ #  # ]:          0 :     SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
    3898         [ #  # ]:          0 :     if (!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
    3899                 :            :         // Use the existing master key if we have it
    3900   [ #  #  #  # ]:          0 :         if (data.master_key.key.IsValid()) {
    3901         [ #  # ]:          0 :             SetupDescriptorScriptPubKeyMans(data.master_key);
    3902                 :          0 :         } else {
    3903                 :            :             // Setup with a new seed if we don't.
    3904         [ #  # ]:          0 :             SetupDescriptorScriptPubKeyMans();
    3905                 :            :         }
    3906                 :          0 :     }
    3907                 :            : 
    3908                 :            :     // Check if the transactions in the wallet are still ours. Either they belong here, or they belong in the watchonly wallet.
    3909                 :            :     // We need to go through these in the tx insertion order so that lookups to spends works.
    3910                 :          0 :     std::vector<uint256> txids_to_delete;
    3911         [ #  # ]:          0 :     for (const auto& [_pos, wtx] : wtxOrdered) {
    3912   [ #  #  #  #  :          0 :         if (!IsMine(*wtx->tx) && !IsFromMe(*wtx->tx)) {
             #  #  #  # ]
    3913                 :            :             // Check it is the watchonly wallet's
    3914                 :            :             // solvable_wallet doesn't need to be checked because transactions for those scripts weren't being watched for
    3915   [ #  #  #  # ]:          0 :             if (data.watchonly_wallet) {
    3916   [ #  #  #  # ]:          0 :                 LOCK(data.watchonly_wallet->cs_wallet);
    3917   [ #  #  #  #  :          0 :                 if (data.watchonly_wallet->IsMine(*wtx->tx) || data.watchonly_wallet->IsFromMe(*wtx->tx)) {
          #  #  #  #  #  
                #  #  # ]
    3918                 :            :                     // Add to watchonly wallet
    3919   [ #  #  #  #  :          0 :                     if (!data.watchonly_wallet->AddToWallet(wtx->tx, wtx->m_state)) {
             #  #  #  # ]
    3920         [ #  # ]:          0 :                         error = _("Error: Could not add watchonly tx to watchonly wallet");
    3921                 :          0 :                         return false;
    3922                 :            :                     }
    3923                 :            :                     // Mark as to remove from this wallet
    3924   [ #  #  #  # ]:          0 :                     txids_to_delete.push_back(wtx->GetHash());
    3925                 :          0 :                     continue;
    3926                 :            :                 }
    3927      [ #  #  # ]:          0 :             }
    3928                 :            :             // Both not ours and not in the watchonly wallet
    3929   [ #  #  #  #  :          0 :             error = strprintf(_("Error: Transaction %s in wallet cannot be identified to belong to migrated wallets"), wtx->GetHash().GetHex());
             #  #  #  # ]
    3930                 :          0 :             return false;
    3931                 :            :         }
    3932                 :            :     }
    3933                 :            :     // Do the removes
    3934         [ #  # ]:          0 :     if (txids_to_delete.size() > 0) {
    3935                 :          0 :         std::vector<uint256> deleted_txids;
    3936   [ #  #  #  # ]:          0 :         if (ZapSelectTx(txids_to_delete, deleted_txids) != DBErrors::LOAD_OK) {
    3937         [ #  # ]:          0 :             error = _("Error: Could not delete watchonly transactions");
    3938                 :          0 :             return false;
    3939                 :            :         }
    3940   [ #  #  #  # ]:          0 :         if (deleted_txids != txids_to_delete) {
    3941         [ #  # ]:          0 :             error = _("Error: Not all watchonly txs could be deleted");
    3942                 :          0 :             return false;
    3943                 :            :         }
    3944                 :            :         // Tell the GUI of each tx
    3945         [ #  # ]:          0 :         for (const uint256& txid : deleted_txids) {
    3946         [ #  # ]:          0 :             NotifyTransactionChanged(txid, CT_UPDATED);
    3947                 :            :         }
    3948         [ #  # ]:          0 :     }
    3949                 :            : 
    3950                 :            :     // Check the address book data in the same way we did for transactions
    3951                 :          0 :     std::vector<CTxDestination> dests_to_delete;
    3952         [ #  # ]:          0 :     for (const auto& addr_pair : m_address_book) {
    3953                 :            :         // Labels applied to receiving addresses should go based on IsMine
    3954   [ #  #  #  # ]:          0 :         if (addr_pair.second.purpose == AddressPurpose::RECEIVE) {
    3955   [ #  #  #  # ]:          0 :             if (!IsMine(addr_pair.first)) {
    3956                 :            :                 // Check the address book data is the watchonly wallet's
    3957   [ #  #  #  # ]:          0 :                 if (data.watchonly_wallet) {
    3958   [ #  #  #  # ]:          0 :                     LOCK(data.watchonly_wallet->cs_wallet);
    3959   [ #  #  #  # ]:          0 :                     if (data.watchonly_wallet->IsMine(addr_pair.first)) {
    3960                 :            :                         // Add to the watchonly. Preserve the labels, purpose, and change-ness
    3961         [ #  # ]:          0 :                         std::string label = addr_pair.second.GetLabel();
    3962         [ #  # ]:          0 :                         data.watchonly_wallet->m_address_book[addr_pair.first].purpose = addr_pair.second.purpose;
    3963   [ #  #  #  # ]:          0 :                         if (!addr_pair.second.IsChange()) {
    3964   [ #  #  #  #  :          0 :                             data.watchonly_wallet->m_address_book[addr_pair.first].SetLabel(label);
                   #  # ]
    3965                 :          0 :                         }
    3966         [ #  # ]:          0 :                         dests_to_delete.push_back(addr_pair.first);
    3967                 :            :                         continue;
    3968                 :          0 :                     }
    3969         [ #  # ]:          0 :                 }
    3970   [ #  #  #  # ]:          0 :                 if (data.solvable_wallet) {
    3971   [ #  #  #  # ]:          0 :                     LOCK(data.solvable_wallet->cs_wallet);
    3972   [ #  #  #  # ]:          0 :                     if (data.solvable_wallet->IsMine(addr_pair.first)) {
    3973                 :            :                         // Add to the solvable. Preserve the labels, purpose, and change-ness
    3974         [ #  # ]:          0 :                         std::string label = addr_pair.second.GetLabel();
    3975         [ #  # ]:          0 :                         data.solvable_wallet->m_address_book[addr_pair.first].purpose = addr_pair.second.purpose;
    3976   [ #  #  #  # ]:          0 :                         if (!addr_pair.second.IsChange()) {
    3977   [ #  #  #  #  :          0 :                             data.solvable_wallet->m_address_book[addr_pair.first].SetLabel(label);
                   #  # ]
    3978                 :          0 :                         }
    3979         [ #  # ]:          0 :                         dests_to_delete.push_back(addr_pair.first);
    3980                 :            :                         continue;
    3981                 :          0 :                     }
    3982         [ #  # ]:          0 :                 }
    3983                 :            : 
    3984                 :            :                 // Skip invalid/non-watched scripts that will not be migrated
    3985   [ #  #  #  # ]:          0 :                 if (not_migrated_dests.count(addr_pair.first) > 0) {
    3986         [ #  # ]:          0 :                     dests_to_delete.push_back(addr_pair.first);
    3987                 :          0 :                     continue;
    3988                 :            :                 }
    3989                 :            : 
    3990                 :            :                 // Not ours, not in watchonly wallet, and not in solvable
    3991         [ #  # ]:          0 :                 error = _("Error: Address book data in wallet cannot be identified to belong to migrated wallets");
    3992                 :          0 :                 return false;
    3993                 :            :             }
    3994                 :          0 :         } else {
    3995                 :            :             // Labels for everything else ("send") should be cloned to all
    3996   [ #  #  #  # ]:          0 :             if (data.watchonly_wallet) {
    3997   [ #  #  #  # ]:          0 :                 LOCK(data.watchonly_wallet->cs_wallet);
    3998                 :            :                 // Add to the watchonly. Preserve the labels, purpose, and change-ness
    3999         [ #  # ]:          0 :                 std::string label = addr_pair.second.GetLabel();
    4000         [ #  # ]:          0 :                 data.watchonly_wallet->m_address_book[addr_pair.first].purpose = addr_pair.second.purpose;
    4001   [ #  #  #  # ]:          0 :                 if (!addr_pair.second.IsChange()) {
    4002   [ #  #  #  #  :          0 :                     data.watchonly_wallet->m_address_book[addr_pair.first].SetLabel(label);
                   #  # ]
    4003                 :          0 :                 }
    4004                 :          0 :             }
    4005   [ #  #  #  # ]:          0 :             if (data.solvable_wallet) {
    4006   [ #  #  #  # ]:          0 :                 LOCK(data.solvable_wallet->cs_wallet);
    4007                 :            :                 // Add to the solvable. Preserve the labels, purpose, and change-ness
    4008         [ #  # ]:          0 :                 std::string label = addr_pair.second.GetLabel();
    4009         [ #  # ]:          0 :                 data.solvable_wallet->m_address_book[addr_pair.first].purpose = addr_pair.second.purpose;
    4010   [ #  #  #  # ]:          0 :                 if (!addr_pair.second.IsChange()) {
    4011   [ #  #  #  #  :          0 :                     data.solvable_wallet->m_address_book[addr_pair.first].SetLabel(label);
                   #  # ]
    4012                 :          0 :                 }
    4013                 :          0 :             }
    4014                 :            :         }
    4015                 :            :     }
    4016                 :            : 
    4017                 :            :     // Persist added address book entries (labels, purpose) for watchonly and solvable wallets
    4018                 :          0 :     auto persist_address_book = [](const CWallet& wallet) {
    4019                 :          0 :         LOCK(wallet.cs_wallet);
    4020   [ #  #  #  # ]:          0 :         WalletBatch batch{wallet.GetDatabase()};
    4021         [ #  # ]:          0 :         for (const auto& [destination, addr_book_data] : wallet.m_address_book) {
    4022         [ #  # ]:          0 :             auto address{EncodeDestination(destination)};
    4023   [ #  #  #  #  :          0 :             std::optional<std::string> label = addr_book_data.IsChange() ? std::nullopt : std::make_optional(addr_book_data.GetLabel());
          #  #  #  #  #  
                      # ]
    4024                 :            :             // don't bother writing default values (unknown purpose)
    4025   [ #  #  #  #  :          0 :             if (addr_book_data.purpose) batch.WritePurpose(address, PurposeToString(*addr_book_data.purpose));
                   #  # ]
    4026   [ #  #  #  #  :          0 :             if (label) batch.WriteName(address, *label);
                   #  # ]
    4027                 :          0 :         }
    4028                 :          0 :     };
    4029   [ #  #  #  #  :          0 :     if (data.watchonly_wallet) persist_address_book(*data.watchonly_wallet);
                   #  # ]
    4030   [ #  #  #  #  :          0 :     if (data.solvable_wallet) persist_address_book(*data.solvable_wallet);
                   #  # ]
    4031                 :            : 
    4032                 :            :     // Remove the things to delete
    4033         [ #  # ]:          0 :     if (dests_to_delete.size() > 0) {
    4034         [ #  # ]:          0 :         for (const auto& dest : dests_to_delete) {
    4035   [ #  #  #  # ]:          0 :             if (!DelAddressBook(dest)) {
    4036         [ #  # ]:          0 :                 error = _("Error: Unable to remove watchonly address book data");
    4037                 :          0 :                 return false;
    4038                 :            :             }
    4039                 :            :         }
    4040                 :          0 :     }
    4041                 :            : 
    4042                 :            :     // Connect the SPKM signals
    4043         [ #  # ]:          0 :     ConnectScriptPubKeyManNotifiers();
    4044         [ #  # ]:          0 :     NotifyCanGetAddressesChanged();
    4045                 :            : 
    4046         [ #  # ]:          0 :     WalletLogPrintf("Wallet migration complete.\n");
    4047                 :            : 
    4048                 :          0 :     return true;
    4049                 :          0 : }
    4050                 :            : 
    4051                 :          0 : bool CWallet::CanGrindR() const
    4052                 :            : {
    4053                 :          0 :     return !IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER);
    4054                 :            : }
    4055                 :            : 
    4056                 :          0 : bool DoMigration(CWallet& wallet, WalletContext& context, bilingual_str& error, MigrationResult& res) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
    4057                 :            : {
    4058                 :          0 :     AssertLockHeld(wallet.cs_wallet);
    4059                 :            : 
    4060                 :            :     // Get all of the descriptors from the legacy wallet
    4061                 :          0 :     std::optional<MigrationData> data = wallet.GetDescriptorsForLegacy(error);
    4062         [ #  # ]:          0 :     if (data == std::nullopt) return false;
    4063                 :            : 
    4064                 :            :     // Create the watchonly and solvable wallets if necessary
    4065   [ #  #  #  #  :          0 :     if (data->watch_descs.size() > 0 || data->solvable_descs.size() > 0) {
             #  #  #  # ]
    4066                 :          0 :         DatabaseOptions options;
    4067                 :          0 :         options.require_existing = false;
    4068                 :          0 :         options.require_create = true;
    4069                 :            : 
    4070                 :            :         // Make the wallets
    4071                 :          0 :         options.create_flags = WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET | WALLET_FLAG_DESCRIPTORS;
    4072         [ #  # ]:          0 :         if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
    4073                 :          0 :             options.create_flags |= WALLET_FLAG_AVOID_REUSE;
    4074                 :          0 :         }
    4075         [ #  # ]:          0 :         if (wallet.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
    4076                 :          0 :             options.create_flags |= WALLET_FLAG_KEY_ORIGIN_METADATA;
    4077                 :          0 :         }
    4078   [ #  #  #  # ]:          0 :         if (data->watch_descs.size() > 0) {
    4079         [ #  # ]:          0 :             wallet.WalletLogPrintf("Making a new watchonly wallet containing the watched scripts\n");
    4080                 :            : 
    4081                 :            :             DatabaseStatus status;
    4082                 :          0 :             std::vector<bilingual_str> warnings;
    4083   [ #  #  #  # ]:          0 :             std::string wallet_name = wallet.GetName() + "_watchonly";
    4084   [ #  #  #  # ]:          0 :             data->watchonly_wallet = CreateWallet(context, wallet_name, std::nullopt, options, status, error, warnings);
    4085         [ #  # ]:          0 :             if (status != DatabaseStatus::SUCCESS) {
    4086         [ #  # ]:          0 :                 error = _("Error: Failed to create new watchonly wallet");
    4087                 :          0 :                 return false;
    4088                 :            :             }
    4089         [ #  # ]:          0 :             res.watchonly_wallet = data->watchonly_wallet;
    4090   [ #  #  #  #  :          0 :             LOCK(data->watchonly_wallet->cs_wallet);
                   #  # ]
    4091                 :            : 
    4092                 :            :             // Parse the descriptors and add them to the new wallet
    4093   [ #  #  #  # ]:          0 :             for (const auto& [desc_str, creation_time] : data->watch_descs) {
    4094                 :            :                 // Parse the descriptor
    4095                 :          0 :                 FlatSigningProvider keys;
    4096                 :          0 :                 std::string parse_err;
    4097         [ #  # ]:          0 :                 std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, parse_err, /* require_checksum */ true);
    4098         [ #  # ]:          0 :                 assert(desc); // It shouldn't be possible to have the LegacyScriptPubKeyMan make an invalid descriptor
    4099   [ #  #  #  # ]:          0 :                 assert(!desc->IsRange()); // It shouldn't be possible to have LegacyScriptPubKeyMan make a ranged watchonly descriptor
    4100                 :            : 
    4101                 :            :                 // Add to the wallet
    4102   [ #  #  #  # ]:          0 :                 WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
    4103   [ #  #  #  #  :          0 :                 data->watchonly_wallet->AddWalletDescriptor(w_desc, keys, "", false);
                   #  # ]
    4104                 :          0 :             }
    4105                 :            : 
    4106                 :            :             // Add the wallet to settings
    4107   [ #  #  #  # ]:          0 :             UpdateWalletSetting(*context.chain, wallet_name, /*load_on_startup=*/true, warnings);
    4108         [ #  # ]:          0 :         }
    4109   [ #  #  #  # ]:          0 :         if (data->solvable_descs.size() > 0) {
    4110         [ #  # ]:          0 :             wallet.WalletLogPrintf("Making a new watchonly wallet containing the unwatched solvable scripts\n");
    4111                 :            : 
    4112                 :            :             DatabaseStatus status;
    4113                 :          0 :             std::vector<bilingual_str> warnings;
    4114   [ #  #  #  # ]:          0 :             std::string wallet_name = wallet.GetName() + "_solvables";
    4115   [ #  #  #  # ]:          0 :             data->solvable_wallet = CreateWallet(context, wallet_name, std::nullopt, options, status, error, warnings);
    4116         [ #  # ]:          0 :             if (status != DatabaseStatus::SUCCESS) {
    4117         [ #  # ]:          0 :                 error = _("Error: Failed to create new watchonly wallet");
    4118                 :          0 :                 return false;
    4119                 :            :             }
    4120         [ #  # ]:          0 :             res.solvables_wallet = data->solvable_wallet;
    4121   [ #  #  #  #  :          0 :             LOCK(data->solvable_wallet->cs_wallet);
                   #  # ]
    4122                 :            : 
    4123                 :            :             // Parse the descriptors and add them to the new wallet
    4124   [ #  #  #  # ]:          0 :             for (const auto& [desc_str, creation_time] : data->solvable_descs) {
    4125                 :            :                 // Parse the descriptor
    4126                 :          0 :                 FlatSigningProvider keys;
    4127                 :          0 :                 std::string parse_err;
    4128         [ #  # ]:          0 :                 std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, parse_err, /* require_checksum */ true);
    4129         [ #  # ]:          0 :                 assert(desc); // It shouldn't be possible to have the LegacyScriptPubKeyMan make an invalid descriptor
    4130   [ #  #  #  # ]:          0 :                 assert(!desc->IsRange()); // It shouldn't be possible to have LegacyScriptPubKeyMan make a ranged watchonly descriptor
    4131                 :            : 
    4132                 :            :                 // Add to the wallet
    4133   [ #  #  #  # ]:          0 :                 WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
    4134   [ #  #  #  #  :          0 :                 data->solvable_wallet->AddWalletDescriptor(w_desc, keys, "", false);
                   #  # ]
    4135                 :          0 :             }
    4136                 :            : 
    4137                 :            :             // Add the wallet to settings
    4138   [ #  #  #  # ]:          0 :             UpdateWalletSetting(*context.chain, wallet_name, /*load_on_startup=*/true, warnings);
    4139         [ #  # ]:          0 :         }
    4140         [ #  # ]:          0 :     }
    4141                 :            : 
    4142                 :            :     // Add the descriptors to wallet, remove LegacyScriptPubKeyMan, and cleanup txs and address book data
    4143   [ #  #  #  #  :          0 :     if (!wallet.ApplyMigrationData(*data, error)) {
                   #  # ]
    4144                 :          0 :         return false;
    4145                 :            :     }
    4146                 :          0 :     return true;
    4147                 :          0 : }
    4148                 :            : 
    4149                 :          0 : util::Result<MigrationResult> MigrateLegacyToDescriptor(const std::string& wallet_name, const SecureString& passphrase, WalletContext& context)
    4150                 :            : {
    4151                 :          0 :     MigrationResult res;
    4152                 :          0 :     bilingual_str error;
    4153                 :          0 :     std::vector<bilingual_str> warnings;
    4154                 :            : 
    4155                 :            :     // If the wallet is still loaded, unload it so that nothing else tries to use it while we're changing it
    4156   [ #  #  #  #  :          0 :     if (auto wallet = GetWallet(context, wallet_name)) {
             #  #  #  # ]
    4157   [ #  #  #  # ]:          0 :         if (!RemoveWallet(context, wallet, /*load_on_start=*/std::nullopt, warnings)) {
    4158   [ #  #  #  # ]:          0 :             return util::Error{_("Unable to unload the wallet before migrating")};
    4159                 :            :         }
    4160         [ #  # ]:          0 :         UnloadWallet(std::move(wallet));
    4161                 :          0 :     }
    4162                 :            : 
    4163                 :            :     // Load the wallet but only in the context of this function.
    4164                 :            :     // No signals should be connected nor should anything else be aware of this wallet
    4165         [ #  # ]:          0 :     WalletContext empty_context;
    4166                 :          0 :     empty_context.args = context.args;
    4167                 :          0 :     DatabaseOptions options;
    4168                 :          0 :     options.require_existing = true;
    4169                 :            :     DatabaseStatus status;
    4170         [ #  # ]:          0 :     std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
    4171         [ #  # ]:          0 :     if (!database) {
    4172   [ #  #  #  #  :          0 :         return util::Error{Untranslated("Wallet file verification failed.") + Untranslated(" ") + error};
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    4173                 :            :     }
    4174                 :            : 
    4175                 :            :     // Make the local wallet
    4176         [ #  # ]:          0 :     std::shared_ptr<CWallet> local_wallet = CWallet::Create(empty_context, wallet_name, std::move(database), options.create_flags, error, warnings);
    4177   [ #  #  #  # ]:          0 :     if (!local_wallet) {
    4178   [ #  #  #  #  :          0 :         return util::Error{Untranslated("Wallet loading failed.") + Untranslated(" ") + error};
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    4179                 :            :     }
    4180                 :            : 
    4181                 :            :     // Before anything else, check if there is something to migrate.
    4182   [ #  #  #  # ]:          0 :     if (!local_wallet->GetLegacyScriptPubKeyMan()) {
    4183   [ #  #  #  # ]:          0 :         return util::Error{_("Error: This wallet is already a descriptor wallet")};
    4184                 :            :     }
    4185                 :            : 
    4186                 :            :     // Make a backup of the DB
    4187   [ #  #  #  #  :          0 :     fs::path this_wallet_dir = fs::absolute(fs::PathFromString(local_wallet->GetDatabase().Filename())).parent_path();
          #  #  #  #  #  
                #  #  # ]
    4188   [ #  #  #  #  :          0 :     fs::path backup_filename = fs::PathFromString(strprintf("%s-%d.legacy.bak", wallet_name, GetTime()));
                   #  # ]
    4189   [ #  #  #  #  :          0 :     fs::path backup_path = this_wallet_dir / backup_filename;
                   #  # ]
    4190   [ #  #  #  #  :          0 :     if (!local_wallet->BackupWallet(fs::PathToString(backup_path))) {
                   #  # ]
    4191   [ #  #  #  # ]:          0 :         return util::Error{_("Error: Unable to make a backup of your wallet")};
    4192                 :            :     }
    4193         [ #  # ]:          0 :     res.backup_path = backup_path;
    4194                 :            : 
    4195                 :          0 :     bool success = false;
    4196                 :            :     {
    4197   [ #  #  #  # ]:          0 :         LOCK(local_wallet->cs_wallet);
    4198                 :            : 
    4199                 :            :         // Unlock the wallet if needed
    4200   [ #  #  #  #  :          0 :         if (local_wallet->IsLocked() && !local_wallet->Unlock(passphrase)) {
             #  #  #  # ]
    4201         [ #  # ]:          0 :             if (passphrase.find('\0') == std::string::npos) {
    4202   [ #  #  #  #  :          0 :                 return util::Error{Untranslated("Error: Wallet decryption failed, the wallet passphrase was not provided or was incorrect.")};
                   #  # ]
    4203                 :            :             } else {
    4204   [ #  #  #  #  :          0 :                 return util::Error{Untranslated("Error: Wallet decryption failed, the wallet passphrase entered was incorrect. "
                   #  # ]
    4205                 :            :                                                 "The passphrase contains a null character (ie - a zero byte). "
    4206                 :            :                                                 "If this passphrase was set with a version of this software prior to 25.0, "
    4207                 :            :                                                 "please try again with only the characters up to — but not including — "
    4208                 :            :                                                 "the first null character.")};
    4209                 :            :             }
    4210                 :            :         }
    4211                 :            : 
    4212                 :            :         // First change to using SQLite
    4213   [ #  #  #  #  :          0 :         if (!local_wallet->MigrateToSQLite(error)) return util::Error{error};
             #  #  #  # ]
    4214                 :            : 
    4215                 :            :         // Do the migration, and cleanup if it fails
    4216         [ #  # ]:          0 :         success = DoMigration(*local_wallet, context, error, res);
    4217         [ #  # ]:          0 :     }
    4218                 :            : 
    4219         [ #  # ]:          0 :     if (success) {
    4220                 :            :         // Migration successful, unload the wallet locally, then reload it.
    4221         [ #  # ]:          0 :         assert(local_wallet.use_count() == 1);
    4222                 :          0 :         local_wallet.reset();
    4223         [ #  # ]:          0 :         res.wallet = LoadWallet(context, wallet_name, /*load_on_start=*/std::nullopt, options, status, error, warnings);
    4224         [ #  # ]:          0 :         res.wallet_name = wallet_name;
    4225                 :          0 :     } else {
    4226                 :            :         // Migration failed, cleanup
    4227                 :            :         // Copy the backup to the actual wallet dir
    4228   [ #  #  #  # ]:          0 :         fs::path temp_backup_location = fsbridge::AbsPathJoin(GetWalletDir(), backup_filename);
    4229         [ #  # ]:          0 :         fs::copy_file(backup_path, temp_backup_location, fs::copy_options::none);
    4230                 :            : 
    4231                 :            :         // Remember this wallet's walletdir to remove after unloading
    4232                 :          0 :         std::vector<fs::path> wallet_dirs;
    4233   [ #  #  #  #  :          0 :         wallet_dirs.push_back(fs::PathFromString(local_wallet->GetDatabase().Filename()).parent_path());
          #  #  #  #  #  
                #  #  # ]
    4234                 :            : 
    4235                 :            :         // Unload the wallet locally
    4236         [ #  # ]:          0 :         assert(local_wallet.use_count() == 1);
    4237                 :          0 :         local_wallet.reset();
    4238                 :            : 
    4239                 :            :         // Make list of wallets to cleanup
    4240                 :          0 :         std::vector<std::shared_ptr<CWallet>> created_wallets;
    4241   [ #  #  #  #  :          0 :         if (res.watchonly_wallet) created_wallets.push_back(std::move(res.watchonly_wallet));
                   #  # ]
    4242   [ #  #  #  #  :          0 :         if (res.solvables_wallet) created_wallets.push_back(std::move(res.solvables_wallet));
                   #  # ]
    4243                 :            : 
    4244                 :            :         // Get the directories to remove after unloading
    4245         [ #  # ]:          0 :         for (std::shared_ptr<CWallet>& w : created_wallets) {
    4246   [ #  #  #  #  :          0 :             wallet_dirs.push_back(fs::PathFromString(w->GetDatabase().Filename()).parent_path());
          #  #  #  #  #  
                #  #  # ]
    4247                 :            :         }
    4248                 :            : 
    4249                 :            :         // Unload the wallets
    4250         [ #  # ]:          0 :         for (std::shared_ptr<CWallet>& w : created_wallets) {
    4251   [ #  #  #  #  :          0 :             if (!RemoveWallet(context, w, /*load_on_start=*/false)) {
                   #  # ]
    4252   [ #  #  #  # ]:          0 :                 error += _("\nUnable to cleanup failed migration");
    4253   [ #  #  #  # ]:          0 :                 return util::Error{error};
    4254                 :            :             }
    4255         [ #  # ]:          0 :             UnloadWallet(std::move(w));
    4256                 :            :         }
    4257                 :            : 
    4258                 :            :         // Delete the wallet directories
    4259         [ #  # ]:          0 :         for (fs::path& dir : wallet_dirs) {
    4260         [ #  # ]:          0 :             fs::remove_all(dir);
    4261                 :            :         }
    4262                 :            : 
    4263                 :            :         // Restore the backup
    4264                 :            :         DatabaseStatus status;
    4265                 :          0 :         std::vector<bilingual_str> warnings;
    4266   [ #  #  #  #  :          0 :         if (!RestoreWallet(context, temp_backup_location, wallet_name, /*load_on_start=*/std::nullopt, status, error, warnings)) {
                   #  # ]
    4267   [ #  #  #  # ]:          0 :             error += _("\nUnable to restore backup of wallet.");
    4268   [ #  #  #  # ]:          0 :             return util::Error{error};
    4269                 :            :         }
    4270                 :            : 
    4271                 :            :         // Move the backup to the wallet dir
    4272         [ #  # ]:          0 :         fs::copy_file(temp_backup_location, backup_path, fs::copy_options::none);
    4273         [ #  # ]:          0 :         fs::remove(temp_backup_location);
    4274                 :            : 
    4275   [ #  #  #  # ]:          0 :         return util::Error{error};
    4276                 :          0 :     }
    4277         [ #  # ]:          0 :     return res;
    4278                 :          0 : }
    4279                 :            : } // namespace wallet

Generated by: LCOV version 1.14