The wallet state and lifecycle

2501                        mapTxSpends.erase(iter);
2502                        break;
2503                    }
2504                }
2505            }
2506            for (unsigned int i = 0; i < it->second.GetTx()->vout.size(); ++i) {
2507                m_txos.erase(COutPoint(hash, i));
2508            }
2509            mapWallet.erase(it);
2510            NotifyTransactionChanged(hash, CT_DELETED);
2511        }
2512
2513        MarkDirty();
2514    }, .on_abort={}});
2515
2516    return {};
2517}
2518
2519bool CWallet::SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& new_purpose)
2520{
2521    bool fUpdated = false;
2522    bool is_mine;
2523    std::optional<AddressPurpose> purpose;
2524    {
2525        LOCK(cs_wallet);
2526        std::map<CTxDestination, CAddressBookData>::iterator mi = m_address_book.find(address);
2527        fUpdated = mi != m_address_book.end() && !mi->second.IsChange();
2528
2529        CAddressBookData& record = mi != m_address_book.end() ? mi->second : m_address_book[address];
2530        record.SetLabel(strName);
2531        is_mine = IsMine(address);
2532        if (new_purpose) { /* update purpose only if requested */
2533            record.purpose = new_purpose;
2534        }
2535        purpose = record.purpose;
2536    }
2537
2538    const std::string& encoded_dest = EncodeDestination(address);
2539    if (new_purpose && !batch.WritePurpose(encoded_dest, PurposeToString(*new_purpose))) {
2540        WalletLogPrintf("Error: fail to write address book 'purpose' entry\n");
2541        return false;
2542    }
2543    if (!batch.WriteName(encoded_dest, strName)) {
2544        WalletLogPrintf("Error: fail to write address book 'name' entry\n");
2545        return false;
2546    }
2547
2548    // In very old wallets, address purpose may not be recorded so we derive it from IsMine
2549    NotifyAddressBookChanged(address, strName, is_mine,
2550                             purpose.value_or(is_mine ? AddressPurpose::RECEIVE : AddressPurpose::SEND),
2551                             (fUpdated ? CT_UPDATED : CT_NEW));
2552    return true;
2553}
2554
2555bool CWallet::SetAddressBook(const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& purpose)
2556{
2557    WalletBatch batch(GetDatabase());
2558    return SetAddressBookWithDB(batch, address, strName, purpose);
2559}
2560
2561bool CWallet::DelAddressBook(const CTxDestination& address)
2562{
2563    return RunWithinTxn(GetDatabase(), /*process_desc=*/"address book entry removal", [&](WalletBatch& batch){
2564        return DelAddressBookWithDB(batch, address);
2565    });
2566}
2567
2568bool CWallet::DelAddressBookWithDB(WalletBatch& batch, const CTxDestination& address)
2569{
2570    const std::string& dest = EncodeDestination(address);
2571    {
2572        LOCK(cs_wallet);
2573        // 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.
2574        // NOTE: This isn't a problem for sending addresses because they don't have any data that needs to be kept.
2575        // When adding new address data, it should be considered here whether to retain or delete it.
2576        if (IsMine(address)) {
2577            WalletLogPrintf("%s called with IsMine address, NOT SUPPORTED. Please report this bug! %s\n", __func__, CLIENT_BUGREPORT);
2578            return false;
2579        }
2580        // Delete data rows associated with this address
2581        if (!batch.EraseAddressData(address)) {
2582            WalletLogPrintf("Error: cannot erase address book entry data\n");
2583            return false;
2584        }
2585
2586        // Delete purpose entry
2587        if (!batch.ErasePurpose(dest)) {
2588            WalletLogPrintf("Error: cannot erase address book entry purpose\n");
2589            return false;
2590        }
2591
2592        // Delete name entry
2593        if (!batch.EraseName(dest)) {
2594            WalletLogPrintf("Error: cannot erase address book entry name\n");
2595            return false;
2596        }
2597
2598        // finally, remove it from the map
2599        m_address_book.erase(address);
2600    }
2601
2602    // All good, signal changes
2603    NotifyAddressBookChanged(address, "", /*is_mine=*/false, AddressPurpose::SEND, CT_DELETED);
2604    return true;
2605}
2606
2607size_t CWallet::KeypoolCountExternalKeys() const
2608{
2609    AssertLockHeld(cs_wallet);
2610
2611    unsigned int count = 0;
2612    for (auto spk_man : m_external_spk_managers) {
2613        count += spk_man.second->GetKeyPoolSize();
2614    }
2615
2616    return count;
2617}
2618
2619unsigned int CWallet::GetKeyPoolSize() const
2620{
2621    AssertLockHeld(cs_wallet);
2622
2623    unsigned int count = 0;
2624    for (auto spk_man : GetActiveScriptPubKeyMans()) {
2625        count += spk_man->GetKeyPoolSize();
2626    }
2627    return count;
2628}
2629
2630bool CWallet::TopUpKeyPool(unsigned int kpSize)
2631{
2632    LOCK(cs_wallet);
2633    bool res = true;
2634    for (auto spk_man : GetActiveScriptPubKeyMans()) {
2635        res &= spk_man->TopUp(kpSize);
2636    }
2637    return res;
2638}
2639
2640util::Result<CTxDestination> CWallet::GetNewDestination(const OutputType type, const std::string& label)
2641{
2642    LOCK(cs_wallet);
2643    auto spk_man = GetScriptPubKeyMan(type, /*internal=*/false);
2644    if (!spk_man) {
2645        return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
2646    }
2647
2648    auto op_dest = spk_man->GetNewDestination(type);
2649    if (op_dest) {
2650        SetAddressBook(*op_dest, label, AddressPurpose::RECEIVE);
2651    }
2652
2653    return op_dest;
2654}
2655
2656util::Result<CTxDestination> CWallet::GetNewChangeDestination(const OutputType type)
2657{
2658    LOCK(cs_wallet);
2659
2660    ReserveDestination reservedest(this, type);
2661    auto op_dest = reservedest.GetReservedDestination(true);
2662    if (op_dest) reservedest.KeepDestination();
2663
2664    return op_dest;
2665}
2666
2667void CWallet::MarkDestinationsDirty(const std::set<CTxDestination>& destinations) {
2668    for (auto& entry : mapWallet) {
2669        CWalletTx& wtx = entry.second;
2670        if (wtx.m_is_cache_empty) continue;
2671        for (unsigned int i = 0; i < wtx.GetTx()->vout.size(); i++) {
2672            CTxDestination dst;
2673            if (ExtractDestination(wtx.GetTx()->vout[i].scriptPubKey, dst) && destinations.contains(dst)) {
2674                wtx.MarkDirty();
2675                break;
2676            }
2677        }
2678    }
2679}
2680
2681void CWallet::ForEachAddrBookEntry(const ListAddrBookFunc& func) const
2682{
2683    AssertLockHeld(cs_wallet);
2684    for (const std::pair<const CTxDestination, CAddressBookData>& item : m_address_book) {
2685        const auto& entry = item.second;
2686        func(item.first, entry.GetLabel(), entry.IsChange(), entry.purpose);
2687    }
2688}
2689
2690std::vector<CTxDestination> CWallet::ListAddrBookAddresses(const std::optional<AddrBookFilter>& _filter) const
2691{
2692    AssertLockHeld(cs_wallet);
2693    std::vector<CTxDestination> result;
2694    AddrBookFilter filter = _filter ? *_filter : AddrBookFilter();
2695    ForEachAddrBookEntry([&result, &filter](const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose>& purpose) {
2696        // Filter by change
2697        if (filter.ignore_change && is_change) return;
2698        // Filter by label
2699        if (filter.m_op_label && *filter.m_op_label != label) return;
2700        // All good
2701        result.emplace_back(dest);
2702    });
2703    return result;
2704}
2705
2706std::set<std::string> CWallet::ListAddrBookLabels(const std::optional<AddressPurpose> purpose) const
2707{
2708    AssertLockHeld(cs_wallet);
2709    std::set<std::string> label_set;
2710    ForEachAddrBookEntry([&](const CTxDestination& _dest, const std::string& _label,
2711                             bool _is_change, const std::optional<AddressPurpose>& _purpose) {
2712        if (_is_change) return;
2713        if (!purpose || purpose == _purpose) {
2714            label_set.insert(_label);
2715        }
2716    });
2717    return label_set;
2718}
2719
2720util::Result<CTxDestination> ReserveDestination::GetReservedDestination(bool internal)
2721{
2722    m_spk_man = pwallet->GetScriptPubKeyMan(type, internal);
2723    if (!m_spk_man) {
2724        return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
2725    }
2726
2727    if (nIndex == -1) {
2728        int64_t index;
2729        auto op_address = m_spk_man->GetReservedDestination(type, internal, index);
2730        if (!op_address) return op_address;
2731        nIndex = index;
2732        address = *op_address;
2733    }
2734    return address;
2735}
2736
2737void ReserveDestination::KeepDestination()
2738{
2739    if (nIndex != -1) {
2740        m_spk_man->KeepDestination(nIndex, type);
2741    }
2742    nIndex = -1;
2743    address = CNoDestination();
2744}
2745
2746void ReserveDestination::ReturnDestination()
2747{
2748    if (nIndex != -1) {
2749        m_spk_man->ReturnDestination(nIndex, fInternal, address);
2750    }