doxygen/html/transactiondesc_8cpp_source.html

 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Copyright (c) 2014-2017 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.

 #include "transactiondesc.h"

 #include "bitcoinunits.h"
 #include "guiutil.h"
 #include "paymentserver.h"
 #include "transactionrecord.h"

 #include "base58.h"
 #include "consensus/consensus.h"
 #include "validation.h"
 #include "script/script.h"
 #include "timedata.h"
 #include "util.h"
 #include "wallet/db.h"
 #include "wallet/wallet.h"

 #include "instantx.h"

 #include <stdint.h>
 #include <string>

 QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)
 {
     AssertLockHeld(cs_main);
     if (!CheckFinalTx(wtx))
     {
         if (wtx.nLockTime < LOCKTIME_THRESHOLD)
             return tr("Open for %n more block(s)", "", wtx.nLockTime - chainActive.Height());
         else
             return tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx.nLockTime));
     }
     else
     {
         int nDepth = wtx.GetDepthInMainChain();
         if (nDepth < 0) return tr("conflicted");

         QString strTxStatus;
         bool fOffline = (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60) && (wtx.GetRequestCount() == 0);

         if (fOffline) {
             strTxStatus = tr("%1/offline").arg(nDepth);
         } else if (nDepth == 0) {
             strTxStatus = tr("0/unconfirmed, %1").arg((wtx.InMempool() ? tr("in memory pool") : tr("not in memory pool"))) + (wtx.isAbandoned() ? ", "+tr("abandoned") : "");
         } else if (nDepth < 6) {
             strTxStatus = tr("%1/unconfirmed").arg(nDepth);
         } else {
             strTxStatus = tr("%1 confirmations").arg(nDepth);
         }

         if(!instantsend.HasTxLockRequest(wtx.GetHash())) return strTxStatus; // regular tx

         int nSignatures = instantsend.GetTransactionLockSignatures(wtx.GetHash());
         int nSignaturesMax = CTxLockRequest(wtx).GetMaxSignatures();
         // InstantSend
         strTxStatus += " (";
         if(instantsend.IsLockedInstantSendTransaction(wtx.GetHash())) {
             strTxStatus += tr("verified via InstantSend");
         } else if(!instantsend.IsTxLockCandidateTimedOut(wtx.GetHash())) {
             strTxStatus += tr("InstantSend verification in progress - %1 of %2 signatures").arg(nSignatures).arg(nSignaturesMax);
         } else {
             strTxStatus += tr("InstantSend verification failed");
         }
         strTxStatus += ")";

         return strTxStatus;
     }
 }

 QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx, TransactionRecord *rec, int unit)
 {
     QString strHTML;

     LOCK2(cs_main, wallet->cs_wallet);
     strHTML.reserve(4000);
     strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";

     int64_t nTime = wtx.GetTxTime();
     CAmount nCredit = wtx.GetCredit(ISMINE_ALL);
     CAmount nDebit = wtx.GetDebit(ISMINE_ALL);
     CAmount nNet = nCredit - nDebit;

     strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(wtx);
     int nRequests = wtx.GetRequestCount();
     if (nRequests != -1)
     {
         if (nRequests == 0)
             strHTML += tr(", has not been successfully broadcast yet");
         else if (nRequests > 0)
             strHTML += tr(", broadcast through %n node(s)", "", nRequests);
     }
     strHTML += "<br>";

     strHTML += "<b>" + tr("Date") + ":</b> " + (nTime ? GUIUtil::dateTimeStr(nTime) : "") + "<br>";

     //
     // From
     //
     if (wtx.IsCoinBase())
     {
         strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
     }
     else if (wtx.mapValue.count("from") && !wtx.mapValue["from"].empty())
     {
         // Online transaction
         strHTML += "<b>" + tr("From") + ":</b> " + GUIUtil::HtmlEscape(wtx.mapValue["from"]) + "<br>";
     }
     else
     {
         // Offline transaction
         if (nNet > 0)
         {
             // Credit
             if (CBitcoinAddress(rec->address).IsValid())
             {
                 CTxDestination address = CBitcoinAddress(rec->address).Get();
                 if (wallet->mapAddressBook.count(address))
                 {
                     strHTML += "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
                     strHTML += "<b>" + tr("To") + ":</b> ";
                     strHTML += GUIUtil::HtmlEscape(rec->address);
                     QString addressOwned = (::IsMine(*wallet, address) == ISMINE_SPENDABLE) ? tr("own address") : tr("watch-only");
                     if (!wallet->mapAddressBook[address].name.empty())
                         strHTML += " (" + addressOwned + ", " + tr("label") + ": " + GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + ")";
                     else
                         strHTML += " (" + addressOwned + ")";
                     strHTML += "<br>";
                 }
             }
         }
     }

     //
     // To
     //
     if (wtx.mapValue.count("to") && !wtx.mapValue["to"].empty())
     {
         // Online transaction
         std::string strAddress = wtx.mapValue["to"];
         strHTML += "<b>" + tr("To") + ":</b> ";
         CTxDestination dest = CBitcoinAddress(strAddress).Get();
         if (wallet->mapAddressBook.count(dest) && !wallet->mapAddressBook[dest].name.empty())
             strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[dest].name) + " ";
         strHTML += GUIUtil::HtmlEscape(strAddress) + "<br>";
     }

     //
     // Amount
     //
     if (wtx.IsCoinBase() && nCredit == 0)
     {
         //
         // Coinbase
         //
         CAmount nUnmatured = 0;
         BOOST_FOREACH(const CTxOut& txout, wtx.vout)
             nUnmatured += wallet->GetCredit(txout, ISMINE_ALL);
         strHTML += "<b>" + tr("Credit") + ":</b> ";
         if (wtx.IsInMainChain())
             strHTML += BitcoinUnits::formatHtmlWithUnit(unit, nUnmatured)+ " (" + tr("matures in %n more block(s)", "", wtx.GetBlocksToMaturity()) + ")";
         else
             strHTML += "(" + tr("not accepted") + ")";
         strHTML += "<br>";
     }
     else if (nNet > 0)
     {
         //
         // Credit
         //
         strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nNet) + "<br>";
     }
     else
     {
         isminetype fAllFromMe = ISMINE_SPENDABLE;
         BOOST_FOREACH(const CTxIn& txin, wtx.vin)
         {
             isminetype mine = wallet->IsMine(txin);
             if(fAllFromMe > mine) fAllFromMe = mine;
         }

         isminetype fAllToMe = ISMINE_SPENDABLE;
         BOOST_FOREACH(const CTxOut& txout, wtx.vout)
         {
             isminetype mine = wallet->IsMine(txout);
             if(fAllToMe > mine) fAllToMe = mine;
         }

         if (fAllFromMe)
         {
             if(fAllFromMe & ISMINE_WATCH_ONLY)
                 strHTML += "<b>" + tr("From") + ":</b> " + tr("watch-only") + "<br>";

             //
             // Debit
             //
             BOOST_FOREACH(const CTxOut& txout, wtx.vout)
             {
                 // Ignore change
                 isminetype toSelf = wallet->IsMine(txout);
                 if ((toSelf == ISMINE_SPENDABLE) && (fAllFromMe == ISMINE_SPENDABLE))
                     continue;

                 if (!wtx.mapValue.count("to") || wtx.mapValue["to"].empty())
                 {
                     // Offline transaction
                     CTxDestination address;
                     if (ExtractDestination(txout.scriptPubKey, address))
                     {
                         strHTML += "<b>" + tr("To") + ":</b> ";
                         if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].name.empty())
                             strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + " ";
                         strHTML += GUIUtil::HtmlEscape(CBitcoinAddress(address).ToString());
                         if(toSelf == ISMINE_SPENDABLE)
                             strHTML += " (own address)";
                         else if(toSelf & ISMINE_WATCH_ONLY)
                             strHTML += " (watch-only)";
                         strHTML += "<br>";
                     }
                 }

                 strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -txout.nValue) + "<br>";
                 if(toSelf)
                     strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, txout.nValue) + "<br>";
             }

             if (fAllToMe)
             {
                 // Payment to self
                 CAmount nChange = wtx.GetChange();
                 CAmount nValue = nCredit - nChange;
                 strHTML += "<b>" + tr("Total debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nValue) + "<br>";
                 strHTML += "<b>" + tr("Total credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nValue) + "<br>";
             }

             CAmount nTxFee = nDebit - wtx.GetValueOut();
             if (nTxFee > 0)
                 strHTML += "<b>" + tr("Transaction fee") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nTxFee) + "<br>";
         }
         else
         {
             //
             // Mixed debit transaction
             //
             BOOST_FOREACH(const CTxIn& txin, wtx.vin)
                 if (wallet->IsMine(txin))
                     strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -wallet->GetDebit(txin, ISMINE_ALL)) + "<br>";
             BOOST_FOREACH(const CTxOut& txout, wtx.vout)
                 if (wallet->IsMine(txout))
                     strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet->GetCredit(txout, ISMINE_ALL)) + "<br>";
         }
     }

     strHTML += "<b>" + tr("Net amount") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nNet, true) + "<br>";

     //
     // Message
     //
     if (wtx.mapValue.count("message") && !wtx.mapValue["message"].empty())
         strHTML += "<br><b>" + tr("Message") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.mapValue["message"], true) + "<br>";
     if (wtx.mapValue.count("comment") && !wtx.mapValue["comment"].empty())
         strHTML += "<br><b>" + tr("Comment") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.mapValue["comment"], true) + "<br>";

     strHTML += "<b>" + tr("Transaction ID") + ":</b> " + TransactionRecord::formatSubTxId(wtx.GetHash(), rec->idx) + "<br>";
     strHTML += "<b>" + tr("Transaction total size") + ":</b> " + QString::number(wtx.GetTotalSize()) + " bytes<br>";

     // Message from normal dash:URI (dash:XyZ...?message=example)
     Q_FOREACH (const PAIRTYPE(std::string, std::string)& r, wtx.vOrderForm)
         if (r.first == "Message")
             strHTML += "<br><b>" + tr("Message") + ":</b><br>" + GUIUtil::HtmlEscape(r.second, true) + "<br>";

     //
     // PaymentRequest info:
     //
     Q_FOREACH (const PAIRTYPE(std::string, std::string)& r, wtx.vOrderForm)
     {
         if (r.first == "PaymentRequest")
         {
             PaymentRequestPlus req;
             req.parse(QByteArray::fromRawData(r.second.data(), r.second.size()));
             QString merchant;
             if (req.getMerchant(PaymentServer::getCertStore(), merchant))
                 strHTML += "<b>" + tr("Merchant") + ":</b> " + GUIUtil::HtmlEscape(merchant) + "<br>";
         }
     }

     if (wtx.IsCoinBase())
     {
         quint32 numBlocksToMaturity = COINBASE_MATURITY +  1;
         strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.").arg(QString::number(numBlocksToMaturity)) + "<br>";
     }

     //
     // Debug view
     //
     if (fDebug)
     {
         strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";
         BOOST_FOREACH(const CTxIn& txin, wtx.vin)
             if(wallet->IsMine(txin))
                 strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -wallet->GetDebit(txin, ISMINE_ALL)) + "<br>";
         BOOST_FOREACH(const CTxOut& txout, wtx.vout)
             if(wallet->IsMine(txout))
                 strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet->GetCredit(txout, ISMINE_ALL)) + "<br>";

         strHTML += "<br><b>" + tr("Transaction") + ":</b><br>";
         strHTML += GUIUtil::HtmlEscape(wtx.ToString(), true);

         strHTML += "<br><b>" + tr("Inputs") + ":</b>";
         strHTML += "<ul>";

         BOOST_FOREACH(const CTxIn& txin, wtx.vin)
         {
             COutPoint prevout = txin.prevout;

             CCoins prev;
             if(pcoinsTip->GetCoins(prevout.hash, prev))
             {
                 if (prevout.n < prev.vout.size())
                 {
                     strHTML += "<li>";
                     const CTxOut &vout = prev.vout[prevout.n];
                     CTxDestination address;
                     if (ExtractDestination(vout.scriptPubKey, address))
                     {
                         if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].name.empty())
                             strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + " ";
                         strHTML += QString::fromStdString(CBitcoinAddress(address).ToString());
                     }
                     strHTML = strHTML + " " + tr("Amount") + "=" + BitcoinUnits::formatHtmlWithUnit(unit, vout.nValue);
                     strHTML = strHTML + " IsMine=" + (wallet->IsMine(vout) & ISMINE_SPENDABLE ? tr("true") : tr("false"));
                     strHTML = strHTML + " IsWatchOnly=" + (wallet->IsMine(vout) & ISMINE_WATCH_ONLY ? tr("true") : tr("false")) + "</li>";
                 }
             }
         }

         strHTML += "</ul>";
     }

     strHTML += "</font></html>";
     return strHTML;
 }
