doge/transactiondesc_8cpp_source.html

 // Copyright (c) 2011-2016 The Bitcoin 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 "chainparams.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 <stdint.h>

 #include <string>


 QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)

 {

     AssertLockHeld(cs_main);

     if (!CheckFinalTx(wtx))

     {

         if (wtx.tx->nLockTime < LOCKTIME_THRESHOLD)

             return tr("Open for %n more block(s)", "", wtx.tx->nLockTime - chainActive.Height());

         else

             return tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx.tx->nLockTime));

     }

     else

     {

         int nDepth = wtx.GetDepthInMainChain();

         if (nDepth < 0)

             return tr("conflicted with a transaction with %1 confirmations").arg(-nDepth);

         else if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)

             return tr("%1/offline").arg(nDepth);

         else if (nDepth == 0)

             return tr("0/unconfirmed, %1").arg((wtx.InMempool() ? tr("in memory pool") : tr("not in memory pool"))) + (wtx.isAbandoned() ? ", "+tr("abandoned") : "");

         else if (nDepth < 6)

             return tr("%1/unconfirmed").arg(nDepth);

         else

             return tr("%1 confirmations").arg(nDepth);

     }

 }


 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.tx->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.tx->vin)

         {

             isminetype mine = wallet->IsMine(txin);

             if(fAllFromMe > mine) fAllFromMe = mine;

         }


         isminetype fAllToMe = ISMINE_SPENDABLE;

         BOOST_FOREACH(const CTxOut& txout, wtx.tx->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.tx->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.tx->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.tx->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.tx->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> " + rec->getTxID() + "<br>";

     strHTML += "<b>" + tr("Transaction total size") + ":</b> " + QString::number(wtx.tx->GetTotalSize()) + " bytes<br>";

     strHTML += "<b>" + tr("Output index") + ":</b> " + QString::number(rec->getOutputIndex()) + "<br>";


     // Message from normal bitcoin:URI (bitcoin:123...?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 nCoinbaseMaturity = Params().GetConsensus(chainActive.Height()).nCoinbaseMaturity + 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(nCoinbaseMaturity)) + "<br>";

     }


     //

     // Debug view

     //

     if (fDebug)

     {

         strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";

         BOOST_FOREACH(const CTxIn& txin, wtx.tx->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.tx->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.tx->ToString(), true);


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

         strHTML += "<ul>";


         BOOST_FOREACH(const CTxIn& txin, wtx.tx->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")) + "</li>";

                     strHTML = strHTML + " IsWatchOnly=" + (wallet->IsMine(vout) & ISMINE_WATCH_ONLY ? tr("true") : tr("false")) + "</li>";

                 }

             }

         }


         strHTML += "</ul>";

     }


     strHTML += "</font></html>";

     return strHTML;

 }

CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:15

base58.h

bitcoinunits.h

Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:486

chainparams.h

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:139

CBitcoinAddress
base58-encoded Bitcoin addresses.
Definition: base58.h:104

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

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

CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:474

CChainParams::GetConsensus
const Consensus::Params & GetConsensus(uint32_t nTargetHeight) const
Definition: chainparams.h:59

CCoins
Pruned version of CTransaction: only retains metadata and unspent transaction outputs.
Definition: coins.h:75

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:81

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

CMerkleTx::GetDepthInMainChain
int GetDepthInMainChain(const CBlockIndex *&pindexRet) const
Return depth of transaction in blockchain: <0 : conflicts with a transaction this deep in the blockch...
Definition: auxpow.cpp:45

CMerkleTx::isAbandoned
bool isAbandoned() const
Definition: auxpow.h:110

CMerkleTx::IsCoinBase
bool IsCoinBase() const
Definition: auxpow.h:114

CMerkleTx::GetBlocksToMaturity
int GetBlocksToMaturity() const
Definition: auxpow.cpp:64

CMerkleTx::IsInMainChain
bool IsInMainChain() const
Definition: auxpow.h:105

CMerkleTx::tx
CTransactionRef tx
Definition: auxpow.h:37

COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:20

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

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

CTxIn
An input of a transaction.
Definition: transaction.h:63

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

CTxOut
An output of a transaction.
Definition: transaction.h:133

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

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

CWallet
A CWallet is an extension of a keystore, which also maintains a set of transactions and balances,...
Definition: wallet.h:493

CWallet::mapAddressBook
std::map< CTxDestination, CAddressBookData > mapAddressBook
Definition: wallet.h:624

CWallet::cs_wallet
CCriticalSection cs_wallet
Definition: wallet.h:559

CWalletTx
A transaction with a bunch of additional info that only the owner cares about.
Definition: wallet.h:177

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

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

CWalletTx::nTimeReceived
unsigned int nTimeReceived
time received by this node
Definition: wallet.h:185

PaymentRequestPlus
Definition: paymentrequestplus.h:29

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

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

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

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

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

TransactionRecord
UI model for a transaction.
Definition: transactionrecord.h:70

TransactionRecord::getOutputIndex
int getOutputIndex() const
Return the output index of the subtransaction
Definition: transactionrecord.cpp:269

TransactionRecord::getTxID
QString getTxID() const
Return the unique identifier for this transaction (part)
Definition: transactionrecord.cpp:264

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

consensus.h

db.h

CWalletTx::GetCredit
CAmount GetCredit(const isminefilter &filter) const
Definition: wallet.cpp:1695

CWallet::IsMine
isminetype IsMine(const CTxIn &txin) const
Definition: wallet.cpp:1201

CWallet::GetDebit
CAmount GetDebit(const CTxIn &txin, const isminefilter &filter) const
Returns amount of debit if the input matches the filter, otherwise returns 0.
Definition: wallet.cpp:1218

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

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

CWallet::GetCredit
CAmount GetCredit(const CTxOut &txout, const isminefilter &filter) const
Definition: wallet.cpp:1239

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

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

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

guiutil.h

IsMine
isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey, SigVersion sigversion)
Definition: ismine.cpp:32

isminetype
isminetype
IsMine() return codes.
Definition: ismine.h:18

ISMINE_ALL
@ ISMINE_ALL
Definition: ismine.h:26

ISMINE_SPENDABLE
@ ISMINE_SPENDABLE
Definition: ismine.h:25

ISMINE_WATCH_ONLY
@ ISMINE_WATCH_ONLY
Definition: ismine.h:24

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

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

paymentserver.h

script.h

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

CTxDestination
boost::variant< CNoDestination, CKeyID, CScriptID > CTxDestination
A txout script template with a specific destination.
Definition: standard.h:71

Consensus::Params::nCoinbaseMaturity
uint32_t nCoinbaseMaturity
Definition: params.h:61

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

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

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

timedata.h

transactiondesc.h

transactionrecord.h

fDebug
bool fDebug
Definition: util.cpp:113

PAIRTYPE
#define PAIRTYPE(t1, t2)
This is needed because the foreach macro can't get over the comma in pair<t1, t2>
Definition: utilstrencodings.h:23

pcoinsTip
CCoinsViewCache * pcoinsTip
Global variable that points to the active CCoinsView (protected by cs_main)
Definition: validation.cpp:223

cs_main
CCriticalSection cs_main
Global state.
Definition: validation.cpp:61

CheckFinalTx
bool CheckFinalTx(const CTransaction &tx, int flags)
Check if transaction will be final in the next block to be created.
Definition: validation.cpp:250

chainActive
CChain chainActive
The currently-connected chain of blocks (protected by cs_main).
Definition: validation.cpp:64

wallet.h