20469d83dd
With an encrypted wallet the GUI was prompting for a passphrase every time the user requested a new address. This is unnecessary, increases the exposure to keyboard sniffers, and discourages using fresh addresses for every transaction. Instead only prompt for a passphrase when the keypool runs out, also call the new address function with the flag that prevents reuse. Thanks to AlexNagy on IRC for pointing this out and who wouldn't take any lip from a curmudgeonly developer and insisted on what he knew to be true.
441 lines
13 KiB
C++
441 lines
13 KiB
C++
#include "addresstablemodel.h"
|
|
|
|
#include "guiutil.h"
|
|
#include "walletmodel.h"
|
|
|
|
#include "wallet.h"
|
|
#include "base58.h"
|
|
|
|
#include <QFont>
|
|
|
|
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) {}
|
|
};
|
|
|
|
struct AddressTableEntryLessThan
|
|
{
|
|
bool operator()(const AddressTableEntry &a, const AddressTableEntry &b) const
|
|
{
|
|
return a.address < b.address;
|
|
}
|
|
bool operator()(const AddressTableEntry &a, const QString &b) const
|
|
{
|
|
return a.address < b;
|
|
}
|
|
bool operator()(const QString &a, const AddressTableEntry &b) const
|
|
{
|
|
return a < b.address;
|
|
}
|
|
};
|
|
|
|
// Private implementation
|
|
class AddressTablePriv
|
|
{
|
|
public:
|
|
CWallet *wallet;
|
|
QList<AddressTableEntry> cachedAddressTable;
|
|
AddressTableModel *parent;
|
|
|
|
AddressTablePriv(CWallet *wallet, AddressTableModel *parent):
|
|
wallet(wallet), parent(parent) {}
|
|
|
|
void refreshAddressTable()
|
|
{
|
|
cachedAddressTable.clear();
|
|
{
|
|
LOCK(wallet->cs_wallet);
|
|
BOOST_FOREACH(const PAIRTYPE(CTxDestination, CAddressBookData)& item, wallet->mapAddressBook)
|
|
{
|
|
const CBitcoinAddress& address = item.first;
|
|
|
|
AddressTableEntry::Type addressType;
|
|
const std::string& strPurpose = item.second.purpose;
|
|
if (strPurpose == "send") addressType = AddressTableEntry::Sending;
|
|
else if (strPurpose == "receive") addressType = AddressTableEntry::Receiving;
|
|
else if (strPurpose == "unknown") {
|
|
bool fMine = IsMine(*wallet, address.Get());
|
|
addressType = (fMine ? AddressTableEntry::Receiving : AddressTableEntry::Sending);
|
|
}
|
|
else continue; // "refund" addresses aren't shown, and change addresses aren't in mapAddressBook at all.
|
|
|
|
const std::string& strName = item.second.name;
|
|
cachedAddressTable.append(AddressTableEntry(addressType,
|
|
QString::fromStdString(strName),
|
|
QString::fromStdString(address.ToString())));
|
|
}
|
|
}
|
|
// qLowerBound() and qUpperBound() require our cachedAddressTable list to be sorted in asc order
|
|
qSort(cachedAddressTable.begin(), cachedAddressTable.end(), AddressTableEntryLessThan());
|
|
}
|
|
|
|
void updateEntry(const QString &address, const QString &label, bool isMine, int status)
|
|
{
|
|
// Find address / label in model
|
|
QList<AddressTableEntry>::iterator lower = qLowerBound(
|
|
cachedAddressTable.begin(), cachedAddressTable.end(), address, AddressTableEntryLessThan());
|
|
QList<AddressTableEntry>::iterator upper = qUpperBound(
|
|
cachedAddressTable.begin(), cachedAddressTable.end(), address, AddressTableEntryLessThan());
|
|
int lowerIndex = (lower - cachedAddressTable.begin());
|
|
int upperIndex = (upper - cachedAddressTable.begin());
|
|
bool inModel = (lower != upper);
|
|
AddressTableEntry::Type newEntryType = isMine ? AddressTableEntry::Receiving : AddressTableEntry::Sending;
|
|
|
|
switch(status)
|
|
{
|
|
case CT_NEW:
|
|
if(inModel)
|
|
{
|
|
OutputDebugStringF("Warning: AddressTablePriv::updateEntry: Got CT_NOW, but entry is already in model\n");
|
|
break;
|
|
}
|
|
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex);
|
|
cachedAddressTable.insert(lowerIndex, AddressTableEntry(newEntryType, label, address));
|
|
parent->endInsertRows();
|
|
break;
|
|
case CT_UPDATED:
|
|
if(!inModel)
|
|
{
|
|
OutputDebugStringF("Warning: AddressTablePriv::updateEntry: Got CT_UPDATED, but entry is not in model\n");
|
|
break;
|
|
}
|
|
lower->type = newEntryType;
|
|
lower->label = label;
|
|
parent->emitDataChanged(lowerIndex);
|
|
break;
|
|
case CT_DELETED:
|
|
if(!inModel)
|
|
{
|
|
OutputDebugStringF("Warning: AddressTablePriv::updateEntry: Got CT_DELETED, but entry is not in model\n");
|
|
break;
|
|
}
|
|
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
|
|
cachedAddressTable.erase(lower, upper);
|
|
parent->endRemoveRows();
|
|
break;
|
|
}
|
|
}
|
|
|
|
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, this);
|
|
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());
|
|
std::string strPurpose = (rec->type == AddressTableEntry::Sending ? "send" : "receive");
|
|
editStatus = OK;
|
|
|
|
if(role == Qt::EditRole)
|
|
{
|
|
switch(index.column())
|
|
{
|
|
case Label:
|
|
// Do nothing, if old label == new label
|
|
if(rec->label == value.toString())
|
|
{
|
|
editStatus = NO_CHANGES;
|
|
return false;
|
|
}
|
|
wallet->SetAddressBook(CBitcoinAddress(rec->address.toStdString()).Get(), value.toString().toStdString(), strPurpose);
|
|
break;
|
|
case Address:
|
|
// Do nothing, if old address == new address
|
|
if(CBitcoinAddress(rec->address.toStdString()) == CBitcoinAddress(value.toString().toStdString()))
|
|
{
|
|
editStatus = NO_CHANGES;
|
|
return false;
|
|
}
|
|
// Refuse to set invalid address, set error status and return false
|
|
else if(!walletModel->validateAddress(value.toString()))
|
|
{
|
|
editStatus = INVALID_ADDRESS;
|
|
return false;
|
|
}
|
|
// Check for duplicate addresses to prevent accidental deletion of addresses, if you try
|
|
// to paste an existing address over another address (with a different label)
|
|
else if(wallet->mapAddressBook.count(CBitcoinAddress(value.toString().toStdString()).Get()))
|
|
{
|
|
editStatus = DUPLICATE_ADDRESS;
|
|
return false;
|
|
}
|
|
// Double-check that we're not overwriting a receiving address
|
|
else if(rec->type == AddressTableEntry::Sending)
|
|
{
|
|
{
|
|
LOCK(wallet->cs_wallet);
|
|
// Remove old entry
|
|
wallet->DelAddressBook(CBitcoinAddress(rec->address.toStdString()).Get());
|
|
// Add new entry with new address
|
|
wallet->SetAddressBook(CBitcoinAddress(value.toString().toStdString()).Get(), rec->label.toStdString(), strPurpose);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
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::updateEntry(const QString &address, const QString &label, bool isMine, int status)
|
|
{
|
|
// Update address book model from Bitcoin core
|
|
priv->updateEntry(address, label, isMine, status);
|
|
}
|
|
|
|
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 addresses
|
|
{
|
|
LOCK(wallet->cs_wallet);
|
|
if(wallet->mapAddressBook.count(CBitcoinAddress(strAddress).Get()))
|
|
{
|
|
editStatus = DUPLICATE_ADDRESS;
|
|
return QString();
|
|
}
|
|
}
|
|
}
|
|
else if(type == Receive)
|
|
{
|
|
// Generate a new address to associate with given label
|
|
CPubKey newKey;
|
|
if(!wallet->GetKeyFromPool(newKey, false))
|
|
{
|
|
WalletModel::UnlockContext ctx(walletModel->requestUnlock());
|
|
if(!ctx.isValid())
|
|
{
|
|
// Unlock wallet failed or was cancelled
|
|
editStatus = WALLET_UNLOCK_FAILURE;
|
|
return QString();
|
|
}
|
|
if(!wallet->GetKeyFromPool(newKey, false))
|
|
{
|
|
editStatus = KEY_GENERATION_FAILURE;
|
|
return QString();
|
|
}
|
|
}
|
|
strAddress = CBitcoinAddress(newKey.GetID()).ToString();
|
|
}
|
|
else
|
|
{
|
|
return QString();
|
|
}
|
|
|
|
// Add entry
|
|
{
|
|
LOCK(wallet->cs_wallet);
|
|
wallet->SetAddressBook(CBitcoinAddress(strAddress).Get(), strLabel,
|
|
(type == Send ? "send" : "receive"));
|
|
}
|
|
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;
|
|
}
|
|
{
|
|
LOCK(wallet->cs_wallet);
|
|
wallet->DelAddressBook(CBitcoinAddress(rec->address.toStdString()).Get());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Look up label for address in address book, if not found return empty string.
|
|
*/
|
|
QString AddressTableModel::labelForAddress(const QString &address) const
|
|
{
|
|
{
|
|
LOCK(wallet->cs_wallet);
|
|
CBitcoinAddress address_parsed(address.toStdString());
|
|
std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(address_parsed.Get());
|
|
if (mi != wallet->mapAddressBook.end())
|
|
{
|
|
return QString::fromStdString(mi->second.name);
|
|
}
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
|
|
void AddressTableModel::emitDataChanged(int idx)
|
|
{
|
|
emit dataChanged(index(idx, 0, QModelIndex()), index(idx, columns.length()-1, QModelIndex()));
|
|
}
|