CWalletTx::GetCredit
CAmount GetCredit(const isminefilter &filter) const
Definition: wallet.cpp:1824

COutPoint::n
uint32_t n
Definition: transaction.h:19

CMerkleTx::isAbandoned
bool isAbandoned() const
Definition: wallet.h:267

CTxDestination
boost::variant< CNoDestination, CKeyID, CScriptID > CTxDestination
Definition: standard.h:69

CTransaction::nLockTime
const uint32_t nLockTime
Definition: transaction.h:235

CTxIn
Definition: transaction.h:58

ExtractDestination
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Definition: standard.cpp:164

CCoinsViewCache::GetCoins
bool GetCoins(const uint256 &txid, CCoins &coins) const
Retrieve the CCoins (unspent transaction outputs) for a given txid.
Definition: coins.cpp:90

ISMINE_SPENDABLE
Definition: wallet_ismine.h:25

CCoins
Definition: coins.h:73

CInstantSend::IsTxLockCandidateTimedOut
bool IsTxLockCandidateTimedOut(const uint256 &txHash)
Definition: instantx.cpp:816

TransactionRecord::idx
int idx
Definition: transactionrecord.h:130

fDebug
bool fDebug
Definition: util.cpp:124

CBitcoinAddress::IsValid
bool IsValid() const
Definition: base58.cpp:247

