git / moonbite-core / src/qt/walletmodel.cpp · raw

// 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 <node/ui_interface.h>#include <psbt.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),    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 && m_cached_last_update_tip == getLastBlockProcessed()) 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;    uint256 block_hash;    if (!m_wallet->tryGetBalances(new_balances, block_hash)) {        return;    }    if (fForceCheckBalanceChanged || block_hash != m_cached_last_update_tip) {        fForceCheckBalanceChanged = false;        // Balance and number of transactions might have changed        m_cached_last_update_tip = block_hash;        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;    CCoinControl coin_control_copy = coinControl;    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;            DestinationAddr receiver;            switch (rcp.type) {            case SendCoinsRecipient::MWEB_PEGIN: {                coin_control_copy.fPegIn = true;                StealthAddress pegin_address;                if (!m_wallet->getPeginAddress(pegin_address)) {                    return TransactionCreationFailed;                }                receiver = pegin_address;                break;            }            case SendCoinsRecipient::MWEB_PEGOUT: {                coin_control_copy.fPegOut = true;                receiver = DecodeDestination(rcp.address.toStdString());                break;            }            default:                receiver = DecodeDestination(rcp.address.toStdString());            }            CRecipient recipient = {receiver, rcp.amount, rcp.fSubtractFeeFromAmount};            vecSend.push_back(recipient);            total += rcp.amount;        }    }    if(setAddress.size() != nAddresses)    {        return DuplicateAddress;    }    CAmount nBalance = m_wallet->getAvailableBalance(coin_control_copy);    if(total > nBalance)    {        return AmountExceedsBalance;    }    {        CAmount nFeeRequired = 0;        int nChangePosRet = -1;        bilingual_str error;        auto& newTx = transaction.getWtx();        newTx = m_wallet->createTransaction(vecSend, coin_control_copy, !wallet().privateKeysDisabled() /* sign */, nChangePosRet, nFeeRequired, error);        transaction.setTransactionFee(nFeeRequired);        if (fSubtractFeeFromAmount && newTx)            transaction.reassignAmounts(*m_wallet, 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;        std::vector<ReserveDestination*> reserved_keys;        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());            if (rcp.reserved_dest != nullptr) {                reserved_keys.push_back(rcp.reserved_dest.get());            }        }        auto& newTx = transaction.getWtx();        wallet().commitTransaction(newTx, {} /* mapValue */, std::move(vOrderForm), reserved_keys);        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) {        return m_wallet->encryptWallet(passphrase);    }    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 signalsstatic 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(std::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 implementationWalletModel::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, nullptr);        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.walletClient().getWallets().size() > 1;}void WalletModel::refresh(bool pk_hash_only){    addressTableModel = new AddressTableModel(this, pk_hash_only);}uint256 WalletModel::getLastBlockProcessed() const{    return m_client_model ? m_client_model->getBestBlockHash() : uint256{};}