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 <qt/walletmodel.h>
   6
   7 #include <qt/addresstablemodel.h>
   8 #include <consensus/validation.h>
   9 #include <qt/guiconstants.h>
  10 #include <qt/guiutil.h>
  11 #include <qt/optionsmodel.h>
  12 #include <qt/paymentserver.h>
  13 #include <qt/recentrequeststablemodel.h>
  14 #include <qt/sendcoinsdialog.h>
  15 #include <qt/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     return IsValidDestinationString(address.toStdString());
 192 }
 193
 194 WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction &transaction, const CCoinControl& coinControl)
 195 {
 196     CAmount total = 0;
 197     bool fSubtractFeeFromAmount = false;
 198     QList<SendCoinsRecipient> recipients = transaction.getRecipients();
 199     std::vector<CRecipient> vecSend;
 200
 201     if(recipients.empty())
 202     {
 203         return OK;
 204     }
 205
 206     QSet<QString> setAddress; // Used to detect duplicates
 207     int nAddresses = 0;
 208
 209     // Pre-check input data for validity
 210     for (const SendCoinsRecipient &rcp : recipients)
 211     {
 212         if (rcp.fSubtractFeeFromAmount)
 213             fSubtractFeeFromAmount = true;
 214
 215         if (rcp.paymentRequest.IsInitialized())
 216         {   // PaymentRequest...
 217             CAmount subtotal = 0;
 218             const payments::PaymentDetails& details = rcp.paymentRequest.getDetails();
 219             for (int i = 0; i < details.outputs_size(); i++)
 220             {
 221                 const payments::Output& out = details.outputs(i);
 222                 if (out.amount() <= 0) continue;
 223                 subtotal += out.amount();
 224                 const unsigned char* scriptStr = (const unsigned char*)out.script().data();
 225                 CScript scriptPubKey(scriptStr, scriptStr+out.script().size());
 226                 CAmount nAmount = out.amount();
 227                 CRecipient recipient = {scriptPubKey, nAmount, rcp.fSubtractFeeFromAmount};
 228                 vecSend.push_back(recipient);
 229             }
 230             if (subtotal <= 0)
 231             {
 232                 return InvalidAmount;
 233             }
 234             total += subtotal;
 235         }
 236         else
 237         {   // User-entered bitcoin address / amount:
 238             if(!validateAddress(rcp.address))
 239             {
 240                 return InvalidAddress;
 241             }
 242             if(rcp.amount <= 0)
 243             {
 244                 return InvalidAmount;
 245             }
 246             setAddress.insert(rcp.address);
 247             ++nAddresses;
 248
 249             CScript scriptPubKey = GetScriptForDestination(DecodeDestination(rcp.address.toStdString()));
 250             CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
 251             vecSend.push_back(recipient);
 252
 253             total += rcp.amount;
 254         }
 255     }
 256     if(setAddress.size() != nAddresses)
 257     {
 258         return DuplicateAddress;
 259     }
 260
 261     CAmount nBalance = getBalance(&coinControl);
 262
 263     if(total > nBalance)
 264     {
 265         return AmountExceedsBalance;
 266     }
 267
 268     {
 269         LOCK2(cs_main, wallet->cs_wallet);
 270
 271         transaction.newPossibleKeyChange(wallet);
 272
 273         CAmount nFeeRequired = 0;
 274         int nChangePosRet = -1;
 275         std::string strFailReason;
 276
 277         CWalletTx *newTx = transaction.getTransaction();
 278         CReserveKey *keyChange = transaction.getPossibleKeyChange();
 279         bool fCreated = wallet->CreateTransaction(vecSend, *newTx, *keyChange, nFeeRequired, nChangePosRet, strFailReason, coinControl);
 280         transaction.setTransactionFee(nFeeRequired);
 281         if (fSubtractFeeFromAmount && fCreated)
 282             transaction.reassignAmounts(nChangePosRet);
 283
 284         if(!fCreated)
 285         {
 286             if(!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance)
 287             {
 288                 return SendCoinsReturn(AmountWithFeeExceedsBalance);
 289             }
 290             Q_EMIT message(tr("Send Coins"), QString::fromStdString(strFailReason),
 291                          CClientUIInterface::MSG_ERROR);
 292             return TransactionCreationFailed;
 293         }
 294
 295         // reject absurdly high fee. (This can never happen because the
 296         // wallet caps the fee at maxTxFee. This merely serves as a
 297         // belt-and-suspenders check)
 298         if (nFeeRequired > maxTxFee)
 299             return AbsurdFee;
 300     }
 301
 302     return SendCoinsReturn(OK);
 303 }
 304
 305 WalletModel::SendCoinsReturn WalletModel::sendCoins(WalletModelTransaction &transaction)
 306 {
 307     QByteArray transaction_array; /* store serialized transaction */
 308
 309     {
 310         LOCK2(cs_main, wallet->cs_wallet);
 311         CWalletTx *newTx = transaction.getTransaction();
 312
 313         for (const SendCoinsRecipient &rcp : transaction.getRecipients())
 314         {
 315             if (rcp.paymentRequest.IsInitialized())
 316             {
 317                 // Make sure any payment requests involved are still valid.
 318                 if (PaymentServer::verifyExpired(rcp.paymentRequest.getDetails())) {
 319                     return PaymentRequestExpired;
 320                 }
 321
 322                 // Store PaymentRequests in wtx.vOrderForm in wallet.
 323                 std::string key("PaymentRequest");
 324                 std::string value;
 325                 rcp.paymentRequest.SerializeToString(&value);
 326                 newTx->vOrderForm.push_back(make_pair(key, value));
 327             }
 328             else if (!rcp.message.isEmpty()) // Message from normal bitcoin:URI (bitcoin:123...?message=example)
 329                 newTx->vOrderForm.push_back(make_pair("Message", rcp.message.toStdString()));
 330         }
 331
 332         CReserveKey *keyChange = transaction.getPossibleKeyChange();
 333         CValidationState state;
 334         if(!wallet->CommitTransaction(*newTx, *keyChange, g_connman.get(), state))
 335             return SendCoinsReturn(TransactionCommitFailed, QString::fromStdString(state.GetRejectReason()));
 336
 337         CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
 338         ssTx << *newTx->tx;
 339         transaction_array.append(&(ssTx[0]), ssTx.size());
 340     }
 341
 342     // Add addresses / update labels that we've sent to the address book,
 343     // and emit coinsSent signal for each recipient
 344     for (const SendCoinsRecipient &rcp : transaction.getRecipients())
 345     {
 346         // Don't touch the address book when we have a payment request
 347         if (!rcp.paymentRequest.IsInitialized())
 348         {
 349             std::string strAddress = rcp.address.toStdString();
 350             CTxDestination dest = DecodeDestination(strAddress);
 351             std::string strLabel = rcp.label.toStdString();
 352             {
 353                 LOCK(wallet->cs_wallet);
 354
 355                 std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(dest);
 356
 357                 // Check if we have a new address or an updated label
 358                 if (mi == wallet->mapAddressBook.end())
 359                 {
 360                     wallet->SetAddressBook(dest, strLabel, "send");
 361                 }
 362                 else if (mi->second.name != strLabel)
 363                 {
 364                     wallet->SetAddressBook(dest, strLabel, ""); // "" means don't change purpose
 365                 }
 366             }
 367         }
 368         Q_EMIT coinsSent(wallet, rcp, transaction_array);
 369     }
 370     checkBalanceChanged(); // update balance immediately, otherwise there could be a short noticeable delay until pollBalanceChanged hits
 371
 372     return SendCoinsReturn(OK);
 373 }
 374
 375 OptionsModel *WalletModel::getOptionsModel()
 376 {
 377     return optionsModel;
 378 }
 379
 380 AddressTableModel *WalletModel::getAddressTableModel()
 381 {
 382     return addressTableModel;
 383 }
 384
 385 TransactionTableModel *WalletModel::getTransactionTableModel()
 386 {
 387     return transactionTableModel;
 388 }
 389
 390 RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel()
 391 {
 392     return recentRequestsTableModel;
 393 }
 394
 395 WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const
 396 {
 397     if(!wallet->IsCrypted())
 398     {
 399         return Unencrypted;
 400     }
 401     else if(wallet->IsLocked())
 402     {
 403         return Locked;
 404     }
 405     else
 406     {
 407         return Unlocked;
 408     }
 409 }
 410
 411 bool WalletModel::setWalletEncrypted(bool encrypted, const SecureString &passphrase)
 412 {
 413     if(encrypted)
 414     {
 415         // Encrypt
 416         return wallet->EncryptWallet(passphrase);
 417     }
 418     else
 419     {
 420         // Decrypt -- TODO; not supported yet
 421         return false;
 422     }
 423 }
 424
 425 bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase)
 426 {
 427     if(locked)
 428     {
 429         // Lock
 430         return wallet->Lock();
 431     }
 432     else
 433     {
 434         // Unlock
 435         return wallet->Unlock(passPhrase);
 436     }
 437 }
 438
 439 bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureString &newPass)
 440 {
 441     bool retval;
 442     {
 443         LOCK(wallet->cs_wallet);
 444         wallet->Lock(); // Make sure wallet is locked before attempting pass change
 445         retval = wallet->ChangeWalletPassphrase(oldPass, newPass);
 446     }
 447     return retval;
 448 }
 449
 450 bool WalletModel::backupWallet(const QString &filename)
 451 {
 452     return wallet->BackupWallet(filename.toLocal8Bit().data());
 453 }
 454
 455 // Handlers for core signals
 456 static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel, CCryptoKeyStore *wallet)
 457 {
 458     qDebug() << "NotifyKeyStoreStatusChanged";
 459     QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
 460 }
 461
 462 static void NotifyAddressBookChanged(WalletModel *walletmodel, CWallet *wallet,
 463         const CTxDestination &address, const std::string &label, bool isMine,
 464         const std::string &purpose, ChangeType status)
 465 {
 466     QString strAddress = QString::fromStdString(EncodeDestination(address));
 467     QString strLabel = QString::fromStdString(label);
 468     QString strPurpose = QString::fromStdString(purpose);
 469
 470     qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);
 471     QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
 472                               Q_ARG(QString, strAddress),
 473                               Q_ARG(QString, strLabel),
 474                               Q_ARG(bool, isMine),
 475                               Q_ARG(QString, strPurpose),
 476                               Q_ARG(int, status));
 477 }
 478
 479 static void NotifyTransactionChanged(WalletModel *walletmodel, CWallet *wallet, const uint256 &hash, ChangeType status)
 480 {
 481     Q_UNUSED(wallet);
 482     Q_UNUSED(hash);
 483     Q_UNUSED(status);
 484     QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
 485 }
 486
 487 static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
 488 {
 489     // emits signal "showProgress"
 490     QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
 491                               Q_ARG(QString, QString::fromStdString(title)),
 492                               Q_ARG(int, nProgress));
 493 }
 494
 495 static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)
 496 {
 497     QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
 498                               Q_ARG(bool, fHaveWatchonly));
 499 }
 500
 501 void WalletModel::subscribeToCoreSignals()
 502 {
 503     // Connect signals to wallet
 504     wallet->NotifyStatusChanged.connect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
 505     wallet->NotifyAddressBookChanged.connect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
 506     wallet->NotifyTransactionChanged.connect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
 507     wallet->ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
 508     wallet->NotifyWatchonlyChanged.connect(boost::bind(NotifyWatchonlyChanged, this, _1));
 509 }
 510
 511 void WalletModel::unsubscribeFromCoreSignals()
 512 {
 513     // Disconnect signals from wallet
 514     wallet->NotifyStatusChanged.disconnect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
 515     wallet->NotifyAddressBookChanged.disconnect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
 516     wallet->NotifyTransactionChanged.disconnect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
 517     wallet->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
 518     wallet->NotifyWatchonlyChanged.disconnect(boost::bind(NotifyWatchonlyChanged, this, _1));
 519 }
 520
 521 // WalletModel::UnlockContext implementation
 522 WalletModel::UnlockContext WalletModel::requestUnlock()
 523 {
 524     bool was_locked = getEncryptionStatus() == Locked;
 525     if(was_locked)
 526     {
 527         // Request UI to unlock wallet
 528         Q_EMIT requireUnlock();
 529     }
 530     // If wallet is still locked, unlock was failed or cancelled, mark context as invalid
 531     bool valid = getEncryptionStatus() != Locked;
 532
 533     return UnlockContext(this, valid, was_locked);
 534 }
 535
 536 WalletModel::UnlockContext::UnlockContext(WalletModel *_wallet, bool _valid, bool _relock):
 537         wallet(_wallet),
 538         valid(_valid),
 539         relock(_relock)
 540 {
 541 }
 542
 543 WalletModel::UnlockContext::~UnlockContext()
 544 {
 545     if(valid && relock)
 546     {
 547         wallet->setWalletLocked(true);
 548     }
 549 }
 550
 551 void WalletModel::UnlockContext::CopyFrom(const UnlockContext& rhs)
 552 {
 553     // Transfer context; old object no longer relocks wallet
 554     *this = rhs;
 555     rhs.relock = false;
 556 }
 557
 558 bool WalletModel::getPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
 559 {
 560     return wallet->GetPubKey(address, vchPubKeyOut);
 561 }
 562
 563 bool WalletModel::IsSpendable(const CTxDestination& dest) const
 564 {
 565     return IsMine(*wallet, dest) & ISMINE_SPENDABLE;
 566 }
 567
 568 bool WalletModel::getPrivKey(const CKeyID &address, CKey& vchPrivKeyOut) const
 569 {
 570     return wallet->GetKey(address, vchPrivKeyOut);
 571 }
 572
 573 // returns a list of COutputs from COutPoints
 574 void WalletModel::getOutputs(const std::vector<COutPoint>& vOutpoints, std::vector<COutput>& vOutputs)
 575 {
 576     LOCK2(cs_main, wallet->cs_wallet);
 577     for (const COutPoint& outpoint : vOutpoints)
 578     {
 579         auto it = wallet->mapWallet.find(outpoint.hash);
 580         if (it == wallet->mapWallet.end()) continue;
 581         int nDepth = it->second.GetDepthInMainChain();
 582         if (nDepth < 0) continue;
 583         COutput out(&it->second, 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(EncodeDestination(group.first))];
 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 = DecodeDestination(sAddress);
 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     return feebumper::TransactionCanBeBumped(wallet, hash);
 663 }
 664
 665 bool WalletModel::bumpFee(uint256 hash)
 666 {
 667     CCoinControl coin_control;
 668     coin_control.signalRbf = true;
 669     std::vector<std::string> errors;
 670     CAmount old_fee;
 671     CAmount new_fee;
 672     CMutableTransaction mtx;
 673     if (feebumper::CreateTransaction(wallet, hash, coin_control, 0 /* totalFee */, errors, old_fee, new_fee, mtx) != feebumper::Result::OK) {
 674         QMessageBox::critical(0, tr("Fee bump error"), tr("Increasing transaction fee failed") + "<br />(" +
 675             (errors.size() ? QString::fromStdString(errors[0]) : "") +")");
 676          return false;
 677     }
 678
 679     // allow a user based fee verification
 680     QString questionString = tr("Do you want to increase the fee?");
 681     questionString.append("<br />");
 682     questionString.append("<table style=\"text-align: left;\">");
 683     questionString.append("<tr><td>");
 684     questionString.append(tr("Current fee:"));
 685     questionString.append("</td><td>");
 686     questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), old_fee));
 687     questionString.append("</td></tr><tr><td>");
 688     questionString.append(tr("Increase:"));
 689     questionString.append("</td><td>");
 690     questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), new_fee - old_fee));
 691     questionString.append("</td></tr><tr><td>");
 692     questionString.append(tr("New fee:"));
 693     questionString.append("</td><td>");
 694     questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), new_fee));
 695     questionString.append("</td></tr></table>");
 696     SendConfirmationDialog confirmationDialog(tr("Confirm fee bump"), questionString);
 697     confirmationDialog.exec();
 698     QMessageBox::StandardButton retval = (QMessageBox::StandardButton)confirmationDialog.result();
 699
 700     // cancel sign&broadcast if users doesn't want to bump the fee
 701     if (retval != QMessageBox::Yes) {
 702         return false;
 703     }
 704
 705     WalletModel::UnlockContext ctx(requestUnlock());
 706     if(!ctx.isValid())
 707     {
 708         return false;
 709     }
 710
 711     // sign bumped transaction
 712     if (!feebumper::SignTransaction(wallet, mtx)) {
 713         QMessageBox::critical(0, tr("Fee bump error"), tr("Can't sign transaction."));
 714         return false;
 715     }
 716     // commit the bumped transaction
 717     uint256 txid;
 718     if (feebumper::CommitTransaction(wallet, hash, std::move(mtx), errors, txid) != feebumper::Result::OK) {
 719         QMessageBox::critical(0, tr("Fee bump error"), tr("Could not commit transaction") + "<br />(" +
 720             QString::fromStdString(errors[0])+")");
 721          return false;
 722     }
 723     return true;
 724 }
 725
 726 bool WalletModel::isWalletEnabled()
 727 {
 728    return !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
 729 }
 730
 731 bool WalletModel::hdEnabled() const
 732 {
 733     return wallet->IsHDEnabled();
 734 }
 735
 736 int WalletModel::getDefaultConfirmTarget() const
 737 {
 738     return nTxConfirmTarget;
 739 }
 740
 741 bool WalletModel::getDefaultWalletRbf() const
 742 {
 743     return fWalletRbf;
 744 }