wallet.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2018-2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_WALLET_WALLET_H
#define BITCOIN_WALLET_WALLET_H
 
#include <common/signmessage.h>
#include <common/system.h>
#include <consensus/amount.h>
#include <interfaces/chain.h>
#include <interfaces/handler.h>
#include <logging.h>
#include <outputtype.h>
#include <primitives/blockhash.h>
#include <psbt.h>
#include <tinyformat.h>
#include <util/result.h>
#include <util/strencodings.h>
#include <util/string.h>
#include <util/translation.h>
#include <util/ui_change_type.h>
#include <validationinterface.h>
#include <wallet/coinselection.h>
#include <wallet/crypter.h>
#include <wallet/rpcwallet.h>
#include <wallet/scriptpubkeyman.h>
#include <wallet/transaction.h>
#include <wallet/walletdb.h>
#include <wallet/walletutil.h>
 
#include <algorithm>
#include <atomic>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
#include <boost/signals2/signal.hpp>
 
struct WalletContext;
namespace common {
enum class PSBTError;
} // namespace common
 
using LoadWalletFn =
    std::function<void(std::unique_ptr<interfaces::Wallet> wallet)>;
 
struct bilingual_str;
 
void UnloadWallet(std::shared_ptr<CWallet> &&wallet);
 
bool AddWallet(WalletContext &context, const std::shared_ptr<CWallet> &wallet);
bool RemoveWallet(WalletContext &context,
                  const std::shared_ptr<CWallet> &wallet,
                  std::optional<bool> load_on_start,
                  std::vector<bilingual_str> &warnings);
bool RemoveWallet(WalletContext &context,
                  const std::shared_ptr<CWallet> &wallet,
                  std::optional<bool> load_on_start);
 
std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext &context);
std::shared_ptr<CWallet> GetWallet(WalletContext &context,
                                   const std::string &name);
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);
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);
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);
std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext &context,
                                                      LoadWalletFn load_wallet);
void NotifyWalletLoaded(WalletContext &context,
                        const std::shared_ptr<CWallet> &wallet);
std::unique_ptr<WalletDatabase>
MakeWalletDatabase(const std::string &name, const DatabaseOptions &options,
                   DatabaseStatus &status, bilingual_str &error);
 
constexpr Amount DEFAULT_PAY_TX_FEE = Amount::zero();
static const Amount DEFAULT_FALLBACK_FEE = Amount::zero();
static const Amount DEFAULT_TRANSACTION_MINFEE_PER_KB = 1000 * SATOSHI;
static const Amount DEFAULT_MAX_AVOIDPARTIALSPEND_FEE = Amount::zero();
constexpr Amount HIGH_APS_FEE{COIN / 10000};
static const Amount WALLET_INCREMENTAL_RELAY_FEE(5000 * SATOSHI);
static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true;
static const bool DEFAULT_WALLETBROADCAST = true;
static const bool DEFAULT_DISABLE_WALLET = false;
constexpr Amount DEFAULT_TRANSACTION_MAXFEE{COIN / 10};
constexpr Amount HIGH_TX_FEE_PER_KB{COIN / 100};
constexpr Amount HIGH_MAX_TX_FEE{100 * HIGH_TX_FEE_PER_KB};
static constexpr size_t DUMMY_P2PKH_INPUT_SIZE = 148;
 
class CChainParams;
class CCoinControl;
class COutput;
class CScript;
class CTxMemPool;
class CWalletTx;
class ReserveDestination;
 
constexpr OutputType DEFAULT_ADDRESS_TYPE{OutputType::LEGACY};
 
static constexpr uint64_t KNOWN_WALLET_FLAGS =
    WALLET_FLAG_AVOID_REUSE | WALLET_FLAG_BLANK_WALLET |
    WALLET_FLAG_KEY_ORIGIN_METADATA | WALLET_FLAG_DISABLE_PRIVATE_KEYS |
    WALLET_FLAG_DESCRIPTORS;
 
static constexpr uint64_t MUTABLE_WALLET_FLAGS = WALLET_FLAG_AVOID_REUSE;
 
static const std::map<std::string, WalletFlags> WALLET_FLAG_MAP{
    {"avoid_reuse", WALLET_FLAG_AVOID_REUSE},
    {"blank", WALLET_FLAG_BLANK_WALLET},
    {"key_origin_metadata", WALLET_FLAG_KEY_ORIGIN_METADATA},
    {"disable_private_keys", WALLET_FLAG_DISABLE_PRIVATE_KEYS},
    {"descriptor_wallet", WALLET_FLAG_DESCRIPTORS},
};
 
