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 <amount.h>
#include <interfaces/chain.h>
#include <interfaces/handler.h>
#include <outputtype.h>
#include <primitives/blockhash.h>
#include <psbt.h>
#include <tinyformat.h>
#include <util/message.h>
#include <util/strencodings.h>
#include <util/string.h>
#include <util/system.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/walletdb.h>
#include <wallet/walletutil.h>

#include <algorithm>
#include <atomic>
#include <cstdint>
#include <map>
#include <memory>
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <boost/signals2/signal.hpp>

using LoadWalletFn =
    std::function<void(std::unique_ptr<interfaces::Wallet> wallet)>;

struct bilingual_str;

void UnloadWallet(std::shared_ptr<CWallet> &&wallet);

bool AddWallet(const std::shared_ptr<CWallet> &wallet);
bool RemoveWallet(const std::shared_ptr<CWallet> &wallet);
bool HasWallets();
std::vector<std::shared_ptr<CWallet>> GetWallets();
std::shared_ptr<CWallet> GetWallet(const std::string &name);
std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
                                    interfaces::Chain &chain,
                                    const WalletLocation &location,
                                    bilingual_str &error,
                                    std::vector<bilingual_str> &warnings);
std::unique_ptr<interfaces::Handler> HandleLoadWallet(LoadWalletFn load_wallet);

enum class WalletCreationStatus { SUCCESS, CREATION_FAILED, ENCRYPTION_FAILED };

WalletCreationStatus CreateWallet(const CChainParams &params,
                                  interfaces::Chain &chain,
                                  const SecureString &passphrase,
                                  uint64_t wallet_creation_flags,
                                  const std::string &name, bilingual_str &error,
                                  std::vector<bilingual_str> &warnings,
                                  std::shared_ptr<CWallet> &result);
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_WALLET_REJECT_LONG_CHAINS = false;
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};

constexpr OutputType DEFAULT_CHANGE_TYPE{OutputType::CHANGE_AUTO};

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;
};

typedef std::map<std::string, std::string> mapValue_t;

static inline void ReadOrderPos(int64_t &nOrderPos, mapValue_t &mapValue) {
    if (!mapValue.count("n")) {
        // TODO: calculate elsewhere
        nOrderPos = -1;
        return;
    }

    nOrderPos = atoi64(mapValue["n"].c_str());
}

static inline void WriteOrderPos(const int64_t &nOrderPos,
                                 mapValue_t &mapValue) {
    if (nOrderPos == -1) {
        return;
    }
    mapValue["n"] = ToString(nOrderPos);
}

struct COutputEntry {
    CTxDestination destination;
    Amount amount;
    int vout;
};

class CMerkleTx {
public:
    template <typename Stream> void Unserialize(Stream &s) {
        CTransactionRef tx;
        BlockHash hashBlock;
        std::vector<uint256> vMerkleBranch;
        int nIndex = 0;

        s >> tx >> hashBlock >> vMerkleBranch >> nIndex;
    }
};

// Get the marginal bytes of spending the specified output
int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *pwallet,
                                    bool use_max_sig = false);

class CWalletTx {
private:
    const CWallet *pwallet;

    static const BlockHash ABANDON_HASH;

public:
    mapValue_t mapValue;
    std::vector<std::pair<std::string, std::string>> vOrderForm;
    unsigned int fTimeReceivedIsTxTime;
    unsigned int nTimeReceived;
    unsigned int nTimeSmart;
    bool fFromMe;
    int64_t nOrderPos;
    std::multimap<int64_t, CWalletTx *>::const_iterator m_it_wtxOrdered;

    // memory only
    enum AmountType {
        DEBIT,
        CREDIT,
        IMMATURE_CREDIT,
        AVAILABLE_CREDIT,
        AMOUNTTYPE_ENUM_ELEMENTS
    };
    Amount GetCachableAmount(AmountType type, const isminefilter &filter,
                             bool recalculate = false) const;
    mutable CachableAmount m_amounts[AMOUNTTYPE_ENUM_ELEMENTS];
    mutable bool m_is_cache_empty{true};
    mutable bool fChangeCached;
    mutable bool fInMempool;
    mutable Amount nChangeCached;

