The wallet state and lifecycle

2751    nIndex = -1;
2752    address = CNoDestination();
2753}
2754
2755util::Result<void> CWallet::DisplayAddress(const CTxDestination& dest)
2756{
2757    CScript scriptPubKey = GetScriptForDestination(dest);
2758    for (const auto& spk_man : GetScriptPubKeyMans(scriptPubKey)) {
2759        auto signer_spk_man = dynamic_cast<ExternalSignerScriptPubKeyMan *>(spk_man);
2760        if (signer_spk_man == nullptr) {
2761            continue;
2762        }
2763        auto signer{ExternalSignerScriptPubKeyMan::GetExternalSigner()};
2764        if (!signer) throw std::runtime_error(util::ErrorString(signer).original);
2765        return signer_spk_man->DisplayAddress(dest, *signer);
2766    }
2767    return util::Error{_("There is no ScriptPubKeyManager for this address")};
2768}
2769
2770void CWallet::LoadLockedCoin(const COutPoint& coin, bool persistent)
2771{
2772    AssertLockHeld(cs_wallet);
2773    m_locked_coins.emplace(coin, persistent);
2774}
2775
2776bool CWallet::LockCoin(const COutPoint& output, bool persist)
2777{
2778    AssertLockHeld(cs_wallet);
2779    LoadLockedCoin(output, persist);
2780    if (persist) {
2781        WalletBatch batch(GetDatabase());
2782        return batch.WriteLockedUTXO(output);
2783    }
2784    return true;
2785}
2786
2787bool CWallet::UnlockCoin(const COutPoint& output)
2788{
2789    AssertLockHeld(cs_wallet);
2790    auto locked_coin_it = m_locked_coins.find(output);
2791    if (locked_coin_it != m_locked_coins.end()) {
2792        bool persisted = locked_coin_it->second;
2793        m_locked_coins.erase(locked_coin_it);
2794        if (persisted) {
2795            WalletBatch batch(GetDatabase());
2796            return batch.EraseLockedUTXO(output);
2797        }
2798    }
2799    return true;
2800}
2801
2802bool CWallet::UnlockAllCoins()
2803{
2804    AssertLockHeld(cs_wallet);
2805    bool success = true;
2806    WalletBatch batch(GetDatabase());
2807    for (const auto& [coin, persistent] : m_locked_coins) {
2808        if (persistent) success = success && batch.EraseLockedUTXO(coin);
2809    }
2810    m_locked_coins.clear();
2811    return success;
2812}
2813
2814bool CWallet::IsLockedCoin(const COutPoint& output) const
2815{
2816    AssertLockHeld(cs_wallet);
2817    return m_locked_coins.contains(output);
2818}
2819
2820void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
2821{
2822    AssertLockHeld(cs_wallet);
2823    for (const auto& [coin, _] : m_locked_coins) {
2824        vOutpts.push_back(coin);
2825    }
2826}
2827
2828/**
2829 * Compute smart timestamp for a transaction being added to the wallet.
2830 *
2831 * Logic:
2832 * - If sending a transaction, assign its timestamp to the current time.
2833 * - If receiving a transaction outside a block, assign its timestamp to the
2834 *   current time.
2835 * - If receiving a transaction during a rescanning process, assign all its
2836 *   (not already known) transactions' timestamps to the block time.
2837 * - If receiving a block with a future timestamp, assign all its (not already
2838 *   known) transactions' timestamps to the current time.
2839 * - If receiving a block with a past timestamp, before the most recent known
2840 *   transaction (that we care about), assign all its (not already known)
2841 *   transactions' timestamps to the same timestamp as that most-recent-known
2842 *   transaction.
2843 * - If receiving a block with a past timestamp, but after the most recent known
2844 *   transaction, assign all its (not already known) transactions' timestamps to
2845 *   the block time.
2846 *
2847 * For more information see CWalletTx::nTimeSmart,
2848 * https://bitcointalk.org/?topic=54527, or
2849 * https://github.com/bitcoin/bitcoin/pull/1393.
2850 */
2851unsigned int CWallet::ComputeTimeSmart(const CWalletTx& wtx, bool rescanning_old_block) const
2852{
2853    std::optional<uint256> block_hash;
2854    if (auto* conf = wtx.state<TxStateConfirmed>()) {
2855        block_hash = conf->confirmed_block_hash;
2856    } else if (auto* conf = wtx.state<TxStateBlockConflicted>()) {
2857        block_hash = conf->conflicting_block_hash;
2858    }
2859
2860    unsigned int nTimeSmart = wtx.nTimeReceived;
2861    if (block_hash) {
2862        int64_t blocktime;
2863        int64_t block_max_time;
2864        if (chain().findBlock(*block_hash, FoundBlock().time(blocktime).maxTime(block_max_time))) {
2865            if (rescanning_old_block) {
2866                nTimeSmart = block_max_time;
2867            } else {
2868                int64_t latestNow = wtx.nTimeReceived;
2869                int64_t latestEntry = 0;
2870
2871                // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
2872                int64_t latestTolerated = latestNow + 300;
2873                const TxItems& txOrdered = wtxOrdered;
2874                for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
2875                    CWalletTx* const pwtx = it->second;
2876                    if (pwtx == &wtx) {
2877                        continue;
2878                    }
2879                    int64_t nSmartTime;
2880                    nSmartTime = pwtx->nTimeSmart;
2881                    if (!nSmartTime) {
2882                        nSmartTime = pwtx->nTimeReceived;
2883                    }
2884                    if (nSmartTime <= latestTolerated) {
2885                        latestEntry = nSmartTime;
2886                        if (nSmartTime > latestNow) {
2887                            latestNow = nSmartTime;
2888                        }
2889                        break;
2890                    }
2891                }
2892
2893                nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
2894            }
2895        } else {
2896            WalletLogPrintf("%s: found %s in block %s not in index\n", __func__, wtx.GetHash().ToString(), block_hash->ToString());
2897        }
2898    }
2899    return nTimeSmart;
2900}
2901
2902bool CWallet::SetAddressPreviouslySpent(WalletBatch& batch, const CTxDestination& dest, bool used)
2903{
2904    if (std::get_if<CNoDestination>(&dest))
2905        return false;
2906
2907    if (!used) {
2908        if (auto* data{common::FindKey(m_address_book, dest)}) data->previously_spent = false;
2909        return batch.WriteAddressPreviouslySpent(dest, false);
2910    }
2911
2912    LoadAddressPreviouslySpent(dest);
2913    return batch.WriteAddressPreviouslySpent(dest, true);
2914}
2915
2916void CWallet::LoadAddressPreviouslySpent(const CTxDestination& dest)
2917{
2918    m_address_book[dest].previously_spent = true;
2919}
2920
2921void CWallet::LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request)
2922{
2923    m_address_book[dest].receive_requests[id] = request;
2924}
2925
2926bool CWallet::IsAddressPreviouslySpent(const CTxDestination& dest) const
2927{
2928    if (auto* data{common::FindKey(m_address_book, dest)}) return data->previously_spent;
2929    return false;
2930}
2931
2932std::vector<std::string> CWallet::GetAddressReceiveRequests() const
2933{
2934    std::vector<std::string> values;
2935    for (const auto& [dest, entry] : m_address_book) {
2936        for (const auto& [id, request] : entry.receive_requests) {
2937            values.emplace_back(request);
2938        }
2939    }
2940    return values;
2941}
2942
2943bool CWallet::SetAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id, const std::string& value)
2944{
2945    if (!batch.WriteAddressReceiveRequest(dest, id, value)) return false;
2946    m_address_book[dest].receive_requests[id] = value;
2947    return true;
2948}
2949
2950bool CWallet::EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id)
2951{
2952    if (!batch.EraseAddressReceiveRequest(dest, id)) return false;
2953    m_address_book[dest].receive_requests.erase(id);
2954    return true;
2955}
2956
2957util::Result<fs::path> GetWalletPath(const std::string& name)
2958{
2959    const fs::path name_path = fs::PathFromString(name);
2960
2961    // 'name' must be a normalized path, i.e. no . or .. except at the root
2962    if (name_path != name_path.lexically_normal()) {
2963        return util::Error{Untranslated("Wallet name given as a path must be normalized")};
2964    }
2965
2966    // 'name' cannot begin with ./ or ../
2967    if (!name_path.empty() && (*name_path.begin() == fs::PathFromString(".") || *name_path.begin() == fs::PathFromString(".."))) {
2968        return util::Error{Untranslated("Wallet name given as a relative path cannot begin with ./ or ../, for wallets not in the walletdir, please use an absolute path.")};
2969    }
2970
2971    // Disallow path at root
2972    if (name_path.has_root_path() && name_path.root_path() == name_path) {
2973        return util::Error{Untranslated("Wallet name cannot be the root path")};
2974    }
2975
2976    // Do some checking on wallet path. It should be either a:
2977    //
2978    // 1. Path where a directory can be created.
2979    // 2. Path to an existing directory.
2980    // 3. Path to a symlink to a directory.
2981    // 4. For backwards compatibility, the name of a data file in -walletdir.
2982    const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), name_path);
2983    fs::file_type path_type = fs::symlink_status(wallet_path).type();
2984    if (!(path_type == fs::file_type::not_found || path_type == fs::file_type::directory ||
2985          (path_type == fs::file_type::symlink && fs::is_directory(wallet_path)) ||
2986          (path_type == fs::file_type::regular && name_path.filename() == name_path))) {
2987        return util::Error{Untranslated(strprintf(
2988              "Invalid -wallet path '%s'. -wallet path should point to a directory where wallet.dat and "
2989              "database/log.?????????? files can be stored, a location where such a directory could be created, "
2990              "or (for backwards compatibility) the name of an existing data file in -walletdir (%s)",
2991              name, fs::quoted(fs::PathToString(GetWalletDir()))))};
2992    }
2993    return wallet_path;
2994}
2995
2996std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error_string)
2997{
2998    const auto& wallet_path = GetWalletPath(name);
2999    if (!wallet_path) {
3000        error_string = util::ErrorString(wallet_path);