The wallet state and lifecycle

4501                }
4502            }
4503        }
4504    }
4505    if (!success) {
4506        // Make list of wallets to cleanup
4507        std::vector<std::shared_ptr<CWallet>> created_wallets;
4508        if (local_wallet) created_wallets.push_back(std::move(local_wallet));
4509        if (res.watchonly_wallet) created_wallets.push_back(std::move(res.watchonly_wallet));
4510        if (res.solvables_wallet) created_wallets.push_back(std::move(res.solvables_wallet));
4511
4512        // Get the directories to remove after unloading
4513        for (std::shared_ptr<CWallet>& wallet : created_wallets) {
4514            track_for_cleanup(*wallet);
4515        }
4516
4517        // Unload the wallets
4518        for (std::shared_ptr<CWallet>& w : created_wallets) {
4519            if (w->HaveChain()) {
4520                // Unloading for wallets that were loaded for normal use
4521                if (!RemoveWallet(context, w, /*load_on_start=*/false)) {
4522                    error += _("\nUnable to cleanup failed migration");
4523                    return util::Error{error};
4524                }
4525                WaitForDeleteWallet(std::move(w));
4526            } else {
4527                // Unloading for wallets in local context
4528                assert(w.use_count() == 1);
4529                w.reset();
4530            }
4531        }
4532
4533        // First, delete the db files we have created throughout this process and nothing else
4534        for (const fs::path& file : wallet_files_to_remove) {
4535            fs::remove(file);
4536        }
4537
4538        // Second, delete the created wallet directories and nothing else. They must be empty at this point.
4539        for (const fs::path& dir : wallet_empty_dirs_to_remove) {
4540            Assume(fs::is_empty(dir));
4541            fs::remove(dir);
4542        }
4543
4544        // Restore the backup
4545        // Convert the backup file to the wallet db file by renaming it and moving it into the wallet's directory.
4546        bilingual_str restore_error;
4547        const auto& ptr_wallet = RestoreWallet(context, backup_path, wallet_name, /*load_on_start=*/std::nullopt, status, restore_error, warnings, /*load_after_restore=*/false, /*allow_unnamed=*/true);
4548        if (!restore_error.empty()) {
4549            error += restore_error + _("\nUnable to restore backup of wallet.");
4550            return util::Error{error};
4551        }
4552        // Verify that the legacy wallet is not loaded after restoring from the backup.
4553        assert(!ptr_wallet);
4554
4555        return util::Error{error};
4556    }
4557    return res;
4558}
4559
4560void CWallet::CacheNewScriptPubKeys(const std::set<CScript>& spks, ScriptPubKeyMan* spkm)
4561{
4562    for (const auto& script : spks) {
4563        m_cached_spks[script].push_back(spkm);
4564    }
4565}
4566
4567void CWallet::TopUpCallback(const std::set<CScript>& spks, ScriptPubKeyMan* spkm)
4568{
4569    // Update scriptPubKey cache
4570    CacheNewScriptPubKeys(spks, spkm);
4571}
4572
4573CWallet::HDPubKeyMap CWallet::GetHDPubKeys(HDKeyFilter filter) const
4574{
4575    AssertLockHeld(cs_wallet);
4576
4577    Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4578
4579    HDPubKeyMap xpubs;
4580    for (const auto& spkm : filter == HDKeyFilter::Active ? GetActiveScriptPubKeyMans() : GetAllScriptPubKeyMans()) {
4581        auto* desc_spkm = Assert(dynamic_cast<DescriptorScriptPubKeyMan*>(spkm));
4582        LOCK(desc_spkm->cs_desc_man);
4583        WalletDescriptor w_desc = desc_spkm->GetWalletDescriptor();
4584        if (filter == HDKeyFilter::UnusedKey && w_desc.descriptor->HasScripts()) continue;
4585
4586        std::set<CPubKey> desc_pubkeys;
4587        std::set<CExtPubKey> desc_xpubs;
4588        w_desc.descriptor->GetPubKeys(desc_pubkeys, desc_xpubs);
4589        for (const CExtPubKey& xpub : desc_xpubs) {
4590            xpubs[xpub].insert(desc_spkm);
4591        }
4592    }
4593    return xpubs;
4594}
4595
4596std::optional<CKey> CWallet::GetKey(const CKeyID& keyid) const
4597{
4598    Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4599
4600    for (const auto& spkm : GetAllScriptPubKeyMans()) {
4601        const DescriptorScriptPubKeyMan* desc_spkm = dynamic_cast<DescriptorScriptPubKeyMan*>(spkm);
4602        assert(desc_spkm);
4603        LOCK(desc_spkm->cs_desc_man);
4604        if (std::optional<CKey> key = desc_spkm->GetKey(keyid)) {
4605            return key;
4606        }
4607    }
4608    return std::nullopt;
4609}
4610
4611std::optional<CExtKey> CWallet::GetExtKey(const CExtPubKey& xpub) const
4612{
4613    if (std::optional<CKey> key = GetKey(xpub.pubkey.GetID())) {
4614        return CExtKey{xpub, *key};
4615    }
4616    return std::nullopt;
4617}
4618
4619void CWallet::WriteBestBlock() const
4620{
4621    AssertLockHeld(cs_wallet);
4622
4623    if (!m_last_block_processed.IsNull()) {
4624        CBlockLocator loc;
4625        chain().findBlock(m_last_block_processed, FoundBlock().locator(loc));
4626
4627        if (!loc.IsNull()) {
4628            WalletBatch batch(GetDatabase());
4629            batch.WriteBestBlock(loc);
4630        }
4631    }
4632}
4633
4634void CWallet::RefreshTXOsFromTx(const CWalletTx& wtx)
4635{
4636    AssertLockHeld(cs_wallet);
4637    for (uint32_t i = 0; i < wtx.GetTx()->vout.size(); ++i) {
4638        const CTxOut& txout = wtx.GetTx()->vout.at(i);
4639        if (!IsMine(txout)) continue;
4640        COutPoint outpoint(wtx.GetHash(), i);
4641        if (m_txos.contains(outpoint)) {
4642        } else {
4643            m_txos.emplace(outpoint, WalletTXO{wtx, txout});
4644        }
4645    }
4646}
4647
4648void CWallet::RefreshAllTXOs()
4649{
4650    AssertLockHeld(cs_wallet);
4651    for (const auto& [_, wtx] : mapWallet) {
4652        RefreshTXOsFromTx(wtx);
4653    }
4654}
4655
4656std::optional<WalletTXO> CWallet::GetTXO(const COutPoint& outpoint) const
4657{
4658    AssertLockHeld(cs_wallet);
4659    const auto& it = m_txos.find(outpoint);
4660    if (it == m_txos.end()) {
4661        return std::nullopt;
4662    }
4663    return it->second;
4664}
4665
4666void CWallet::DisconnectChainNotifications()
4667{
4668    if (m_chain_notifications_handler) {
4669        m_chain_notifications_handler->disconnect();
4670        chain().waitForNotifications();
4671        m_chain_notifications_handler.reset();
4672    }
4673}
4674
4675} // namespace wallet
4676