Changeset View
Changeset View
Standalone View
Standalone View
src/interfaces/wallet.cpp
| Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines | static WalletTxOut MakeWalletTxOut(interfaces::Chain::Lock &locked_chain, | ||||
| result.is_spent = | result.is_spent = | ||||
| wallet.IsSpent(locked_chain, COutPoint(wtx.GetId(), n)); | wallet.IsSpent(locked_chain, COutPoint(wtx.GetId(), n)); | ||||
| return result; | return result; | ||||
| } | } | ||||
| class WalletImpl : public Wallet { | class WalletImpl : public Wallet { | ||||
| public: | public: | ||||
| explicit WalletImpl(const std::shared_ptr<CWallet> &wallet) | explicit WalletImpl(const std::shared_ptr<CWallet> &wallet) | ||||
| : m_shared_wallet(wallet), m_wallet(*wallet.get()) {} | : m_wallet(wallet) {} | ||||
| bool encryptWallet(const SecureString &wallet_passphrase) override { | bool encryptWallet(const SecureString &wallet_passphrase) override { | ||||
| return m_wallet.EncryptWallet(wallet_passphrase); | return m_wallet->EncryptWallet(wallet_passphrase); | ||||
| } | } | ||||
| bool isCrypted() override { return m_wallet.IsCrypted(); } | bool isCrypted() override { return m_wallet->IsCrypted(); } | ||||
| bool lock() override { return m_wallet.Lock(); } | bool lock() override { return m_wallet->Lock(); } | ||||
| bool unlock(const SecureString &wallet_passphrase) override { | bool unlock(const SecureString &wallet_passphrase) override { | ||||
| return m_wallet.Unlock(wallet_passphrase); | return m_wallet->Unlock(wallet_passphrase); | ||||
| } | } | ||||
| bool isLocked() override { return m_wallet.IsLocked(); } | bool isLocked() override { return m_wallet->IsLocked(); } | ||||
| bool changeWalletPassphrase( | bool changeWalletPassphrase( | ||||
| const SecureString &old_wallet_passphrase, | const SecureString &old_wallet_passphrase, | ||||
| const SecureString &new_wallet_passphrase) override { | const SecureString &new_wallet_passphrase) override { | ||||
| return m_wallet.ChangeWalletPassphrase(old_wallet_passphrase, | return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase, | ||||
| new_wallet_passphrase); | new_wallet_passphrase); | ||||
| } | } | ||||
| void abortRescan() override { m_wallet.AbortRescan(); } | void abortRescan() override { m_wallet->AbortRescan(); } | ||||
| bool backupWallet(const std::string &filename) override { | bool backupWallet(const std::string &filename) override { | ||||
| return m_wallet.BackupWallet(filename); | return m_wallet->BackupWallet(filename); | ||||
| } | } | ||||
| std::string getWalletName() override { return m_wallet.GetName(); } | std::string getWalletName() override { return m_wallet->GetName(); } | ||||
| std::set<CTxDestination> | std::set<CTxDestination> | ||||
| getLabelAddresses(const std::string &label) override { | getLabelAddresses(const std::string &label) override { | ||||
| return m_wallet.GetLabelAddresses(label); | return m_wallet->GetLabelAddresses(label); | ||||
| }; | }; | ||||
| bool getKeyFromPool(bool internal, CPubKey &pub_key) override { | bool getKeyFromPool(bool internal, CPubKey &pub_key) override { | ||||
| return m_wallet.GetKeyFromPool(pub_key, internal); | return m_wallet->GetKeyFromPool(pub_key, internal); | ||||
| } | } | ||||
| const CChainParams &getChainParams() override { | const CChainParams &getChainParams() override { | ||||
| return m_wallet.chainParams; | return m_wallet->chainParams; | ||||
| } | } | ||||
| bool getPubKey(const CKeyID &address, CPubKey &pub_key) override { | bool getPubKey(const CKeyID &address, CPubKey &pub_key) override { | ||||
| return m_wallet.GetPubKey(address, pub_key); | return m_wallet->GetPubKey(address, pub_key); | ||||
| } | } | ||||
| bool getPrivKey(const CKeyID &address, CKey &key) override { | bool getPrivKey(const CKeyID &address, CKey &key) override { | ||||
| return m_wallet.GetKey(address, key); | return m_wallet->GetKey(address, key); | ||||
| } | } | ||||
| bool isSpendable(const CTxDestination &dest) override { | bool isSpendable(const CTxDestination &dest) override { | ||||
| return IsMine(m_wallet, dest) & ISMINE_SPENDABLE; | return IsMine(*m_wallet, dest) & ISMINE_SPENDABLE; | ||||
| } | } | ||||
| bool haveWatchOnly() override { return m_wallet.HaveWatchOnly(); }; | bool haveWatchOnly() override { return m_wallet->HaveWatchOnly(); }; | ||||
| bool setAddressBook(const CTxDestination &dest, const std::string &name, | bool setAddressBook(const CTxDestination &dest, const std::string &name, | ||||
| const std::string &purpose) override { | const std::string &purpose) override { | ||||
| return m_wallet.SetAddressBook(dest, name, purpose); | return m_wallet->SetAddressBook(dest, name, purpose); | ||||
| } | } | ||||
| bool delAddressBook(const CTxDestination &dest) override { | bool delAddressBook(const CTxDestination &dest) override { | ||||
| return m_wallet.DelAddressBook(dest); | return m_wallet->DelAddressBook(dest); | ||||
| } | } | ||||
| bool getAddress(const CTxDestination &dest, std::string *name, | bool getAddress(const CTxDestination &dest, std::string *name, | ||||
| isminetype *is_mine, std::string *purpose) override { | isminetype *is_mine, std::string *purpose) override { | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| auto it = m_wallet.mapAddressBook.find(dest); | auto it = m_wallet->mapAddressBook.find(dest); | ||||
| if (it == m_wallet.mapAddressBook.end()) { | if (it == m_wallet->mapAddressBook.end()) { | ||||
| return false; | return false; | ||||
| } | } | ||||
| if (name) { | if (name) { | ||||
| *name = it->second.name; | *name = it->second.name; | ||||
| } | } | ||||
| if (is_mine) { | if (is_mine) { | ||||
| *is_mine = IsMine(m_wallet, dest); | *is_mine = IsMine(*m_wallet, dest); | ||||
| } | } | ||||
| if (purpose) { | if (purpose) { | ||||
| *purpose = it->second.purpose; | *purpose = it->second.purpose; | ||||
| } | } | ||||
| return true; | return true; | ||||
| } | } | ||||
| std::vector<WalletAddress> getAddresses() override { | std::vector<WalletAddress> getAddresses() override { | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| std::vector<WalletAddress> result; | std::vector<WalletAddress> result; | ||||
| for (const auto &item : m_wallet.mapAddressBook) { | for (const auto &item : m_wallet->mapAddressBook) { | ||||
| result.emplace_back(item.first, IsMine(m_wallet, item.first), | result.emplace_back(item.first, IsMine(*m_wallet, item.first), | ||||
| item.second.name, item.second.purpose); | item.second.name, item.second.purpose); | ||||
| } | } | ||||
| return result; | return result; | ||||
| } | } | ||||
| void learnRelatedScripts(const CPubKey &key, OutputType type) override { | void learnRelatedScripts(const CPubKey &key, OutputType type) override { | ||||
| m_wallet.LearnRelatedScripts(key, type); | m_wallet->LearnRelatedScripts(key, type); | ||||
| } | } | ||||
| bool addDestData(const CTxDestination &dest, const std::string &key, | bool addDestData(const CTxDestination &dest, const std::string &key, | ||||
| const std::string &value) override { | const std::string &value) override { | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.AddDestData(dest, key, value); | return m_wallet->AddDestData(dest, key, value); | ||||
| } | } | ||||
| bool eraseDestData(const CTxDestination &dest, | bool eraseDestData(const CTxDestination &dest, | ||||
| const std::string &key) override { | const std::string &key) override { | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.EraseDestData(dest, key); | return m_wallet->EraseDestData(dest, key); | ||||
| } | } | ||||
| std::vector<std::string> | std::vector<std::string> | ||||
| getDestValues(const std::string &prefix) override { | getDestValues(const std::string &prefix) override { | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.GetDestValues(prefix); | return m_wallet->GetDestValues(prefix); | ||||
| } | } | ||||
| void lockCoin(const COutPoint &output) override { | void lockCoin(const COutPoint &output) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.LockCoin(output); | return m_wallet->LockCoin(output); | ||||
| } | } | ||||
| void unlockCoin(const COutPoint &output) override { | void unlockCoin(const COutPoint &output) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.UnlockCoin(output); | return m_wallet->UnlockCoin(output); | ||||
| } | } | ||||
| bool isLockedCoin(const COutPoint &output) override { | bool isLockedCoin(const COutPoint &output) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.IsLockedCoin(output); | return m_wallet->IsLockedCoin(output); | ||||
| } | } | ||||
| void listLockedCoins(std::vector<COutPoint> &outputs) override { | void listLockedCoins(std::vector<COutPoint> &outputs) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.ListLockedCoins(outputs); | return m_wallet->ListLockedCoins(outputs); | ||||
| } | } | ||||
| std::unique_ptr<PendingWalletTx> | std::unique_ptr<PendingWalletTx> | ||||
| createTransaction(const std::vector<CRecipient> &recipients, | createTransaction(const std::vector<CRecipient> &recipients, | ||||
| const CCoinControl &coin_control, bool sign, | const CCoinControl &coin_control, bool sign, | ||||
| int &change_pos, Amount &fee, | int &change_pos, Amount &fee, | ||||
| std::string &fail_reason) override { | std::string &fail_reason) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| auto pending = std::make_unique<PendingWalletTxImpl>(m_wallet); | auto pending = std::make_unique<PendingWalletTxImpl>(*m_wallet); | ||||
| if (!m_wallet.CreateTransaction( | if (!m_wallet->CreateTransaction( | ||||
| *locked_chain, recipients, pending->m_tx, pending->m_key, | *locked_chain, recipients, pending->m_tx, pending->m_key, | ||||
| fee, change_pos, fail_reason, coin_control, sign)) { | fee, change_pos, fail_reason, coin_control, sign)) { | ||||
| return {}; | return {}; | ||||
| } | } | ||||
| return pending; | return pending; | ||||
| } | } | ||||
| bool transactionCanBeAbandoned(const TxId &txid) override { | bool transactionCanBeAbandoned(const TxId &txid) override { | ||||
| return m_wallet.TransactionCanBeAbandoned(txid); | return m_wallet->TransactionCanBeAbandoned(txid); | ||||
| } | } | ||||
| bool abandonTransaction(const TxId &txid) override { | bool abandonTransaction(const TxId &txid) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.AbandonTransaction(*locked_chain, txid); | return m_wallet->AbandonTransaction(*locked_chain, txid); | ||||
| } | } | ||||
| CTransactionRef getTx(const TxId &txid) override { | CTransactionRef getTx(const TxId &txid) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| auto mi = m_wallet.mapWallet.find(txid); | auto mi = m_wallet->mapWallet.find(txid); | ||||
| if (mi != m_wallet.mapWallet.end()) { | if (mi != m_wallet->mapWallet.end()) { | ||||
| return mi->second.tx; | return mi->second.tx; | ||||
| } | } | ||||
| return {}; | return {}; | ||||
| } | } | ||||
| WalletTx getWalletTx(const TxId &txid) override { | WalletTx getWalletTx(const TxId &txid) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| auto mi = m_wallet.mapWallet.find(txid); | auto mi = m_wallet->mapWallet.find(txid); | ||||
| if (mi != m_wallet.mapWallet.end()) { | if (mi != m_wallet->mapWallet.end()) { | ||||
| return MakeWalletTx(*locked_chain, m_wallet, mi->second); | return MakeWalletTx(*locked_chain, *m_wallet, mi->second); | ||||
| } | } | ||||
| return {}; | return {}; | ||||
| } | } | ||||
| std::vector<WalletTx> getWalletTxs() override { | std::vector<WalletTx> getWalletTxs() override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| std::vector<WalletTx> result; | std::vector<WalletTx> result; | ||||
| result.reserve(m_wallet.mapWallet.size()); | result.reserve(m_wallet->mapWallet.size()); | ||||
| for (const auto &entry : m_wallet.mapWallet) { | for (const auto &entry : m_wallet->mapWallet) { | ||||
| result.emplace_back( | result.emplace_back( | ||||
| MakeWalletTx(*locked_chain, m_wallet, entry.second)); | MakeWalletTx(*locked_chain, *m_wallet, entry.second)); | ||||
| } | } | ||||
| return result; | return result; | ||||
| } | } | ||||
| bool tryGetTxStatus(const TxId &txid, | bool tryGetTxStatus(const TxId &txid, | ||||
| interfaces::WalletTxStatus &tx_status, | interfaces::WalletTxStatus &tx_status, | ||||
| int &num_blocks, int64_t &block_time) override { | int &num_blocks, int64_t &block_time) override { | ||||
| auto locked_chain = m_wallet.chain().lock(true /* try_lock */); | auto locked_chain = m_wallet->chain().lock(true /* try_lock */); | ||||
| if (!locked_chain) { | if (!locked_chain) { | ||||
| return false; | return false; | ||||
| } | } | ||||
| TRY_LOCK(m_wallet.cs_wallet, locked_wallet); | TRY_LOCK(m_wallet->cs_wallet, locked_wallet); | ||||
| if (!locked_wallet) { | if (!locked_wallet) { | ||||
| return false; | return false; | ||||
| } | } | ||||
| auto mi = m_wallet.mapWallet.find(txid); | auto mi = m_wallet->mapWallet.find(txid); | ||||
| if (mi == m_wallet.mapWallet.end()) { | if (mi == m_wallet->mapWallet.end()) { | ||||
| return false; | return false; | ||||
| } | } | ||||
| if (Optional<int> height = locked_chain->getHeight()) { | if (Optional<int> height = locked_chain->getHeight()) { | ||||
| num_blocks = *height; | num_blocks = *height; | ||||
| block_time = locked_chain->getBlockTime(*height); | block_time = locked_chain->getBlockTime(*height); | ||||
| } else { | } else { | ||||
| num_blocks = -1; | num_blocks = -1; | ||||
| block_time = -1; | block_time = -1; | ||||
| } | } | ||||
| tx_status = MakeWalletTxStatus(*locked_chain, mi->second); | tx_status = MakeWalletTxStatus(*locked_chain, mi->second); | ||||
| return true; | return true; | ||||
| } | } | ||||
| WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status, | WalletTx getWalletTxDetails(const TxId &txid, WalletTxStatus &tx_status, | ||||
| WalletOrderForm &order_form, | WalletOrderForm &order_form, | ||||
| bool &in_mempool, | bool &in_mempool, | ||||
| int &num_blocks) override { | int &num_blocks) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| auto mi = m_wallet.mapWallet.find(txid); | auto mi = m_wallet->mapWallet.find(txid); | ||||
| if (mi != m_wallet.mapWallet.end()) { | if (mi != m_wallet->mapWallet.end()) { | ||||
| num_blocks = locked_chain->getHeight().value_or(-1); | num_blocks = locked_chain->getHeight().value_or(-1); | ||||
| in_mempool = mi->second.InMempool(); | in_mempool = mi->second.InMempool(); | ||||
| order_form = mi->second.vOrderForm; | order_form = mi->second.vOrderForm; | ||||
| tx_status = MakeWalletTxStatus(*locked_chain, mi->second); | tx_status = MakeWalletTxStatus(*locked_chain, mi->second); | ||||
| return MakeWalletTx(*locked_chain, m_wallet, mi->second); | return MakeWalletTx(*locked_chain, *m_wallet, mi->second); | ||||
| } | } | ||||
| return {}; | return {}; | ||||
| } | } | ||||
| WalletBalances getBalances() override { | WalletBalances getBalances() override { | ||||
| const auto bal = m_wallet.GetBalance(); | const auto bal = m_wallet->GetBalance(); | ||||
| WalletBalances result; | WalletBalances result; | ||||
| result.balance = bal.m_mine_trusted; | result.balance = bal.m_mine_trusted; | ||||
| result.unconfirmed_balance = bal.m_mine_untrusted_pending; | result.unconfirmed_balance = bal.m_mine_untrusted_pending; | ||||
| result.immature_balance = bal.m_mine_immature; | result.immature_balance = bal.m_mine_immature; | ||||
| result.have_watch_only = m_wallet.HaveWatchOnly(); | result.have_watch_only = m_wallet->HaveWatchOnly(); | ||||
| if (result.have_watch_only) { | if (result.have_watch_only) { | ||||
| result.watch_only_balance = bal.m_watchonly_trusted; | result.watch_only_balance = bal.m_watchonly_trusted; | ||||
| result.unconfirmed_watch_only_balance = | result.unconfirmed_watch_only_balance = | ||||
| bal.m_watchonly_untrusted_pending; | bal.m_watchonly_untrusted_pending; | ||||
| result.immature_watch_only_balance = bal.m_watchonly_immature; | result.immature_watch_only_balance = bal.m_watchonly_immature; | ||||
| } | } | ||||
| return result; | return result; | ||||
| } | } | ||||
| bool tryGetBalances(WalletBalances &balances, | bool tryGetBalances(WalletBalances &balances, | ||||
| int &num_blocks) override { | int &num_blocks) override { | ||||
| auto locked_chain = m_wallet.chain().lock(true /* try_lock */); | auto locked_chain = m_wallet->chain().lock(true /* try_lock */); | ||||
| if (!locked_chain) { | if (!locked_chain) { | ||||
| return false; | return false; | ||||
| } | } | ||||
| TRY_LOCK(m_wallet.cs_wallet, locked_wallet); | TRY_LOCK(m_wallet->cs_wallet, locked_wallet); | ||||
| if (!locked_wallet) { | if (!locked_wallet) { | ||||
| return false; | return false; | ||||
| } | } | ||||
| balances = getBalances(); | balances = getBalances(); | ||||
| num_blocks = locked_chain->getHeight().value_or(-1); | num_blocks = locked_chain->getHeight().value_or(-1); | ||||
| return true; | return true; | ||||
| } | } | ||||
| Amount getBalance() override { | Amount getBalance() override { | ||||
| return m_wallet.GetBalance().m_mine_trusted; | return m_wallet->GetBalance().m_mine_trusted; | ||||
| } | } | ||||
| Amount getAvailableBalance(const CCoinControl &coin_control) override { | Amount getAvailableBalance(const CCoinControl &coin_control) override { | ||||
| return m_wallet.GetAvailableBalance(&coin_control); | return m_wallet->GetAvailableBalance(&coin_control); | ||||
| } | } | ||||
| isminetype txinIsMine(const CTxIn &txin) override { | isminetype txinIsMine(const CTxIn &txin) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.IsMine(txin); | return m_wallet->IsMine(txin); | ||||
| } | } | ||||
| isminetype txoutIsMine(const CTxOut &txout) override { | isminetype txoutIsMine(const CTxOut &txout) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.IsMine(txout); | return m_wallet->IsMine(txout); | ||||
| } | } | ||||
| Amount getDebit(const CTxIn &txin, isminefilter filter) override { | Amount getDebit(const CTxIn &txin, isminefilter filter) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.GetDebit(txin, filter); | return m_wallet->GetDebit(txin, filter); | ||||
| } | } | ||||
| Amount getCredit(const CTxOut &txout, isminefilter filter) override { | Amount getCredit(const CTxOut &txout, isminefilter filter) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| return m_wallet.GetCredit(txout, filter); | return m_wallet->GetCredit(txout, filter); | ||||
| } | } | ||||
| CoinsList listCoins() override { | CoinsList listCoins() override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| CoinsList result; | CoinsList result; | ||||
| for (const auto &entry : m_wallet.ListCoins(*locked_chain)) { | for (const auto &entry : m_wallet->ListCoins(*locked_chain)) { | ||||
| auto &group = result[entry.first]; | auto &group = result[entry.first]; | ||||
| for (const auto &coin : entry.second) { | for (const auto &coin : entry.second) { | ||||
| group.emplace_back(COutPoint(coin.tx->GetId(), coin.i), | group.emplace_back(COutPoint(coin.tx->GetId(), coin.i), | ||||
| MakeWalletTxOut(*locked_chain, m_wallet, | MakeWalletTxOut(*locked_chain, *m_wallet, | ||||
| *coin.tx, coin.i, | *coin.tx, coin.i, | ||||
| coin.nDepth)); | coin.nDepth)); | ||||
| } | } | ||||
| } | } | ||||
| return result; | return result; | ||||
| } | } | ||||
| std::vector<WalletTxOut> | std::vector<WalletTxOut> | ||||
| getCoins(const std::vector<COutPoint> &outputs) override { | getCoins(const std::vector<COutPoint> &outputs) override { | ||||
| auto locked_chain = m_wallet.chain().lock(); | auto locked_chain = m_wallet->chain().lock(); | ||||
| LOCK(m_wallet.cs_wallet); | LOCK(m_wallet->cs_wallet); | ||||
| std::vector<WalletTxOut> result; | std::vector<WalletTxOut> result; | ||||
| result.reserve(outputs.size()); | result.reserve(outputs.size()); | ||||
| for (const auto &output : outputs) { | for (const auto &output : outputs) { | ||||
| result.emplace_back(); | result.emplace_back(); | ||||
| auto it = m_wallet.mapWallet.find(output.GetTxId()); | auto it = m_wallet->mapWallet.find(output.GetTxId()); | ||||
| if (it != m_wallet.mapWallet.end()) { | if (it != m_wallet->mapWallet.end()) { | ||||
| int depth = it->second.GetDepthInMainChain(*locked_chain); | int depth = it->second.GetDepthInMainChain(*locked_chain); | ||||
| if (depth >= 0) { | if (depth >= 0) { | ||||
| result.back() = | result.back() = | ||||
| MakeWalletTxOut(*locked_chain, m_wallet, it->second, | MakeWalletTxOut(*locked_chain, *m_wallet, | ||||
| output.GetN(), depth); | it->second, output.GetN(), depth); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| return result; | return result; | ||||
| } | } | ||||
| bool hdEnabled() override { return m_wallet.IsHDEnabled(); } | bool hdEnabled() override { return m_wallet->IsHDEnabled(); } | ||||
| OutputType getDefaultAddressType() override { | OutputType getDefaultAddressType() override { | ||||
| return m_wallet.m_default_address_type; | return m_wallet->m_default_address_type; | ||||
| } | } | ||||
| bool canGetAddresses() override { return m_wallet.CanGetAddresses(); } | bool canGetAddresses() override { return m_wallet->CanGetAddresses(); } | ||||
| bool IsWalletFlagSet(uint64_t flag) override { | bool IsWalletFlagSet(uint64_t flag) override { | ||||
| return m_wallet.IsWalletFlagSet(flag); | return m_wallet->IsWalletFlagSet(flag); | ||||
| } | } | ||||
| OutputType getDefaultChangeType() override { | OutputType getDefaultChangeType() override { | ||||
| return m_wallet.m_default_change_type; | return m_wallet->m_default_change_type; | ||||
| } | } | ||||
| Amount getDefaultMaxTxFee() override { | Amount getDefaultMaxTxFee() override { | ||||
| return m_wallet.m_default_max_tx_fee; | return m_wallet->m_default_max_tx_fee; | ||||
| } | } | ||||
| void remove() override { RemoveWallet(m_shared_wallet); } | void remove() override { RemoveWallet(m_wallet); } | ||||
| std::unique_ptr<Handler> handleUnload(UnloadFn fn) override { | std::unique_ptr<Handler> handleUnload(UnloadFn fn) override { | ||||
| return MakeHandler(m_wallet.NotifyUnload.connect(fn)); | return MakeHandler(m_wallet->NotifyUnload.connect(fn)); | ||||
| } | } | ||||
| std::unique_ptr<Handler> | std::unique_ptr<Handler> | ||||
| handleShowProgress(ShowProgressFn fn) override { | handleShowProgress(ShowProgressFn fn) override { | ||||
| return MakeHandler(m_wallet.ShowProgress.connect(fn)); | return MakeHandler(m_wallet->ShowProgress.connect(fn)); | ||||
| } | } | ||||
| std::unique_ptr<Handler> | std::unique_ptr<Handler> | ||||
| handleStatusChanged(StatusChangedFn fn) override { | handleStatusChanged(StatusChangedFn fn) override { | ||||
| return MakeHandler(m_wallet.NotifyStatusChanged.connect( | return MakeHandler(m_wallet->NotifyStatusChanged.connect( | ||||
| [fn](CCryptoKeyStore *) { fn(); })); | [fn](CCryptoKeyStore *) { fn(); })); | ||||
| } | } | ||||
| std::unique_ptr<Handler> | std::unique_ptr<Handler> | ||||
| handleAddressBookChanged(AddressBookChangedFn fn) override { | handleAddressBookChanged(AddressBookChangedFn fn) override { | ||||
| return MakeHandler(m_wallet.NotifyAddressBookChanged.connect( | return MakeHandler(m_wallet->NotifyAddressBookChanged.connect( | ||||
| [fn](CWallet *, const CTxDestination &address, | [fn](CWallet *, const CTxDestination &address, | ||||
| const std::string &label, bool is_mine, | const std::string &label, bool is_mine, | ||||
| const std::string &purpose, ChangeType status) { | const std::string &purpose, ChangeType status) { | ||||
| fn(address, label, is_mine, purpose, status); | fn(address, label, is_mine, purpose, status); | ||||
| })); | })); | ||||
| } | } | ||||
| std::unique_ptr<Handler> | std::unique_ptr<Handler> | ||||
| handleTransactionChanged(TransactionChangedFn fn) override { | handleTransactionChanged(TransactionChangedFn fn) override { | ||||
| return MakeHandler(m_wallet.NotifyTransactionChanged.connect( | return MakeHandler(m_wallet->NotifyTransactionChanged.connect( | ||||
| [fn](CWallet *, const TxId &txid, ChangeType status) { | [fn](CWallet *, const TxId &txid, ChangeType status) { | ||||
| fn(txid, status); | fn(txid, status); | ||||
| })); | })); | ||||
| } | } | ||||
| std::unique_ptr<Handler> | std::unique_ptr<Handler> | ||||
| handleWatchOnlyChanged(WatchOnlyChangedFn fn) override { | handleWatchOnlyChanged(WatchOnlyChangedFn fn) override { | ||||
| return MakeHandler(m_wallet.NotifyWatchonlyChanged.connect(fn)); | return MakeHandler(m_wallet->NotifyWatchonlyChanged.connect(fn)); | ||||
| } | } | ||||
| std::unique_ptr<Handler> | std::unique_ptr<Handler> | ||||
| handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override { | handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override { | ||||
| return MakeHandler( | return MakeHandler( | ||||
| m_wallet.NotifyCanGetAddressesChanged.connect(fn)); | m_wallet->NotifyCanGetAddressesChanged.connect(fn)); | ||||
| } | } | ||||
| Amount getRequiredFee(unsigned int tx_bytes) override { | Amount getRequiredFee(unsigned int tx_bytes) override { | ||||
| return GetRequiredFee(m_wallet, tx_bytes); | return GetRequiredFee(*m_wallet, tx_bytes); | ||||
| } | } | ||||
| Amount getMinimumFee(unsigned int tx_bytes, | Amount getMinimumFee(unsigned int tx_bytes, | ||||
| const CCoinControl &coin_control) override { | const CCoinControl &coin_control) override { | ||||
| return GetMinimumFee(m_wallet, tx_bytes, coin_control); | return GetMinimumFee(*m_wallet, tx_bytes, coin_control); | ||||
| } | } | ||||
| std::shared_ptr<CWallet> m_shared_wallet; | std::shared_ptr<CWallet> m_wallet; | ||||
| CWallet &m_wallet; | |||||
| }; | }; | ||||
| class WalletClientImpl : public ChainClient { | class WalletClientImpl : public ChainClient { | ||||
| public: | public: | ||||
| WalletClientImpl(Chain &chain, | WalletClientImpl(Chain &chain, | ||||
| std::vector<std::string> wallet_filenames) | std::vector<std::string> wallet_filenames) | ||||
| : m_chain(chain), m_wallet_filenames(std::move(wallet_filenames)) {} | : m_chain(chain), m_wallet_filenames(std::move(wallet_filenames)) {} | ||||
| Show All 35 Lines | |||||