src/qt/walletmodel.cpp

   1 // Copyright (c) 2011-2016 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "walletmodel.h"
   6
   7 #include "addresstablemodel.h"
   8 #include "consensus/validation.h"
   9 #include "guiconstants.h"
  10 #include "guiutil.h"
  11 #include "optionsmodel.h"
  12 #include "paymentserver.h"
  13 #include "recentrequeststablemodel.h"
  14 #include "sendcoinsdialog.h"
  15 #include "transactiontablemodel.h"
  16
  17 #include "base58.h"
  18 #include "chain.h"
  19 #include "keystore.h"
  20 #include "validation.h"
  21 #include "net.h" // for g_connman
  22 #include "policy/fees.h"
  23 #include "policy/rbf.h"
  24 #include "sync.h"
  25 #include "ui_interface.h"
  26 #include "util.h" // for GetBoolArg
  27 #include "wallet/coincontrol.h"
  28 #include "wallet/feebumper.h"
  29 #include "wallet/wallet.h"
  30 #include "wallet/walletdb.h" // for BackupWallet
  31
  32 #include <stdint.h>
  33
  34 #include <QDebug>
  35 #include <QMessageBox>
  36 #include <QSet>
  37 #include <QTimer>
  38
  39
  40 WalletModel::WalletModel(const PlatformStyle *platformStyle, CWallet *_wallet, OptionsModel *_optionsModel, QObject *parent) :
  41     QObject(parent), wallet(_wallet), optionsModel(_optionsModel), addressTableModel(0),
  42     transactionTableModel(0),
  43     recentRequestsTableModel(0),
  44     cachedBalance(0), cachedUnconfirmedBalance(0), cachedImmatureBalance(0),
  45     cachedEncryptionStatus(Unencrypted),
  46     cachedNumBlocks(0)
  47 {
  48     fHaveWatchOnly = wallet->HaveWatchOnly();
  49     fForceCheckBalanceChanged = false;
  50
  51     addressTableModel = new AddressTableModel(wallet, this);
  52     transactionTableModel = new TransactionTableModel(platformStyle, wallet, this);
  53     recentRequestsTableModel = new RecentRequestsTableModel(wallet, this);
  54
  55     // This timer will be fired repeatedly to update the balance
  56     pollTimer = new QTimer(this);
  57     connect(pollTimer, SIGNAL(timeout()), this, SLOT(pollBalanceChanged()));
  58     pollTimer->start(MODEL_UPDATE_DELAY);
  59
  60     subscribeToCoreSignals();
  61 }
  62
  63 WalletModel::~WalletModel()
  64 {
  65     unsubscribeFromCoreSignals();
  66 }
  67
  68 CAmount WalletModel::getBalance(const CCoinControl *coinControl) const
  69 {
  70     if (coinControl)
  71     {
  72         return wallet->GetAvailableBalance(coinControl);
  73     }
  74
  75     return wallet->GetBalance();
  76 }
  77
  78 CAmount WalletModel::getUnconfirmedBalance() const
  79 {
  80     return wallet->GetUnconfirmedBalance();
  81 }
  82
  83 CAmount WalletModel::getImmatureBalance() const
  84 {
  85     return wallet->GetImmatureBalance();
  86 }
  87
  88 bool WalletModel::haveWatchOnly() const
  89 {
  90     return fHaveWatchOnly;
  91 }
  92
  93 CAmount WalletModel::getWatchBalance() const
  94 {
  95     return wallet->GetWatchOnlyBalance();
  96 }
  97
  98 CAmount WalletModel::getWatchUnconfirmedBalance() const
  99 {
 100     return wallet->GetUnconfirmedWatchOnlyBalance();
 101 }
 102
 103 CAmount WalletModel::getWatchImmatureBalance() const
 104 {
 105     return wallet->GetImmatureWatchOnlyBalance();
 106 }
 107
 108 void WalletModel::updateStatus()
 109 {
 110     EncryptionStatus newEncryptionStatus = getEncryptionStatus();
 111
 112     if(cachedEncryptionStatus != newEncryptionStatus)
 113         Q_EMIT encryptionStatusChanged(newEncryptionStatus);
 114 }
 115
 116 void WalletModel::pollBalanceChanged()
 117 {
 118     // Get required locks upfront. This avoids the GUI from getting stuck on
 119     // periodical polls if the core is holding the locks for a longer time -
 120     // for example, during a wallet rescan.
 121     TRY_LOCK(cs_main, lockMain);
 122     if(!lockMain)
 123         return;
 124     TRY_LOCK(wallet->cs_wallet, lockWallet);
 125     if(!lockWallet)
 126         return;
 127
 128     if(fForceCheckBalanceChanged || chainActive.Height() != cachedNumBlocks)
 129     {
 130         fForceCheckBalanceChanged = false;
 131
 132         // Balance and number of transactions might have changed
 133         cachedNumBlocks = chainActive.Height();
 134
 135         checkBalanceChanged();
 136         if(transactionTableModel)
 137             transactionTableModel->updateConfirmations();
 138     }
 139 }
 140
 141 void WalletModel::checkBalanceChanged()
 142 {
 143     CAmount newBalance = getBalance();
 144     CAmount newUnconfirmedBalance = getUnconfirmedBalance();
 145     CAmount newImmatureBalance = getImmatureBalance();
 146     CAmount newWatchOnlyBalance = 0;
 147     CAmount newWatchUnconfBalance = 0;
 148     CAmount newWatchImmatureBalance = 0;
 149     if (haveWatchOnly())
 150     {
 151         newWatchOnlyBalance = getWatchBalance();
 152         newWatchUnconfBalance = getWatchUnconfirmedBalance();
 153         newWatchImmatureBalance = getWatchImmatureBalance();
 154     }
 155
 156     if(cachedBalance != newBalance || cachedUnconfirmedBalance != newUnconfirmedBalance || cachedImmatureBalance != newImmatureBalance ||
 157         cachedWatchOnlyBalance != newWatchOnlyBalance || cachedWatchUnconfBalance != newWatchUnconfBalance || cachedWatchImmatureBalance != newWatchImmatureBalance)
 158     {
 159         cachedBalance = newBalance;
 160         cachedUnconfirmedBalance = newUnconfirmedBalance;
 161         cachedImmatureBalance = newImmatureBalance;
 162         cachedWatchOnlyBalance = newWatchOnlyBalance;
 163         cachedWatchUnconfBalance = newWatchUnconfBalance;
 164         cachedWatchImmatureBalance = newWatchImmatureBalance;
 165         Q_EMIT balanceChanged(newBalance, newUnconfirmedBalance, newImmatureBalance,
 166                             newWatchOnlyBalance, newWatchUnconfBalance, newWatchImmatureBalance);
 167     }
 168 }
 169
 170 void WalletModel::updateTransaction()
 171 {
 172     // Balance and number of transactions might have changed
 173     fForceCheckBalanceChanged = true;
 174 }
 175
 176 void WalletModel::updateAddressBook(const QString &address, const QString &label,
 177         bool isMine, const QString &purpose, int status)
 178 {
 179     if(addressTableModel)
 180         addressTableModel->updateEntry(address, label, isMine, purpose, status);
 181 }
 182
 183 void WalletModel::updateWatchOnlyFlag(bool fHaveWatchonly)
 184 {
 185     fHaveWatchOnly = fHaveWatchonly;
 186     Q_EMIT notifyWatchonlyChanged(fHaveWatchonly);
 187 }
 188
 189 bool WalletModel::validateAddress(const QString &address)
 190 {
 191     CBitcoinAddress addressParsed(address.toStdString());
 192     return addressParsed.IsValid();
 193 }
 194
 195 WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction &transaction, const CCoinControl& coinControl)
 196 {
 197     CAmount total = 0;
 198     bool fSubtractFeeFromAmount = false;
 199     QList<SendCoinsRecipient> recipients = transaction.getRecipients();
 200     std::vector<CRecipient> vecSend;
 201
 202     if(recipients.empty())
 203     {
 204         return OK;
 205     }
 206
 207     QSet<QString> setAddress; // Used to detect duplicates
 208     int nAddresses = 0;
 209
 210     // Pre-check input data for validity
 211     for (const SendCoinsRecipient &rcp : recipients)
 212     {
 213         if (rcp.fSubtractFeeFromAmount)
 214             fSubtractFeeFromAmount = true;
 215
 216         if (rcp.paymentRequest.IsInitialized())
 217         {   // PaymentRequest...
 218             CAmount subtotal = 0;
 219             const payments::PaymentDetails& details = rcp.paymentRequest.getDetails();
 220             for (int i = 0; i < details.outputs_size(); i++)
 221             {
 222                 const payments::Output& out = details.outputs(i);
 223                 if (out.amount() <= 0) continue;
 224                 subtotal += out.amount();
 225                 const unsigned char* scriptStr = (const unsigned char*)out.script().data();
 226                 CScript scriptPubKey(scriptStr, scriptStr+out.script().size());
 227                 CAmount nAmount = out.amount();
 228                 CRecipient recipient = {scriptPubKey, nAmount, rcp.fSubtractFeeFromAmount};
 229                 vecSend.push_back(recipient);
 230             }
 231             if (subtotal <= 0)
 232             {
 233                 return InvalidAmount;
 234             }
 235             total += subtotal;
 236         }
 237         else
 238         {   // User-entered bitcoin address / amount:
 239             if(!validateAddress(rcp.address))
 240             {
 241                 return InvalidAddress;
 242             }
 243             if(rcp.amount <= 0)
 244             {
 245                 return InvalidAmount;
 246             }
 247             setAddress.insert(rcp.address);
 248             ++nAddresses;
 249
 250             CScript scriptPubKey = GetScriptForDestination(CBitcoinAddress(rcp.address.toStdString()).Get());
 251             CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
 252             vecSend.push_back(recipient);
 253
 254             total += rcp.amount;
 255         }
 256     }
 257     if(setAddress.size() != nAddresses)
 258     {
 259         return DuplicateAddress;
 260     }
 261
 262     CAmount nBalance = getBalance(&coinControl);
 263
 264     if(total > nBalance)
 265     {
 266         return AmountExceedsBalance;
 267     }
 268
 269     {
 270         LOCK2(cs_main, wallet->cs_wallet);
 271
 272         transaction.newPossibleKeyChange(wallet);
 273
 274         CAmount nFeeRequired = 0;
 275         int nChangePosRet = -1;
 276         std::string strFailReason;
 277
 278         CWalletTx *newTx = transaction.getTransaction();
 279         CReserveKey *keyChange = transaction.getPossibleKeyChange();
 280         bool fCreated = wallet->CreateTransaction(vecSend, *newTx, *keyChange, nFeeRequired, nChangePosRet, strFailReason, coinControl);
 281         transaction.setTransactionFee(nFeeRequired);
 282         if (fSubtractFeeFromAmount && fCreated)
 283             transaction.reassignAmounts(nChangePosRet);
 284
 285         if(!fCreated)
 286         {
 287             if(!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance)
 288             {
 289                 return SendCoinsReturn(AmountWithFeeExceedsBalance);
 290             }
 291             Q_EMIT message(tr("Send Coins"), QString::fromStdString(strFailReason),
 292                          CClientUIInterface::MSG_ERROR);
 293             return TransactionCreationFailed;
 294         }
 295
 296         // reject absurdly high fee. (This can never happen because the
 297         // wallet caps the fee at maxTxFee. This merely serves as a
 298         // belt-and-suspenders check)
 299         if (nFeeRequired > maxTxFee)
 300             return AbsurdFee;
 301     }
 302
 303     return SendCoinsReturn(OK);
 304 }
 305
 306 WalletModel::SendCoinsReturn WalletModel::sendCoins(WalletModelTransaction &transaction)
 307 {
 308     QByteArray transaction_array; /* store serialized transaction */
 309
 310     {
 311         LOCK2(cs_main, wallet->cs_wallet);
 312         CWalletTx *newTx = transaction.getTransaction();
 313
 314         for (const SendCoinsRecipient &rcp : transaction.getRecipients())
 315         {
 316             if (rcp.paymentRequest.IsInitialized())
 317             {
 318                 // Make sure any payment requests involved are still valid.
 319                 if (PaymentServer::verifyExpired(rcp.paymentRequest.getDetails())) {
 320                     return PaymentRequestExpired;
 321                 }
 322
 323                 // Store PaymentRequests in wtx.vOrderForm in wallet.
 324                 std::string key("PaymentRequest");
 325                 std::string value;
 326                 rcp.paymentRequest.SerializeToString(&value);
 327                 newTx->vOrderForm.push_back(make_pair(key, value));
 328             }
 329             else if (!rcp.message.isEmpty()) // Message from normal bitcoin:URI (bitcoin:123...?message=example)
 330                 newTx->vOrderForm.push_back(make_pair("Message", rcp.message.toStdString()));
 331         }
 332
 333         CReserveKey *keyChange = transaction.getPossibleKeyChange();
 334         CValidationState state;
 335         if(!wallet->CommitTransaction(*newTx, *keyChange, g_connman.get(), state))
 336             return SendCoinsReturn(TransactionCommitFailed, QString::fromStdString(state.GetRejectReason()));
 337
 338         CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
 339         ssTx << *newTx->tx;
 340         transaction_array.append(&(ssTx[0]), ssTx.size());
 341     }
 342
 343     // Add addresses / update labels that we've sent to the address book,
 344     // and emit coinsSent signal for each recipient
 345     for (const SendCoinsRecipient &rcp : transaction.getRecipients())
 346     {
 347         // Don't touch the address book when we have a payment request
 348         if (!rcp.paymentRequest.IsInitialized())
 349         {
 350             std::string strAddress = rcp.address.toStdString();
 351             CTxDestination dest = CBitcoinAddress(strAddress).Get();
 352             std::string strLabel = rcp.label.toStdString();
 353             {
 354                 LOCK(wallet->cs_wallet);
 355
 356                 std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(dest);
 357
 358                 // Check if we have a new address or an updated label
 359                 if (mi == wallet->mapAddressBook.end())
 360                 {
 361                     wallet->SetAddressBook(dest, strLabel, "send");
 362                 }
 363                 else if (mi->second.name != strLabel)
 364                 {
 365                     wallet->SetAddressBook(dest, strLabel, ""); // "" means don't change purpose
 366                 }
 367             }
 368         }
 369         Q_EMIT coinsSent(wallet, rcp, transaction_array);
 370     }
 371     checkBalanceChanged(); // update balance immediately, otherwise there could be a short noticeable delay until pollBalanceChanged hits
 372
 373     return SendCoinsReturn(OK);
 374 }
 375
 376 OptionsModel *WalletModel::getOptionsModel()
 377 {
 378     return optionsModel;
 379 }
 380
 381 AddressTableModel *WalletModel::getAddressTableModel()
 382 {
 383     return addressTableModel;
 384 }
 385
 386 TransactionTableModel *WalletModel::getTransactionTableModel()
 387 {
 388     return transactionTableModel;
 389 }
 390
 391 RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel()
 392 {
 393     return recentRequestsTableModel;
 394 }
 395
 396 WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const
 397 {
 398     if(!wallet->IsCrypted())
 399     {
 400         return Unencrypted;
 401     }
 402     else if(wallet->IsLocked())
 403     {
 404         return Locked;
 405     }
 406     else
 407     {
 408         return Unlocked;
 409     }
 410 }
 411
 412 bool WalletModel::setWalletEncrypted(bool encrypted, const SecureString &passphrase)
 413 {
 414     if(encrypted)
 415     {
 416         // Encrypt
 417         return wallet->EncryptWallet(passphrase);
 418     }
 419     else
 420     {
 421         // Decrypt -- TODO; not supported yet
 422         return false;
 423     }
 424 }
 425
 426 bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase)
 427 {
 428     if(locked)
 429     {
 430         // Lock
 431         return wallet->Lock();
 432     }
 433     else
 434     {
 435         // Unlock
 436         return wallet->Unlock(passPhrase);
 437     }
 438 }
 439
 440 bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureString &newPass)
 441 {
 442     bool retval;
 443     {
 444         LOCK(wallet->cs_wallet);
 445         wallet->Lock(); // Make sure wallet is locked before attempting pass change
 446         retval = wallet->ChangeWalletPassphrase(oldPass, newPass);
 447     }
 448     return retval;
 449 }
 450
 451 bool WalletModel::backupWallet(const QString &filename)
 452 {
 453     return wallet->BackupWallet(filename.toLocal8Bit().data());
 454 }
 455
 456 // Handlers for core signals
 457 static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel, CCryptoKeyStore *wallet)
 458 {
 459     qDebug() << "NotifyKeyStoreStatusChanged";
 460     QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
 461 }
 462
 463 static void NotifyAddressBookChanged(WalletModel *walletmodel, CWallet *wallet,
 464         const CTxDestination &address, const std::string &label, bool isMine,
 465         const std::string &purpose, ChangeType status)
 466 {
 467     QString strAddress = QString::fromStdString(CBitcoinAddress(address).ToString());
 468     QString strLabel = QString::fromStdString(label);
 469     QString strPurpose = QString::fromStdString(purpose);
 470
 471     qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);
 472     QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
 473                               Q_ARG(QString, strAddress),
 474                               Q_ARG(QString, strLabel),
 475                               Q_ARG(bool, isMine),
 476                               Q_ARG(QString, strPurpose),
 477                               Q_ARG(int, status));
 478 }
 479
 480 static void NotifyTransactionChanged(WalletModel *walletmodel, CWallet *wallet, const uint256 &hash, ChangeType status)
 481 {
 482     Q_UNUSED(wallet);
 483     Q_UNUSED(hash);
 484     Q_UNUSED(status);
 485     QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
 486 }
 487
 488 static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
 489 {
 490     // emits signal "showProgress"
 491     QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
 492                               Q_ARG(QString, QString::fromStdString(title)),
 493                               Q_ARG(int, nProgress));
 494 }
 495
 496 static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)
 497 {
 498     QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
 499                               Q_ARG(bool, fHaveWatchonly));
 500 }
 501
 502 void WalletModel::subscribeToCoreSignals()
 503 {
 504     // Connect signals to wallet
 505     wallet->NotifyStatusChanged.connect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
 506     wallet->NotifyAddressBookChanged.connect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
 507     wallet->NotifyTransactionChanged.connect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
 508     wallet->ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
 509     wallet->NotifyWatchonlyChanged.connect(boost::bind(NotifyWatchonlyChanged, this, _1));
 510 }
 511
 512 void WalletModel::unsubscribeFromCoreSignals()
 513 {
 514     // Disconnect signals from wallet
 515     wallet->NotifyStatusChanged.disconnect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
 516     wallet->NotifyAddressBookChanged.disconnect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
 517     wallet->NotifyTransactionChanged.disconnect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
 518     wallet->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
 519     wallet->NotifyWatchonlyChanged.disconnect(boost::bind(NotifyWatchonlyChanged, this, _1));
 520 }
 521
 522 // WalletModel::UnlockContext implementation
 523 WalletModel::UnlockContext WalletModel::requestUnlock()
 524 {
 525     bool was_locked = getEncryptionStatus() == Locked;
 526     if(was_locked)
 527     {
 528         // Request UI to unlock wallet
 529         Q_EMIT requireUnlock();
 530     }
 531     // If wallet is still locked, unlock was failed or cancelled, mark context as invalid
 532     bool valid = getEncryptionStatus() != Locked;
 533
 534     return UnlockContext(this, valid, was_locked);
 535 }
 536
 537 WalletModel::UnlockContext::UnlockContext(WalletModel *_wallet, bool _valid, bool _relock):
 538         wallet(_wallet),
 539         valid(_valid),
 540         relock(_relock)
 541 {
 542 }
 543
 544 WalletModel::UnlockContext::~UnlockContext()
 545 {
 546     if(valid && relock)
 547     {
 548         wallet->setWalletLocked(true);
 549     }
 550 }
 551
 552 void WalletModel::UnlockContext::CopyFrom(const UnlockContext& rhs)
 553 {
 554     // Transfer context; old object no longer relocks wallet
 555     *this = rhs;
 556     rhs.relock = false;
 557 }
 558
 559 bool WalletModel::getPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
 560 {
 561     return wallet->GetPubKey(address, vchPubKeyOut);
 562 }
 563
 564 bool WalletModel::havePrivKey(const CKeyID &address) const
 565 {
 566     return wallet->HaveKey(address);
 567 }
 568
 569 bool WalletModel::getPrivKey(const CKeyID &address, CKey& vchPrivKeyOut) const
 570 {
 571     return wallet->GetKey(address, vchPrivKeyOut);
 572 }
 573
 574 // returns a list of COutputs from COutPoints
 575 void WalletModel::getOutputs(const std::vector<COutPoint>& vOutpoints, std::vector<COutput>& vOutputs)
 576 {
 577     LOCK2(cs_main, wallet->cs_wallet);
 578     for (const COutPoint& outpoint : vOutpoints)
 579     {
 580         if (!wallet->mapWallet.count(outpoint.hash)) continue;
 581         int nDepth = wallet->mapWallet[outpoint.hash].GetDepthInMainChain();
 582         if (nDepth < 0) continue;
 583         COutput out(&wallet->mapWallet[outpoint.hash], outpoint.n, nDepth, true /* spendable */, true /* solvable */, true /* safe */);
 584         vOutputs.push_back(out);
 585     }
 586 }
 587
 588 bool WalletModel::isSpent(const COutPoint& outpoint) const
 589 {
 590     LOCK2(cs_main, wallet->cs_wallet);
 591     return wallet->IsSpent(outpoint.hash, outpoint.n);
 592 }
 593
 594 // AvailableCoins + LockedCoins grouped by wallet address (put change in one group with wallet address)
 595 void WalletModel::listCoins(std::map<QString, std::vector<COutput> >& mapCoins) const
 596 {
 597     for (auto& group : wallet->ListCoins()) {
 598         auto& resultGroup = mapCoins[QString::fromStdString(CBitcoinAddress(group.first).ToString())];
 599         for (auto& coin : group.second) {
 600             resultGroup.emplace_back(std::move(coin));
 601         }
 602     }
 603 }
 604
 605 bool WalletModel::isLockedCoin(uint256 hash, unsigned int n) const
 606 {
 607     LOCK2(cs_main, wallet->cs_wallet);
 608     return wallet->IsLockedCoin(hash, n);
 609 }
 610
 611 void WalletModel::lockCoin(COutPoint& output)
 612 {
 613     LOCK2(cs_main, wallet->cs_wallet);
 614     wallet->LockCoin(output);
 615 }
 616
 617 void WalletModel::unlockCoin(COutPoint& output)
 618 {
 619     LOCK2(cs_main, wallet->cs_wallet);
 620     wallet->UnlockCoin(output);
 621 }
 622
 623 void WalletModel::listLockedCoins(std::vector<COutPoint>& vOutpts)
 624 {
 625     LOCK2(cs_main, wallet->cs_wallet);
 626     wallet->ListLockedCoins(vOutpts);
 627 }
 628
 629 void WalletModel::loadReceiveRequests(std::vector<std::string>& vReceiveRequests)
 630 {
 631     vReceiveRequests = wallet->GetDestValues("rr"); // receive request
 632 }
 633
 634 bool WalletModel::saveReceiveRequest(const std::string &sAddress, const int64_t nId, const std::string &sRequest)
 635 {
 636     CTxDestination dest = CBitcoinAddress(sAddress).Get();
 637
 638     std::stringstream ss;
 639     ss << nId;
 640     std::string key = "rr" + ss.str(); // "rr" prefix = "receive request" in destdata
 641
 642     LOCK(wallet->cs_wallet);
 643     if (sRequest.empty())
 644         return wallet->EraseDestData(dest, key);
 645     else
 646         return wallet->AddDestData(dest, key, sRequest);
 647 }
 648
 649 bool WalletModel::transactionCanBeAbandoned(uint256 hash) const
 650 {
 651     return wallet->TransactionCanBeAbandoned(hash);
 652 }
 653
 654 bool WalletModel::abandonTransaction(uint256 hash) const
 655 {
 656     LOCK2(cs_main, wallet->cs_wallet);
 657     return wallet->AbandonTransaction(hash);
 658 }
 659
 660 bool WalletModel::transactionCanBeBumped(uint256 hash) const
 661 {
 662     LOCK2(cs_main, wallet->cs_wallet);
 663     const CWalletTx *wtx = wallet->GetWalletTx(hash);
 664     return wtx && SignalsOptInRBF(*wtx) && !wtx->mapValue.count("replaced_by_txid");
 665 }
 666
 667 bool WalletModel::bumpFee(uint256 hash)
 668 {
 669     std::unique_ptr<CFeeBumper> feeBump;
 670     {
 671         CCoinControl coin_control;
 672         coin_control.signalRbf = true;
 673         LOCK2(cs_main, wallet->cs_wallet);
 674         feeBump.reset(new CFeeBumper(wallet, hash, coin_control, 0));
 675     }
 676     if (feeBump->getResult() != BumpFeeResult::OK)
 677     {
 678         QMessageBox::critical(0, tr("Fee bump error"), tr("Increasing transaction fee failed") + "<br />(" +
 679             (feeBump->getErrors().size() ? QString::fromStdString(feeBump->getErrors()[0]) : "") +")");
 680          return false;
 681     }
 682
 683     // allow a user based fee verification
 684     QString questionString = tr("Do you want to increase the fee?");
 685     questionString.append("<br />");
 686     CAmount oldFee = feeBump->getOldFee();
 687     CAmount newFee = feeBump->getNewFee();
 688     questionString.append("<table style=\"text-align: left;\">");
 689     questionString.append("<tr><td>");
 690     questionString.append(tr("Current fee:"));
 691     questionString.append("</td><td>");
 692     questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), oldFee));
 693     questionString.append("</td></tr><tr><td>");
 694     questionString.append(tr("Increase:"));
 695     questionString.append("</td><td>");
 696     questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), newFee - oldFee));
 697     questionString.append("</td></tr><tr><td>");
 698     questionString.append(tr("New fee:"));
 699     questionString.append("</td><td>");
 700     questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), newFee));
 701     questionString.append("</td></tr></table>");
 702     SendConfirmationDialog confirmationDialog(tr("Confirm fee bump"), questionString);
 703     confirmationDialog.exec();
 704     QMessageBox::StandardButton retval = (QMessageBox::StandardButton)confirmationDialog.result();
 705
 706     // cancel sign&broadcast if users doesn't want to bump the fee
 707     if (retval != QMessageBox::Yes) {
 708         return false;
 709     }
 710
 711     WalletModel::UnlockContext ctx(requestUnlock());
 712     if(!ctx.isValid())
 713     {
 714         return false;
 715     }
 716
 717     // sign bumped transaction
 718     bool res = false;
 719     {
 720         LOCK2(cs_main, wallet->cs_wallet);
 721         res = feeBump->signTransaction(wallet);
 722     }
 723     if (!res) {
 724         QMessageBox::critical(0, tr("Fee bump error"), tr("Can't sign transaction."));
 725         return false;
 726     }
 727     // commit the bumped transaction
 728     {
 729         LOCK2(cs_main, wallet->cs_wallet);
 730         res = feeBump->commit(wallet);
 731     }
 732     if(!res) {
 733         QMessageBox::critical(0, tr("Fee bump error"), tr("Could not commit transaction") + "<br />(" +
 734             QString::fromStdString(feeBump->getErrors()[0])+")");
 735          return false;
 736     }
 737     return true;
 738 }
 739
 740 bool WalletModel::isWalletEnabled()
 741 {
 742    return !GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
 743 }
 744
 745 bool WalletModel::hdEnabled() const
 746 {
 747     return wallet->IsHDEnabled();
 748 }
 749
 750 int WalletModel::getDefaultConfirmTarget() const
 751 {
 752     return nTxConfirmTarget;
 753 }
 754
 755 bool WalletModel::getDefaultWalletRbf() const
 756 {
 757     return fWalletRbf;
 758 }