Bitcoin Core 29.99.0
P2P Digital Currency
walletmodel.cpp
Go to the documentation of this file.
1// Copyright (c) 2011-present 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
8#include <qt/clientmodel.h>
9#include <qt/guiconstants.h>
10#include <qt/guiutil.h>
11#include <qt/optionsmodel.h>
12#include <qt/paymentserver.h>
14#include <qt/sendcoinsdialog.h>
16
17#include <common/args.h>
18#include <interfaces/handler.h>
19#include <interfaces/node.h>
20#include <key_io.h>
21#include <node/interface_ui.h>
22#include <node/types.h>
23#include <psbt.h>
24#include <util/translation.h>
25#include <wallet/coincontrol.h>
26#include <wallet/wallet.h>
27
28#include <cstdint>
29#include <functional>
30#include <memory>
31#include <vector>
32
33#include <QDebug>
34#include <QMessageBox>
35#include <QSet>
36#include <QTimer>
37
41
42WalletModel::WalletModel(std::unique_ptr<interfaces::Wallet> wallet, ClientModel& client_model, const PlatformStyle *platformStyle, QObject *parent) :
43 QObject(parent),
44 m_wallet(std::move(wallet)),
45 m_client_model(&client_model),
46 m_node(client_model.node()),
47 optionsModel(client_model.getOptionsModel()),
48 timer(new QTimer(this))
49{
51 transactionTableModel = new TransactionTableModel(platformStyle, this);
53
55}
56
58{
60}
61
63{
64 // Update the cached balance right away, so every view can make use of it,
65 // so them don't need to waste resources recalculating it.
67
68 // This timer will be fired repeatedly to update the balance
69 // Since the QTimer::timeout is a private signal, it cannot be used
70 // in the GUIUtil::ExceptionSafeConnect directly.
71 connect(timer, &QTimer::timeout, this, &WalletModel::timerTimeout);
74}
75
77{
78 m_client_model = client_model;
79 if (!m_client_model) timer->stop();
80}
81
83{
84 EncryptionStatus newEncryptionStatus = getEncryptionStatus();
85
86 if(cachedEncryptionStatus != newEncryptionStatus) {
88 }
89}
90
92{
93 // Avoid recomputing wallet balances unless a TransactionChanged or
94 // BlockTip notification was received.
96
97 // Try to get balances and return early if locks can't be acquired. This
98 // avoids the GUI from getting stuck on periodical polls if the core is
99 // holding the locks for a longer time - for example, during a wallet
100 // rescan.
101 interfaces::WalletBalances new_balances;
102 uint256 block_hash;
103 if (!m_wallet->tryGetBalances(new_balances, block_hash)) {
104 return;
105 }
106
109
110 // Balance and number of transactions might have changed
111 m_cached_last_update_tip = block_hash;
112
113 checkBalanceChanged(new_balances);
116 }
117}
118
120{
121 if (new_balances.balanceChanged(m_cached_balances)) {
122 m_cached_balances = new_balances;
123 Q_EMIT balanceChanged(new_balances);
124 }
125}
126
128{
129 return m_cached_balances;
130}
131
133{
134 // Balance and number of transactions might have changed
136}
137
138void WalletModel::updateAddressBook(const QString &address, const QString &label,
139 bool isMine, wallet::AddressPurpose purpose, int status)
140{
142 addressTableModel->updateEntry(address, label, isMine, purpose, status);
143}
144
145bool WalletModel::validateAddress(const QString& address) const
146{
147 return IsValidDestinationString(address.toStdString());
148}
149
151{
152 CAmount total = 0;
153 bool fSubtractFeeFromAmount = false;
154 QList<SendCoinsRecipient> recipients = transaction.getRecipients();
155 std::vector<CRecipient> vecSend;
156
157 if(recipients.empty())
158 {
159 return OK;
160 }
161
162 QSet<QString> setAddress; // Used to detect duplicates
163 int nAddresses = 0;
164
165 // Pre-check input data for validity
166 for (const SendCoinsRecipient &rcp : recipients)
167 {
168 if (rcp.fSubtractFeeFromAmount)
169 fSubtractFeeFromAmount = true;
170 { // User-entered bitcoin address / amount:
171 if(!validateAddress(rcp.address))
172 {
173 return InvalidAddress;
174 }
175 if(rcp.amount <= 0)
176 {
177 return InvalidAmount;
178 }
179 setAddress.insert(rcp.address);
180 ++nAddresses;
181
182 vecSend.emplace_back(CRecipient{DecodeDestination(rcp.address.toStdString()), rcp.amount, rcp.fSubtractFeeFromAmount});
183
184 total += rcp.amount;
185 }
186 }
187 if(setAddress.size() != nAddresses)
188 {
189 return DuplicateAddress;
190 }
191
192 // If no coin was manually selected, use the cached balance
193 // Future: can merge this call with 'createTransaction'.
194 CAmount nBalance = getAvailableBalance(&coinControl);
195
196 if(total > nBalance)
197 {
199 }
200
201 try {
202 CAmount nFeeRequired = 0;
203 int nChangePosRet = -1;
204
205 auto& newTx = transaction.getWtx();
206 const auto& res = m_wallet->createTransaction(vecSend, coinControl, /*sign=*/!wallet().privateKeysDisabled(), nChangePosRet, nFeeRequired);
207 newTx = res ? *res : nullptr;
208 transaction.setTransactionFee(nFeeRequired);
209 if (fSubtractFeeFromAmount && newTx)
210 transaction.reassignAmounts(nChangePosRet);
211
212 if(!newTx)
213 {
214 if(!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance)
215 {
217 }
218 Q_EMIT message(tr("Send Coins"), QString::fromStdString(util::ErrorString(res).translated),
221 }
222
223 // Reject absurdly high fee. (This can never happen because the
224 // wallet never creates transactions with fee greater than
225 // m_default_max_tx_fee. This merely a belt-and-suspenders check).
226 if (nFeeRequired > m_wallet->getDefaultMaxTxFee()) {
227 return AbsurdFee;
228 }
229 } catch (const std::runtime_error& err) {
230 // Something unexpected happened, instruct user to report this bug.
231 Q_EMIT message(tr("Send Coins"), QString::fromStdString(err.what()),
234 }
235
236 return SendCoinsReturn(OK);
237}
238
240{
241 QByteArray transaction_array; /* store serialized transaction */
242
243 {
244 std::vector<std::pair<std::string, std::string>> vOrderForm;
245 for (const SendCoinsRecipient &rcp : transaction.getRecipients())
246 {
247 if (!rcp.message.isEmpty()) // Message from normal bitcoin:URI (bitcoin:123...?message=example)
248 vOrderForm.emplace_back("Message", rcp.message.toStdString());
249 }
250
251 auto& newTx = transaction.getWtx();
252 wallet().commitTransaction(newTx, /*value_map=*/{}, std::move(vOrderForm));
253
254 DataStream ssTx;
255 ssTx << TX_WITH_WITNESS(*newTx);
256 transaction_array.append((const char*)ssTx.data(), ssTx.size());
257 }
258
259 // Add addresses / update labels that we've sent to the address book,
260 // and emit coinsSent signal for each recipient
261 for (const SendCoinsRecipient &rcp : transaction.getRecipients())
262 {
263 {
264 std::string strAddress = rcp.address.toStdString();
265 CTxDestination dest = DecodeDestination(strAddress);
266 std::string strLabel = rcp.label.toStdString();
267 {
268 // Check if we have a new address or an updated label
269 std::string name;
270 if (!m_wallet->getAddress(
271 dest, &name, /*purpose=*/nullptr))
272 {
273 m_wallet->setAddressBook(dest, strLabel, wallet::AddressPurpose::SEND);
274 }
275 else if (name != strLabel)
276 {
277 m_wallet->setAddressBook(dest, strLabel, {}); // {} means don't change purpose
278 }
279 }
280 }
281 Q_EMIT coinsSent(this, rcp, transaction_array);
282 }
283
284 checkBalanceChanged(m_wallet->getBalances()); // update balance immediately, otherwise there could be a short noticeable delay until pollBalanceChanged hits
285}
286
288{
289 return optionsModel;
290}
291
293{
294 return addressTableModel;
295}
296
298{
300}
301
303{
305}
306
308{
309 if(!m_wallet->isCrypted())
310 {
311 // A previous bug allowed for watchonly wallets to be encrypted (encryption keys set, but nothing is actually encrypted).
312 // To avoid misrepresenting the encryption status of such wallets, we only return NoKeys for watchonly wallets that are unencrypted.
313 if (m_wallet->privateKeysDisabled()) {
314 return NoKeys;
315 }
316 return Unencrypted;
317 }
318 else if(m_wallet->isLocked())
319 {
320 return Locked;
321 }
322 else
323 {
324 return Unlocked;
325 }
326}
327
329{
330 return m_wallet->encryptWallet(passphrase);
331}
332
333bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase)
334{
335 if(locked)
336 {
337 // Lock
338 return m_wallet->lock();
339 }
340 else
341 {
342 // Unlock
343 return m_wallet->unlock(passPhrase);
344 }
345}
346
347bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureString &newPass)
348{
349 m_wallet->lock(); // Make sure wallet is locked before attempting pass change
350 return m_wallet->changeWalletPassphrase(oldPass, newPass);
351}
352
353// Handlers for core signals
354static void NotifyUnload(WalletModel* walletModel)
355{
356 qDebug() << "NotifyUnload";
357 bool invoked = QMetaObject::invokeMethod(walletModel, "unload");
358 assert(invoked);
359}
360
362{
363 qDebug() << "NotifyKeyStoreStatusChanged";
364 bool invoked = QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
365 assert(invoked);
366}
367
368static void NotifyAddressBookChanged(WalletModel *walletmodel,
369 const CTxDestination &address, const std::string &label, bool isMine,
370 wallet::AddressPurpose purpose, ChangeType status)
371{
372 QString strAddress = QString::fromStdString(EncodeDestination(address));
373 QString strLabel = QString::fromStdString(label);
374
375 qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + QString::number(static_cast<uint8_t>(purpose)) + " status=" + QString::number(status);
376 bool invoked = QMetaObject::invokeMethod(walletmodel, "updateAddressBook",
377 Q_ARG(QString, strAddress),
378 Q_ARG(QString, strLabel),
379 Q_ARG(bool, isMine),
380 Q_ARG(wallet::AddressPurpose, purpose),
381 Q_ARG(int, status));
382 assert(invoked);
383}
384
385static void NotifyTransactionChanged(WalletModel *walletmodel, const Txid& hash, ChangeType status)
386{
387 Q_UNUSED(hash);
388 Q_UNUSED(status);
389 bool invoked = QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
390 assert(invoked);
391}
392
393static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
394{
395 // emits signal "showProgress"
396 bool invoked = QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
397 Q_ARG(QString, QString::fromStdString(title)),
398 Q_ARG(int, nProgress));
399 assert(invoked);
400}
401
403{
404 bool invoked = QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");
405 assert(invoked);
406}
407
409{
410 // Connect signals to wallet
411 m_handler_unload = m_wallet->handleUnload(std::bind(&NotifyUnload, this));
412 m_handler_status_changed = m_wallet->handleStatusChanged(std::bind(&NotifyKeyStoreStatusChanged, this));
413 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));
414 m_handler_transaction_changed = m_wallet->handleTransactionChanged(std::bind(NotifyTransactionChanged, this, std::placeholders::_1, std::placeholders::_2));
415 m_handler_show_progress = m_wallet->handleShowProgress(std::bind(ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
416 m_handler_can_get_addrs_changed = m_wallet->handleCanGetAddressesChanged(std::bind(NotifyCanGetAddressesChanged, this));
417}
418
420{
421 // Disconnect signals from wallet
422 m_handler_unload->disconnect();
423 m_handler_status_changed->disconnect();
424 m_handler_address_book_changed->disconnect();
425 m_handler_transaction_changed->disconnect();
426 m_handler_show_progress->disconnect();
428}
429
430// WalletModel::UnlockContext implementation
432{
433 // Bugs in earlier versions may have resulted in wallets with private keys disabled to become "encrypted"
434 // (encryption keys are present, but not actually doing anything).
435 // To avoid issues with such wallets, check if the wallet has private keys disabled, and if so, return a context
436 // that indicates the wallet is not encrypted.
437 if (m_wallet->privateKeysDisabled()) {
438 return UnlockContext(this, /*valid=*/true, /*relock=*/false);
439 }
440 bool was_locked = getEncryptionStatus() == Locked;
441 if(was_locked)
442 {
443 // Request UI to unlock wallet
444 Q_EMIT requireUnlock();
445 }
446 // If wallet is still locked, unlock was failed or cancelled, mark context as invalid
447 bool valid = getEncryptionStatus() != Locked;
448
449 return UnlockContext(this, valid, was_locked);
450}
451
452WalletModel::UnlockContext::UnlockContext(WalletModel *_wallet, bool _valid, bool _relock):
453 wallet(_wallet),
454 valid(_valid),
455 relock(_relock)
456{
457}
458
460{
461 if(valid && relock)
462 {
463 wallet->setWalletLocked(true);
464 }
465}
466
467bool WalletModel::bumpFee(Txid hash, Txid& new_hash)
468{
469 CCoinControl coin_control;
470 coin_control.m_signal_bip125_rbf = true;
471 std::vector<bilingual_str> errors;
472 CAmount old_fee;
473 CAmount new_fee;
475 if (!m_wallet->createBumpTransaction(hash, coin_control, errors, old_fee, new_fee, mtx)) {
476 QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Increasing transaction fee failed") + "<br />(" +
477 (errors.size() ? QString::fromStdString(errors[0].translated) : "") +")");
478 return false;
479 }
480
481 // allow a user based fee verification
482 /*: Asks a user if they would like to manually increase the fee of a transaction that has already been created. */
483 QString questionString = tr("Do you want to increase the fee?");
484 questionString.append("<br />");
485 questionString.append("<table style=\"text-align: left;\">");
486 questionString.append("<tr><td>");
487 questionString.append(tr("Current fee:"));
488 questionString.append("</td><td>");
489 questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), old_fee));
490 questionString.append("</td></tr><tr><td>");
491 questionString.append(tr("Increase:"));
492 questionString.append("</td><td>");
493 questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), new_fee - old_fee));
494 questionString.append("</td></tr><tr><td>");
495 questionString.append(tr("New fee:"));
496 questionString.append("</td><td>");
497 questionString.append(BitcoinUnits::formatHtmlWithUnit(getOptionsModel()->getDisplayUnit(), new_fee));
498 questionString.append("</td></tr></table>");
499
500 // Display warning in the "Confirm fee bump" window if the "Coin Control Features" option is enabled
501 if (getOptionsModel()->getCoinControlFeatures()) {
502 questionString.append("<br><br>");
503 questionString.append(tr("Warning: This may pay the additional fee by reducing change outputs or adding inputs, when necessary. It may add a new change output if one does not already exist. These changes may potentially leak privacy."));
504 }
505
506 const bool enable_send{!wallet().privateKeysDisabled() || wallet().hasExternalSigner()};
507 const bool always_show_unsigned{getOptionsModel()->getEnablePSBTControls()};
508 auto confirmationDialog = new SendConfirmationDialog(tr("Confirm fee bump"), questionString, "", "", SEND_CONFIRM_DELAY, enable_send, always_show_unsigned, nullptr);
509 confirmationDialog->setAttribute(Qt::WA_DeleteOnClose);
510 // TODO: Replace QDialog::exec() with safer QDialog::show().
511 const auto retval = static_cast<QMessageBox::StandardButton>(confirmationDialog->exec());
512
513 // cancel sign&broadcast if user doesn't want to bump the fee
514 if (retval != QMessageBox::Yes && retval != QMessageBox::Save) {
515 return false;
516 }
517
518 // Short-circuit if we are returning a bumped transaction PSBT to clipboard
519 if (retval == QMessageBox::Save) {
520 // "Create Unsigned" clicked
522 bool complete = false;
523 const auto err{wallet().fillPSBT(std::nullopt, /*sign=*/false, /*bip32derivs=*/true, nullptr, psbtx, complete)};
524 if (err || complete) {
525 QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Can't draft transaction."));
526 return false;
527 }
528 // Serialize the PSBT
529 DataStream ssTx{};
530 ssTx << psbtx;
531 GUIUtil::setClipboard(EncodeBase64(ssTx.str()).c_str());
532 Q_EMIT message(tr("PSBT copied"), tr("Fee-bump PSBT copied to clipboard"), CClientUIInterface::MSG_INFORMATION | CClientUIInterface::MODAL);
533 return true;
534 }
535
537 if (!ctx.isValid()) {
538 return false;
539 }
540
541 assert(!m_wallet->privateKeysDisabled() || wallet().hasExternalSigner());
542
543 // sign bumped transaction
544 if (!m_wallet->signBumpTransaction(mtx)) {
545 QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Can't sign transaction."));
546 return false;
547 }
548 // commit the bumped transaction
549 if(!m_wallet->commitBumpTransaction(hash, std::move(mtx), errors, new_hash)) {
550 QMessageBox::critical(nullptr, tr("Fee bump error"), tr("Could not commit transaction") + "<br />(" +
551 QString::fromStdString(errors[0].translated)+")");
552 return false;
553 }
554 return true;
555}
556
557void WalletModel::displayAddress(std::string sAddress) const
558{
559 CTxDestination dest = DecodeDestination(sAddress);
560 try {
561 util::Result<void> result = m_wallet->displayAddress(dest);
562 if (!result) {
563 QMessageBox::warning(nullptr, tr("Signer error"), QString::fromStdString(util::ErrorString(result).translated));
564 }
565 } catch (const std::runtime_error& e) {
566 QMessageBox::critical(nullptr, tr("Can't display address"), e.what());
567 }
568}
569
571{
572 return !gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET);
573}
574
576{
577 return QString::fromStdString(m_wallet->getWalletName());
578}
579
581{
583}
584
586{
587 return m_node.walletLoader().getWallets().size() > 1;
588}
589
590void WalletModel::refresh(bool pk_hash_only)
591{
592 addressTableModel = new AddressTableModel(this, pk_hash_only);
593}
594
596{
598}
599
601{
602 // No selected coins, return the cached balance
603 if (!control || !control->HasSelected()) {
605 return balances.balance;
606 }
607 // Fetch balance from the wallet, taking into account the selected coins
608 return wallet().getAvailableBalance(*control);
609}
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:143
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
ArgsManager gArgs
Definition: args.cpp:42
node::NodeContext m_node
Definition: bitcoin-gui.cpp:42
Qt model of the address book in the core.
void updateEntry(const QString &address, const QString &label, bool isMine, wallet::AddressPurpose purpose, int status)
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: args.cpp:507
static QString formatHtmlWithUnit(Unit unit, const CAmount &amount, bool plussign=false, SeparatorStyle separators=SeparatorStyle::STANDARD)
Format as HTML string (with unit)
@ MSG_INFORMATION
Predefined combinations for certain default usage cases.
Definition: interface_ui.h:66
@ MODAL
Force blocking, modal message box dialog (not just OS notification)
Definition: interface_ui.h:60
Model for Bitcoin network client.
Definition: clientmodel.h:57
uint256 getBestBlockHash() EXCLUSIVE_LOCKS_REQUIRED(!m_cached_tip_mutex)
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:130
size_type size() const
Definition: streams.h:164
value_type * data()
Definition: streams.h:171
Interface from Qt to configuration data structure for Bitcoin client.
Definition: optionsmodel.h:43
bool getEnablePSBTControls() const
Definition: optionsmodel.h:108
Model for list of recently generated payment requests / bitcoin: URIs.
UI model for the transaction table of a wallet.
UnlockContext(WalletModel *wallet, bool valid, bool relock)
Interface to Bitcoin wallet from Qt view code.
Definition: walletmodel.h:49
OptionsModel * optionsModel
Definition: walletmodel.h:174
AddressTableModel * addressTableModel
Definition: walletmodel.h:176
RecentRequestsTableModel * getRecentRequestsTableModel() const
EncryptionStatus cachedEncryptionStatus
Definition: walletmodel.h:182
void refresh(bool pk_hash_only=false)
uint256 m_cached_last_update_tip
Definition: walletmodel.h:186
ClientModel * m_client_model
Definition: walletmodel.h:167
bool bumpFee(Txid hash, Txid &new_hash)
interfaces::Node & m_node
Definition: walletmodel.h:168
std::unique_ptr< interfaces::Handler > m_handler_transaction_changed
Definition: walletmodel.h:164
void startPollBalance()
Definition: walletmodel.cpp:62
void pollBalanceChanged()
Definition: walletmodel.cpp:91
AddressTableModel * getAddressTableModel() const
RecentRequestsTableModel * recentRequestsTableModel
Definition: walletmodel.h:178
SendCoinsReturn prepareTransaction(WalletModelTransaction &transaction, const wallet::CCoinControl &coinControl)
TransactionTableModel * transactionTableModel
Definition: walletmodel.h:177
bool setWalletEncrypted(const SecureString &passphrase)
bool changePassphrase(const SecureString &oldPass, const SecureString &newPass)
bool setWalletLocked(bool locked, const SecureString &passPhrase=SecureString())
void updateAddressBook(const QString &address, const QString &label, bool isMine, wallet::AddressPurpose purpose, int status)
void message(const QString &title, const QString &message, unsigned int style)
bool validateAddress(const QString &address) const
void sendCoins(WalletModelTransaction &transaction)
void setClientModel(ClientModel *client_model)
Definition: walletmodel.cpp:76
void updateStatus()
Definition: walletmodel.cpp:82
CAmount getAvailableBalance(const wallet::CCoinControl *control)
bool isMultiwallet() const
void timerTimeout()
std::unique_ptr< interfaces::Handler > m_handler_can_get_addrs_changed
Definition: walletmodel.h:166
std::unique_ptr< interfaces::Handler > m_handler_unload
Definition: walletmodel.h:161
void displayAddress(std::string sAddress) const
EncryptionStatus getEncryptionStatus() const
TransactionTableModel * getTransactionTableModel() const
interfaces::Wallet & wallet() const
Definition: walletmodel.h:139
std::unique_ptr< interfaces::Handler > m_handler_status_changed
Definition: walletmodel.h:162
interfaces::WalletBalances m_cached_balances
Definition: walletmodel.h:181
bool fForceCheckBalanceChanged
Definition: walletmodel.h:170
void coinsSent(WalletModel *wallet, SendCoinsRecipient recipient, QByteArray transaction)
QString getDisplayName() const
OptionsModel * getOptionsModel() const
void checkBalanceChanged(const interfaces::WalletBalances &new_balances)
void unsubscribeFromCoreSignals()
void requireUnlock()
void updateTransaction()
uint256 getLastBlockProcessed() const
QTimer * timer
Definition: walletmodel.h:183
WalletModel(std::unique_ptr< interfaces::Wallet > wallet, ClientModel &client_model, const PlatformStyle *platformStyle, QObject *parent=nullptr)
Definition: walletmodel.cpp:42
std::unique_ptr< interfaces::Handler > m_handler_address_book_changed
Definition: walletmodel.h:163
void encryptionStatusChanged()
std::unique_ptr< interfaces::Wallet > m_wallet
Definition: walletmodel.h:160
UnlockContext requestUnlock()
void balanceChanged(const interfaces::WalletBalances &balances)
static bool isWalletEnabled()
interfaces::WalletBalances getCachedBalance() const
QString getWalletName() const
std::unique_ptr< interfaces::Handler > m_handler_show_progress
Definition: walletmodel.h:165
@ AmountWithFeeExceedsBalance
Definition: walletmodel.h:62
@ TransactionCreationFailed
Definition: walletmodel.h:64
@ AmountExceedsBalance
Definition: walletmodel.h:61
@ DuplicateAddress
Definition: walletmodel.h:63
void subscribeToCoreSignals()
Data model for a walletmodel transaction.
void setTransactionFee(const CAmount &newFee)
void reassignAmounts(int nChangePosRet)
QList< SendCoinsRecipient > getRecipients() const
virtual WalletLoader & walletLoader()=0
Get wallet loader.
virtual CAmount getAvailableBalance(const wallet::CCoinControl &coin_control)=0
Get available balance.
virtual std::optional< common::PSBTError > fillPSBT(std::optional< int > sighash_type, bool sign, bool bip32derivs, size_t *n_signed, PartiallySignedTransaction &psbtx, bool &complete)=0
Fill PSBT.
virtual bool hasExternalSigner()=0
virtual void commitTransaction(CTransactionRef tx, WalletValueMap value_map, WalletOrderForm order_form)=0
Commit transaction.
virtual bool privateKeysDisabled()=0
virtual std::vector< std::unique_ptr< Wallet > > getWallets()=0
Return interfaces for accessing wallets (if any).
256-bit opaque blob.
Definition: uint256.h:196
Coin Control Features.
Definition: coincontrol.h:83
std::optional< bool > m_signal_bip125_rbf
Override the wallet's m_signal_rbf if set.
Definition: coincontrol.h:101
bool HasSelected() const
Returns true if there are pre-selected inputs.
Definition: coincontrol.cpp:15
static constexpr auto MODEL_UPDATE_DELAY
Definition: guiconstants.h:14
bool IsValidDestinationString(const std::string &str, const CChainParams &params)
Definition: key_io.cpp:310
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
Definition: key_io.cpp:299
std::string EncodeDestination(const CTxDestination &dest)
Definition: key_io.cpp:294
QString WalletDisplayName(const QString &name)
Definition: guiutil.cpp:990
auto ExceptionSafeConnect(Sender sender, Signal signal, Receiver receiver, Slot method, Qt::ConnectionType type=Qt::AutoConnection)
A drop-in replacement of QObject::connect function (see: https://doc.qt.io/qt-5/qobject....
Definition: guiutil.h:369
void setClipboard(const QString &str)
Definition: guiutil.cpp:668
Definition: messages.h:20
bilingual_str ErrorString(const Result< T > &result)
Definition: result.h:93
static const bool DEFAULT_DISABLE_WALLET
Definition: wallet.h:135
AddressPurpose
Address purpose field that has been been stored with wallet sending and receiving addresses since BIP...
Definition: types.h:28
is a home for public enum and struct type definitions that are used internally by node code,...
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
const char * name
Definition: rest.cpp:50
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
Definition: secure.h:58
#define SEND_CONFIRM_DELAY
A mutable version of CTransaction.
Definition: transaction.h:378
A version of CTransaction with the PSBT format.
Definition: psbt.h:1119
Collection of wallet balances.
Definition: wallet.h:368
bool balanceChanged(const WalletBalances &prev) const
Definition: wallet.h:373
ChangeType
General change type (added, updated, removed).
Definition: ui_change_type.h:9
std::string EncodeBase64(std::span< const unsigned char > input)
assert(!tx.IsCoinBase())
std::shared_ptr< CWallet > m_wallet
Definition: interfaces.cpp:533
static void NotifyTransactionChanged(WalletModel *walletmodel, const Txid &hash, ChangeType status)
static void NotifyUnload(WalletModel *walletModel)
static void NotifyAddressBookChanged(WalletModel *walletmodel, const CTxDestination &address, const std::string &label, bool isMine, wallet::AddressPurpose purpose, ChangeType status)
static void NotifyCanGetAddressesChanged(WalletModel *walletmodel)
static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel)