src/qt/transactionrecord.cpp

   1 // Copyright (c) 2011-2016 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "transactionrecord.h"
   6
   7 #include "base58.h"
   8 #include "consensus/consensus.h"
   9 #include "validation.h"
  10 #include "timedata.h"
  11 #include "wallet/wallet.h"
  12
  13 #include <stdint.h>
  14
  15
  16 /* Return positive answer if transaction should be shown in list.
  17  */
  18 bool TransactionRecord::showTransaction(const CWalletTx &wtx)
  19 {
  20     // There are currently no cases where we hide transactions, but
  21     // we may want to use this in the future for things like RBF.
  22     return true;
  23 }
  24
  25 /*
  26  * Decompose CWallet transaction to model transaction records.
  27  */
  28 QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
  29 {
  30     QList<TransactionRecord> parts;
  31     int64_t nTime = wtx.GetTxTime();
  32     CAmount nCredit = wtx.GetCredit(ISMINE_ALL);
  33     CAmount nDebit = wtx.GetDebit(ISMINE_ALL);
  34     CAmount nNet = nCredit - nDebit;
  35     uint256 hash = wtx.GetHash();
  36     std::map<std::string, std::string> mapValue = wtx.mapValue;
  37
  38     if (nNet > 0 || wtx.IsCoinBase())
  39     {
  40         //
  41         // Credit
  42         //
  43         for(unsigned int i = 0; i < wtx.tx->vout.size(); i++)
  44         {
  45             const CTxOut& txout = wtx.tx->vout[i];
  46             isminetype mine = wallet->IsMine(txout);
  47             if(mine)
  48             {
  49                 TransactionRecord sub(hash, nTime);
  50                 CTxDestination address;
  51                 sub.idx = i; // vout index
  52                 sub.credit = txout.nValue;
  53                 sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
  54                 if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
  55                 {
  56                     // Received by Bitcoin Address
  57                     sub.type = TransactionRecord::RecvWithAddress;
  58                     sub.address = CBitcoinAddress(address).ToString();
  59                 }
  60                 else
  61                 {
  62                     // Received by IP connection (deprecated features), or a multisignature or other non-simple transaction
  63                     sub.type = TransactionRecord::RecvFromOther;
  64                     sub.address = mapValue["from"];
  65                 }
  66                 if (wtx.IsCoinBase())
  67                 {
  68                     // Generated
  69                     sub.type = TransactionRecord::Generated;
  70                 }
  71
  72                 parts.append(sub);
  73             }
  74         }
  75     }
  76     else
  77     {
  78         bool involvesWatchAddress = false;
  79         isminetype fAllFromMe = ISMINE_SPENDABLE;
  80         for (const CTxIn& txin : wtx.tx->vin)
  81         {
  82             isminetype mine = wallet->IsMine(txin);
  83             if(mine & ISMINE_WATCH_ONLY) involvesWatchAddress = true;
  84             if(fAllFromMe > mine) fAllFromMe = mine;
  85         }
  86
  87         isminetype fAllToMe = ISMINE_SPENDABLE;
  88         for (const CTxOut& txout : wtx.tx->vout)
  89         {
  90             isminetype mine = wallet->IsMine(txout);
  91             if(mine & ISMINE_WATCH_ONLY) involvesWatchAddress = true;
  92             if(fAllToMe > mine) fAllToMe = mine;
  93         }
  94
  95         if (fAllFromMe && fAllToMe)
  96         {
  97             // Payment to self
  98             CAmount nChange = wtx.GetChange();
  99
 100             parts.append(TransactionRecord(hash, nTime, TransactionRecord::SendToSelf, "",
 101                             -(nDebit - nChange), nCredit - nChange));
 102             parts.last().involvesWatchAddress = involvesWatchAddress;   // maybe pass to TransactionRecord as constructor argument
 103         }
 104         else if (fAllFromMe)
 105         {
 106             //
 107             // Debit
 108             //
 109             CAmount nTxFee = nDebit - wtx.tx->GetValueOut();
 110
 111             for (unsigned int nOut = 0; nOut < wtx.tx->vout.size(); nOut++)
 112             {
 113                 const CTxOut& txout = wtx.tx->vout[nOut];
 114                 TransactionRecord sub(hash, nTime);
 115                 sub.idx = nOut;
 116                 sub.involvesWatchAddress = involvesWatchAddress;
 117
 118                 if(wallet->IsMine(txout))
 119                 {
 120                     // Ignore parts sent to self, as this is usually the change
 121                     // from a transaction sent back to our own address.
 122                     continue;
 123                 }
 124
 125                 CTxDestination address;
 126                 if (ExtractDestination(txout.scriptPubKey, address))
 127                 {
 128                     // Sent to Bitcoin Address
 129                     sub.type = TransactionRecord::SendToAddress;
 130                     sub.address = CBitcoinAddress(address).ToString();
 131                 }
 132                 else
 133                 {
 134                     // Sent to IP, or other non-address transaction like OP_EVAL
 135                     sub.type = TransactionRecord::SendToOther;
 136                     sub.address = mapValue["to"];
 137                 }
 138
 139                 CAmount nValue = txout.nValue;
 140                 /* Add fee to first output */
 141                 if (nTxFee > 0)
 142                 {
 143                     nValue += nTxFee;
 144                     nTxFee = 0;
 145                 }
 146                 sub.debit = -nValue;
 147
 148                 parts.append(sub);
 149             }
 150         }
 151         else
 152         {
 153             //
 154             // Mixed debit transaction, can't break down payees
 155             //
 156             parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", nNet, 0));
 157             parts.last().involvesWatchAddress = involvesWatchAddress;
 158         }
 159     }
 160
 161     return parts;
 162 }
 163
 164 void TransactionRecord::updateStatus(const CWalletTx &wtx)
 165 {
 166     AssertLockHeld(cs_main);
 167     // Determine transaction status
 168
 169     // Find the block the tx is in
 170     CBlockIndex* pindex = NULL;
 171     BlockMap::iterator mi = mapBlockIndex.find(wtx.hashBlock);
 172     if (mi != mapBlockIndex.end())
 173         pindex = (*mi).second;
 174
 175     // Sort order, unrecorded transactions sort to the top
 176     status.sortKey = strprintf("%010d-%01d-%010u-%03d",
 177         (pindex ? pindex->nHeight : std::numeric_limits<int>::max()),
 178         (wtx.IsCoinBase() ? 1 : 0),
 179         wtx.nTimeReceived,
 180         idx);
 181     status.countsForBalance = wtx.IsTrusted() && !(wtx.GetBlocksToMaturity() > 0);
 182     status.depth = wtx.GetDepthInMainChain();
 183     status.cur_num_blocks = chainActive.Height();
 184
 185     if (!CheckFinalTx(wtx))
 186     {
 187         if (wtx.tx->nLockTime < LOCKTIME_THRESHOLD)
 188         {
 189             status.status = TransactionStatus::OpenUntilBlock;
 190             status.open_for = wtx.tx->nLockTime - chainActive.Height();
 191         }
 192         else
 193         {
 194             status.status = TransactionStatus::OpenUntilDate;
 195             status.open_for = wtx.tx->nLockTime;
 196         }
 197     }
 198     // For generated transactions, determine maturity
 199     else if(type == TransactionRecord::Generated)
 200     {
 201         if (wtx.GetBlocksToMaturity() > 0)
 202         {
 203             status.status = TransactionStatus::Immature;
 204
 205             if (wtx.IsInMainChain())
 206             {
 207                 status.matures_in = wtx.GetBlocksToMaturity();
 208
 209                 // Check if the block was requested by anyone
 210                 if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
 211                     status.status = TransactionStatus::MaturesWarning;
 212             }
 213             else
 214             {
 215                 status.status = TransactionStatus::NotAccepted;
 216             }
 217         }
 218         else
 219         {
 220             status.status = TransactionStatus::Confirmed;
 221         }
 222     }
 223     else
 224     {
 225         if (status.depth < 0)
 226         {
 227             status.status = TransactionStatus::Conflicted;
 228         }
 229         else if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
 230         {
 231             status.status = TransactionStatus::Offline;
 232         }
 233         else if (status.depth == 0)
 234         {
 235             status.status = TransactionStatus::Unconfirmed;
 236             if (wtx.isAbandoned())
 237                 status.status = TransactionStatus::Abandoned;
 238         }
 239         else if (status.depth < RecommendedNumConfirmations)
 240         {
 241             status.status = TransactionStatus::Confirming;
 242         }
 243         else
 244         {
 245             status.status = TransactionStatus::Confirmed;
 246         }
 247     }
 248     status.needsUpdate = false;
 249 }
 250
 251 bool TransactionRecord::statusUpdateNeeded()
 252 {
 253     AssertLockHeld(cs_main);
 254     return status.cur_num_blocks != chainActive.Height() || status.needsUpdate;
 255 }
 256
 257 QString TransactionRecord::getTxID() const
 258 {
 259     return QString::fromStdString(hash.ToString());
 260 }
 261
 262 int TransactionRecord::getOutputIndex() const
 263 {
 264     return idx;
 265 }