extern const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS;
 
class ReserveDestination {
protected:
    const CWallet *const pwallet;
    ScriptPubKeyMan *m_spk_man{nullptr};
    OutputType const type;
    int64_t nIndex{-1};
    CTxDestination address;
    bool fInternal{false};
 
public:
    explicit ReserveDestination(CWallet *_pwallet, OutputType _type)
        : pwallet(_pwallet), type(_type) {}
 
    ReserveDestination(const ReserveDestination &) = delete;
    ReserveDestination &operator=(const ReserveDestination &) = delete;
 
    ~ReserveDestination() { ReturnDestination(); }
 
    bool GetReservedDestination(CTxDestination &pubkey, bool internal);
    void ReturnDestination();
    void KeepDestination();
};
 
class CAddressBookData {
private:
    bool m_change{true};
    std::string m_label;
 
public:
    std::string purpose;
 
    CAddressBookData() : purpose("unknown") {}
 
    typedef std::map<std::string, std::string> StringMap;
    StringMap destdata;
 
    bool IsChange() const { return m_change; }
    const std::string &GetLabel() const { return m_label; }
    void SetLabel(const std::string &label) {
        m_change = false;
        m_label = label;
    }
};
 
struct CRecipient {
    CScript scriptPubKey;
    Amount nAmount;
    bool fSubtractFeeFromAmount;
};
 
struct CoinSelectionParams {
    bool use_bnb = true;
    size_t change_output_size = 0;
    size_t change_spend_size = 0;
    CFeeRate effective_fee = CFeeRate(Amount::zero());
    size_t tx_noinputs_size = 0;
    bool m_subtract_fee_outputs = false;
    bool m_avoid_partial_spends = false;
 
    CoinSelectionParams(bool use_bnb_, size_t change_output_size_,
                        size_t change_spend_size_, CFeeRate effective_fee_,
                        size_t tx_noinputs_size_, bool avoid_partial)
        : use_bnb(use_bnb_), change_output_size(change_output_size_),
          change_spend_size(change_spend_size_), effective_fee(effective_fee_),
          tx_noinputs_size(tx_noinputs_size_),
          m_avoid_partial_spends(avoid_partial) {}
    CoinSelectionParams() {}
};
 
// forward declarations for ScanForWalletTransactions/RescanFromTime
class WalletRescanReserver;
 
class CWallet final : public WalletStorage,
                      public interfaces::Chain::Notifications {
private:
    CKeyingMaterial vMasterKey GUARDED_BY(cs_wallet);
 
    bool Unlock(const CKeyingMaterial &vMasterKeyIn,
                bool accept_no_keys = false);
 
    std::atomic<bool> fAbortRescan{false};
    // controlled by WalletRescanReserver
    std::atomic<bool> fScanningWallet{false};
    std::atomic<bool> m_attaching_chain{false};
    std::atomic<SteadyClock::time_point> m_scanning_start{
        SteadyClock::time_point{}};
    std::atomic<double> m_scanning_progress{0};
    friend class WalletRescanReserver;
 
    int nWalletVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;
 
    int nWalletMaxVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;
 
    int64_t nNextResend = 0;
    bool fBroadcastTransactions = false;
    // Local time that the tip block was received. Used to schedule wallet
    // rebroadcasts.
    std::atomic<int64_t> m_best_block_time{0};
 
    typedef std::multimap<COutPoint, TxId> TxSpends;
    TxSpends mapTxSpends GUARDED_BY(cs_wallet);
    void AddToSpends(const COutPoint &outpoint, const TxId &wtxid)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void AddToSpends(const TxId &wtxid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool AddToWalletIfInvolvingMe(const CTransactionRef &tx,
                                  CWalletTx::Confirmation confirm, bool fUpdate)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    void MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
                        const TxId &txid);
 
    void MarkInputsDirty(const CTransactionRef &tx)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    void SyncTransaction(const CTransactionRef &tx,
                         CWalletTx::Confirmation confirm, bool update_tx = true)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    std::atomic<uint64_t> m_wallet_flags{0};
 
    bool SetAddressBookWithDB(WalletBatch &batch, const CTxDestination &address,
                              const std::string &strName,
                              const std::string &strPurpose);
 
    void UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag);
 
    void UnsetBlankWalletFlag(WalletBatch &batch) override;
 
    interfaces::Chain *m_chain;
 
    std::string m_name;
 
    std::unique_ptr<WalletDatabase> database;
 
    BlockHash m_last_block_processed GUARDED_BY(cs_wallet);
 
    /* Height of last block processed is used by wallet to know depth of
     * transactions without relying on Chain interface beyond asynchronous
     * updates. For safety, we initialize it to -1. Height is a pointer on
     * node's tip and doesn't imply that the wallet has scanned sequentially all
     * blocks up to this one.
     */
    int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1;
 
    std::map<OutputType, ScriptPubKeyMan *> m_external_spk_managers;
    std::map<OutputType, ScriptPubKeyMan *> m_internal_spk_managers;
 
    // Indexed by a unique identifier produced by each ScriptPubKeyMan using
    // ScriptPubKeyMan::GetID. In many cases it will be the hash of an internal
    // structure
    std::map<uint256, std::unique_ptr<ScriptPubKeyMan>> m_spk_managers;
 
    static bool AttachChain(const std::shared_ptr<CWallet> &wallet,
                            interfaces::Chain &chain, bilingual_str &error,
                            std::vector<bilingual_str> &warnings);
 