CWallet
Definition: wallet.h:617

CBitcoinAddress
Definition: base58.h:104

cs_main
CCriticalSection cs_main
Definition: validation.cpp:62

IsMine
isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest)
Definition: wallet_ismine.cpp:32

PaymentRequestPlus::parse
bool parse(const QByteArray &data)
Definition: paymentrequestplus.cpp:28

CTxOut::nValue
CAmount nValue
Definition: transaction.h:136

PaymentRequestPlus
Definition: paymentrequestplus.h:25

COINBASE_MATURITY
static const int COINBASE_MATURITY
Definition: consensus.h:23

CWalletTx::mapValue
mapValue_t mapValue
Definition: wallet.h:281

PaymentServer::getCertStore
static X509_STORE * getCertStore()
Definition: paymentserver.cpp:812

transactiondesc.h

CTransaction::GetValueOut
CAmount GetValueOut() const
Definition: transaction.cpp:112

wallet.h

script.h

CWalletTx::nTimeReceived
unsigned int nTimeReceived
Definition: wallet.h:284

CWalletTx::GetChange
CAmount GetChange() const
Definition: wallet.cpp:2023

CMerkleTx::IsInMainChain
bool IsInMainChain() const
Definition: wallet.h:263

bitcoinunits.h

CAmount
int64_t CAmount
Definition: amount.h:14

