transactionrecord.h

Go to the documentation of this file.

// Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2014-2016 The Dash developers
// Copyright (c) 2016-2021 The PIVX Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_QT_TRANSACTIONRECORD_H
#define PIVX_QT_TRANSACTIONRECORD_H
 
#include "amount.h"
#include "script/script.h"
#include "optional.h"
#include "uint256.h"
 
#include <QList>
#include <QString>
 
class CWallet;
class CWalletTx;
 
class TransactionStatus
{
public:
    TransactionStatus() : countsForBalance(false), sortKey(""),
                          matures_in(0), status(Unconfirmed), depth(0), open_for(0), cur_num_blocks(-1)
    {
    }
 
    enum Status : uint16_t{
        Confirmed = 0, 
        OpenUntilDate,  
        OpenUntilBlock, 
        Unconfirmed,    
        Confirming,     
        Conflicted,     
        Immature,       
        NotAccepted     
    };
 
    bool countsForBalance;
    std::string sortKey;
 
    int matures_in;
    Status status;
    qint64 depth;
    qint64 open_for; 
    int cur_num_blocks;
 
    bool needsUpdate;
};
 
class TransactionRecord
{
public:
    enum Type : uint16_t {
        Other = 0,
        Generated,
        StakeMint,
        StakeZPIV,
        SendToAddress,
        SendToOther,
        RecvWithAddress,
        MNReward,
        BudgetPayment,
        RecvFromOther,
        SendToSelf,
        ZerocoinMint,
        ZerocoinSpend,
        RecvFromZerocoinSpend,
        ZerocoinSpend_Change_zPiv,
        ZerocoinSpend_FromMe,
        StakeDelegated, // Received cold stake (owner)
        StakeHot, // Staked via a delegated P2CS.
        P2CSDelegation, // Non-spendable P2CS, staker side.
        P2CSDelegationSent, // Non-spendable P2CS delegated utxo. (coin-owner transferred ownership to external wallet)
        P2CSDelegationSentOwner, // Spendable P2CS delegated utxo. (coin-owner)
        P2CSUnlockOwner, // Coin-owner spent the delegated utxo
        P2CSUnlockStaker, // Staker watching the owner spent the delegated utxo
        SendToShielded, // Shielded send
        RecvWithShieldedAddress, // Shielded receive
        RecvWithShieldedAddressMemo, // Shielded receive with memo
        SendToSelfShieldedAddress, // Shielded send to self
        SendToSelfShieldToTransparent, // Unshield coins to self
        SendToSelfShieldToShieldChangeAddress, // Changing coins from one shielded address to another inside the wallet.
        SendToNobody // Burned PIVs, op_return output.
    };
 
    static const int RecommendedNumConfirmations = 6;
 
    explicit TransactionRecord(unsigned int size) : hash(), time(0), type(Other), address(""), debit(0), credit(0), size(size), idx(0)
    {
    }
 
    TransactionRecord(uint256 hash, qint64 time, unsigned int size) : hash(hash), time(time), type(Other), address(""), debit(0),
                                                   credit(0), size(size), idx(0)
    {
    }
 
    TransactionRecord(uint256 hash, qint64 time, unsigned int size, Type type, const std::string& address, const CAmount& debit, const CAmount& credit) : hash(hash), time(time), type(type), address(address), debit(debit), credit(credit),
                                                                                                                                       size(size), idx(0)
    {
    }
 
    static QList<TransactionRecord> decomposeTransaction(const CWallet* wallet, const CWalletTx& wtx);
 
    static bool decomposeCoinStake(const CWallet* wallet, const CWalletTx& wtx,
                                   const CAmount& nCredit, const CAmount& nDebit,
                                   QList<TransactionRecord>& parts);
 
    static bool decomposeZcSpendTx(const CWallet* wallet, const CWalletTx& wtx,
                                   const CAmount& nCredit, const CAmount& nDebit,
                                   QList<TransactionRecord>& parts);
 
    static bool decomposeP2CS(const CWallet* wallet, const CWalletTx& wtx,
                                    const CAmount& nCredit, const CAmount& nDebit,
                                    QList<TransactionRecord>& parts);
 
    static bool decomposeCreditTransaction(const CWallet* wallet, const CWalletTx& wtx,
                                    QList<TransactionRecord>& parts);
 
    static bool decomposeSendToSelfTransaction(const CWalletTx& wtx, const CAmount& nCredit,
                                    const CAmount& nDebit, bool involvesWatchAddress,
                                    QList<TransactionRecord>& parts, const CWallet* wallet);
 
    static bool decomposeDebitTransaction(const CWallet* wallet, const CWalletTx& wtx,
                                                      const CAmount& nDebit, bool involvesWatchAddress,
                                                      QList<TransactionRecord>& parts);
 
    static bool decomposeShieldedDebitTransaction(const CWallet* wallet, const CWalletTx& wtx, CAmount nTxFee,
                                                  bool involvesWatchAddress, QList<TransactionRecord>& parts);
 
    static std::string getValueOrReturnEmpty(const std::map<std::string, std::string>& mapValue, const std::string& key);
    static void loadHotOrColdStakeOrContract(const CWallet* wallet, const CWalletTx& wtx,
                                            TransactionRecord& record, bool isContract = false);
    static void loadUnlockColdStake(const CWallet* wallet, const CWalletTx& wtx, TransactionRecord& record);
 
    uint256 hash;
    qint64 time;
    Type type;
    std::string address;
    CAmount debit;
    CAmount credit;
    unsigned int size;
    Optional<CAmount> shieldedCredit{nullopt};
    Optional<std::string> memo{nullopt};
    int idx;
 
    TransactionStatus status;
 
    bool involvesWatchAddress{false};
 
    int getOutputIndex() const;
 
    void updateStatus(const CWalletTx& wtx, int chainHeight);
 
    bool statusUpdateNeeded(int blockHeight) const;
 
    std::string statusToString();
 
    bool isCoinStake() const;
 
    bool isMNReward() const;
 
    bool isAnyColdStakingType() const;
 
    bool isNull() const;
 
};
 
#endif // PIVX_QT_TRANSACTIONRECORD_H