mirror of
https://github.com/dashpay/dash.git
synced 2024-12-28 13:32:47 +01:00
623 lines
19 KiB
C++
623 lines
19 KiB
C++
#include "transactiontablemodel.h"
|
|
#include "guiutil.h"
|
|
#include "transactionrecord.h"
|
|
#include "guiconstants.h"
|
|
#include "transactiondesc.h"
|
|
#include "walletmodel.h"
|
|
#include "optionsmodel.h"
|
|
#include "addresstablemodel.h"
|
|
#include "bitcoinunits.h"
|
|
|
|
#include "headers.h"
|
|
|
|
#include <QLocale>
|
|
#include <QList>
|
|
#include <QColor>
|
|
#include <QTimer>
|
|
#include <QIcon>
|
|
#include <QDateTime>
|
|
#include <QtAlgorithms>
|
|
|
|
// Amount column is right-aligned it contains numbers
|
|
static int column_alignments[] = {
|
|
Qt::AlignLeft|Qt::AlignVCenter,
|
|
Qt::AlignLeft|Qt::AlignVCenter,
|
|
Qt::AlignLeft|Qt::AlignVCenter,
|
|
Qt::AlignLeft|Qt::AlignVCenter,
|
|
Qt::AlignRight|Qt::AlignVCenter
|
|
};
|
|
|
|
// Comparison operator for sort/binary search of model tx list
|
|
struct TxLessThan
|
|
{
|
|
bool operator()(const TransactionRecord &a, const TransactionRecord &b) const
|
|
{
|
|
return a.hash < b.hash;
|
|
}
|
|
bool operator()(const TransactionRecord &a, const uint256 &b) const
|
|
{
|
|
return a.hash < b;
|
|
}
|
|
bool operator()(const uint256 &a, const TransactionRecord &b) const
|
|
{
|
|
return a < b.hash;
|
|
}
|
|
};
|
|
|
|
// Private implementation
|
|
struct TransactionTablePriv
|
|
{
|
|
TransactionTablePriv(CWallet *wallet, TransactionTableModel *parent):
|
|
wallet(wallet),
|
|
parent(parent)
|
|
{
|
|
}
|
|
CWallet *wallet;
|
|
TransactionTableModel *parent;
|
|
|
|
/* Local cache of wallet.
|
|
* As it is in the same order as the CWallet, by definition
|
|
* this is sorted by sha256.
|
|
*/
|
|
QList<TransactionRecord> cachedWallet;
|
|
|
|
/* Query entire wallet anew from core.
|
|
*/
|
|
void refreshWallet()
|
|
{
|
|
#ifdef WALLET_UPDATE_DEBUG
|
|
qDebug() << "refreshWallet";
|
|
#endif
|
|
cachedWallet.clear();
|
|
CRITICAL_BLOCK(wallet->cs_wallet)
|
|
{
|
|
for(std::map<uint256, CWalletTx>::iterator it = wallet->mapWallet.begin(); it != wallet->mapWallet.end(); ++it)
|
|
{
|
|
cachedWallet.append(TransactionRecord::decomposeTransaction(wallet, it->second));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Update our model of the wallet incrementally, to synchronize our model of the wallet
|
|
with that of the core.
|
|
|
|
Call with list of hashes of transactions that were added, removed or changed.
|
|
*/
|
|
void updateWallet(const QList<uint256> &updated)
|
|
{
|
|
// Walk through updated transactions, update model as needed.
|
|
#ifdef WALLET_UPDATE_DEBUG
|
|
qDebug() << "updateWallet";
|
|
#endif
|
|
// Sort update list, and iterate through it in reverse, so that model updates
|
|
// can be emitted from end to beginning (so that earlier updates will not influence
|
|
// the indices of latter ones).
|
|
QList<uint256> updated_sorted = updated;
|
|
qSort(updated_sorted);
|
|
|
|
CRITICAL_BLOCK(wallet->cs_wallet)
|
|
{
|
|
for(int update_idx = updated_sorted.size()-1; update_idx >= 0; --update_idx)
|
|
{
|
|
const uint256 &hash = updated_sorted.at(update_idx);
|
|
// Find transaction in wallet
|
|
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(hash);
|
|
bool inWallet = mi != wallet->mapWallet.end();
|
|
// Find bounds of this transaction in model
|
|
QList<TransactionRecord>::iterator lower = qLowerBound(
|
|
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
|
|
QList<TransactionRecord>::iterator upper = qUpperBound(
|
|
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
|
|
int lowerIndex = (lower - cachedWallet.begin());
|
|
int upperIndex = (upper - cachedWallet.begin());
|
|
|
|
// Determine if transaction is in model already
|
|
bool inModel = false;
|
|
if(lower != upper)
|
|
{
|
|
inModel = true;
|
|
}
|
|
|
|
#ifdef WALLET_UPDATE_DEBUG
|
|
qDebug() << " " << QString::fromStdString(hash.ToString()) << inWallet << " " << inModel
|
|
<< lowerIndex << "-" << upperIndex;
|
|
#endif
|
|
|
|
if(inWallet && !inModel)
|
|
{
|
|
// Added -- insert at the right position
|
|
QList<TransactionRecord> toInsert =
|
|
TransactionRecord::decomposeTransaction(wallet, mi->second);
|
|
if(!toInsert.isEmpty()) /* only if something to insert */
|
|
{
|
|
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
|
|
int insert_idx = lowerIndex;
|
|
foreach(const TransactionRecord &rec, toInsert)
|
|
{
|
|
cachedWallet.insert(insert_idx, rec);
|
|
insert_idx += 1;
|
|
}
|
|
parent->endInsertRows();
|
|
}
|
|
}
|
|
else if(!inWallet && inModel)
|
|
{
|
|
// Removed -- remove entire transaction from table
|
|
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
|
|
cachedWallet.erase(lower, upper);
|
|
parent->endRemoveRows();
|
|
}
|
|
else if(inWallet && inModel)
|
|
{
|
|
// Updated -- nothing to do, status update will take care of this
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int size()
|
|
{
|
|
return cachedWallet.size();
|
|
}
|
|
|
|
TransactionRecord *index(int idx)
|
|
{
|
|
if(idx >= 0 && idx < cachedWallet.size())
|
|
{
|
|
TransactionRecord *rec = &cachedWallet[idx];
|
|
|
|
// If a status update is needed (blocks came in since last check),
|
|
// update the status of this transaction from the wallet. Otherwise,
|
|
// simply re-use the cached status.
|
|
if(rec->statusUpdateNeeded())
|
|
{
|
|
CRITICAL_BLOCK(wallet->cs_wallet)
|
|
{
|
|
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(rec->hash);
|
|
|
|
if(mi != wallet->mapWallet.end())
|
|
{
|
|
rec->updateStatus(mi->second);
|
|
}
|
|
}
|
|
}
|
|
return rec;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
QString describe(TransactionRecord *rec)
|
|
{
|
|
CRITICAL_BLOCK(wallet->cs_wallet)
|
|
{
|
|
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(rec->hash);
|
|
if(mi != wallet->mapWallet.end())
|
|
{
|
|
return TransactionDesc::toHTML(wallet, mi->second);
|
|
}
|
|
}
|
|
return QString("");
|
|
}
|
|
|
|
};
|
|
|
|
TransactionTableModel::TransactionTableModel(CWallet* wallet, WalletModel *parent):
|
|
QAbstractTableModel(parent),
|
|
wallet(wallet),
|
|
walletModel(parent),
|
|
priv(new TransactionTablePriv(wallet, this))
|
|
{
|
|
columns << QString() << tr("Date") << tr("Type") << tr("Address") << tr("Amount");
|
|
|
|
priv->refreshWallet();
|
|
|
|
QTimer *timer = new QTimer(this);
|
|
connect(timer, SIGNAL(timeout()), this, SLOT(update()));
|
|
timer->start(MODEL_UPDATE_DELAY);
|
|
}
|
|
|
|
TransactionTableModel::~TransactionTableModel()
|
|
{
|
|
delete priv;
|
|
}
|
|
|
|
void TransactionTableModel::update()
|
|
{
|
|
QList<uint256> updated;
|
|
|
|
// Check if there are changes to wallet map
|
|
TRY_CRITICAL_BLOCK(wallet->cs_wallet)
|
|
{
|
|
if(!wallet->vWalletUpdated.empty())
|
|
{
|
|
BOOST_FOREACH(uint256 hash, wallet->vWalletUpdated)
|
|
{
|
|
updated.append(hash);
|
|
}
|
|
wallet->vWalletUpdated.clear();
|
|
}
|
|
}
|
|
|
|
if(!updated.empty())
|
|
{
|
|
priv->updateWallet(updated);
|
|
|
|
// Status (number of confirmations) and (possibly) description
|
|
// columns changed for all rows.
|
|
emit dataChanged(index(0, Status), index(priv->size()-1, Status));
|
|
emit dataChanged(index(0, ToAddress), index(priv->size()-1, ToAddress));
|
|
}
|
|
}
|
|
|
|
int TransactionTableModel::rowCount(const QModelIndex &parent) const
|
|
{
|
|
Q_UNUSED(parent);
|
|
return priv->size();
|
|
}
|
|
|
|
int TransactionTableModel::columnCount(const QModelIndex &parent) const
|
|
{
|
|
Q_UNUSED(parent);
|
|
return columns.length();
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxStatus(const TransactionRecord *wtx) const
|
|
{
|
|
QString status;
|
|
|
|
switch(wtx->status.status)
|
|
{
|
|
case TransactionStatus::OpenUntilBlock:
|
|
status = tr("Open for %n block(s)","",wtx->status.open_for);
|
|
break;
|
|
case TransactionStatus::OpenUntilDate:
|
|
status = tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx->status.open_for));
|
|
break;
|
|
case TransactionStatus::Offline:
|
|
status = tr("Offline (%1 confirmations)").arg(wtx->status.depth);
|
|
break;
|
|
case TransactionStatus::Unconfirmed:
|
|
status = tr("Unconfirmed (%1 of %2 confirmations)").arg(wtx->status.depth).arg(TransactionRecord::NumConfirmations);
|
|
break;
|
|
case TransactionStatus::HaveConfirmations:
|
|
status = tr("Confirmed (%1 confirmations)").arg(wtx->status.depth);
|
|
break;
|
|
}
|
|
if(wtx->type == TransactionRecord::Generated)
|
|
{
|
|
status += "\n";
|
|
switch(wtx->status.maturity)
|
|
{
|
|
case TransactionStatus::Immature:
|
|
status += tr("Mined balance will be available in %n more blocks", "",
|
|
wtx->status.matures_in);
|
|
break;
|
|
case TransactionStatus::Mature:
|
|
break;
|
|
case TransactionStatus::MaturesWarning:
|
|
status += tr("This block was not received by any other nodes and will probably not be accepted!");
|
|
break;
|
|
case TransactionStatus::NotAccepted:
|
|
status += tr("Generated but not accepted");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const
|
|
{
|
|
if(wtx->time)
|
|
{
|
|
return GUIUtil::dateTimeStr(wtx->time);
|
|
}
|
|
else
|
|
{
|
|
return QString();
|
|
}
|
|
}
|
|
|
|
/* Look up address in address book, if found return label (address)
|
|
otherwise just return (address)
|
|
*/
|
|
QString TransactionTableModel::lookupAddress(const std::string &address, bool tooltip) const
|
|
{
|
|
QString label = walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(address));
|
|
QString description;
|
|
if(!label.isEmpty())
|
|
{
|
|
description += label + QString(" ");
|
|
}
|
|
if(label.isEmpty() || walletModel->getOptionsModel()->getDisplayAddresses() || tooltip)
|
|
{
|
|
description += QString("(") + QString::fromStdString(address) + QString(")");
|
|
}
|
|
return description;
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxType(const TransactionRecord *wtx) const
|
|
{
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::RecvWithAddress:
|
|
return tr("Received with");
|
|
case TransactionRecord::RecvFromIP:
|
|
return tr("Received from IP");
|
|
case TransactionRecord::SendToAddress:
|
|
return tr("Sent to");
|
|
case TransactionRecord::SendToIP:
|
|
return tr("Sent to IP");
|
|
case TransactionRecord::SendToSelf:
|
|
return tr("Payment to yourself");
|
|
case TransactionRecord::Generated:
|
|
return tr("Mined");
|
|
default:
|
|
return QString();
|
|
}
|
|
}
|
|
|
|
QVariant TransactionTableModel::txAddressDecoration(const TransactionRecord *wtx) const
|
|
{
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::Generated:
|
|
return QIcon(":/icons/tx_mined");
|
|
case TransactionRecord::RecvWithAddress:
|
|
case TransactionRecord::RecvFromIP:
|
|
return QIcon(":/icons/tx_input");
|
|
case TransactionRecord::SendToAddress:
|
|
case TransactionRecord::SendToIP:
|
|
return QIcon(":/icons/tx_output");
|
|
default:
|
|
return QIcon(":/icons/tx_inout");
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx, bool tooltip) const
|
|
{
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::RecvFromIP:
|
|
return QString::fromStdString(wtx->address);
|
|
case TransactionRecord::RecvWithAddress:
|
|
case TransactionRecord::SendToAddress:
|
|
return lookupAddress(wtx->address, tooltip);
|
|
case TransactionRecord::SendToIP:
|
|
return QString::fromStdString(wtx->address);
|
|
case TransactionRecord::SendToSelf:
|
|
case TransactionRecord::Generated:
|
|
default:
|
|
return tr("(n/a)");
|
|
}
|
|
}
|
|
|
|
QVariant TransactionTableModel::addressColor(const TransactionRecord *wtx) const
|
|
{
|
|
// Show addresses without label in a less visible color
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::RecvWithAddress:
|
|
case TransactionRecord::SendToAddress:
|
|
{
|
|
QString label = walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(wtx->address));
|
|
if(label.isEmpty())
|
|
return COLOR_BAREADDRESS;
|
|
} break;
|
|
case TransactionRecord::SendToSelf:
|
|
case TransactionRecord::Generated:
|
|
return COLOR_BAREADDRESS;
|
|
default:
|
|
break;
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxAmount(const TransactionRecord *wtx, bool showUnconfirmed) const
|
|
{
|
|
QString str = BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(), wtx->credit + wtx->debit);
|
|
if(showUnconfirmed)
|
|
{
|
|
if(!wtx->status.confirmed || wtx->status.maturity != TransactionStatus::Mature)
|
|
{
|
|
str = QString("[") + str + QString("]");
|
|
}
|
|
}
|
|
return QString(str);
|
|
}
|
|
|
|
QVariant TransactionTableModel::txStatusDecoration(const TransactionRecord *wtx) const
|
|
{
|
|
if(wtx->type == TransactionRecord::Generated)
|
|
{
|
|
switch(wtx->status.maturity)
|
|
{
|
|
case TransactionStatus::Immature: {
|
|
int total = wtx->status.depth + wtx->status.matures_in;
|
|
int part = (wtx->status.depth * 4 / total) + 1;
|
|
return QIcon(QString(":/icons/transaction_%1").arg(part));
|
|
}
|
|
case TransactionStatus::Mature:
|
|
return QIcon(":/icons/transaction_confirmed");
|
|
case TransactionStatus::MaturesWarning:
|
|
case TransactionStatus::NotAccepted:
|
|
return QIcon(":/icons/transaction_0");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(wtx->status.status)
|
|
{
|
|
case TransactionStatus::OpenUntilBlock:
|
|
case TransactionStatus::OpenUntilDate:
|
|
return QColor(64,64,255);
|
|
break;
|
|
case TransactionStatus::Offline:
|
|
return QColor(192,192,192);
|
|
case TransactionStatus::Unconfirmed:
|
|
switch(wtx->status.depth)
|
|
{
|
|
case 0: return QIcon(":/icons/transaction_0");
|
|
case 1: return QIcon(":/icons/transaction_1");
|
|
case 2: return QIcon(":/icons/transaction_2");
|
|
case 3: return QIcon(":/icons/transaction_3");
|
|
case 4: return QIcon(":/icons/transaction_4");
|
|
default: return QIcon(":/icons/transaction_5");
|
|
};
|
|
case TransactionStatus::HaveConfirmations:
|
|
return QIcon(":/icons/transaction_confirmed");
|
|
}
|
|
}
|
|
return QColor(0,0,0);
|
|
}
|
|
|
|
QString TransactionTableModel::formatTooltip(const TransactionRecord *rec) const
|
|
{
|
|
QString tooltip = formatTxStatus(rec) + QString("\n") + formatTxType(rec);
|
|
if(rec->type==TransactionRecord::RecvFromIP || rec->type==TransactionRecord::SendToIP ||
|
|
rec->type==TransactionRecord::SendToAddress || rec->type==TransactionRecord::RecvWithAddress)
|
|
{
|
|
tooltip += QString(" ") + formatTxToAddress(rec, true);
|
|
}
|
|
return tooltip;
|
|
}
|
|
|
|
QVariant TransactionTableModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if(!index.isValid())
|
|
return QVariant();
|
|
TransactionRecord *rec = static_cast<TransactionRecord*>(index.internalPointer());
|
|
|
|
switch(role)
|
|
{
|
|
case Qt::DecorationRole:
|
|
switch(index.column())
|
|
{
|
|
case Status:
|
|
return txStatusDecoration(rec);
|
|
case ToAddress:
|
|
return txAddressDecoration(rec);
|
|
}
|
|
break;
|
|
case Qt::DisplayRole:
|
|
switch(index.column())
|
|
{
|
|
case Date:
|
|
return formatTxDate(rec);
|
|
case Type:
|
|
return formatTxType(rec);
|
|
case ToAddress:
|
|
return formatTxToAddress(rec, false);
|
|
case Amount:
|
|
return formatTxAmount(rec);
|
|
}
|
|
break;
|
|
case Qt::EditRole:
|
|
// Edit role is used for sorting, so return the unformatted values
|
|
switch(index.column())
|
|
{
|
|
case Status:
|
|
return QString::fromStdString(rec->status.sortKey);
|
|
case Date:
|
|
return rec->time;
|
|
case Type:
|
|
return formatTxType(rec);
|
|
case ToAddress:
|
|
return formatTxToAddress(rec, true);
|
|
case Amount:
|
|
return rec->credit + rec->debit;
|
|
}
|
|
break;
|
|
case Qt::ToolTipRole:
|
|
return formatTooltip(rec);
|
|
case Qt::TextAlignmentRole:
|
|
return column_alignments[index.column()];
|
|
case Qt::ForegroundRole:
|
|
// Non-confirmed transactions are grey
|
|
if(!rec->status.confirmed)
|
|
{
|
|
return COLOR_UNCONFIRMED;
|
|
}
|
|
if(index.column() == Amount && (rec->credit+rec->debit) < 0)
|
|
{
|
|
return COLOR_NEGATIVE;
|
|
}
|
|
if(index.column() == ToAddress)
|
|
{
|
|
return addressColor(rec);
|
|
}
|
|
break;
|
|
case TypeRole:
|
|
return rec->type;
|
|
case DateRole:
|
|
return QDateTime::fromTime_t(static_cast<uint>(rec->time));
|
|
case LongDescriptionRole:
|
|
return priv->describe(rec);
|
|
case AddressRole:
|
|
return QString::fromStdString(rec->address);
|
|
case LabelRole:
|
|
return walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(rec->address));
|
|
case AmountRole:
|
|
return rec->credit + rec->debit;
|
|
case TxIDRole:
|
|
return QString::fromStdString(rec->getTxID());
|
|
case ConfirmedRole:
|
|
// Return True if transaction counts for balance
|
|
return rec->status.confirmed && !(rec->type == TransactionRecord::Generated &&
|
|
rec->status.maturity != TransactionStatus::Mature);
|
|
case FormattedAmountRole:
|
|
return formatTxAmount(rec, false);
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant TransactionTableModel::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if(orientation == Qt::Horizontal)
|
|
{
|
|
if(role == Qt::DisplayRole)
|
|
{
|
|
return columns[section];
|
|
}
|
|
else if (role == Qt::TextAlignmentRole)
|
|
{
|
|
return column_alignments[section];
|
|
} else if (role == Qt::ToolTipRole)
|
|
{
|
|
switch(section)
|
|
{
|
|
case Status:
|
|
return tr("Transaction status. Hover over this field to show number of confirmations.");
|
|
case Date:
|
|
return tr("Date and time that the transaction was received.");
|
|
case Type:
|
|
return tr("Type of transaction.");
|
|
case ToAddress:
|
|
return tr("Destination address of transaction.");
|
|
case Amount:
|
|
return tr("Amount removed from or added to balance.");
|
|
}
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QModelIndex TransactionTableModel::index(int row, int column, const QModelIndex &parent) const
|
|
{
|
|
Q_UNUSED(parent);
|
|
TransactionRecord *data = priv->index(row);
|
|
if(data)
|
|
{
|
|
return createIndex(row, column, priv->index(row));
|
|
}
|
|
else
|
|
{
|
|
return QModelIndex();
|
|
}
|
|
}
|
|
|