mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-02-05 10:17:30 -05:00
fae51a5c6f
Common errors and warnings should be translated when displayed in the GUI, but not translated when displayed elsewhere. The wallet method CreateWalletFromFile does not know its caller, so this commit changes it to return a bilingual_str to the caller.
313 lines
11 KiB
C++
313 lines
11 KiB
C++
// Copyright (c) 2019-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.
|
|
|
|
#include <qt/walletcontroller.h>
|
|
|
|
#include <qt/askpassphrasedialog.h>
|
|
#include <qt/clientmodel.h>
|
|
#include <qt/createwalletdialog.h>
|
|
#include <qt/guiconstants.h>
|
|
#include <qt/guiutil.h>
|
|
#include <qt/walletmodel.h>
|
|
|
|
#include <interfaces/handler.h>
|
|
#include <interfaces/node.h>
|
|
#include <util/string.h>
|
|
#include <util/translation.h>
|
|
#include <wallet/wallet.h>
|
|
|
|
#include <algorithm>
|
|
|
|
#include <QApplication>
|
|
#include <QMessageBox>
|
|
#include <QMutexLocker>
|
|
#include <QThread>
|
|
#include <QTimer>
|
|
#include <QWindow>
|
|
|
|
WalletController::WalletController(ClientModel& client_model, const PlatformStyle* platform_style, QObject* parent)
|
|
: QObject(parent)
|
|
, m_activity_thread(new QThread(this))
|
|
, m_activity_worker(new QObject)
|
|
, m_client_model(client_model)
|
|
, m_node(client_model.node())
|
|
, m_platform_style(platform_style)
|
|
, m_options_model(client_model.getOptionsModel())
|
|
{
|
|
m_handler_load_wallet = m_node.handleLoadWallet([this](std::unique_ptr<interfaces::Wallet> wallet) {
|
|
getOrCreateWallet(std::move(wallet));
|
|
});
|
|
|
|
for (std::unique_ptr<interfaces::Wallet>& wallet : m_node.getWallets()) {
|
|
getOrCreateWallet(std::move(wallet));
|
|
}
|
|
|
|
m_activity_worker->moveToThread(m_activity_thread);
|
|
m_activity_thread->start();
|
|
}
|
|
|
|
// Not using the default destructor because not all member types definitions are
|
|
// available in the header, just forward declared.
|
|
WalletController::~WalletController()
|
|
{
|
|
m_activity_thread->quit();
|
|
m_activity_thread->wait();
|
|
delete m_activity_worker;
|
|
}
|
|
|
|
std::vector<WalletModel*> WalletController::getOpenWallets() const
|
|
{
|
|
QMutexLocker locker(&m_mutex);
|
|
return m_wallets;
|
|
}
|
|
|
|
std::map<std::string, bool> WalletController::listWalletDir() const
|
|
{
|
|
QMutexLocker locker(&m_mutex);
|
|
std::map<std::string, bool> wallets;
|
|
for (const std::string& name : m_node.listWalletDir()) {
|
|
wallets[name] = false;
|
|
}
|
|
for (WalletModel* wallet_model : m_wallets) {
|
|
auto it = wallets.find(wallet_model->wallet().getWalletName());
|
|
if (it != wallets.end()) it->second = true;
|
|
}
|
|
return wallets;
|
|
}
|
|
|
|
void WalletController::closeWallet(WalletModel* wallet_model, QWidget* parent)
|
|
{
|
|
QMessageBox box(parent);
|
|
box.setWindowTitle(tr("Close wallet"));
|
|
box.setText(tr("Are you sure you wish to close the wallet <i>%1</i>?").arg(GUIUtil::HtmlEscape(wallet_model->getDisplayName())));
|
|
box.setInformativeText(tr("Closing the wallet for too long can result in having to resync the entire chain if pruning is enabled."));
|
|
box.setStandardButtons(QMessageBox::Yes|QMessageBox::Cancel);
|
|
box.setDefaultButton(QMessageBox::Yes);
|
|
if (box.exec() != QMessageBox::Yes) return;
|
|
|
|
// First remove wallet from node.
|
|
wallet_model->wallet().remove();
|
|
// Now release the model.
|
|
removeAndDeleteWallet(wallet_model);
|
|
}
|
|
|
|
WalletModel* WalletController::getOrCreateWallet(std::unique_ptr<interfaces::Wallet> wallet)
|
|
{
|
|
QMutexLocker locker(&m_mutex);
|
|
|
|
// Return model instance if exists.
|
|
if (!m_wallets.empty()) {
|
|
std::string name = wallet->getWalletName();
|
|
for (WalletModel* wallet_model : m_wallets) {
|
|
if (wallet_model->wallet().getWalletName() == name) {
|
|
return wallet_model;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Instantiate model and register it.
|
|
WalletModel* wallet_model = new WalletModel(std::move(wallet), m_client_model, m_platform_style, nullptr);
|
|
// Handler callback runs in a different thread so fix wallet model thread affinity.
|
|
wallet_model->moveToThread(thread());
|
|
wallet_model->setParent(this);
|
|
m_wallets.push_back(wallet_model);
|
|
|
|
// WalletModel::startPollBalance needs to be called in a thread managed by
|
|
// Qt because of startTimer. Considering the current thread can be a RPC
|
|
// thread, better delegate the calling to Qt with Qt::AutoConnection.
|
|
const bool called = QMetaObject::invokeMethod(wallet_model, "startPollBalance");
|
|
assert(called);
|
|
|
|
connect(wallet_model, &WalletModel::unload, this, [this, wallet_model] {
|
|
// Defer removeAndDeleteWallet when no modal widget is active.
|
|
// TODO: remove this workaround by removing usage of QDiallog::exec.
|
|
if (QApplication::activeModalWidget()) {
|
|
connect(qApp, &QApplication::focusWindowChanged, wallet_model, [this, wallet_model]() {
|
|
if (!QApplication::activeModalWidget()) {
|
|
removeAndDeleteWallet(wallet_model);
|
|
}
|
|
}, Qt::QueuedConnection);
|
|
} else {
|
|
removeAndDeleteWallet(wallet_model);
|
|
}
|
|
}, Qt::QueuedConnection);
|
|
|
|
// Re-emit coinsSent signal from wallet model.
|
|
connect(wallet_model, &WalletModel::coinsSent, this, &WalletController::coinsSent);
|
|
|
|
// Notify walletAdded signal on the GUI thread.
|
|
Q_EMIT walletAdded(wallet_model);
|
|
|
|
return wallet_model;
|
|
}
|
|
|
|
void WalletController::removeAndDeleteWallet(WalletModel* wallet_model)
|
|
{
|
|
// Unregister wallet model.
|
|
{
|
|
QMutexLocker locker(&m_mutex);
|
|
m_wallets.erase(std::remove(m_wallets.begin(), m_wallets.end(), wallet_model));
|
|
}
|
|
Q_EMIT walletRemoved(wallet_model);
|
|
// Currently this can trigger the unload since the model can hold the last
|
|
// CWallet shared pointer.
|
|
delete wallet_model;
|
|
}
|
|
|
|
WalletControllerActivity::WalletControllerActivity(WalletController* wallet_controller, QWidget* parent_widget)
|
|
: QObject(wallet_controller)
|
|
, m_wallet_controller(wallet_controller)
|
|
, m_parent_widget(parent_widget)
|
|
{
|
|
}
|
|
|
|
WalletControllerActivity::~WalletControllerActivity()
|
|
{
|
|
delete m_progress_dialog;
|
|
}
|
|
|
|
void WalletControllerActivity::showProgressDialog(const QString& label_text)
|
|
{
|
|
assert(!m_progress_dialog);
|
|
m_progress_dialog = new QProgressDialog(m_parent_widget);
|
|
|
|
m_progress_dialog->setLabelText(label_text);
|
|
m_progress_dialog->setRange(0, 0);
|
|
m_progress_dialog->setCancelButton(nullptr);
|
|
m_progress_dialog->setWindowModality(Qt::ApplicationModal);
|
|
GUIUtil::PolishProgressDialog(m_progress_dialog);
|
|
}
|
|
|
|
void WalletControllerActivity::destroyProgressDialog()
|
|
{
|
|
assert(m_progress_dialog);
|
|
delete m_progress_dialog;
|
|
m_progress_dialog = nullptr;
|
|
}
|
|
|
|
CreateWalletActivity::CreateWalletActivity(WalletController* wallet_controller, QWidget* parent_widget)
|
|
: WalletControllerActivity(wallet_controller, parent_widget)
|
|
{
|
|
m_passphrase.reserve(MAX_PASSPHRASE_SIZE);
|
|
}
|
|
|
|
CreateWalletActivity::~CreateWalletActivity()
|
|
{
|
|
delete m_create_wallet_dialog;
|
|
delete m_passphrase_dialog;
|
|
}
|
|
|
|
void CreateWalletActivity::askPassphrase()
|
|
{
|
|
m_passphrase_dialog = new AskPassphraseDialog(AskPassphraseDialog::Encrypt, m_parent_widget, &m_passphrase);
|
|
m_passphrase_dialog->setWindowModality(Qt::ApplicationModal);
|
|
m_passphrase_dialog->show();
|
|
|
|
connect(m_passphrase_dialog, &QObject::destroyed, [this] {
|
|
m_passphrase_dialog = nullptr;
|
|
});
|
|
connect(m_passphrase_dialog, &QDialog::accepted, [this] {
|
|
createWallet();
|
|
});
|
|
connect(m_passphrase_dialog, &QDialog::rejected, [this] {
|
|
Q_EMIT finished();
|
|
});
|
|
}
|
|
|
|
void CreateWalletActivity::createWallet()
|
|
{
|
|
showProgressDialog(tr("Creating Wallet <b>%1</b>...").arg(m_create_wallet_dialog->walletName().toHtmlEscaped()));
|
|
|
|
std::string name = m_create_wallet_dialog->walletName().toStdString();
|
|
uint64_t flags = 0;
|
|
if (m_create_wallet_dialog->isDisablePrivateKeysChecked()) {
|
|
flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
|
|
}
|
|
if (m_create_wallet_dialog->isMakeBlankWalletChecked()) {
|
|
flags |= WALLET_FLAG_BLANK_WALLET;
|
|
}
|
|
if (m_create_wallet_dialog->isDescriptorWalletChecked()) {
|
|
flags |= WALLET_FLAG_DESCRIPTORS;
|
|
}
|
|
|
|
QTimer::singleShot(500, worker(), [this, name, flags] {
|
|
WalletCreationStatus status;
|
|
std::unique_ptr<interfaces::Wallet> wallet = node().createWallet(m_passphrase, flags, name, m_error_message, m_warning_message, status);
|
|
|
|
if (status == WalletCreationStatus::SUCCESS) m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(wallet));
|
|
|
|
QTimer::singleShot(500, this, &CreateWalletActivity::finish);
|
|
});
|
|
}
|
|
|
|
void CreateWalletActivity::finish()
|
|
{
|
|
destroyProgressDialog();
|
|
|
|
if (!m_error_message.original.empty()) {
|
|
QMessageBox::critical(m_parent_widget, tr("Create wallet failed"), QString::fromStdString(m_error_message.translated));
|
|
} else if (!m_warning_message.empty()) {
|
|
QMessageBox::warning(m_parent_widget, tr("Create wallet warning"), QString::fromStdString(Join(m_warning_message, "\n", OpTranslated)));
|
|
}
|
|
|
|
if (m_wallet_model) Q_EMIT created(m_wallet_model);
|
|
|
|
Q_EMIT finished();
|
|
}
|
|
|
|
void CreateWalletActivity::create()
|
|
{
|
|
m_create_wallet_dialog = new CreateWalletDialog(m_parent_widget);
|
|
m_create_wallet_dialog->setWindowModality(Qt::ApplicationModal);
|
|
m_create_wallet_dialog->show();
|
|
|
|
connect(m_create_wallet_dialog, &QObject::destroyed, [this] {
|
|
m_create_wallet_dialog = nullptr;
|
|
});
|
|
connect(m_create_wallet_dialog, &QDialog::rejected, [this] {
|
|
Q_EMIT finished();
|
|
});
|
|
connect(m_create_wallet_dialog, &QDialog::accepted, [this] {
|
|
if (m_create_wallet_dialog->isEncryptWalletChecked()) {
|
|
askPassphrase();
|
|
} else {
|
|
createWallet();
|
|
}
|
|
});
|
|
}
|
|
|
|
OpenWalletActivity::OpenWalletActivity(WalletController* wallet_controller, QWidget* parent_widget)
|
|
: WalletControllerActivity(wallet_controller, parent_widget)
|
|
{
|
|
}
|
|
|
|
void OpenWalletActivity::finish()
|
|
{
|
|
destroyProgressDialog();
|
|
|
|
if (!m_error_message.original.empty()) {
|
|
QMessageBox::critical(m_parent_widget, tr("Open wallet failed"), QString::fromStdString(m_error_message.translated));
|
|
} else if (!m_warning_message.empty()) {
|
|
QMessageBox::warning(m_parent_widget, tr("Open wallet warning"), QString::fromStdString(Join(m_warning_message, "\n", OpTranslated)));
|
|
}
|
|
|
|
if (m_wallet_model) Q_EMIT opened(m_wallet_model);
|
|
|
|
Q_EMIT finished();
|
|
}
|
|
|
|
void OpenWalletActivity::open(const std::string& path)
|
|
{
|
|
QString name = path.empty() ? QString("["+tr("default wallet")+"]") : QString::fromStdString(path);
|
|
|
|
showProgressDialog(tr("Opening Wallet <b>%1</b>...").arg(name.toHtmlEscaped()));
|
|
|
|
QTimer::singleShot(0, worker(), [this, path] {
|
|
std::unique_ptr<interfaces::Wallet> wallet = node().loadWallet(path, m_error_message, m_warning_message);
|
|
|
|
if (wallet) m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(wallet));
|
|
|
|
QTimer::singleShot(0, this, &OpenWalletActivity::finish);
|
|
});
|
|
}
|