AssertLockHeld
#define AssertLockHeld(cs)
Definition: sync.h:96

BitcoinUnits::formatHtmlWithUnit
static QString formatHtmlWithUnit(int unit, const CAmount &amount, bool plussign=false, SeparatorStyle separators=separatorStandard)
Format as HTML string (with unit)
Definition: bitcoinunits.cpp:167

base58.h

pcoinsTip
CCoinsViewCache * pcoinsTip
Definition: validation.cpp:187

LOCK2
#define LOCK2(cs1, cs2)
Definition: sync.h:169

CCoins::vout
std::vector< CTxOut > vout
unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are d...
Definition: coins.h:80

guiutil.h

CTransaction::GetTotalSize
unsigned int GetTotalSize() const
Definition: transaction.cpp:150

db.h

CheckFinalTx
bool CheckFinalTx(const CTransaction &tx, int flags)
Definition: validation.cpp:213

CInstantSend::GetTransactionLockSignatures
int GetTransactionLockSignatures(const uint256 &txHash)
Definition: instantx.cpp:795

PaymentRequestPlus::getMerchant
bool getMerchant(X509_STORE *certStore, QString &merchant) const
Definition: paymentrequestplus.cpp:60

CTxIn::prevout
COutPoint prevout
Definition: transaction.h:61

COutPoint
Definition: transaction.h:15

TransactionDesc::toHTML
static QString toHTML(CWallet *wallet, CWalletTx &wtx, TransactionRecord *rec, int unit)
Definition: transactiondesc.cpp:74

TransactionDesc::FormatTxStatus
static QString FormatTxStatus(const CWalletTx &wtx)
Definition: transactiondesc.cpp:27

CWalletTx::GetTxTime
int64_t GetTxTime() const
Definition: wallet.cpp:1540

instantx.h

CChain::Height
int Height() const
Definition: chain.h:397

GUIUtil::HtmlEscape
QString HtmlEscape(const QString &str, bool fMultiLine)
Definition: guiutil.cpp:261

instantsend
CInstantSend instantsend
Definition: instantx.cpp:30

CWalletTx::GetDebit
CAmount GetDebit(const isminefilter &filter) const
filter decides which addresses will count towards the debit
Definition: wallet.cpp:1793

CTxLockRequest
Definition: instantx.h:121

CWalletTx::vOrderForm
std::vector< std::pair< std::string, std::string > > vOrderForm
Definition: wallet.h:282

CInstantSend::IsLockedInstantSendTransaction
bool IsLockedInstantSendTransaction(const uint256 &txHash)
Definition: instantx.cpp:770

chainActive
CChain chainActive
Definition: validation.cpp:65

paymentserver.h

timedata.h

CWalletTx
Definition: wallet.h:275

transactionrecord.h

wallet
Definition: wallet.py:1

CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:137

CTransaction::vin
const std::vector< CTxIn > vin
Definition: transaction.h:233

CBitcoinAddress::Get
CTxDestination Get() const
Definition: base58.cpp:260

TransactionRecord::formatSubTxId
static QString formatSubTxId(const uint256 &hash, int vout)
Definition: transactionrecord.cpp:330

CTransaction::GetHash
const uint256 & GetHash() const
Definition: transaction.h:262

GetAdjustedTime
int64_t GetAdjustedTime()
Definition: timedata.cpp:33

CTransaction::ToString
std::string ToString() const
Definition: transaction.cpp:155

CTransaction::IsCoinBase
bool IsCoinBase() const
Definition: transaction.h:284

consensus.h

CTransaction::vout
const std::vector< CTxOut > vout
Definition: transaction.h:234

ISMINE_WATCH_ONLY
Definition: wallet_ismine.h:24

CInstantSend::HasTxLockRequest
bool HasTxLockRequest(const uint256 &txHash)
Definition: instantx.cpp:730

LOCKTIME_THRESHOLD
static const unsigned int LOCKTIME_THRESHOLD
Definition: script.h:32

isminetype
isminetype
Definition: wallet_ismine.h:17

ISMINE_ALL
Definition: wallet_ismine.h:26

CTxLockRequest::GetMaxSignatures
int GetMaxSignatures() const
Definition: instantx.cpp:990

TransactionRecord::address
std::string address
Definition: transactionrecord.h:124

PAIRTYPE
#define PAIRTYPE(t1, t2)
Definition: utilstrencodings.h:23

COutPoint::hash
uint256 hash
Definition: transaction.h:18

CMerkleTx::GetBlocksToMaturity
int GetBlocksToMaturity() const
Definition: wallet.cpp:4449

CMerkleTx::GetDepthInMainChain
int GetDepthInMainChain(const CBlockIndex *&pindexRet, bool enableIX=true) const
Definition: wallet.cpp:4416

CWalletTx::InMempool
bool InMempool() const
Definition: wallet.cpp:2032

TransactionRecord
Definition: transactionrecord.h:72

CWalletTx::GetRequestCount
int GetRequestCount() const
Definition: wallet.cpp:1546

CTxOut
Definition: transaction.h:133

GUIUtil::dateTimeStr
QString dateTimeStr(const QDateTime &date)
Definition: guiutil.cpp:87