    CWalletTx(const CWallet *pwalletIn, CTransactionRef arg)
        : tx(std::move(arg)) {
        Init(pwalletIn);
    }

    void Init(const CWallet *pwalletIn) {
        pwallet = pwalletIn;
        mapValue.clear();
        vOrderForm.clear();
        fTimeReceivedIsTxTime = false;
        nTimeReceived = 0;
        nTimeSmart = 0;
        fFromMe = false;
        fChangeCached = false;
        fInMempool = false;
        nChangeCached = Amount::zero();
        nOrderPos = -1;
        m_confirm = Confirmation{};
    }

    CTransactionRef tx;

    enum Status { UNCONFIRMED, CONFIRMED, CONFLICTED, ABANDONED };

    struct Confirmation {
        Status status;
        int block_height;
        BlockHash hashBlock;
        int nIndex;
        Confirmation(Status s = UNCONFIRMED, int b = 0,
                     BlockHash h = BlockHash(), int i = 0)
            : status(s), block_height(b), hashBlock(h), nIndex(i) {}
    };

    Confirmation m_confirm;

    template <typename Stream> void Serialize(Stream &s) const {
        mapValue_t mapValueCopy = mapValue;

        mapValueCopy["fromaccount"] = "";
        WriteOrderPos(nOrderPos, mapValueCopy);
        if (nTimeSmart) {
            mapValueCopy["timesmart"] = strprintf("%u", nTimeSmart);
        }

        std::vector<char> dummy_vector1;
        std::vector<char> dummy_vector2;
        bool dummy_bool = false;
        uint256 serializedHash =
            isAbandoned() ? ABANDON_HASH : m_confirm.hashBlock;
        int serializedIndex =
            isAbandoned() || isConflicted() ? -1 : m_confirm.nIndex;
        s << tx << serializedHash << dummy_vector1 << serializedIndex
          << dummy_vector2 << mapValueCopy << vOrderForm
          << fTimeReceivedIsTxTime << nTimeReceived << fFromMe << dummy_bool;
    }

    template <typename Stream> void Unserialize(Stream &s) {
        Init(nullptr);

        std::vector<uint256> dummy_vector1;
        std::vector<CMerkleTx> dummy_vector2;
        bool dummy_bool;
        int serializedIndex;
        s >> tx >> m_confirm.hashBlock >> dummy_vector1 >> serializedIndex >>
            dummy_vector2 >> mapValue >> vOrderForm >> fTimeReceivedIsTxTime >>
            nTimeReceived >> fFromMe >> dummy_bool;

        /*
         * At serialization/deserialization, an nIndex == -1 means that
         * hashBlock refers to the earliest block in the chain we know this or
         * any in-wallet ancestor conflicts with. If nIndex == -1 and hashBlock
         * is ABANDON_HASH, it means transaction is abandoned. In same context,
         * an nIndex >= 0 refers to a confirmed transaction (if hashBlock set)
         * or unconfirmed one. Older clients interpret nIndex == -1 as
         * unconfirmed for backward compatibility (pre-commit 9ac63d6).
         */
        if (serializedIndex == -1 && m_confirm.hashBlock == ABANDON_HASH) {
            setAbandoned();
        } else if (serializedIndex == -1) {
            setConflicted();
        } else if (!m_confirm.hashBlock.IsNull()) {
            m_confirm.nIndex = serializedIndex;
            setConfirmed();
        }

        ReadOrderPos(nOrderPos, mapValue);
        nTimeSmart = mapValue.count("timesmart")
                         ? (unsigned int)atoi64(mapValue["timesmart"])
                         : 0;

        mapValue.erase("fromaccount");
        mapValue.erase("spent");
        mapValue.erase("n");
        mapValue.erase("timesmart");
    }

    void SetTx(CTransactionRef arg) { tx = std::move(arg); }

    void MarkDirty() {
        m_amounts[DEBIT].Reset();
        m_amounts[CREDIT].Reset();
        m_amounts[IMMATURE_CREDIT].Reset();
        m_amounts[AVAILABLE_CREDIT].Reset();
        fChangeCached = false;
        m_is_cache_empty = true;
    }

    void BindWallet(CWallet *pwalletIn) {
        pwallet = pwalletIn;
        MarkDirty();
    }