public:
    /*
     * Main wallet lock.
     * This lock protects all the fields added by CWallet.
     */
    mutable RecursiveMutex cs_wallet;
 
    WalletDatabase &GetDBHandle() { return *database; }
    WalletDatabase &GetDatabase() override { return *database; }
 
    const std::string &GetName() const { return m_name; }
 
    typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
    MasterKeyMap mapMasterKeys;
    unsigned int nMasterKeyMaxID = 0;
 
    CWallet(interfaces::Chain *chain, const std::string &name,
            std::unique_ptr<WalletDatabase> _database)
        : m_chain(chain), m_name(name), database(std::move(_database)) {}
 
    ~CWallet() {
        // Should not have slots connected at this point.
        assert(NotifyUnload.empty());
    }
 
    /* Returns the chain params used by this wallet. */
    const CChainParams &GetChainParams() const override;
 
    bool IsCrypted() const;
    bool IsLocked() const override;
    bool Lock();
 
    bool HaveChain() const { return m_chain ? true : false; }
 
    std::map<TxId, CWalletTx> mapWallet GUARDED_BY(cs_wallet);
 
    typedef std::multimap<int64_t, CWalletTx *> TxItems;
    TxItems wtxOrdered;
 
    int64_t nOrderPosNext GUARDED_BY(cs_wallet) = 0;
    uint64_t nAccountingEntryNumber = 0;
 
    std::map<CTxDestination, CAddressBookData>
        m_address_book GUARDED_BY(cs_wallet);
    const CAddressBookData *
    FindAddressBookEntry(const CTxDestination &,
                         bool allow_change = false) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet);
 
    std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
 
    interfaces::Chain &chain() const {
        assert(m_chain);
        return *m_chain;
    }
 
    const CWalletTx *GetWalletTx(const TxId &txid) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    std::set<TxId> GetTxConflicts(const CWalletTx &wtx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    int GetTxDepthInMainChain(const CWalletTx &wtx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool IsTxInMainChain(const CWalletTx &wtx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
 
        return GetTxDepthInMainChain(wtx) > 0;
    }
 
    int GetTxBlocksToMaturity(const CWalletTx &wtx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool IsTxImmatureCoinBase(const CWalletTx &wtx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool CanSupportFeature(enum WalletFeature wf) const override
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
        return nWalletMaxVersion >= wf;
    }
 
    bool IsSpent(const COutPoint &outpoint) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    // Whether this or any UTXO with the same CTxDestination has been spent.
    bool IsSpentKey(const TxId &txid, unsigned int n) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void SetSpentKeyState(WalletBatch &batch, const TxId &txid, unsigned int n,
                          bool used, std::set<CTxDestination> &tx_destinations)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool IsLockedCoin(const COutPoint &outpoint) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void LockCoin(const COutPoint &output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void UnlockCoin(const COutPoint &output)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void ListLockedCoins(std::vector<COutPoint> &vOutpts) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    /*
     * Rescan abort properties
     */
    void AbortRescan() { fAbortRescan = true; }
    bool IsAbortingRescan() const { return fAbortRescan; }
    bool IsScanning() const { return fScanningWallet; }
    SteadyClock::duration ScanningDuration() const {
        return fScanningWallet ? SteadyClock::now() - m_scanning_start.load()
                               : SteadyClock::duration{};
    }
    double ScanningProgress() const {
        return fScanningWallet ? double(m_scanning_progress) : 0;
    }
 
    void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool LoadMinVersion(int nVersion) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
        nWalletVersion = nVersion;
        nWalletMaxVersion = std::max(nWalletMaxVersion, nVersion);
        return true;
    }
 
    bool AddDestData(WalletBatch &batch, const CTxDestination &dest,
                     const std::string &key, const std::string &value)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool EraseDestData(WalletBatch &batch, const CTxDestination &dest,
                       const std::string &key)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void LoadDestData(const CTxDestination &dest, const std::string &key,
                      const std::string &value)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool GetDestData(const CTxDestination &dest, const std::string &key,
                     std::string *value) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    std::vector<std::string> GetDestValues(const std::string &prefix) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    int64_t nRelockTime GUARDED_BY(cs_wallet){0};
 
    // Used to prevent concurrent calls to walletpassphrase RPC.
    Mutex m_unlock_mutex;
    bool Unlock(const SecureString &strWalletPassphrase,
                bool accept_no_keys = false);
    bool ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase,
                                const SecureString &strNewWalletPassphrase);
    bool EncryptWallet(const SecureString &strWalletPassphrase);
 
    void GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    unsigned int ComputeTimeSmart(const CWalletTx &wtx) const;
 
    int64_t IncOrderPosNext(WalletBatch *batch = nullptr)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    DBErrors ReorderTransactions();
 
    void MarkDirty();
 
    using UpdateWalletTxFn = std::function<bool(CWalletTx &wtx, bool new_tx)>;
 
    CWalletTx *AddToWallet(CTransactionRef tx,
                           const CWalletTx::Confirmation &confirm,
                           const UpdateWalletTxFn &update_wtx = nullptr,
                           bool fFlushOnClose = true);
    bool LoadToWallet(const TxId &txid, const UpdateWalletTxFn &fill_wtx)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void transactionAddedToMempool(const CTransactionRef &tx,
                                   uint64_t mempool_sequence) override;
    void blockConnected(ChainstateRole role, const CBlock &block,
                        int height) override;
    void blockDisconnected(const CBlock &block, int height) override;
    void updatedBlockTip() override;
    int64_t RescanFromTime(int64_t startTime,
                           const WalletRescanReserver &reserver, bool update);
 
    struct ScanResult {
        enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS;
 
        BlockHash last_scanned_block;
        std::optional<int> last_scanned_height;
 
        BlockHash last_failed_block;
    };
    ScanResult ScanForWalletTransactions(const BlockHash &start_block,
                                         int start_height,
                                         std::optional<int> max_height,
                                         const WalletRescanReserver &reserver,
                                         bool fUpdate);
    void transactionRemovedFromMempool(const CTransactionRef &tx,
                                       MemPoolRemovalReason reason,
                                       uint64_t mempool_sequence) override;
    void ReacceptWalletTransactions() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void ResendWalletTransactions();
 
    OutputType
    TransactionChangeType(const std::optional<OutputType> &change_type,
                          const std::vector<CRecipient> &vecSend) const;
 
    // Fetch the inputs and sign with SIGHASH_ALL.
    bool SignTransaction(CMutableTransaction &tx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    // Sign the tx given the input coins and sighash.
    bool SignTransaction(CMutableTransaction &tx,
                         const std::map<COutPoint, Coin> &coins,
                         SigHashType sighash,
                         std::map<int, std::string> &input_errors) const;
    SigningResult SignMessage(const std::string &message, const PKHash &pkhash,
                              std::string &str_sig) const;
 
    std::optional<common::PSBTError>
    FillPSBT(PartiallySignedTransaction &psbtx, bool &complete,
             SigHashType sighash_type = SigHashType().withForkId(),
             bool sign = true, bool bip32derivs = true) const;
 
    void CommitTransaction(
        CTransactionRef tx, mapValue_t mapValue,
        std::vector<std::pair<std::string, std::string>> orderForm,
        bool broadcast = true);
 
    bool SubmitTxMemoryPoolAndRelay(const CWalletTx &wtx,
                                    std::string &err_string, bool relay) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts,
                     bool use_max_sig = false) const {
        std::vector<CTxOut> v_txouts(txouts.size());
        std::copy(txouts.begin(), txouts.end(), v_txouts.begin());
        return DummySignTx(txNew, v_txouts, use_max_sig);
    }
    bool DummySignTx(CMutableTransaction &txNew,
                     const std::vector<CTxOut> &txouts,
                     bool use_max_sig = false) const;
    bool DummySignInput(CTxIn &tx_in, const CTxOut &txout,
                        bool use_max_sig = false) const;
 
    bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                        const int64_t timestamp)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool 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)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool 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)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    CFeeRate m_pay_tx_fee{DEFAULT_PAY_TX_FEE};
    bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE};
    bool m_allow_fallback_fee{true};
    // Override with -mintxfee
    CFeeRate m_min_fee{DEFAULT_TRANSACTION_MINFEE_PER_KB};
    CFeeRate m_fallback_fee{DEFAULT_FALLBACK_FEE};
    Amount m_max_aps_fee{DEFAULT_MAX_AVOIDPARTIALSPEND_FEE};
    OutputType m_default_address_type{DEFAULT_ADDRESS_TYPE};
    std::optional<OutputType> m_default_change_type{};
    Amount m_default_max_tx_fee{DEFAULT_TRANSACTION_MAXFEE};
 
    size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool TopUpKeyPool(unsigned int kpSize = 0);
 
    int64_t GetOldestKeyPoolTime() const;
 
    std::set<CTxDestination> GetLabelAddresses(const std::string &label) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    void MarkDestinationsDirty(const std::set<CTxDestination> &destinations)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    util::Result<CTxDestination> GetNewDestination(const OutputType type,
                                                   const std::string &label);
    util::Result<CTxDestination> GetNewChangeDestination(const OutputType type);
 
    isminetype IsMine(const CTxDestination &dest) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    isminetype IsMine(const CScript &script) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    Amount GetDebit(const CTxIn &txin, const isminefilter &filter) const;
    isminetype IsMine(const CTxOut &txout) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    ;
    bool IsMine(const CTransaction &tx) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    bool IsFromMe(const CTransaction &tx) const;
    Amount GetDebit(const CTransaction &tx, const isminefilter &filter) const;
    void chainStateFlushed(ChainstateRole role,
                           const CBlockLocator &loc) override;
 
    DBErrors LoadWallet();
    DBErrors ZapSelectTx(std::vector<TxId> &txIdsIn,
                         std::vector<TxId> &txIdsOut)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool SetAddressBook(const CTxDestination &address,
                        const std::string &strName, const std::string &purpose);
 
    bool DelAddressBook(const CTxDestination &address);
 
    unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    void SetMinVersion(enum WalletFeature, WalletBatch *batch_in = nullptr,
                       bool fExplicit = false) override;
 
    bool SetMaxVersion(int nVersion);
 
    int GetVersion() const {
        LOCK(cs_wallet);
        return nWalletVersion;
    }
 
    std::set<TxId> GetConflicts(const TxId &txid) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    bool HasWalletSpend(const TxId &txid) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    void Flush();
 
    void Close();
 
    boost::signals2::signal<void()> NotifyUnload;
 
    boost::signals2::signal<void(CWallet *wallet, const CTxDestination &address,
                                 const std::string &label, bool isMine,
                                 const std::string &purpose, ChangeType status)>
        NotifyAddressBookChanged;
 
    boost::signals2::signal<void(CWallet *wallet, const TxId &txid,
                                 ChangeType status)>
        NotifyTransactionChanged;
 
    boost::signals2::signal<void(const std::string &title, int nProgress)>
        ShowProgress;
 
    boost::signals2::signal<void(bool fHaveWatchOnly)> NotifyWatchonlyChanged;
 
    boost::signals2::signal<void()> NotifyCanGetAddressesChanged;
 
    boost::signals2::signal<void(CWallet *wallet)> NotifyStatusChanged;
 
    bool GetBroadcastTransactions() const { return fBroadcastTransactions; }
    void SetBroadcastTransactions(bool broadcast) {
        fBroadcastTransactions = broadcast;
    }
 
    bool TransactionCanBeAbandoned(const TxId &txid) const;
 
    bool AbandonTransaction(const TxId &txid);
 
    static std::shared_ptr<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);
 
    void postInitProcess();
 
    bool BackupWallet(const std::string &strDest) const;
 
    /* Returns true if HD is enabled */
    bool IsHDEnabled() const;
 
    bool CanGetAddresses(bool internal = false) const;
 
    void BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(::cs_main)
        EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet);
 
    void SetWalletFlag(uint64_t flags);
 
    void UnsetWalletFlag(uint64_t flag);
 
    bool IsWalletFlagSet(uint64_t flag) const override;
 
    bool AddWalletFlags(uint64_t flags);
    bool LoadWalletFlags(uint64_t flags);
 
    bool IsLegacy() const;
 
    std::string GetDisplayName() const override {
        std::string wallet_name =
            GetName().length() == 0 ? "default wallet" : GetName();
        return strprintf("[%s]", wallet_name);
    };
 
    template <typename... Params>
    void WalletLogPrintf(std::string fmt, Params... parameters) const {
        LogPrintf(("%s " + fmt).c_str(), GetDisplayName(), parameters...);
    };
 
    template <typename... Params>
    void WalletLogPrintfToBeContinued(std::string fmt,
                                      Params... parameters) const {
        LogPrintfToBeContinued(("%s " + fmt).c_str(), GetDisplayName(),
                               parameters...);
    };
 
    bool UpgradeWallet(int version, bilingual_str &error);
 
    std::set<ScriptPubKeyMan *> GetActiveScriptPubKeyMans() const;
 
    std::set<ScriptPubKeyMan *> GetAllScriptPubKeyMans() const;
 
    ScriptPubKeyMan *GetScriptPubKeyMan(const OutputType &type,
                                        bool internal) const;
 
    ScriptPubKeyMan *GetScriptPubKeyMan(const CScript &script) const;
    ScriptPubKeyMan *GetScriptPubKeyMan(const uint256 &id) const;
 
    std::set<ScriptPubKeyMan *>
    GetScriptPubKeyMans(const CScript &script, SignatureData &sigdata) const;
 
    std::unique_ptr<SigningProvider>
    GetSolvingProvider(const CScript &script) const;
    std::unique_ptr<SigningProvider>
    GetSolvingProvider(const CScript &script, SignatureData &sigdata) const;
 
    LegacyScriptPubKeyMan *GetLegacyScriptPubKeyMan() const;
    LegacyScriptPubKeyMan *GetOrCreateLegacyScriptPubKeyMan();
 
    void SetupLegacyScriptPubKeyMan();
 
    bool WithEncryptionKey(
        const std::function<bool(const CKeyingMaterial &)> &cb) const override;
 
    bool HasEncryptionKeys() const override;
 
    int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
        assert(m_last_block_processed_height >= 0);
        return m_last_block_processed_height;
    };
    BlockHash GetLastBlockHash() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
        assert(m_last_block_processed_height >= 0);
        return m_last_block_processed;
    }
    void SetLastBlockProcessed(int block_height, BlockHash block_hash)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
        m_last_block_processed_height = block_height;
        m_last_block_processed = block_hash;
    };
 
    void ConnectScriptPubKeyManNotifiers();
 
    void LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor &desc);
 
    void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal);
 
    void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal);
 
    void DeactivateScriptPubKeyMan(const uint256 &id, OutputType type,
                                   bool internal);
 
    void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
    DescriptorScriptPubKeyMan *
    GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const;
 
    ScriptPubKeyMan *
    AddWalletDescriptor(WalletDescriptor &desc,
                        const FlatSigningProvider &signing_provider,
                        const std::string &label, bool internal)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
};
 
void MaybeResendWalletTxs(WalletContext &context);
 
class WalletRescanReserver {
private:
    CWallet &m_wallet;
    bool m_could_reserve;
 
public:
    explicit WalletRescanReserver(CWallet &w)
        : m_wallet(w), m_could_reserve(false) {}
 
    bool reserve() {
        assert(!m_could_reserve);
        if (m_wallet.fScanningWallet.exchange(true)) {
            return false;
        }
        m_wallet.m_scanning_start = SteadyClock::now();
        m_wallet.m_scanning_progress = 0;
        m_could_reserve = true;
        return true;
    }
 
    bool isReserved() const {
        return (m_could_reserve && m_wallet.fScanningWallet);
    }
 
    ~WalletRescanReserver() {
        if (m_could_reserve) {
            m_wallet.fScanningWallet = false;
        }
    }
};
 
bool AddWalletSetting(interfaces::Chain &chain, const std::string &wallet_name);
 
bool RemoveWalletSetting(interfaces::Chain &chain,
                         const std::string &wallet_name);
 
#endif // BITCOIN_WALLET_WALLET_H