transaction.h

Go to the documentation of this file.

// Copyright (c) 2021 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_WALLET_TRANSACTION_H
#define BITCOIN_WALLET_TRANSACTION_H
 
#include <consensus/amount.h>
#include <primitives/blockhash.h>
#include <primitives/transaction.h>
#include <serialize.h>
#include <threadsafety.h>
#include <tinyformat.h>
#include <util/strencodings.h>
#include <util/string.h>
#include <wallet/ismine.h>
 
#include <list>
#include <vector>
 
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"]);
}
 
static inline void WriteOrderPos(const int64_t &nOrderPos,
                                 mapValue_t &mapValue) {
    if (nOrderPos == -1) {
        return;
    }
    mapValue["n"] = ToString(nOrderPos);
}
 
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;
    }
};
 
class CWalletTx {
private:
    static constexpr const uint256 &ABANDON_HASH = uint256::ONE;
 
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
    };
    mutable CachableAmount m_amounts[AMOUNTTYPE_ENUM_ELEMENTS];
    mutable bool m_is_cache_empty{true};
    mutable bool fChangeCached;
    mutable bool fInMempool;
    mutable Amount nChangeCached;
 
    CWalletTx(CTransactionRef arg) : tx(std::move(arg)) { Init(); }
 
    void Init() {
        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<uint8_t> dummy_vector1;
        std::vector<uint8_t> 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();
 
        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;
    }
 
    // True if only scriptSigs are different
    bool IsEquivalentTo(const CWalletTx &tx) const;
 
    bool InMempool() const;
 
    int64_t GetTxTime() 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(); }
 
    // Disable copying of CWalletTx objects to prevent bugs where instances get
    // copied in and out of the mapWallet map, and fields are updated in the
    // wrong copy.
    CWalletTx(CWalletTx const &) = delete;
    void operator=(CWalletTx const &x) = delete;
};
 
#endif // BITCOIN_WALLET_TRANSACTION_H