    Amount GetDebit(const isminefilter &filter) const;
    Amount GetCredit(const isminefilter &filter) const;
    Amount GetImmatureCredit(bool fUseCache = true) const;
    // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
    // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The
    // annotation "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid
    // having to resolve the issue of member access into incomplete type
    // CWallet.
    Amount GetAvailableCredit(bool fUseCache = true,
                              const isminefilter &filter = ISMINE_SPENDABLE)
        const NO_THREAD_SAFETY_ANALYSIS;
    Amount GetImmatureWatchOnlyCredit(const bool fUseCache = true) const;
    Amount GetChange() const;

    // Get the marginal bytes if spending the specified output from this
    // transaction
    int GetSpendSize(unsigned int out, bool use_max_sig = false) const {
        return CalculateMaximumSignedInputSize(tx->vout[out], pwallet,
                                               use_max_sig);
    }

    void GetAmounts(std::list<COutputEntry> &listReceived,
                    std::list<COutputEntry> &listSent, Amount &nFee,
                    const isminefilter &filter) const;

    bool IsFromMe(const isminefilter &filter) const {
        return GetDebit(filter) > Amount::zero();
    }

    // True if only scriptSigs are different
    bool IsEquivalentTo(const CWalletTx &tx) const;

    bool InMempool() const;
    bool IsTrusted() const;
    bool IsTrusted(std::set<TxId> &trusted_parents) const;

    int64_t GetTxTime() const;

    // Pass this transaction to node for mempool insertion and relay to peers if
    // flag set to true
    bool SubmitMemoryPoolAndRelay(std::string &err_string, bool relay);

    // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
    // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
    // "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid having to
    // resolve the issue of member access into incomplete type CWallet. Note
    // that we still have the runtime check "AssertLockHeld(pwallet->cs_wallet)"
    // in place.
    std::set<TxId> GetConflicts() const NO_THREAD_SAFETY_ANALYSIS;

    // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
    // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
    // "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid having to
    // resolve the issue of member access into incomplete type CWallet. Note
    // that we still have the runtime check "AssertLockHeld(pwallet->cs_wallet)"
    // in place.
    int GetDepthInMainChain() const NO_THREAD_SAFETY_ANALYSIS;
    bool IsInMainChain() const { return GetDepthInMainChain() > 0; }

    int GetBlocksToMaturity() const;
    bool isAbandoned() const {
        return m_confirm.status == CWalletTx::ABANDONED;
    }
    void setAbandoned() {
        m_confirm.status = CWalletTx::ABANDONED;
        m_confirm.hashBlock = BlockHash();
        m_confirm.block_height = 0;
        m_confirm.nIndex = 0;
    }
    bool isConflicted() const {
        return m_confirm.status == CWalletTx::CONFLICTED;
    }
    void setConflicted() { m_confirm.status = CWalletTx::CONFLICTED; }
    bool isUnconfirmed() const {
        return m_confirm.status == CWalletTx::UNCONFIRMED;
    }
    void setUnconfirmed() { m_confirm.status = CWalletTx::UNCONFIRMED; }
    bool isConfirmed() const {
        return m_confirm.status == CWalletTx::CONFIRMED;
    }
    void setConfirmed() { m_confirm.status = CWalletTx::CONFIRMED; }
    TxId GetId() const { return tx->GetId(); }
    bool IsCoinBase() const { return tx->IsCoinBase(); }
    bool IsImmatureCoinBase() const;
};

class COutput {
public:
    const CWalletTx *tx;
    int i;
    int nDepth;

    int nInputBytes;

    bool fSpendable;

    bool fSolvable;

    bool use_max_sig;

    bool fSafe;

    COutput(const CWalletTx *txIn, int iIn, int nDepthIn, bool fSpendableIn,
            bool fSolvableIn, bool fSafeIn, bool use_max_sig_in = false) {
        tx = txIn;
        i = iIn;
        nDepth = nDepthIn;
        fSpendable = fSpendableIn;
        fSolvable = fSolvableIn;
        fSafe = fSafeIn;
        nInputBytes = -1;
        use_max_sig = use_max_sig_in;
        // If known and signable by the given wallet, compute nInputBytes
        // Failure will keep this value -1
        if (fSpendable && tx) {
            nInputBytes = tx->GetSpendSize(i, use_max_sig);
        }
    }

    std::string ToString() const;

    inline CInputCoin GetInputCoin() const {
        return CInputCoin(tx->tx, i, nInputBytes);
    }
};

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;

    CoinSelectionParams(bool use_bnb_, size_t change_output_size_,
                        size_t change_spend_size_, CFeeRate effective_fee_,
                        size_t tx_noinputs_size_)
        : 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_) {}
    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<int64_t> m_scanning_start{0};
    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;

    WalletLocation m_location;

    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;

    bool CreateTransactionInternal(const std::vector<CRecipient> &vecSend,
                                   CTransactionRef &tx, Amount &nFeeRet,
                                   int &nChangePosInOut, bilingual_str &error,
                                   const CCoinControl &coin_control, bool sign);

    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;

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; }

    bool SelectCoins(const std::vector<COutput> &vAvailableCoins,
                     const Amount nTargetValue,
                     std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
                     const CCoinControl &coin_control,
                     CoinSelectionParams &coin_selection_params,
                     bool &bnb_used) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

    const WalletLocation &GetLocation() const { return m_location; }

    const std::string &GetName() const { return m_location.GetName(); }

    typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
    MasterKeyMap mapMasterKeys;
    unsigned int nMasterKeyMaxID = 0;

    CWallet(interfaces::Chain *chain, const WalletLocation &location,
            std::unique_ptr<WalletDatabase> _database)
        : m_chain(chain), m_location(location), 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;

    bool CanSupportFeature(enum WalletFeature wf) const override
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
        AssertLockHeld(cs_wallet);
        return nWalletMaxVersion >= wf;
    }

    void AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe = true,
                        const CCoinControl *coinControl = nullptr,
                        const Amount nMinimumAmount = SATOSHI,
                        const Amount nMaximumAmount = MAX_MONEY,
                        const Amount nMinimumSumAmount = MAX_MONEY,
                        const uint64_t nMaximumCount = 0) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

    std::map<CTxDestination, std::vector<COutput>> ListCoins() const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

    const CTxOut &FindNonChangeParentOutput(const CTransaction &tx,
                                            int output) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

    bool SelectCoinsMinConf(const Amount nTargetValue,
                            const CoinEligibilityFilter &eligibility_filter,
                            std::vector<OutputGroup> groups,
                            std::set<CInputCoin> &setCoinsRet,
                            Amount &nValueRet,
                            const CoinSelectionParams &coin_selection_params,
                            bool &bnb_used) const;

    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);

    std::vector<OutputGroup> GroupOutputs(const std::vector<COutput> &outputs,
                                          bool single_coin,
                                          const size_t max_ancestors) const;

    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; }
    int64_t ScanningDuration() const {
        return fScanningWallet ? GetTimeMillis() - m_scanning_start : 0;
    }
    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();
    bool AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose = true);
    void LoadToWallet(CWalletTx &wtxIn) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void transactionAddedToMempool(const CTransactionRef &tx) override;
    void blockConnected(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 &ptx) override;
    void ReacceptWalletTransactions() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    void ResendWalletTransactions();
    struct Balance {
        Amount m_mine_trusted{Amount::zero()};
        Amount m_mine_untrusted_pending{Amount::zero()};
        Amount m_mine_immature{Amount::zero()};
        Amount m_watchonly_trusted{Amount::zero()};
        Amount m_watchonly_untrusted_pending{Amount::zero()};
        Amount m_watchonly_immature{Amount::zero()};
    };
    Balance GetBalance(int min_depth = 0, bool avoid_reuse = true) const;
    Amount GetAvailableBalance(const CCoinControl *coinControl = nullptr) const;

    OutputType TransactionChangeType(OutputType change_type,
                                     const std::vector<CRecipient> &vecSend);

    bool FundTransaction(CMutableTransaction &tx, Amount &nFeeRet,
                         int &nChangePosInOut, bilingual_str &error,
                         bool lockUnspents,
                         const std::set<int> &setSubtractFeeFromOutputs,
                         CCoinControl coinControl);
    // 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;

    TransactionError
    FillPSBT(PartiallySignedTransaction &psbtx, bool &complete,
             SigHashType sighash_type = SigHashType().withForkId(),
             bool sign = true, bool bip32derivs = true) const;

    bool CreateTransaction(const std::vector<CRecipient> &vecSend,
                           CTransactionRef &tx, Amount &nFeeRet,
                           int &nChangePosInOut, bilingual_str &error,
                           const CCoinControl &coin_control, bool sign = true);

    void CommitTransaction(
        CTransactionRef tx, mapValue_t mapValue,
        std::vector<std::pair<std::string, std::string>> orderForm);

    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};
    OutputType m_default_change_type{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<std::set<CTxDestination>> GetAddressGroupings() const
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
    std::map<CTxDestination, Amount> GetAddressBalances() const;

    std::set<CTxDestination> GetLabelAddresses(const std::string &label) const;

    void MarkDestinationsDirty(const std::set<CTxDestination> &destinations)
        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

    bool GetNewDestination(const OutputType type, const std::string label,
                           CTxDestination &dest, std::string &error);
    bool GetNewChangeDestination(const OutputType type, CTxDestination &dest,
                                 std::string &error);

    isminetype IsMine(const CTxDestination &dest) const;
    isminetype IsMine(const CScript &script) const;
    isminetype IsMine(const CTxIn &txin) const;
    Amount GetDebit(const CTxIn &txin, const isminefilter &filter) const;
    isminetype IsMine(const CTxOut &txout) const;
    Amount GetCredit(const CTxOut &txout, const isminefilter &filter) const;
    bool IsChange(const CTxOut &txout) const;
    bool IsChange(const CScript &script) const;
    Amount GetChange(const CTxOut &txout) const;
    bool IsMine(const CTransaction &tx) const;
    bool IsFromMe(const CTransaction &tx) const;
    Amount GetDebit(const CTransaction &tx, const isminefilter &filter) const;
    bool IsAllFromMe(const CTransaction &tx, const isminefilter &filter) const;
    Amount GetCredit(const CTransaction &tx, const isminefilter &filter) const;
    Amount GetChange(const CTransaction &tx) const;
    void chainStateFlushed(const CBlockLocator &loc) override;

    DBErrors LoadWallet(bool &fFirstRunRet);
    DBErrors ZapWalletTx(std::vector<CWalletTx> &vWtx);
    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(bool shutdown = false);

    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 bool Verify(const CChainParams &chainParams,
                       interfaces::Chain &chain, const WalletLocation &location,
                       bilingual_str &error_string,
                       std::vector<bilingual_str> &warnings);

    static std::shared_ptr<CWallet>
    CreateWalletFromFile(const CChainParams &chainParams,
                         interfaces::Chain &chain,
                         const WalletLocation &location, bilingual_str &error,
                         std::vector<bilingual_str> &warnings,
                         uint64_t wallet_creation_flags = 0);

    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, cs_wallet);

    void SetWalletFlag(uint64_t flags);

    void UnsetWalletFlag(uint64_t flag);

    bool IsWalletFlagSet(uint64_t flag) const override;

    bool SetWalletFlags(uint64_t overwriteFlags, bool memOnly);

    bool IsLegacy() const;

    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::vector<bilingual_str> &warnings);

    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();

    const CKeyingMaterial &GetEncryptionKey() 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 SetActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal,
                                  bool memonly = false);

    void SetupDescriptorScriptPubKeyMans();

    DescriptorScriptPubKeyMan *
    GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const;

    ScriptPubKeyMan *
    AddWalletDescriptor(WalletDescriptor &desc,
                        const FlatSigningProvider &signing_provider,
                        const std::string &label);
};

void MaybeResendWalletTxs();

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 = GetTimeMillis();
        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;
        }
    }
};

// Calculate the size of the transaction assuming all signatures are max size
// Use DummySignatureCreator, which inserts 71 byte signatures everywhere.
// NOTE: this requires that all inputs must be in mapWallet (eg the tx should
// be IsAllFromMe).
int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                     const CWallet *wallet,
                                     bool use_max_sig = false)
    EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                     const CWallet *wallet,
                                     const std::vector<CTxOut> &txouts,
                                     bool use_max_sig = false);

#endif // BITCOIN_WALLET_WALLET_H