--- /dev/null
+#include "addresstablemodel.h"
+#include "guiutil.h"
+#include "walletmodel.h"
+
+#include "headers.h"
+
+#include <QFont>
+#include <QColor>
+
+const QString AddressTableModel::Send = "S";
+const QString AddressTableModel::Receive = "R";
+
+struct AddressTableEntry
+{
+ enum Type {
+ Sending,
+ Receiving
+ };
+
+ Type type;
+ QString label;
+ QString address;
+
+ AddressTableEntry() {}
+ AddressTableEntry(Type type, const QString &label, const QString &address):
+ type(type), label(label), address(address) {}
+};
+
+// Private implementation
+struct AddressTablePriv
+{
+ CWallet *wallet;
+ QList<AddressTableEntry> cachedAddressTable;
+
+ AddressTablePriv(CWallet *wallet):
+ wallet(wallet) {}
+
+ void refreshAddressTable()
+ {
+ cachedAddressTable.clear();
+
- CRITICAL_BLOCK(cs_mapPubKeys)
++ CRITICAL_BLOCK(wallet->cs_KeyStore)
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
- BOOST_FOREACH(const PAIRTYPE(std::string, std::string)& item, wallet->mapAddressBook)
++ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, std::string)& item, wallet->mapAddressBook)
+ {
- std::string strAddress = item.first;
- std::string strName = item.second;
++ const CBitcoinAddress& address = item.first;
++ const std::string& strName = item.second;
+ uint160 hash160;
- bool fMine = (AddressToHash160(strAddress, hash160) && mapPubKeys.count(hash160));
++ bool fMine = wallet->HaveKey(address);
+ cachedAddressTable.append(AddressTableEntry(fMine ? AddressTableEntry::Receiving : AddressTableEntry::Sending,
+ QString::fromStdString(strName),
- QString::fromStdString(strAddress)));
++ QString::fromStdString(address.ToString())));
+ }
+ }
+ }
+
+ int size()
+ {
+ return cachedAddressTable.size();
+ }
+
+ AddressTableEntry *index(int idx)
+ {
+ if(idx >= 0 && idx < cachedAddressTable.size())
+ {
+ return &cachedAddressTable[idx];
+ }
+ else
+ {
+ return 0;
+ }
+ }
+};
+
+AddressTableModel::AddressTableModel(CWallet *wallet, WalletModel *parent) :
+ QAbstractTableModel(parent),walletModel(parent),wallet(wallet),priv(0)
+{
+ columns << tr("Label") << tr("Address");
+ priv = new AddressTablePriv(wallet);
+ priv->refreshAddressTable();
+}
+
+AddressTableModel::~AddressTableModel()
+{
+ delete priv;
+}
+
+int AddressTableModel::rowCount(const QModelIndex &parent) const
+{
+ Q_UNUSED(parent);
+ return priv->size();
+}
+
+int AddressTableModel::columnCount(const QModelIndex &parent) const
+{
+ Q_UNUSED(parent);
+ return columns.length();
+}
+
+QVariant AddressTableModel::data(const QModelIndex &index, int role) const
+{
+ if(!index.isValid())
+ return QVariant();
+
+ AddressTableEntry *rec = static_cast<AddressTableEntry*>(index.internalPointer());
+
+ if(role == Qt::DisplayRole || role == Qt::EditRole)
+ {
+ switch(index.column())
+ {
+ case Label:
+ if(rec->label.isEmpty() && role == Qt::DisplayRole)
+ {
+ return tr("(no label)");
+ }
+ else
+ {
+ return rec->label;
+ }
+ case Address:
+ return rec->address;
+ }
+ }
+ else if (role == Qt::FontRole)
+ {
+ QFont font;
+ if(index.column() == Address)
+ {
+ font = GUIUtil::bitcoinAddressFont();
+ }
+ return font;
+ }
+ else if (role == TypeRole)
+ {
+ switch(rec->type)
+ {
+ case AddressTableEntry::Sending:
+ return Send;
+ case AddressTableEntry::Receiving:
+ return Receive;
+ default: break;
+ }
+ }
+ return QVariant();
+}
+
+bool AddressTableModel::setData(const QModelIndex & index, const QVariant & value, int role)
+{
+ if(!index.isValid())
+ return false;
+ AddressTableEntry *rec = static_cast<AddressTableEntry*>(index.internalPointer());
+
+ editStatus = OK;
+
+ if(role == Qt::EditRole)
+ {
+ switch(index.column())
+ {
+ case Label:
+ wallet->SetAddressBookName(rec->address.toStdString(), value.toString().toStdString());
+ rec->label = value.toString();
+ break;
+ case Address:
+ // Refuse to set invalid address
+ if(!walletModel->validateAddress(value.toString()))
+ {
+ editStatus = INVALID_ADDRESS;
+ return false;
+ }
+ // Double-check that we're not overwriting receiving address
+ if(rec->type == AddressTableEntry::Sending)
+ {
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
+ // Remove old entry
+ wallet->DelAddressBookName(rec->address.toStdString());
+ // Add new entry with new address
+ wallet->SetAddressBookName(value.toString().toStdString(), rec->label.toStdString());
+ }
+
+ rec->address = value.toString();
+ }
+ break;
+ }
+ emit dataChanged(index, index);
+
+ return true;
+ }
+ return false;
+}
+
+QVariant AddressTableModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+ if(orientation == Qt::Horizontal)
+ {
+ if(role == Qt::DisplayRole)
+ {
+ return columns[section];
+ }
+ }
+ return QVariant();
+}
+
+Qt::ItemFlags AddressTableModel::flags(const QModelIndex & index) const
+{
+ if(!index.isValid())
+ return 0;
+ AddressTableEntry *rec = static_cast<AddressTableEntry*>(index.internalPointer());
+
+ Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
+ // Can edit address and label for sending addresses,
+ // and only label for receiving addresses.
+ if(rec->type == AddressTableEntry::Sending ||
+ (rec->type == AddressTableEntry::Receiving && index.column()==Label))
+ {
+ retval |= Qt::ItemIsEditable;
+ }
+ return retval;
+}
+
+QModelIndex AddressTableModel::index(int row, int column, const QModelIndex & parent) const
+{
+ Q_UNUSED(parent);
+ AddressTableEntry *data = priv->index(row);
+ if(data)
+ {
+ return createIndex(row, column, priv->index(row));
+ }
+ else
+ {
+ return QModelIndex();
+ }
+}
+
+void AddressTableModel::updateList()
+{
+ // Update internal model from Bitcoin core
+ beginResetModel();
+ priv->refreshAddressTable();
+ endResetModel();
+}
+
+QString AddressTableModel::addRow(const QString &type, const QString &label, const QString &address)
+{
+ std::string strLabel = label.toStdString();
+ std::string strAddress = address.toStdString();
+
+ editStatus = OK;
+
+
+ if(type == Send)
+ {
+ if(!walletModel->validateAddress(address))
+ {
+ editStatus = INVALID_ADDRESS;
+ return QString();
+ }
+ // Check for duplicate
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
+ if(wallet->mapAddressBook.count(strAddress))
+ {
+ editStatus = DUPLICATE_ADDRESS;
+ return QString();
+ }
+ }
+ }
+ else if(type == Receive)
+ {
- // Generate a new address to associate with given label, optionally
- // set as default receiving address.
- strAddress = PubKeyToAddress(wallet->GetOrReuseKeyFromPool());
++ // Generate a new address to associate with given label
++ strAddress = CBitcoinAddress(wallet->GetOrReuseKeyFromPool()).ToString();
+ }
+ else
+ {
+ return QString();
+ }
+ // Add entry and update list
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ wallet->SetAddressBookName(strAddress, strLabel);
+ updateList();
+ return QString::fromStdString(strAddress);
+}
+
+bool AddressTableModel::removeRows(int row, int count, const QModelIndex & parent)
+{
+ Q_UNUSED(parent);
+ AddressTableEntry *rec = priv->index(row);
+ if(count != 1 || !rec || rec->type == AddressTableEntry::Receiving)
+ {
+ // Can only remove one row at a time, and cannot remove rows not in model.
+ // Also refuse to remove receiving addresses.
+ return false;
+ }
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
+ wallet->DelAddressBookName(rec->address.toStdString());
+ }
+ updateList();
+ return true;
+}
+
+void AddressTableModel::update()
+{
+
+}
+
+/* Look up label for address in address book, if not found return empty string.
+ */
+QString AddressTableModel::labelForAddress(const QString &address) const
+{
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
- std::map<std::string, std::string>::iterator mi = wallet->mapAddressBook.find(address.toStdString());
++ CBitcoinAddress address_parsed(address.toStdString());
++ std::map<CBitcoinAddress, std::string>::iterator mi = wallet->mapAddressBook.find(address_parsed);
+ if (mi != wallet->mapAddressBook.end())
+ {
+ return QString::fromStdString(mi->second);
+ }
+ }
+ return QString();
+}
+
+int AddressTableModel::lookupAddress(const QString &address) const
+{
+ QModelIndexList lst = match(index(0, Address, QModelIndex()),
+ Qt::EditRole, address, 1, Qt::MatchExactly);
+ if(lst.isEmpty())
+ {
+ return -1;
+ }
+ else
+ {
+ return lst.at(0).row();
+ }
+}
+
--- /dev/null
+#include <transactiondesc.h>
+
+#include "guiutil.h"
+
+#include "headers.h"
+#include "qtui.h"
+
+#include <QString>
+
+// Taken straight from ui.cpp
+// TODO: Convert to use QStrings, Qt::Escape and tr()
+// or: refactor and put describeAsHTML() into bitcoin core but that is unneccesary with better
+// UI<->core API, no need to put display logic in core.
+
+using namespace std;
+
+static string HtmlEscape(const char* psz, bool fMultiLine=false)
+{
+ int len = 0;
+ for (const char* p = psz; *p; p++)
+ {
+ if (*p == '<') len += 4;
+ else if (*p == '>') len += 4;
+ else if (*p == '&') len += 5;
+ else if (*p == '"') len += 6;
+ else if (*p == ' ' && p > psz && p[-1] == ' ' && p[1] == ' ') len += 6;
+ else if (*p == '\n' && fMultiLine) len += 5;
+ else
+ len++;
+ }
+ string str;
+ str.reserve(len);
+ for (const char* p = psz; *p; p++)
+ {
+ if (*p == '<') str += "<";
+ else if (*p == '>') str += ">";
+ else if (*p == '&') str += "&";
+ else if (*p == '"') str += """;
+ else if (*p == ' ' && p > psz && p[-1] == ' ' && p[1] == ' ') str += " ";
+ else if (*p == '\n' && fMultiLine) str += "<br>\n";
+ else
+ str += *p;
+ }
+ return str;
+}
+
+static string HtmlEscape(const string& str, bool fMultiLine=false)
+{
+ return HtmlEscape(str.c_str(), fMultiLine);
+}
+
+static string FormatTxStatus(const CWalletTx& wtx)
+{
+ // Status
+ if (!wtx.IsFinal())
+ {
+ if (wtx.nLockTime < 500000000)
+ return strprintf(_("Open for %d blocks"), nBestHeight - wtx.nLockTime);
+ else
+ return strprintf(_("Open until %s"), GUIUtil::DateTimeStr(wtx.nLockTime).toStdString().c_str());
+ }
+ else
+ {
+ int nDepth = wtx.GetDepthInMainChain();
+ if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
+ return strprintf(_("%d/offline?"), nDepth);
+ else if (nDepth < 6)
+ return strprintf(_("%d/unconfirmed"), nDepth);
+ else
+ return strprintf(_("%d confirmations"), nDepth);
+ }
+}
+
+string TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx)
+{
+ string strHTML;
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
+ strHTML.reserve(4000);
+ strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
+
+ int64 nTime = wtx.GetTxTime();
+ int64 nCredit = wtx.GetCredit();
+ int64 nDebit = wtx.GetDebit();
+ int64 nNet = nCredit - nDebit;
+
+
+
+ strHTML += _("<b>Status:</b> ") + FormatTxStatus(wtx);
+ int nRequests = wtx.GetRequestCount();
+ if (nRequests != -1)
+ {
+ if (nRequests == 0)
+ strHTML += _(", has not been successfully broadcast yet");
+ else if (nRequests == 1)
+ strHTML += strprintf(_(", broadcast through %d node"), nRequests);
+ else
+ strHTML += strprintf(_(", broadcast through %d nodes"), nRequests);
+ }
+ strHTML += "<br>";
+
+ strHTML += _("<b>Date:</b> ") + (nTime ? GUIUtil::DateTimeStr(nTime).toStdString() : "") + "<br>";
+
+
+ //
+ // From
+ //
+ if (wtx.IsCoinBase())
+ {
+ strHTML += _("<b>Source:</b> Generated<br>");
+ }
+ else if (!wtx.mapValue["from"].empty())
+ {
+ // Online transaction
+ if (!wtx.mapValue["from"].empty())
+ strHTML += _("<b>From:</b> ") + HtmlEscape(wtx.mapValue["from"]) + "<br>";
+ }
+ else
+ {
+ // Offline transaction
+ if (nNet > 0)
+ {
+ // Credit
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ {
+ if (wallet->IsMine(txout))
+ {
- vector<unsigned char> vchPubKey;
- if (ExtractPubKey(txout.scriptPubKey, wallet, vchPubKey))
++ CBitcoinAddress address;
++ if (ExtractAddress(txout.scriptPubKey, wallet, address))
+ {
- string strAddress = PubKeyToAddress(vchPubKey);
- if (wallet->mapAddressBook.count(strAddress))
++ if (wallet->mapAddressBook.count(address))
+ {
+ strHTML += string() + _("<b>From:</b> ") + _("unknown") + "<br>";
+ strHTML += _("<b>To:</b> ");
- strHTML += HtmlEscape(strAddress);
- if (!wallet->mapAddressBook[strAddress].empty())
- strHTML += _(" (yours, label: ") + wallet->mapAddressBook[strAddress] + ")";
++ strHTML += HtmlEscape(address.ToString());
++ if (!wallet->mapAddressBook[address].empty())
++ strHTML += _(" (yours, label: ") + wallet->mapAddressBook[address] + ")";
+ else
+ strHTML += _(" (yours)");
+ strHTML += "<br>";
+ }
+ }
+ break;
+ }
+ }
+ }
+ }
+
+
+ //
+ // To
+ //
+ string strAddress;
+ if (!wtx.mapValue["to"].empty())
+ {
+ // Online transaction
+ strAddress = wtx.mapValue["to"];
+ strHTML += _("<b>To:</b> ");
+ if (wallet->mapAddressBook.count(strAddress) && !wallet->mapAddressBook[strAddress].empty())
+ strHTML += wallet->mapAddressBook[strAddress] + " ";
+ strHTML += HtmlEscape(strAddress) + "<br>";
+ }
+
+
+ //
+ // Amount
+ //
+ if (wtx.IsCoinBase() && nCredit == 0)
+ {
+ //
+ // Coinbase
+ //
+ int64 nUnmatured = 0;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ nUnmatured += wallet->GetCredit(txout);
+ strHTML += _("<b>Credit:</b> ");
+ if (wtx.IsInMainChain())
+ strHTML += strprintf(_("(%s matures in %d more blocks)"), FormatMoney(nUnmatured).c_str(), wtx.GetBlocksToMaturity());
+ else
+ strHTML += _("(not accepted)");
+ strHTML += "<br>";
+ }
+ else if (nNet > 0)
+ {
+ //
+ // Credit
+ //
+ strHTML += _("<b>Credit:</b> ") + FormatMoney(nNet) + "<br>";
+ }
+ else
+ {
+ bool fAllFromMe = true;
+ BOOST_FOREACH(const CTxIn& txin, wtx.vin)
+ fAllFromMe = fAllFromMe && wallet->IsMine(txin);
+
+ bool fAllToMe = true;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ fAllToMe = fAllToMe && wallet->IsMine(txout);
+
+ if (fAllFromMe)
+ {
+ //
+ // Debit
+ //
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ {
+ if (wallet->IsMine(txout))
+ continue;
+
+ if (wtx.mapValue["to"].empty())
+ {
+ // Offline transaction
- uint160 hash160;
- if (ExtractHash160(txout.scriptPubKey, hash160))
++ CBitcoinAddress address;
++ if (ExtractAddress(txout.scriptPubKey, wallet, address))
+ {
- string strAddress = Hash160ToAddress(hash160);
+ strHTML += _("<b>To:</b> ");
- if (wallet->mapAddressBook.count(strAddress) && !wallet->mapAddressBook[strAddress].empty())
- strHTML += wallet->mapAddressBook[strAddress] + " ";
- strHTML += strAddress;
++ if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].empty())
++ strHTML += wallet->mapAddressBook[address] + " ";
++ strHTML += address.ToString();
+ strHTML += "<br>";
+ }
+ }
+
+ strHTML += _("<b>Debit:</b> ") + FormatMoney(-txout.nValue) + "<br>";
+ }
+
+ if (fAllToMe)
+ {
+ // Payment to self
+ int64 nChange = wtx.GetChange();
+ int64 nValue = nCredit - nChange;
+ strHTML += _("<b>Debit:</b> ") + FormatMoney(-nValue) + "<br>";
+ strHTML += _("<b>Credit:</b> ") + FormatMoney(nValue) + "<br>";
+ }
+
+ int64 nTxFee = nDebit - wtx.GetValueOut();
+ if (nTxFee > 0)
+ strHTML += _("<b>Transaction fee:</b> ") + FormatMoney(-nTxFee) + "<br>";
+ }
+ else
+ {
+ //
+ // Mixed debit transaction
+ //
+ BOOST_FOREACH(const CTxIn& txin, wtx.vin)
+ if (wallet->IsMine(txin))
+ strHTML += _("<b>Debit:</b> ") + FormatMoney(-wallet->GetDebit(txin)) + "<br>";
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ if (wallet->IsMine(txout))
+ strHTML += _("<b>Credit:</b> ") + FormatMoney(wallet->GetCredit(txout)) + "<br>";
+ }
+ }
+
+ strHTML += _("<b>Net amount:</b> ") + FormatMoney(nNet, true) + "<br>";
+
+
+ //
+ // Message
+ //
+ if (!wtx.mapValue["message"].empty())
+ strHTML += string() + "<br><b>" + _("Message:") + "</b><br>" + HtmlEscape(wtx.mapValue["message"], true) + "<br>";
+ if (!wtx.mapValue["comment"].empty())
+ strHTML += string() + "<br><b>" + _("Comment:") + "</b><br>" + HtmlEscape(wtx.mapValue["comment"], true) + "<br>";
+
+ if (wtx.IsCoinBase())
+ strHTML += string() + "<br>" + _("Generated coins must wait 120 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, it will change to \"not accepted\" and not be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.") + "<br>";
+
+
+ //
+ // Debug view
+ //
+ if (fDebug)
+ {
+ strHTML += "<hr><br>debug print<br><br>";
+ BOOST_FOREACH(const CTxIn& txin, wtx.vin)
+ if(wallet->IsMine(txin))
+ strHTML += "<b>Debit:</b> " + FormatMoney(-wallet->IsMine(txin)) + "<br>";
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ if(wallet->IsMine(txout))
+ strHTML += "<b>Credit:</b> " + FormatMoney(wallet->IsMine(txout)) + "<br>";
+
+ strHTML += "<br><b>Transaction:</b><br>";
+ strHTML += HtmlEscape(wtx.ToString(), true);
+
+ strHTML += "<br><b>Inputs:</b><br>";
+ CRITICAL_BLOCK(wallet->cs_mapWallet)
+ {
+ BOOST_FOREACH(const CTxIn& txin, wtx.vin)
+ {
+ COutPoint prevout = txin.prevout;
+ map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(prevout.hash);
+ if (mi != wallet->mapWallet.end())
+ {
+ const CWalletTx& prev = (*mi).second;
+ if (prevout.n < prev.vout.size())
+ {
+ strHTML += HtmlEscape(prev.ToString(), true);
+ strHTML += " " + FormatTxStatus(prev) + ", ";
+ strHTML = strHTML + "IsMine=" + (wallet->IsMine(prev.vout[prevout.n]) ? "true" : "false") + "<br>";
+ }
+ }
+ }
+ }
+ }
+
+
+
+ strHTML += "</font></html>";
+ }
+ return strHTML;
+}
--- /dev/null
+#include "transactionrecord.h"
+
+#include "headers.h"
+
+/* Return positive answer if transaction should be shown in list.
+ */
+bool TransactionRecord::showTransaction(const CWalletTx &wtx)
+{
+ if (wtx.IsCoinBase())
+ {
+ // Don't show generated coin until confirmed by at least one block after it
+ // so we don't get the user's hopes up until it looks like it's probably accepted.
+ //
+ // It is not an error when generated blocks are not accepted. By design,
+ // some percentage of blocks, like 10% or more, will end up not accepted.
+ // This is the normal mechanism by which the network copes with latency.
+ //
+ // We display regular transactions right away before any confirmation
+ // because they can always get into some block eventually. Generated coins
+ // are special because if their block is not accepted, they are not valid.
+ //
+ if (wtx.GetDepthInMainChain() < 2)
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+/*
+ * Decompose CWallet transaction to model transaction records.
+ */
+QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
+{
+ QList<TransactionRecord> parts;
+ int64 nTime = wtx.nTimeDisplayed = wtx.GetTxTime();
+ int64 nCredit = wtx.GetCredit(true);
+ int64 nDebit = wtx.GetDebit();
+ int64 nNet = nCredit - nDebit;
+ uint256 hash = wtx.GetHash();
+ std::map<std::string, std::string> mapValue = wtx.mapValue;
+
+ if (showTransaction(wtx))
+ {
+ if (nNet > 0 || wtx.IsCoinBase())
+ {
+ //
+ // Credit
+ //
+ TransactionRecord sub(hash, nTime);
+
+ sub.credit = nNet;
+
+ if (wtx.IsCoinBase())
+ {
+ // Generated
+ sub.type = TransactionRecord::Generated;
+
+ if (nCredit == 0)
+ {
+ int64 nUnmatured = 0;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ nUnmatured += wallet->GetCredit(txout);
+ sub.credit = nUnmatured;
+ }
+ }
+ else if (!mapValue["from"].empty() || !mapValue["message"].empty())
+ {
+ // Received by IP connection
+ sub.type = TransactionRecord::RecvFromIP;
+ if (!mapValue["from"].empty())
+ sub.address = mapValue["from"];
+ }
+ else
+ {
+ // Received by Bitcoin Address
+ sub.type = TransactionRecord::RecvWithAddress;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ {
+ if(wallet->IsMine(txout))
+ {
- std::vector<unsigned char> vchPubKey;
- if (ExtractPubKey(txout.scriptPubKey, wallet, vchPubKey))
++ CBitcoinAddress address;
++ if (ExtractAddress(txout.scriptPubKey, wallet, address))
+ {
- sub.address = PubKeyToAddress(vchPubKey);
++ sub.address = address.ToString();
+ }
+ break;
+ }
+ }
+ }
+ parts.append(sub);
+ }
+ else
+ {
+ bool fAllFromMe = true;
+ BOOST_FOREACH(const CTxIn& txin, wtx.vin)
+ fAllFromMe = fAllFromMe && wallet->IsMine(txin);
+
+ bool fAllToMe = true;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ fAllToMe = fAllToMe && wallet->IsMine(txout);
+
+ if (fAllFromMe && fAllToMe)
+ {
+ // Payment to self
+ int64 nChange = wtx.GetChange();
+
+ parts.append(TransactionRecord(hash, nTime, TransactionRecord::SendToSelf, "",
+ -(nDebit - nChange), nCredit - nChange));
+ }
+ else if (fAllFromMe)
+ {
+ //
+ // Debit
+ //
+ int64 nTxFee = nDebit - wtx.GetValueOut();
+
+ for (int nOut = 0; nOut < wtx.vout.size(); nOut++)
+ {
+ const CTxOut& txout = wtx.vout[nOut];
+ TransactionRecord sub(hash, nTime);
+ sub.idx = parts.size();
+
+ if(wallet->IsMine(txout))
+ {
+ // Ignore parts sent to self, as this is usually the change
+ // from a transaction sent back to our own address.
+ continue;
+ }
+ else if(!mapValue["to"].empty())
+ {
+ // Sent to IP
+ sub.type = TransactionRecord::SendToIP;
+ sub.address = mapValue["to"];
+ }
+ else
+ {
+ // Sent to Bitcoin Address
+ sub.type = TransactionRecord::SendToAddress;
- uint160 hash160;
- if (ExtractHash160(txout.scriptPubKey, hash160))
- sub.address = Hash160ToAddress(hash160);
++ CBitcoinAddress address;
++ if (ExtractAddress(txout.scriptPubKey, wallet, address))
++ {
++ sub.address = address.ToString();
++ }
+ }
+
+ int64 nValue = txout.nValue;
+ /* Add fee to first output */
+ if (nTxFee > 0)
+ {
+ nValue += nTxFee;
+ nTxFee = 0;
+ }
+ sub.debit = -nValue;
+
+ parts.append(sub);
+ }
+ }
+ else
+ {
+ //
+ // Mixed debit transaction, can't break down payees
+ //
+ bool fAllMine = true;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ fAllMine = fAllMine && wallet->IsMine(txout);
+ BOOST_FOREACH(const CTxIn& txin, wtx.vin)
+ fAllMine = fAllMine && wallet->IsMine(txin);
+
+ parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", nNet, 0));
+ }
+ }
+ }
+
+ return parts;
+}
+
+void TransactionRecord::updateStatus(const CWalletTx &wtx)
+{
+ // Determine transaction status
+
+ // Find the block the tx is in
+ CBlockIndex* pindex = NULL;
+ std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(wtx.hashBlock);
+ if (mi != mapBlockIndex.end())
+ pindex = (*mi).second;
+
+ // Sort order, unrecorded transactions sort to the top
+ status.sortKey = strprintf("%010d-%01d-%010u-%03d",
+ (pindex ? pindex->nHeight : INT_MAX),
+ (wtx.IsCoinBase() ? 1 : 0),
+ wtx.nTimeReceived,
+ idx);
+ status.confirmed = wtx.IsConfirmed();
+ status.depth = wtx.GetDepthInMainChain();
+ status.cur_num_blocks = nBestHeight;
+
+ if (!wtx.IsFinal())
+ {
+ if (wtx.nLockTime < LOCKTIME_THRESHOLD)
+ {
+ status.status = TransactionStatus::OpenUntilBlock;
+ status.open_for = nBestHeight - wtx.nLockTime;
+ }
+ else
+ {
+ status.status = TransactionStatus::OpenUntilDate;
+ status.open_for = wtx.nLockTime;
+ }
+ }
+ else
+ {
+ if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
+ {
+ status.status = TransactionStatus::Offline;
+ }
+ else if (status.depth < NumConfirmations)
+ {
+ status.status = TransactionStatus::Unconfirmed;
+ }
+ else
+ {
+ status.status = TransactionStatus::HaveConfirmations;
+ }
+ }
+
+ // For generated transactions, determine maturity
+ if(type == TransactionRecord::Generated)
+ {
+ int64 nCredit = wtx.GetCredit(true);
+ if (nCredit == 0)
+ {
+ status.maturity = TransactionStatus::Immature;
+
+ if (wtx.IsInMainChain())
+ {
+ status.matures_in = wtx.GetBlocksToMaturity();
+
+ // Check if the block was requested by anyone
+ if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
+ status.maturity = TransactionStatus::MaturesWarning;
+ }
+ else
+ {
+ status.maturity = TransactionStatus::NotAccepted;
+ }
+ }
+ else
+ {
+ status.maturity = TransactionStatus::Mature;
+ }
+ }
+}
+
+bool TransactionRecord::statusUpdateNeeded()
+{
+ return status.cur_num_blocks != nBestHeight;
+}
+
+std::string TransactionRecord::getTxID()
+{
+ return hash.ToString() + strprintf("-%03d", idx);
+}
+
--- /dev/null
+#include "walletmodel.h"
+#include "guiconstants.h"
+#include "optionsmodel.h"
+#include "addresstablemodel.h"
+#include "transactiontablemodel.h"
+
+#include "headers.h"
+
+#include <QTimer>
+#include <QSet>
+
+WalletModel::WalletModel(CWallet *wallet, QObject *parent) :
+ QObject(parent), wallet(wallet), optionsModel(0), addressTableModel(0),
+ transactionTableModel(0),
+ cachedBalance(0), cachedUnconfirmedBalance(0), cachedNumTransactions(0)
+{
+ // Until signal notifications is built into the bitcoin core,
+ // simply update everything after polling using a timer.
+ QTimer *timer = new QTimer(this);
+ connect(timer, SIGNAL(timeout()), this, SLOT(update()));
+ timer->start(MODEL_UPDATE_DELAY);
+
+ optionsModel = new OptionsModel(wallet, this);
+ addressTableModel = new AddressTableModel(wallet, this);
+ transactionTableModel = new TransactionTableModel(wallet, this);
+}
+
+qint64 WalletModel::getBalance() const
+{
+ return wallet->GetBalance();
+}
+
+qint64 WalletModel::getUnconfirmedBalance() const
+{
+ return wallet->GetUnconfirmedBalance();
+}
+
+int WalletModel::getNumTransactions() const
+{
+ int numTransactions = 0;
+ CRITICAL_BLOCK(wallet->cs_mapWallet)
+ {
+ numTransactions = wallet->mapWallet.size();
+ }
+ return numTransactions;
+}
+
+void WalletModel::update()
+{
+ qint64 newBalance = getBalance();
+ qint64 newUnconfirmedBalance = getUnconfirmedBalance();
+ int newNumTransactions = getNumTransactions();
+
+ if(cachedBalance != newBalance || cachedUnconfirmedBalance != newUnconfirmedBalance)
+ emit balanceChanged(newBalance, newUnconfirmedBalance);
+
+ if(cachedNumTransactions != newNumTransactions)
+ emit numTransactionsChanged(newNumTransactions);
+
+ cachedBalance = newBalance;
+ cachedUnconfirmedBalance = newUnconfirmedBalance;
+ cachedNumTransactions = newNumTransactions;
+
+ addressTableModel->update();
+}
+
+bool WalletModel::validateAddress(const QString &address)
+{
- uint160 hash160 = 0;
-
- return AddressToHash160(address.toStdString(), hash160);
++ CBitcoinAddress addressParsed(address.toStdString());
++ return addressParsed.IsValid();
+}
+
+WalletModel::SendCoinsReturn WalletModel::sendCoins(const QList<SendCoinsRecipient> &recipients)
+{
+ qint64 total = 0;
+ QSet<QString> setAddress;
+ QString hex;
+
+ if(recipients.empty())
+ {
+ return OK;
+ }
+
+ // Pre-check input data for validity
+ foreach(const SendCoinsRecipient &rcp, recipients)
+ {
+ uint160 hash160 = 0;
+
- if(!AddressToHash160(rcp.address.toUtf8().constData(), hash160))
++ if(!validateAddress(rcp.address))
+ {
+ return InvalidAddress;
+ }
+ setAddress.insert(rcp.address);
+
+ if(rcp.amount <= 0)
+ {
+ return InvalidAmount;
+ }
+ total += rcp.amount;
+ }
+
+ if(recipients.size() > setAddress.size())
+ {
+ return DuplicateAddress;
+ }
+
+ if(total > getBalance())
+ {
+ return AmountExceedsBalance;
+ }
+
+ if((total + nTransactionFee) > getBalance())
+ {
+ return SendCoinsReturn(AmountWithFeeExceedsBalance, nTransactionFee);
+ }
+
+ CRITICAL_BLOCK(cs_main)
+ CRITICAL_BLOCK(wallet->cs_mapWallet)
+ {
+ // Sendmany
+ std::vector<std::pair<CScript, int64> > vecSend;
+ foreach(const SendCoinsRecipient &rcp, recipients)
+ {
+ CScript scriptPubKey;
+ scriptPubKey.SetBitcoinAddress(rcp.address.toStdString());
+ vecSend.push_back(make_pair(scriptPubKey, rcp.amount));
+ }
+
+ CWalletTx wtx;
+ CReserveKey keyChange(wallet);
+ int64 nFeeRequired = 0;
+ bool fCreated = wallet->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired);
+
+ if(!fCreated)
+ {
+ if((total + nFeeRequired) > wallet->GetBalance())
+ {
+ return SendCoinsReturn(AmountWithFeeExceedsBalance, nFeeRequired);
+ }
+ return TransactionCreationFailed;
+ }
+ if(!ThreadSafeAskFee(nFeeRequired, tr("Sending...").toStdString(), NULL))
+ {
+ return Aborted;
+ }
+ if(!wallet->CommitTransaction(wtx, keyChange))
+ {
+ return TransactionCommitFailed;
+ }
+ hex = QString::fromStdString(wtx.GetHash().GetHex());
+ }
+
+ // Add addresses that we've sent to to the address book
+ foreach(const SendCoinsRecipient &rcp, recipients)
+ {
+ std::string strAddress = rcp.address.toStdString();
+ CRITICAL_BLOCK(wallet->cs_mapAddressBook)
+ {
+ if (!wallet->mapAddressBook.count(strAddress))
+ wallet->SetAddressBookName(strAddress, rcp.label.toStdString());
+ }
+ }
+
+ return SendCoinsReturn(OK, 0, hex);
+}
+
+OptionsModel *WalletModel::getOptionsModel()
+{
+ return optionsModel;
+}
+
+AddressTableModel *WalletModel::getAddressTableModel()
+{
+ return addressTableModel;
+}
+
+TransactionTableModel *WalletModel::getTransactionTableModel()
+{
+ return transactionTableModel;
+}
+
+
{
BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
{
- valtype vchPubKey;
+ uint160 hash160;
if (item.first == OP_PUBKEY)
- {
- vchPubKey = item.second;
- }
+ addressRet.SetPubKey(item.second);
else if (item.first == OP_PUBKEYHASH)
- {
- map<uint160, valtype>::iterator mi = mapPubKeys.find(uint160(item.second));
- if (mi == mapPubKeys.end())
- continue;
- vchPubKey = (*mi).second;
- }
- if (keystore == NULL || keystore->HaveKey(vchPubKey))
- {
- vchPubKeyRet = vchPubKey;
+ addressRet.SetHash160((uint160)item.second);
- if (keystore == NULL || keystore->HaveKey(addressRet))
++ //if (keystore == NULL || keystore->HaveKey(addressRet))
return true;
- }
}
}
- return false;
- }
-
-
- bool ExtractHash160(const CScript& scriptPubKey, uint160& hash160Ret)
- {
- hash160Ret = 0;
+
- vector<pair<opcodetype, valtype> > vSolution;
- if (!Solver(scriptPubKey, vSolution))
- return false;
-
- BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
- {
- if (item.first == OP_PUBKEYHASH)
- {
- hash160Ret = uint160(item.second);
- return true;
- }
- }
return false;
}
if (txout.scriptPubKey == scriptDefaultKey)
{
SetDefaultKey(GetOrReuseKeyFromPool());
- SetAddressBookName(PubKeyToAddress(vchDefaultKey), "");
+ SetAddressBookName(CBitcoinAddress(vchDefaultKey), "");
}
}
-
+#endif
// Notify UI
vWalletUpdated.push_back(hash);
git://git.novaco.in / novacoin.git / commitdiff