mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-01-14 13:52:36 -03:00
a587f85853
d3a56be77a
Revert "gui: Avoid Wallet::GetBalance in WalletModel::pollBalanceChanged" (Russell Yanofsky)bf0a510981
gui: Avoid wallet tryGetBalances calls before TransactionChanged or BlockTip notifications (Russell Yanofsky)2bc9b92ed8
Cancel wallet balance timer when shutdown requested (Russell Yanofsky)83f69fab3a
Switch transaction table to use wallet height not node height (Russell Yanofsky) Pull request description: Main commit `gui: Avoid wallet tryGetBalances calls` is one-line change to `WalletModel::pollBalanceChanged` that returns early if there hasn't been a new `TransactionChanged` or `BlockTip` notification since the previous poll call. This is the same behavior that was implemented in #18160, now implemented in a simpler way. The other commits are a straight revert of #18160, and two tweaks to avoid relying on `WalletModel::m_client_model` lifetime which were causing travis failures with earlier versions of this PR. Motivation for this change is to be able to revert #18160 and cut down on unnecessary cross-process calls that happen when #18160 is combined with #10102 This PR is part of the [process separation project](https://github.com/bitcoin/bitcoin/projects/10). ACKs for top commit: jonasschnelli: utACKd3a56be77a
Tree-SHA512: 3cd31ca515e77c3bd7160d3f1ea0dce5050d4038b2aa441b6f66b8599bd413d81ca5542a197806e773d6092dd1d26830932b1cecbc95298b1f1ab41099e2f12f
593 lines
19 KiB
C++
593 lines
19 KiB
C++
// Copyright (c) 2011-2020 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include <config/bitcoin-config.h>
|
|
#endif
|
|
|
|
#include <qt/walletmodel.h>
|
|
|
|
#include <qt/addresstablemodel.h>
|
|
#include <qt/clientmodel.h>
|
|
#include <qt/guiconstants.h>
|
|
#include <qt/guiutil.h>
|
|
#include <qt/optionsmodel.h>
|
|
#include <qt/paymentserver.h>
|
|
#include <qt/recentrequeststablemodel.h>
|
|
#include <qt/sendcoinsdialog.h>
|
|
#include <qt/transactiontablemodel.h>
|
|
|
|
#include <interfaces/handler.h>
|
|
#include <interfaces/node.h>
|
|
#include <key_io.h>
|
|
#include <psbt.h>
|
|
#include <ui_interface.h>
|
|
#include <util/system.h> // for GetBoolArg
|
|
#include <util/translation.h>
|
|
#include <wallet/coincontrol.h>
|
|
#include <wallet/wallet.h> // for CRecipient
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <QDebug>
|
|
#include <QMessageBox>
|
|
#include <QSet>
|
|
#include <QTimer>
|
|
|
|
|
|
WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet, ClientModel& client_model, const PlatformStyle *platformStyle, QObject *parent) :
|
|
QObject(parent),
|
|
m_wallet(std::move(wallet)),
|
|
m_client_model(&client_model),
|
|
m_node(client_model.node()),
|
|
optionsModel(client_model.getOptionsModel()),
|
|
addressTableModel(nullptr),
|
|
transactionTableModel(nullptr),
|
|
recentRequestsTableModel(nullptr),
|
|
cachedEncryptionStatus(Unencrypted),
|
|
cachedNumBlocks(0),
|
|
timer(new QTimer(this))
|
|
{
|
|
fHaveWatchOnly = m_wallet->haveWatchOnly();
|
|
addressTableModel = new AddressTableModel(this);
|
|
transactionTableModel = new TransactionTableModel(platformStyle, this);
|
|
recentRequestsTableModel = new RecentRequestsTableModel(this);
|
|
|
|
subscribeToCoreSignals();
|
|
}
|
|
|
|
WalletModel::~WalletModel()
|
|
{
|
|
unsubscribeFromCoreSignals();
|
|
}
|
|
|
|
void WalletModel::startPollBalance()
|
|
{
|
|
// This timer will be fired repeatedly to update the balance
|
|
connect(timer, &QTimer::timeout, this, &WalletModel::pollBalanceChanged);
|
|
timer->start(MODEL_UPDATE_DELAY);
|
|
}
|
|
|
|
void WalletModel::setClientModel(ClientModel* client_model)
|
|
{
|
|
m_client_model = client_model;
|
|
if (!m_client_model) timer->stop();
|
|
}
|
|
|
|
void WalletModel::updateStatus()
|
|
{
|
|
EncryptionStatus newEncryptionStatus = getEncryptionStatus();
|
|
|
|
if(cachedEncryptionStatus != newEncryptionStatus) {
|
|
Q_EMIT encryptionStatusChanged();
|
|
}
|
|
}
|
|
|
|
void WalletModel::pollBalanceChanged()
|
|
{
|
|
// Avoid recomputing wallet balances unless a TransactionChanged or
|
|
// BlockTip notification was received.
|
|
if (!fForceCheckBalanceChanged && cachedNumBlocks == m_client_model->getNumBlocks()) return;
|
|
|
|
// Try to get balances and return early if locks can't be acquired. This
|
|
// avoids the GUI from getting stuck on periodical polls if the core is
|
|
// holding the locks for a longer time - for example, during a wallet
|
|
// rescan.
|
|
interfaces::WalletBalances new_balances;
|
|
int numBlocks = -1;
|
|
if (!m_wallet->tryGetBalances(new_balances, numBlocks)) {
|
|
return;
|
|
}
|
|
|
|
if(fForceCheckBalanceChanged || numBlocks != cachedNumBlocks)
|
|
{
|
|
fForceCheckBalanceChanged = false;
|
|
|
|
// Balance and number of transactions might have changed
|
|
cachedNumBlocks = numBlocks;
|
|
|
|
checkBalanceChanged(new_balances);
|
|
if(transactionTableModel)
|
|
transactionTableModel->updateConfirmations();
|
|
}
|
|
}
|
|
|
|
void WalletModel::checkBalanceChanged(const interfaces::WalletBalances& new_balances)
|
|
{
|
|
if(new_balances.balanceChanged(m_cached_balances)) {
|
|
m_cached_balances = new_balances;
|
|
Q_EMIT balanceChanged(new_balances);
|
|
}
|
|
}
|
|
|
|
void WalletModel::updateTransaction()
|
|
{
|
|
// Balance and number of transactions might have changed
|
|
fForceCheckBalanceChanged = true;
|
|
}
|
|
|
|
void WalletModel::updateAddressBook(const QString &address, const QString &label,
|
|
bool isMine, const QString &purpose, int status)
|
|
{
|
|
if(addressTableModel)
|
|
addressTableModel->updateEntry(address, label, isMine, purpose, status);
|
|
}
|
|
|
|
void WalletModel::updateWatchOnlyFlag(bool fHaveWatchonly)
|
|
{
|
|
fHaveWatchOnly = fHaveWatchonly;
|
|
Q_EMIT notifyWatchonlyChanged(fHaveWatchonly);
|
|
}
|
|
|
|
bool WalletModel::validateAddress(const QString &address)
|
|
{
|
|
return IsValidDestinationString(address.toStdString());
|
|
}
|
|
|
|
WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction &transaction, const CCoinControl& coinControl)
|
|
{
|
|
CAmount total = 0;
|
|
bool fSubtractFeeFromAmount = false;
|
|
QList<SendCoinsRecipient> recipients = transaction.getRecipients();
|
|
std::vector<CRecipient> vecSend;
|
|
|
|
if(recipients.empty())
|
|
{
|
|
return OK;
|
|
}
|
|
|
|
QSet<QString> setAddress; // Used to detect duplicates
|
|
int nAddresses = 0;
|
|
|
|
// Pre-check input data for validity
|
|
for (const SendCoinsRecipient &rcp : recipients)
|
|
{
|
|
if (rcp.fSubtractFeeFromAmount)
|
|
fSubtractFeeFromAmount = true;
|
|
{ // User-entered bitcoin address / amount:
|
|
if(!validateAddress(rcp.address))
|
|
{
|
|
return InvalidAddress;
|
|
}
|
|
if(rcp.amount <= 0)
|
|
{
|
|
return InvalidAmount;
|
|
}
|
|
setAddress.insert(rcp.address);
|
|
++nAddresses;
|
|
|
|
CScript scriptPubKey = GetScriptForDestination(DecodeDestination(rcp.address.toStdString()));
|
|
CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
|
|
vecSend.push_back(recipient);
|
|
|
|
total += rcp.amount;
|
|
}
|
|
}
|
|
if(setAddress.size() != nAddresses)
|
|
{
|
|
return DuplicateAddress;
|
|
}
|
|
|
|
CAmount nBalance = m_wallet->getAvailableBalance(coinControl);
|
|
|
|
if(total > nBalance)
|
|
{
|
|
return AmountExceedsBalance;
|
|
}
|
|
|
|
{
|
|
CAmount nFeeRequired = 0;
|
|
int nChangePosRet = -1;
|
|
bilingual_str error;
|
|
|
|
auto& newTx = transaction.getWtx();
|
|
newTx = m_wallet->createTransaction(vecSend, coinControl, !wallet().privateKeysDisabled() /* sign */, nChangePosRet, nFeeRequired, error);
|
|
transaction.setTransactionFee(nFeeRequired);
|
|
if (fSubtractFeeFromAmount && newTx)
|
|
transaction.reassignAmounts(nChangePosRet);
|
|
|
|
if(!newTx)
|
|
{
|
|
if(!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance)
|
|
{
|
|
return SendCoinsReturn(AmountWithFeeExceedsBalance);
|
|
}
|
|
Q_EMIT message(tr("Send Coins"), QString::fromStdString(error.translated),
|
|
CClientUIInterface::MSG_ERROR);
|
|
return TransactionCreationFailed;
|
|
}
|
|
|
|
// Reject absurdly high fee. (This can never happen because the
|
|
// wallet never creates transactions with fee greater than
|
|
// m_default_max_tx_fee. This merely a belt-and-suspenders check).
|
|
if (nFeeRequired > m_wallet->getDefaultMaxTxFee()) {
|
|
return AbsurdFee;
|
|
}
|
|
}
|
|
|
|
return SendCoinsReturn(OK);
|
|
}
|
|
|
|
WalletModel::SendCoinsReturn WalletModel::sendCoins(WalletModelTransaction &transaction)
|
|
{
|
|
QByteArray transaction_array; /* store serialized transaction */
|
|
|
|
{
|
|
std::vector<std::pair<std::string, std::string>> vOrderForm;
|
|
for (const SendCoinsRecipient &rcp : transaction.getRecipients())
|
|
{
|
|
if (!rcp.message.isEmpty()) // Message from normal bitcoin:URI (bitcoin:123...?message=example)
|
|
vOrderForm.emplace_back("Message", rcp.message.toStdString());
|
|
}
|
|
|
|
auto& newTx = transaction.getWtx();
|
|
wallet().commitTransaction(newTx, {} /* mapValue */, std::move(vOrderForm));
|
|
|
|
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
|
|
ssTx << *newTx;
|
|
transaction_array.append(&(ssTx[0]), ssTx.size());
|
|
}
|
|
|
|
// Add addresses / update labels that we've sent to the address book,
|
|
// and emit coinsSent signal for each recipient
|
|
for (const SendCoinsRecipient &rcp : transaction.getRecipients())
|
|
{
|
|
{
|
|
std::string strAddress = rcp.address.toStdString();
|
|
CTxDestination dest = DecodeDestination(strAddress);
|
|
std::string strLabel = rcp.label.toStdString();
|
|
{
|
|
// Check if we have a new address or an updated label
|
|
std::string name;
|
|
if (!m_wallet->getAddress(
|
|
dest, &name, /* is_mine= */ nullptr, /* purpose= */ nullptr))
|
|
{
|
|
m_wallet->setAddressBook(dest, strLabel, "send");
|
|
}
|
|
else if (name != strLabel)
|
|
{
|
|
m_wallet->setAddressBook(dest, strLabel, ""); // "" means don't change purpose
|
|
}
|
|
}
|
|
}
|
|
Q_EMIT coinsSent(this, rcp, transaction_array);
|
|
}
|
|
|
|
checkBalanceChanged(m_wallet->getBalances()); // update balance immediately, otherwise there could be a short noticeable delay until pollBalanceChanged hits
|
|
|
|
return SendCoinsReturn(OK);
|
|
}
|
|
|
|
OptionsModel *WalletModel::getOptionsModel()
|
|
{
|
|
return optionsModel;
|
|
}
|
|
|
|
AddressTableModel *WalletModel::getAddressTableModel()
|
|
{
|
|
return addressTableModel;
|
|
}
|
|
|
|
TransactionTableModel *WalletModel::getTransactionTableModel()
|
|
{
|
|
return transactionTableModel;
|
|
}
|
|
|
|
RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel()
|
|
{
|
|
return recentRequestsTableModel;
|
|
}
|
|
|
|
WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const
|
|
{
|
|
if(!m_wallet->isCrypted())
|
|
{
|
|
return Unencrypted;
|
|
}
|
|
else if(m_wallet->isLocked())
|
|
{
|
|
return Locked;
|
|
}
|
|
else
|
|
{
|
|
return Unlocked;
|
|
}
|
|
}
|
|
|
|
bool WalletModel::setWalletEncrypted(bool encrypted, const SecureString &passphrase)
|
|
{
|
|
if(encrypted)
|
|
{
|
|
// Encrypt
|
|
return m_wallet->encryptWallet(passphrase);
|
|
}
|
|
else
|
|
{
|
|
// Decrypt -- TODO; not supported yet
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase)
|
|
{
|
|
if(locked)
|
|
{
|
|
// Lock
|
|
return m_wallet->lock();
|
|
}
|
|
else
|
|
{
|
|
// Unlock
|
|
return m_wallet->unlock(passPhrase);
|
|
}
|
|
}
|
|
|
|
bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureString &newPass)
|
|
{
|
|
m_wallet->lock(); // Make sure wallet is locked before attempting pass change
|
|
return m_wallet->changeWalletPassphrase(oldPass, newPass);
|
|
}
|
|
|
|
// Handlers for core signals
|
|
static void NotifyUnload(WalletModel* walletModel)
|
|
{
|
|
qDebug() << "NotifyUnload";
|
|
bool invoked = QMetaObject::invokeMethod(walletModel, "unload");
|
|
assert(invoked);
|
|
}
|
|
|
|
static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel)
|
|
{
|
|
qDebug() << "NotifyKeyStoreStatusChanged";
|
|
bool invoked = QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
|
|
assert(invoked);
|
|
}
|
|
|
|
static void NotifyAddressBookChanged(WalletModel *walletmodel,
|
|
const CTxDestination &address, const std::string &label, bool isMine,
|
|
const std::string &purpose, ChangeType status)
|
|
{
|
|
QString strAddress = QString::fromStdString(EncodeDestination(address));
|
|
QString strLabel = QString::fromStdString(label);
|
|
QString strPurpose = QString::fromStdString(purpose);
|
|
|
|
qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);
|
|
bool invoked = QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
|
|
Q_ARG(QString, strAddress),
|
|
Q_ARG(QString, strLabel),
|
|
Q_ARG(bool, isMine),
|
|
Q_ARG(QString, strPurpose),
|
|
Q_ARG(int, status));
|
|
assert(invoked);
|
|
}
|
|
|
|
static void NotifyTransactionChanged(WalletModel *walletmodel, const uint256 &hash, ChangeType status)
|
|
{
|
|
Q_UNUSED(hash);
|
|
Q_UNUSED(status);
|
|
bool invoked = QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
|
|
assert(invoked);
|
|
}
|
|
|
|
static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
|
|
{
|
|
// emits signal "showProgress"
|
|
bool invoked = QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
|
|
Q_ARG(QString, QString::fromStdString(title)),
|
|
Q_ARG(int, nProgress));
|
|
assert(invoked);
|
|
}
|
|
|
|
static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)
|
|
{
|
|
bool invoked = QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
|
|
Q_ARG(bool, fHaveWatchonly));
|
|
assert(invoked);
|
|
}
|
|
|
|
static void NotifyCanGetAddressesChanged(WalletModel* walletmodel)
|
|
{
|
|
bool invoked = QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");
|
|
assert(invoked);
|
|
}
|
|
|
|
void WalletModel::subscribeToCoreSignals()
|
|
{
|
|
// Connect signals to wallet
|
|
m_handler_unload = m_wallet->handleUnload(std::bind(&NotifyUnload, this));
|
|
m_handler_status_changed = m_wallet->handleStatusChanged(std::bind(&NotifyKeyStoreStatusChanged, this));
|
|
m_handler_address_book_changed = m_wallet->handleAddressBookChanged(std::bind(NotifyAddressBookChanged, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
|
|
m_handler_transaction_changed = m_wallet->handleTransactionChanged(std::bind(NotifyTransactionChanged, this, std::placeholders::_1, std::placeholders::_2));
|
|
m_handler_show_progress = m_wallet->handleShowProgress(std::bind(ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
|
|
m_handler_watch_only_changed = m_wallet->handleWatchOnlyChanged(std::bind(NotifyWatchonlyChanged, this, std::placeholders::_1));
|
|
m_handler_can_get_addrs_changed = m_wallet->handleCanGetAddressesChanged(boost::bind(NotifyCanGetAddressesChanged, this));
|
|
}
|
|
|
|
void WalletModel::unsubscribeFromCoreSignals()
|
|
{
|
|
// Disconnect signals from wallet
|
|
m_handler_unload->disconnect();
|
|
m_handler_status_changed->disconnect();
|
|
m_handler_address_book_changed->disconnect();
|
|
m_handler_transaction_changed->disconnect();
|
|
m_handler_show_progress->disconnect();
|
|
m_handler_watch_only_changed->disconnect();
|
|
m_handler_can_get_addrs_changed->disconnect();
|
|
}
|
|
|
|
// WalletModel::UnlockContext implementation
|
|
WalletModel::UnlockContext WalletModel::requestUnlock()
|
|
{
|
|
bool was_locked = getEncryptionStatus() == Locked;
|
|
if(was_locked)
|
|
{
|
|
// Request UI to unlock wallet
|
|
Q_EMIT requireUnlock();
|
|
}
|
|
// If wallet is still locked, unlock was failed or cancelled, mark context as invalid
|
|
bool valid = getEncryptionStatus() != Locked;
|
|
|
|
return UnlockContext(this, valid, was_locked);
|
|
}
|
|
|
|
WalletModel::UnlockContext::UnlockContext(WalletModel *_wallet, bool _valid, bool _relock):
|
|
wallet(_wallet),
|
|
valid(_valid),
|
|
relock(_relock)
|
|
{
|
|
}
|
|
|
|
WalletModel::UnlockContext::~UnlockContext()
|
|
{
|
|
if(valid && relock)
|
|
{
|
|
wallet->setWalletLocked(true);
|
|
}
|
|
}
|
|
|
|
void WalletModel::UnlockContext::CopyFrom(UnlockContext&& rhs)
|
|
{
|
|
// Transfer context; old object no longer relocks wallet
|
|
*this = rhs;
|
|
rhs.relock = false;
|
|
}
|
|
|
|
void WalletModel::loadReceiveRequests(std::vector<std::string>& vReceiveRequests)
|
|
{
|
|
vReceiveRequests = m_wallet->getDestValues("rr"); // receive request
|
|
}
|
|
|
|
bool WalletModel::saveReceiveRequest(const std::string &sAddress, const int64_t nId, const std::string &sRequest)
|
|
{
|
|
CTxDestination dest = DecodeDestination(sAddress);
|
|
|
|
std::stringstream ss;
|
|
ss << nId;
|
|
std::string key = "rr" + ss.str(); // "rr" prefix = "receive request" in destdata
|
|
|
|
if (sRequest.empty())
|
|
return m_wallet->eraseDestData(dest, key);
|
|
else
|
|
return m_wallet->addDestData(dest, key, sRequest);
|
|
}
|
|
|
|
bool WalletModel::bumpFee(uint256 hash, uint256& new_hash)
|
|
{
|
|
CCoinControl coin_control;
|
|
coin_control.m_signal_bip125_rbf = true;
|
|
std::vector<bilingual_str> errors;
|
|
CAmount old_fee;
|
|
CAmount new_fee;
|
|
CMutableTransaction mtx;
|
|
if (!m_wallet->createBumpTransaction(hash, coin_control, errors, old_fee, new_fee, mtx)) {
|
|
QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Increasing transaction fee failed") + "<br />(" +
|
|
(errors.size() ? QString::fromStdString(errors[0].translated) : "") +")");
|
|
return false;
|
|
}
|
|
|
|
const bool create_psbt = m_wallet->privateKeysDisabled();
|
|
|
|
// allow a user based fee verification
|
|
QString questionString = create_psbt ? tr("Do you want to draft a transaction with fee increase?") : tr("Do you want to increase the fee?");
|
|
questionString.append("<br />");
|
|
questionString.append("<table style=\"text-align: left;\">");
|
|
questionString.append("<tr><td>");
|
|
questionString.append(tr("Current fee:"));
|
|
questionString.append("</td><td>");
|
|
questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), old_fee));
|
|
questionString.append("</td></tr><tr><td>");
|
|
questionString.append(tr("Increase:"));
|
|
questionString.append("</td><td>");
|
|
questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), new_fee - old_fee));
|
|
questionString.append("</td></tr><tr><td>");
|
|
questionString.append(tr("New fee:"));
|
|
questionString.append("</td><td>");
|
|
questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), new_fee));
|
|
questionString.append("</td></tr></table>");
|
|
SendConfirmationDialog confirmationDialog(tr("Confirm fee bump"), questionString);
|
|
confirmationDialog.exec();
|
|
QMessageBox::StandardButton retval = static_cast<QMessageBox::StandardButton>(confirmationDialog.result());
|
|
|
|
// cancel sign&broadcast if user doesn't want to bump the fee
|
|
if (retval != QMessageBox::Yes) {
|
|
return false;
|
|
}
|
|
|
|
WalletModel::UnlockContext ctx(requestUnlock());
|
|
if(!ctx.isValid())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Short-circuit if we are returning a bumped transaction PSBT to clipboard
|
|
if (create_psbt) {
|
|
PartiallySignedTransaction psbtx(mtx);
|
|
bool complete = false;
|
|
const TransactionError err = wallet().fillPSBT(SIGHASH_ALL, false /* sign */, true /* bip32derivs */, psbtx, complete);
|
|
if (err != TransactionError::OK || complete) {
|
|
QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Can't draft transaction."));
|
|
return false;
|
|
}
|
|
// Serialize the PSBT
|
|
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
|
|
ssTx << psbtx;
|
|
GUIUtil::setClipboard(EncodeBase64(ssTx.str()).c_str());
|
|
Q_EMIT message(tr("PSBT copied"), "Copied to clipboard", CClientUIInterface::MSG_INFORMATION);
|
|
return true;
|
|
}
|
|
|
|
// sign bumped transaction
|
|
if (!m_wallet->signBumpTransaction(mtx)) {
|
|
QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Can't sign transaction."));
|
|
return false;
|
|
}
|
|
// commit the bumped transaction
|
|
if(!m_wallet->commitBumpTransaction(hash, std::move(mtx), errors, new_hash)) {
|
|
QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Could not commit transaction") + "<br />(" +
|
|
QString::fromStdString(errors[0].translated)+")");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool WalletModel::isWalletEnabled()
|
|
{
|
|
return !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
|
|
}
|
|
|
|
QString WalletModel::getWalletName() const
|
|
{
|
|
return QString::fromStdString(m_wallet->getWalletName());
|
|
}
|
|
|
|
QString WalletModel::getDisplayName() const
|
|
{
|
|
const QString name = getWalletName();
|
|
return name.isEmpty() ? "["+tr("default wallet")+"]" : name;
|
|
}
|
|
|
|
bool WalletModel::isMultiwallet()
|
|
{
|
|
return m_node.getWallets().size() > 1;
|
|
}
|