Bitcoin Core 32.99.0
P2P Digital Currency
Loading...
Searching...
No Matches
wallet.cpp
Go to the documentation of this file.
1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <wallet/wallet.h>
7
8#include <bitcoin-build-config.h> // IWYU pragma: keep
9
10#include <addresstype.h>
11#include <blockfilter.h>
12#include <chain.h>
13#include <coins.h>
14#include <common/args.h>
15#include <common/messages.h>
16#include <common/settings.h>
17#include <common/signmessage.h>
18#include <common/system.h>
19#include <consensus/amount.h>
20#include <consensus/consensus.h>
22#include <external_signer.h>
23#include <interfaces/chain.h>
24#include <interfaces/handler.h>
25#include <interfaces/wallet.h>
27#include <kernel/types.h>
28#include <key.h>
29#include <key_io.h>
30#include <node/types.h>
31#include <outputtype.h>
32#include <policy/feerate.h>
33#include <policy/truc_policy.h>
34#include <primitives/block.h>
36#include <psbt.h>
37#include <pubkey.h>
38#include <random.h>
39#include <script/descriptor.h>
40#include <script/interpreter.h>
41#include <script/script.h>
42#include <script/sign.h>
44#include <script/solver.h>
45#include <serialize.h>
46#include <span.h>
47#include <streams.h>
50#include <support/cleanse.h>
51#include <sync.h>
52#include <tinyformat.h>
53#include <uint256.h>
54#include <univalue.h>
55#include <util/check.h>
56#include <util/expected.h>
57#include <util/fs.h>
58#include <util/fs_helpers.h>
59#include <util/log.h>
60#include <util/moneystr.h>
61#include <util/result.h>
62#include <util/string.h>
63#include <util/time.h>
64#include <util/translation.h>
65#include <wallet/coincontrol.h>
66#include <wallet/context.h>
67#include <wallet/crypter.h>
68#include <wallet/db.h>
70#include <wallet/scan.h>
72#include <wallet/transaction.h>
73#include <wallet/types.h>
74#include <wallet/walletdb.h>
75#include <wallet/walletutil.h>
76
77#include <algorithm>
78#include <cassert>
79#include <condition_variable>
80#include <exception>
81#include <limits>
82#include <optional>
83#include <stdexcept>
84#include <thread>
85#include <tuple>
86#include <utility>
87#include <variant>
88
89struct KeyOriginInfo;
90
97using util::ToString;
98
99namespace wallet {
100
101bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
102{
103 const auto update_function = [&wallet_name](common::SettingsValue& setting_value) {
104 if (!setting_value.isArray()) setting_value.setArray();
105 for (const auto& value : setting_value.getValues()) {
106 if (value.isStr() && value.get_str() == wallet_name) return interfaces::SettingsAction::SKIP_WRITE;
107 }
108 setting_value.push_back(wallet_name);
110 };
111 return chain.updateRwSetting("wallet", update_function);
112}
113
114bool RemoveWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
115{
116 const auto update_function = [&wallet_name](common::SettingsValue& setting_value) {
117 if (!setting_value.isArray()) {
118 if (wallet_name.empty() && setting_value.isNull()) {
119 // Empty setting suppresses backwards-compatible default wallet autoload.
120 setting_value.setArray();
122 }
124 }
126 for (const auto& value : setting_value.getValues()) {
127 if (!value.isStr() || value.get_str() != wallet_name) new_value.push_back(value);
128 }
130 setting_value = std::move(new_value);
132 };
133 return chain.updateRwSetting("wallet", update_function);
134}
135
137 const std::string& wallet_name,
138 std::optional<bool> load_on_startup,
139 std::vector<bilingual_str>& warnings)
140{
141 if (!load_on_startup) return;
142 if (load_on_startup.value() && !AddWalletSetting(chain, wallet_name)) {
143 warnings.emplace_back(Untranslated("Wallet load on startup setting could not be updated, so wallet may not be loaded next node startup."));
144 } else if (!load_on_startup.value() && !RemoveWalletSetting(chain, wallet_name)) {
145 warnings.emplace_back(Untranslated("Wallet load on startup setting could not be updated, so wallet may still be loaded next node startup."));
146 }
147}
148
155{
156 if (chain.isInMempool(tx.GetHash())) {
158 } else if (tx.state<TxStateInMempool>()) {
160 }
161}
162
163bool AddWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
164{
166 assert(wallet);
167 std::vector<std::shared_ptr<CWallet>>::const_iterator i = std::find(context.wallets.begin(), context.wallets.end(), wallet);
168 if (i != context.wallets.end()) return false;
169 context.wallets.push_back(wallet);
170 wallet->ConnectScriptPubKeyManNotifiers();
171 wallet->NotifyCanGetAddressesChanged();
172 return true;
173}
174
175bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start, std::vector<bilingual_str>& warnings)
176{
177 assert(wallet);
178
179 interfaces::Chain& chain = wallet->chain();
180 std::string name = wallet->GetName();
181 WITH_LOCK(wallet->cs_wallet, wallet->WriteBestBlock());
182
183 // Unregister with the validation interface which also drops shared pointers.
184 wallet->DisconnectChainNotifications();
185 {
187 std::vector<std::shared_ptr<CWallet>>::iterator i = std::find(context.wallets.begin(), context.wallets.end(), wallet);
188 if (i == context.wallets.end()) return false;
189 context.wallets.erase(i);
190 }
191 // Notify unload so that upper layers release the shared pointer.
192 wallet->NotifyUnload();
193
194 // Write the wallet setting
195 UpdateWalletSetting(chain, name, load_on_start, warnings);
196
197 return true;
198}
199
200bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start)
201{
202 std::vector<bilingual_str> warnings;
203 return RemoveWallet(context, wallet, load_on_start, warnings);
204}
205
206std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext& context)
207{
209 return context.wallets;
210}
211
212std::shared_ptr<CWallet> GetDefaultWallet(WalletContext& context, size_t& count)
213{
215 count = context.wallets.size();
216 return count == 1 ? context.wallets[0] : nullptr;
217}
218
219std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& name)
220{
222 for (const std::shared_ptr<CWallet>& wallet : context.wallets) {
223 if (wallet->GetName() == name) return wallet;
224 }
225 return nullptr;
226}
227
228std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet)
229{
231 auto it = context.wallet_load_fns.emplace(context.wallet_load_fns.end(), std::move(load_wallet));
232 return interfaces::MakeCleanupHandler([&context, it] { LOCK(context.wallets_mutex); context.wallet_load_fns.erase(it); });
233}
234
235void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
236{
238 for (auto& load_wallet : context.wallet_load_fns) {
240 }
241}
242
245static std::condition_variable g_wallet_release_cv;
248
249// Custom deleter for shared_ptr<CWallet>.
251{
252 const std::string name = wallet->GetName();
253 wallet->WalletLogPrintf("Releasing wallet %s..", name);
254 delete wallet;
255 // Wallet is now released, notify WaitForDeleteWallet, if any.
256 {
258 if (g_unloading_wallet_set.erase(name) == 0) {
259 // WaitForDeleteWallet was not called for this wallet, all done.
260 return;
261 }
262 }
263 g_wallet_release_cv.notify_all();
264}
265
266void WaitForDeleteWallet(std::shared_ptr<CWallet>&& wallet)
267{
268 // Mark wallet for unloading.
269 const std::string name = wallet->GetName();
270 {
273 // Do not expect to be the only one removing this wallet.
274 // Multiple threads could simultaneously be waiting for deletion.
275 }
276
277 // Time to ditch our shared_ptr and wait for FlushAndDeleteWallet call.
278 wallet.reset();
279 {
281 while (g_unloading_wallet_set.contains(name)) {
282 g_wallet_release_cv.wait(lock);
283 }
284 }
285}
286
287namespace {
288std::shared_ptr<CWallet> LoadWalletInternal(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
289{
290 try {
291 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
292 if (!database) {
293 error = Untranslated("Wallet file verification failed.") + Untranslated(" ") + error;
294 return nullptr;
295 }
296
297 context.chain->initMessage(_("Loading wallet…"));
298 std::shared_ptr<CWallet> wallet = CWallet::LoadExisting(context, name, std::move(database), error, warnings);
299 if (!wallet) {
300 error = Untranslated("Wallet loading failed.") + Untranslated(" ") + error;
302 return nullptr;
303 }
304
307 wallet->postInitProcess();
308
309 // Write the wallet setting
311
312 return wallet;
313 } catch (const std::runtime_error& e) {
314 error = Untranslated(e.what());
316 return nullptr;
317 }
318}
319} // namespace
320
321std::shared_ptr<CWallet> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
322{
323 auto result = WITH_LOCK(g_loading_wallet_mutex, return g_loading_wallet_set.insert(name));
324 if (!result.second) {
325 error = Untranslated("Wallet already loading.");
327 return nullptr;
328 }
329 auto wallet = LoadWalletInternal(context, name, load_on_start, options, status, error, warnings);
331 return wallet;
332}
333
334std::shared_ptr<CWallet> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings)
335{
336 // Wallet must have a non-empty name
337 if (name.empty()) {
338 error = Untranslated("Wallet name cannot be empty");
340 return nullptr;
341 }
342
345 bool born_encrypted = !passphrase.empty();
346
347 // Only descriptor wallets can be created
350
351
352 // Private keys must be disabled for an external signer wallet
354 error = Untranslated("Private keys must be disabled when using an external signer");
356 return nullptr;
357 }
358
359 // Do not allow a passphrase when private keys are disabled
361 error = Untranslated("Passphrase provided but private keys are disabled. A passphrase is only used to encrypt private keys, so cannot be used for wallets with private keys disabled.");
363 return nullptr;
364 }
365
366 // Wallet::Verify will check if we're trying to create a wallet with a duplicate name.
367 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
368 if (!database) {
369 error = Untranslated("Wallet file verification failed.") + Untranslated(" ") + error;
371 return nullptr;
372 }
373
374 // Make the wallet
375 context.chain->initMessage(_("Creating wallet…"));
376 std::shared_ptr<CWallet> wallet = CWallet::CreateNew(context, name, std::move(database), wallet_creation_flags, born_encrypted, error, warnings);
377 if (!wallet) {
378 error = Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
380 return nullptr;
381 }
382
383 // Encrypt the wallet
384 if (born_encrypted) {
385 if (!wallet->EncryptWallet(passphrase)) {
386 error = Untranslated("Error: Wallet created but failed to encrypt.");
388 return nullptr;
389 }
390 }
391
392 WITH_LOCK(wallet->cs_wallet, wallet->LogStats());
395 wallet->postInitProcess();
396
397 // Write the wallet settings
399
401 return wallet;
402}
403
404// Re-creates wallet from the backup file by renaming and moving it into the wallet's directory.
405// If 'load_after_restore=true', the wallet object will be fully initialized and appended to the context.
406std::shared_ptr<CWallet> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings, bool load_after_restore, bool allow_unnamed)
407{
408 // Error if the wallet name is empty and allow_unnamed == false
409 // allow_unnamed == true is only used by migration to migrate an unnamed wallet
410 if (!allow_unnamed && wallet_name.empty()) {
411 error = Untranslated("Wallet name cannot be empty");
413 return nullptr;
414 }
415
416 DatabaseOptions options;
417 ReadDatabaseArgs(*context.args, options);
418 options.require_existing = true;
419
420 const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::u8path(wallet_name));
421 auto wallet_file = wallet_path / "wallet.dat";
422 std::shared_ptr<CWallet> wallet;
423 bool wallet_file_copied = false;
424 bool created_parent_dir = false;
425
426 try {
427 if (!fs::exists(backup_file)) {
428 error = Untranslated("Backup file does not exist");
430 return nullptr;
431 }
432
433 // Wallet directories are allowed to exist, but must not contain a .dat file.
434 // Any existing wallet database is treated as a hard failure to prevent overwriting.
435 if (fs::exists(wallet_path)) {
436 // If this is a file, it is the db and we don't want to overwrite it.
437 if (!fs::is_directory(wallet_path)) {
438 error = Untranslated(strprintf("Failed to restore wallet. Database file exists '%s'.", fs::PathToString(wallet_path)));
440 return nullptr;
441 }
442
443 // Check we are not going to overwrite an existing db file
444 if (fs::exists(wallet_file)) {
445 error = Untranslated(strprintf("Failed to restore wallet. Database file exists in '%s'.", fs::PathToString(wallet_file)));
447 return nullptr;
448 }
449 } else {
450 // The directory doesn't exist, create it
452 error = Untranslated(strprintf("Failed to restore database path '%s'.", fs::PathToString(wallet_path)));
454 return nullptr;
455 }
456 created_parent_dir = true;
457 }
458
459 fs::copy_file(backup_file, wallet_file, fs::copy_options::none);
460 wallet_file_copied = true;
461
462 if (load_after_restore) {
463 wallet = LoadWallet(context, wallet_name, load_on_start, options, status, error, warnings);
464 }
465 } catch (const std::exception& e) {
466 assert(!wallet);
467 if (!error.empty()) error += Untranslated("\n");
468 error += Untranslated(strprintf("Unexpected exception: %s", e.what()));
469 }
470
471 // Remove created wallet path only when loading fails
472 if (load_after_restore && !wallet) {
473 if (wallet_file_copied) fs::remove(wallet_file);
474 // Clean up the parent directory if we created it during restoration.
475 // As we have created it, it must be empty after deleting the wallet file.
476 if (created_parent_dir) {
477 Assume(fs::is_empty(wallet_path));
478 fs::remove(wallet_path);
479 }
480 }
481
482 return wallet;
483}
484
485CWallet::CWallet(interfaces::Chain* chain, const std::string& name, std::unique_ptr<WalletDatabase> database)
486 : m_chain(chain),
487 m_name(name),
488 m_database(std::move(database)),
489 m_scanner(std::make_unique<ChainScanner>(*this))
490{
491}
492
494{
495 // Should not have slots connected at this point.
497}
498
500const ChainScanner& CWallet::Scanner() const { return *m_scanner; }
501
507const CWalletTx* CWallet::GetWalletTx(const Txid& hash) const
508{
510 const auto it = mapWallet.find(hash);
511 if (it == mapWallet.end())
512 return nullptr;
513 return &(it->second);
514}
515
528
529/* Given a wallet passphrase string and an unencrypted master key, determine the proper key
530 * derivation parameters (should take at least 100ms) and encrypt the master key. */
532{
533 constexpr MillisecondsDouble target_time{100};
535 CMasterKey updated_master_key{master_key};
536
537 // Get the weighted average of iterations we can do in 100ms over 2 runs.
538 for (int i = 0; i < 2; i++){
539 auto start_time{NodeClock::now()};
540 const bool key_set{crypter.SetKeyFromPassphrase(wallet_passphrase, updated_master_key.vchSalt, updated_master_key.nDeriveIterations, updated_master_key.nDerivationMethod)};
541 auto elapsed_time{NodeClock::now() - start_time};
542 if (!key_set) {
543 return false;
544 }
545
546 if (elapsed_time <= 0s) {
547 // We are probably in a test with a mocked clock.
549 break;
550 }
551
552 // target_iterations : elapsed_iterations :: target_time : elapsed_time
553 const double target_iterations{updated_master_key.nDeriveIterations * target_time / elapsed_time};
554 if (target_iterations < 1 || target_iterations > std::numeric_limits<unsigned int>::max()) {
555 return false;
556 }
557 // Get the weighted average with previous runs. Use 64-bit math so the
558 // sum cannot wrap; the average of two unsigned int values fits in one.
559 updated_master_key.nDeriveIterations = (uint64_t{updated_master_key.nDeriveIterations} * i + static_cast<unsigned int>(target_iterations)) / (i + 1);
560 }
561
564 }
565
566 if (!crypter.SetKeyFromPassphrase(wallet_passphrase, updated_master_key.vchSalt, updated_master_key.nDeriveIterations, updated_master_key.nDerivationMethod)) {
567 return false;
568 }
569 if (!crypter.Encrypt(plain_master_key, updated_master_key.vchCryptedKey)) {
570 return false;
571 }
572
573 master_key = std::move(updated_master_key);
574 return true;
575}
576
578{
580 if (!crypter.SetKeyFromPassphrase(wallet_passphrase, master_key.vchSalt, master_key.nDeriveIterations, master_key.nDerivationMethod)) {
581 return false;
582 }
583 if (!crypter.Decrypt(master_key.vchCryptedKey, plain_master_key)) {
584 return false;
585 }
586
587 return true;
588}
589
591{
592 bilingual_str message;
593 if (passphrase.find('\0') != std::string::npos) {
594 // The passphrase has a null character (see #27067 for details)
595 message = _("Error: The wallet passphrase entered is incorrect. "
596 "It contains a null character (ie - a zero byte). "
597 "If the passphrase was set with a version of this software prior to 25.0, "
598 "please try again with only the characters up to — but not including — "
599 "the first null character. If this is successful, please set a new "
600 "passphrase to avoid this issue in the future.");
601 } else if (passphrase.empty()) {
602 message = _("Error: The wallet passphrase was not provided");
603 } else {
604 message = _("Error: The wallet passphrase entered was incorrect.");
605 }
607}
608
610{
612
613 {
615 for (const auto& [_, master_key] : mapMasterKeys)
616 {
618 continue; // try another master key
619 }
621 // Now that we've unlocked, upgrade the descriptor cache
623
625 // Write the current wallet client features to LAST_DECRYPTED_FEATURES.
626 // This must be done after all automatic upgrades so that those upgrades can be
627 // performed in an upgrade-downgrade-upgrade scenario.
628 WalletBatch batch(GetDatabase());
629 if (batch.WriteLastDecryptedFeatures()) {
631 }
632 }
633
634 return {};
635 }
636 }
637 }
639}
640
642{
643 bool fWasLocked = IsLocked();
644
645 {
647 Lock();
648
650 for (auto& [master_key_id, master_key] : mapMasterKeys)
651 {
654 }
656 {
657 if (fWasLocked) Lock();
658 CMasterKey new_master_key{master_key};
660 return util::Unexpected{WalletError{WalletErrorCode::GenericError, _("Error: Unable to encrypt encryption key with new passphrase")}};
661 }
662 if (!WalletBatch(GetDatabase()).WriteMasterKey(master_key_id, new_master_key)) {
663 return util::Unexpected{WalletError{WalletErrorCode::GenericError, _("Error: Writing the new encryption key to the wallet database failed")}};
664 }
665 WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i", new_master_key.nDeriveIterations);
666 master_key = std::move(new_master_key);
667 return {};
668 }
669 }
670 }
671
673}
674
675void CWallet::SetLastBlockProcessedInMem(int block_height, uint256 block_hash)
676{
678
679 m_last_block_processed = block_hash;
680 m_last_block_processed_height = block_height;
681}
682
683void CWallet::SetLastBlockProcessed(int block_height, uint256 block_hash)
684{
686
687 SetLastBlockProcessedInMem(block_height, block_hash);
689}
690
691std::set<Txid> CWallet::GetConflicts(const Txid& txid) const
692{
693 std::set<Txid> result;
695
696 const auto it = mapWallet.find(txid);
697 if (it == mapWallet.end())
698 return result;
699 const CWalletTx& wtx = it->second;
700
701 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
702
703 for (const CTxIn& txin : wtx.GetTx()->vin)
704 {
705 if (mapTxSpends.count(txin.prevout) <= 1)
706 continue; // No conflict if zero or one spends
707 range = mapTxSpends.equal_range(txin.prevout);
708 for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it)
709 result.insert(_it->second);
710 }
711 return result;
712}
713
715{
717 const Txid& txid = tx->GetHash();
718 for (unsigned int i = 0; i < tx->vout.size(); ++i) {
719 if (IsSpent(COutPoint(txid, i))) {
720 return true;
721 }
722 }
723 return false;
724}
725
727{
728 GetDatabase().Close();
729}
730
731std::set<CWalletTx*, WalletTxOrderComparator> CWallet::GetMalleatedVariants(const CWalletTx& wtx)
732{
734 std::set<CWalletTx*, WalletTxOrderComparator> txs;
735
736 // Coinbases cannot be malleated
737 if (wtx.IsCoinBase()) return txs;
738
739 // Only transactions that have non-witness inputs can be malleated
740 if (std::ranges::none_of(wtx.GetTx()->vin, [](const CTxIn& in) { return in.scriptWitness.IsNull(); })) {
741 return txs;
742 }
743
744 // All variants spend wtx's first input, so a single lookup finds every candidate
745 bool found_self = false;
746 const auto [begin, end] = mapTxSpends.equal_range(wtx.GetTx()->vin.front().prevout);
747 for (auto it = begin; it != end; ++it) {
748 auto entry = mapWallet.find(it->second);
749 if (!Assume(entry != mapWallet.end())) continue; // sanity-check: mapTxSpends has txs that are in mapWallet
750 const bool is_self = &entry->second == &wtx;
752 if (is_self || wtx.IsMalleation(entry->second)) {
753 Assume(txs.insert(&entry->second).second);
754 }
755 }
756 // wtx should always be found as this function is always called after AddToSpends
758 return txs;
759}
760
762{
763 const auto txs = GetMalleatedVariants(wtx);
764 if (txs.size() <= 1) return; // no variants, nothing to do
765
766 // First tx is the oldest one (smallest nOrderPos)
767 const CWalletTx* copyFrom = *txs.begin();
768
769 // The metadata that is kept in sync between malleated variants.
770 // nTimeReceived, nOrderPos and cached members are not copied on purpose.
771 const auto metadata = [](auto& tx) {
772 return std::tie(tx.m_from, tx.m_message, tx.m_comment, tx.m_comment_to,
773 tx.m_replaces_txid, tx.m_replaced_by_txid,
774 tx.m_messages, tx.m_payment_requests, tx.nTimeSmart);
775 };
776
777 // Now copy data from copyFrom to rest:
778 for (CWalletTx* copyTo : txs) {
779 if (copyTo == copyFrom) continue;
781 (void)batch.WriteTxMetadata(*copyTo);
782 }
783}
784
789bool CWallet::IsSpent(const COutPoint& outpoint) const
790{
791 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
792 range = mapTxSpends.equal_range(outpoint);
793
794 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
795 const Txid& txid = it->second;
796 const auto mit = mapWallet.find(txid);
797 if (mit != mapWallet.end()) {
798 const auto& wtx = mit->second;
799 if (!wtx.isAbandoned() && !wtx.isBlockConflicted() && !wtx.isMempoolConflicted())
800 return true; // Spent
801 }
802 }
803 return false;
804}
805
807{
809
810 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
811 range = mapTxSpends.equal_range(outpoint);
812
813 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
814 const Txid& txid = it->second;
815 const auto mit = mapWallet.find(txid);
816 if (mit != mapWallet.end()) {
817 const auto& wtx = mit->second;
818 if (wtx.isConfirmed()) return SpendType::CONFIRMED;
819 if (wtx.InMempool()) {
821 } else if (!wtx.isAbandoned() && !wtx.isBlockConflicted() && !wtx.isMempoolConflicted()) {
823 }
824 }
825 }
826 return st;
827}
828
829void CWallet::AddToSpends(const COutPoint& outpoint, const Txid& txid)
830{
831 mapTxSpends.insert(std::make_pair(outpoint, txid));
832
833 UnlockCoin(outpoint);
834}
835
836
838{
839 if (wtx.IsCoinBase()) // Coinbases don't spend anything!
840 return;
841
842 for (const CTxIn& txin : wtx.GetTx()->vin)
843 AddToSpends(txin.prevout, wtx.GetHash());
844}
845
847{
848 // Only descriptor wallets can be encrypted
850
851 if (HasEncryptionKeys())
852 return false;
853
855
858
859 CMasterKey master_key;
860
861 master_key.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
862 GetStrongRandBytes(master_key.vchSalt);
863
865 return false;
866 }
867 WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i", master_key.nDeriveIterations);
868
869 {
871 const unsigned int new_master_key_id{nMasterKeyMaxID + 1};
872 if (!RunWithinTxn(GetDatabase(), /*process_desc=*/"wallet encryption", [&](WalletBatch& batch) {
873 if (!batch.WriteMasterKey(new_master_key_id, master_key)) {
874 return false;
875 }
876 for (const auto& spk_man_pair : m_spk_managers) {
877 if (!spk_man_pair.second->Encrypt(plain_master_key, &batch)) {
878 return false;
879 }
880 }
881 return true;
882 })) {
883 return false;
884 }
885
887 mapMasterKeys[new_master_key_id] = std::move(master_key);
888
889 Lock();
891 return false;
892 }
893
895
896 Lock();
897
898 // Need to completely rewrite the wallet file; if we don't, the database might keep
899 // bits of the unencrypted private key in slack space in the database file.
901 }
903
904 return true;
905}
906
908{
910 WalletBatch batch(GetDatabase());
911
912 // Old wallets didn't have any defined order for transactions
913 // Probably a bad idea to change the output of this
914
915 // First: get all CWalletTx into a sorted-by-time multimap.
916 typedef std::multimap<int64_t, CWalletTx*> TxItems;
918
919 for (auto& entry : mapWallet)
920 {
921 CWalletTx* wtx = &entry.second;
922 txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
923 }
924
925 nOrderPosNext = 0;
926 std::vector<int64_t> nOrderPosOffsets;
927 for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
928 {
929 CWalletTx *const pwtx = (*it).second;
930 int64_t& nOrderPos = pwtx->nOrderPos;
931
932 if (nOrderPos == -1)
933 {
934 nOrderPos = nOrderPosNext++;
935 nOrderPosOffsets.push_back(nOrderPos);
936
937 if (!batch.WriteTxMetadata(*pwtx))
938 return DBErrors::LOAD_FAIL;
939 }
940 else
941 {
944 {
945 if (nOrderPos >= nOffsetStart)
946 ++nOrderPosOff;
947 }
948 nOrderPos += nOrderPosOff;
949 nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
950
951 if (!nOrderPosOff)
952 continue;
953
954 // Since we're changing the order, write it back
955 if (!batch.WriteTxMetadata(*pwtx))
956 return DBErrors::LOAD_FAIL;
957 }
958 }
960
961 return DBErrors::LOAD_OK;
962}
963
975
977{
978 {
980 for (auto& [_, wtx] : mapWallet)
981 wtx.MarkDirty();
982 }
983}
984
986{
988
989 auto mi = mapWallet.find(originalHash);
990
991 // There is a bug if MarkReplaced is not called on an existing wallet transaction.
992 assert(mi != mapWallet.end());
993
994 CWalletTx& wtx = (*mi).second;
995
996 // Ensure for now that we're not overwriting data
998
1000
1001 // Refresh mempool status without waiting for transactionRemovedFromMempool or transactionAddedToMempool
1003
1004 WalletBatch batch(GetDatabase());
1005
1006 bool success = true;
1007 if (!batch.WriteTxMetadata(wtx)) {
1008 WalletLogPrintf("%s: Updating batch tx %s failed", __func__, wtx.GetHash().ToString());
1009 success = false;
1010 }
1011
1012 // The new transaction also replaces any malleated variants of wtx,
1013 // so bumpfee refuses to bump them afterwards
1014 for (CWalletTx* variant : GetMalleatedVariants(wtx)) {
1015 if (variant == &wtx) continue;
1016 variant->m_replaced_by_txid = newHash;
1017 if (!batch.WriteTxMetadata(*variant)) {
1018 WalletLogPrintf("%s: Updating variant tx %s failed", __func__, variant->GetHash().ToString());
1019 success = false;
1020 }
1021 }
1022
1024
1025 return success;
1026}
1027
1028void CWallet::SetSpentKeyState(WalletBatch& batch, const Txid& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations)
1029{
1031 const CWalletTx* srctx = GetWalletTx(hash);
1032 if (!srctx) return;
1033
1035 if (ExtractDestination(srctx->GetTx()->vout[n].scriptPubKey, dst)) {
1036 if (IsMine(dst)) {
1037 if (used != IsAddressPreviouslySpent(dst)) {
1038 if (used) {
1039 tx_destinations.insert(dst);
1040 }
1041 SetAddressPreviouslySpent(batch, dst, used);
1042 }
1043 }
1044 }
1045}
1046
1047bool CWallet::IsSpentKey(const CScript& scriptPubKey) const
1048{
1050 CTxDestination dest;
1051 if (!ExtractDestination(scriptPubKey, dest)) {
1052 return false;
1053 }
1054 if (IsAddressPreviouslySpent(dest)) {
1055 return true;
1056 }
1057 return false;
1058}
1059
1061{
1062 LOCK(cs_wallet);
1063
1064 WalletBatch batch(GetDatabase());
1065
1066 Txid hash = tx->GetHash();
1067
1069 // Mark used destinations
1070 std::set<CTxDestination> tx_destinations;
1071
1072 for (const CTxIn& txin : tx->vin) {
1073 const COutPoint& op = txin.prevout;
1074 SetSpentKeyState(batch, op.hash, op.n, true, tx_destinations);
1075 }
1076
1078 }
1079
1080 // Inserts only if not already there, returns tx inserted or tx found
1081 auto ret = mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(tx, state));
1082 CWalletTx& wtx = (*ret.first).second;
1083 bool fInsertedNew = ret.second;
1085 if (fInsertedNew) {
1086 wtx.nTimeReceived = GetTime();
1087 wtx.nOrderPos = IncOrderPosNext(&batch);
1088 wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
1090 AddToSpends(wtx);
1091 SyncMalleatedTxMetadata(batch, wtx);
1092
1093 // Update birth time when tx time is older than it.
1095
1096 if (!batch.WriteFullTx(wtx)) {
1097 return nullptr;
1098 }
1099 }
1100
1101 if (!fInsertedNew)
1102 {
1103 try {
1104 fUpdated |= wtx.Update(tx, state, batch, fUpdated);
1105 } catch (const std::ios_base::failure& e) {
1106 WalletLogPrintf("Error: Unable to write tx update, %s", e.what());
1107 return nullptr;
1108 }
1109 }
1110
1111 // Mark inactive coinbase transactions and their descendants as abandoned
1112 if (wtx.IsCoinBase() && wtx.isInactive()) {
1113 std::vector<CWalletTx*> txs{&wtx};
1114
1115 TxStateInactive inactive_state = TxStateInactive{/*abandoned=*/true};
1116
1117 while (!txs.empty()) {
1118 CWalletTx* desc_tx = txs.back();
1119 txs.pop_back();
1121 // Break caches since we have changed the state
1122 desc_tx->MarkDirty();
1123 batch.WriteTxMetadata(*desc_tx);
1124 MarkInputsDirty(desc_tx->GetTx());
1125 for (unsigned int i = 0; i < desc_tx->GetTx()->vout.size(); ++i) {
1126 COutPoint outpoint(desc_tx->GetHash(), i);
1127 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(outpoint);
1128 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
1129 const auto wit = mapWallet.find(it->second);
1130 if (wit != mapWallet.end()) {
1131 txs.push_back(&wit->second);
1132 }
1133 }
1134 }
1135 }
1136 }
1137
1139 std::string status{"no-change"};
1140 if (fInsertedNew || fUpdated) {
1141 status = fInsertedNew ? (fUpdated ? "new, update" : "new") : "update";
1142 }
1143 WalletLogPrintf("AddToWallet %s %s %s", hash.ToString(), status, TxStateString(state));
1144
1145 // Break debit/credit balance caches:
1146 wtx.MarkDirty();
1147
1148 // Cache the outputs that belong to the wallet
1149 RefreshTXOsFromTx(wtx);
1150
1151 // Notify UI of new or updated transaction
1153
1154#if HAVE_SYSTEM
1155 // notify an external script when a wallet transaction comes in or is updated
1156 std::string strCmd = m_notify_tx_changed_script;
1157
1158 if (!strCmd.empty())
1159 {
1160 ReplaceAll(strCmd, "%s", hash.GetHex());
1161 if (auto* conf = wtx.state<TxStateConfirmed>())
1162 {
1163 ReplaceAll(strCmd, "%b", conf->confirmed_block_hash.GetHex());
1164 ReplaceAll(strCmd, "%h", ToString(conf->confirmed_block_height));
1165 } else {
1166 ReplaceAll(strCmd, "%b", "unconfirmed");
1167 ReplaceAll(strCmd, "%h", "-1");
1168 }
1169#ifndef WIN32
1170 // Substituting the wallet name isn't currently supported on windows
1171 // because windows shell escaping has not been implemented yet:
1172 // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
1173 // A few ways it could be implemented in the future are described in:
1174 // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
1175 ReplaceAll(strCmd, "%w", ShellEscape(GetName()));
1176#endif
1177 std::thread t(runCommand, strCmd);
1178 t.detach(); // thread runs free
1179 }
1180#endif
1181
1182 return &wtx;
1183}
1184
1186{
1187 const auto& ins = mapWallet.emplace(wtx_in.GetHash(), std::move(wtx_in));
1188 CWalletTx& wtx = ins.first->second;
1189 if (!ins.second) {
1190 return false;
1191 }
1192 // If wallet doesn't have a chain (e.g when using bitcoin-wallet tool),
1193 // don't bother to update txn.
1194 if (HaveChain()) {
1195 wtx.updateState(chain());
1196 }
1197 wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
1198 AddToSpends(wtx);
1199 for (const CTxIn& txin : wtx.GetTx()->vin) {
1200 auto it = mapWallet.find(txin.prevout.hash);
1201 if (it != mapWallet.end()) {
1202 CWalletTx& prevtx = it->second;
1203 if (auto* prev = prevtx.state<TxStateBlockConflicted>()) {
1204 MarkConflicted(prev->conflicting_block_hash, prev->conflicting_block_height, wtx.GetHash());
1205 }
1206 }
1207 }
1208
1209 // Update birth time when tx time is older than it.
1211
1212 // Make sure the tx outputs are known by the wallet
1213 RefreshTXOsFromTx(wtx);
1214 return true;
1215}
1216
1218{
1219 const CTransaction& tx = *ptx;
1220 {
1222
1223 if (auto* conf = std::get_if<TxStateConfirmed>(&state)) {
1224 for (const CTxIn& txin : tx.vin) {
1225 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(txin.prevout);
1226 while (range.first != range.second) {
1227 if (range.first->second != tx.GetHash()) {
1228 WalletLogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)", tx.GetHash().ToString(), conf->confirmed_block_hash.ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);
1229 MarkConflicted(conf->confirmed_block_hash, conf->confirmed_block_height, range.first->second);
1230 }
1231 range.first++;
1232 }
1233 }
1234 }
1235
1236 bool fExisted = mapWallet.contains(tx.GetHash());
1237 if (fExisted || IsMine(tx) || IsFromMe(tx))
1238 {
1239 /* Check if any keys in the wallet keypool that were supposed to be unused
1240 * have appeared in a new transaction. If so, remove those keys from the keypool.
1241 * This can happen when restoring an old wallet backup that does not contain
1242 * the mostly recently created transactions from newer versions of the wallet.
1243 */
1244
1245 // loop though all outputs
1246 for (const CTxOut& txout: tx.vout) {
1247 for (const auto& spk_man : GetScriptPubKeyMans(txout.scriptPubKey)) {
1248 for (auto &dest : spk_man->MarkUnusedAddresses(txout.scriptPubKey)) {
1249 // If internal flag is not defined try to infer it from the ScriptPubKeyMan
1250 if (!dest.internal.has_value()) {
1251 dest.internal = IsInternalScriptPubKeyMan(spk_man);
1252 }
1253
1254 // skip if can't determine whether it's a receiving address or not
1255 if (!dest.internal.has_value()) continue;
1256
1257 // If this is a receiving address and it's not in the address book yet
1258 // (e.g. it wasn't generated on this node or we're restoring from backup)
1259 // add it to the address book for proper transaction accounting
1260 if (!*dest.internal && !FindAddressBookEntry(dest.dest, /* allow_change= */ false)) {
1262 }
1263 }
1264 }
1265 }
1266
1267 // Block disconnection override an abandoned tx as unconfirmed
1268 // which means user may have to call abandontransaction again
1269 TxState tx_state = std::visit([](auto&& s) -> TxState { return s; }, state);
1270 CWalletTx* wtx = AddToWallet(MakeTransactionRef(tx), tx_state, /*update_wtx=*/nullptr, rescanning_old_block);
1271 if (!wtx) {
1272 // Can only be nullptr if there was a db write error (missing db, read-only db or a db engine internal writing error).
1273 // As we only store arriving transaction in this process, and we don't want an inconsistent state, let's throw an error.
1274 throw std::runtime_error("DB error adding transaction to wallet, write failed");
1275 }
1276 return true;
1277 }
1278 }
1279 return false;
1280}
1281
1283{
1284 LOCK(cs_wallet);
1285 const CWalletTx* wtx = GetWalletTx(hashTx);
1286 return wtx && !wtx->isAbandoned() && GetTxDepthInMainChain(*wtx) == 0 && !wtx->InMempool();
1287}
1288
1290{
1291 // Find all other txs in our wallet that spend utxos from this parent
1292 // so that we can mark them as mempool-conflicted by this new tx.
1293 for (long unsigned int i = 0; i < parent_wtx.GetTx()->vout.size(); i++) {
1294 for (auto range = mapTxSpends.equal_range(COutPoint(parent_wtx.GetTx()->GetHash(), i)); range.first != range.second; range.first++) {
1295 const Txid& sibling_txid = range.first->second;
1296 // Skip the child_tx itself
1297 if (sibling_txid == child_txid) continue;
1298 RecursiveUpdateTxState(/*batch=*/nullptr, sibling_txid, [&child_txid, add_conflict](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1299 return add_conflict ? (wtx.mempool_conflicts.insert(child_txid).second ? TxUpdate::CHANGED : TxUpdate::UNCHANGED)
1300 : (wtx.mempool_conflicts.erase(child_txid) ? TxUpdate::CHANGED : TxUpdate::UNCHANGED);
1301 });
1302 }
1303 }
1304}
1305
1307{
1308 for (const CTxIn& txin : tx->vin) {
1309 auto it = mapWallet.find(txin.prevout.hash);
1310 if (it != mapWallet.end()) {
1311 it->second.MarkDirty();
1312 }
1313 }
1314}
1315
1317{
1318 LOCK(cs_wallet);
1319 auto it = mapWallet.find(hashTx);
1320 assert(it != mapWallet.end());
1321 return AbandonTransaction(it->second);
1322}
1323
1325{
1326 // Can't mark abandoned if confirmed or in mempool
1327 if (GetTxDepthInMainChain(tx) != 0 || tx.InMempool()) {
1328 return false;
1329 }
1330
1332 // If the orig tx was not in block/mempool, none of its spends can be.
1333 assert(!wtx.isConfirmed());
1334 assert(!wtx.InMempool());
1335 // If already conflicted or abandoned, no need to set abandoned
1336 if (!wtx.isBlockConflicted() && !wtx.isAbandoned()) {
1337 wtx.m_state = TxStateInactive{/*abandoned=*/true};
1339 }
1340 return TxUpdate::UNCHANGED;
1341 };
1342
1343 // Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too.
1344 // States are not permanent, so these transactions can become unabandoned if they are re-added to the
1345 // mempool, or confirmed in a block, or conflicted.
1346 // Note: If the reorged coinbase is re-added to the main chain, the descendants that have not had their
1347 // states change will remain abandoned and will require manual broadcast if the user wants them.
1348
1350
1351 return true;
1352}
1353
1355{
1356 LOCK(cs_wallet);
1357
1358 // If number of conflict confirms cannot be determined, this means
1359 // that the block is still unknown or not yet part of the main chain,
1360 // for example when loading the wallet during a reindex. Do nothing in that
1361 // case.
1363 return;
1364 }
1366 if (conflictconfirms >= 0)
1367 return;
1368
1371 // Block is 'more conflicted' than current confirm; update.
1372 // Mark transaction as conflicted with this block.
1373 wtx.m_state = TxStateBlockConflicted{hashBlock, conflicting_height};
1374 return TxUpdate::CHANGED;
1375 }
1376 return TxUpdate::UNCHANGED;
1377 };
1378
1379 // Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too.
1381
1382}
1383
1388
1390 std::set<Txid> todo;
1391 std::set<Txid> done;
1392
1393 todo.insert(tx_hash);
1394
1395 while (!todo.empty()) {
1396 Txid now = *todo.begin();
1397 todo.erase(now);
1398 done.insert(now);
1399 auto it = mapWallet.find(now);
1400 assert(it != mapWallet.end());
1401 CWalletTx& wtx = it->second;
1402
1405 wtx.MarkDirty();
1406 if (batch) batch->WriteTxMetadata(wtx);
1407 // Iterate over all its outputs, and update those tx states as well (if applicable)
1408 for (unsigned int i = 0; i < wtx.GetTx()->vout.size(); ++i) {
1409 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(COutPoint(now, i));
1410 for (TxSpends::const_iterator iter = range.first; iter != range.second; ++iter) {
1411 if (!done.contains(iter->second)) {
1412 todo.insert(iter->second);
1413 }
1414 }
1415 }
1416
1419 }
1420
1421 // If a transaction changes its tx state, that usually changes the balance
1422 // available of the outputs it spends. So force those to be recomputed
1423 MarkInputsDirty(wtx.GetTx());
1424 }
1425 }
1426}
1427
1429{
1431 return false; // Not one of ours
1432
1433 // If a transaction changes 'conflicted' state, that changes the balance
1434 // available of the outputs it spends. So force those to be
1435 // recomputed, also:
1437 return true;
1438}
1439
1441 LOCK(cs_wallet);
1443
1444 auto it = mapWallet.find(tx->GetHash());
1445 if (it != mapWallet.end()) {
1446 RefreshMempoolStatus(it->second, chain());
1447 }
1448
1449 const Txid& txid = tx->GetHash();
1450
1451 for (const CTxIn& tx_in : tx->vin) {
1452 // For each wallet transaction spending this prevout..
1453 for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1454 const Txid& spent_id = range.first->second;
1455 // Skip the recently added tx
1456 if (spent_id == txid) continue;
1459 });
1460 }
1461
1462 }
1463
1464 if (tx->version == TRUC_VERSION) {
1465 // Unconfirmed TRUC transactions are only allowed a 1-parent-1-child topology.
1466 // For any unconfirmed v3 parents (there should be a maximum of 1 except in reorgs),
1467 // record this child so the wallet doesn't try to spend any other outputs
1468 for (const CTxIn& tx_in : tx->vin) {
1469 auto parent_it = mapWallet.find(tx_in.prevout.hash);
1470 if (parent_it != mapWallet.end()) {
1471 CWalletTx& parent_wtx = parent_it->second;
1472 if (parent_wtx.isUnconfirmed()) {
1473 parent_wtx.truc_child_in_mempool = tx->GetHash();
1474 // Even though these siblings do not spend the same utxos, they can't
1475 // be present in the mempool at the same time because of TRUC policy rules
1476 UpdateTrucSiblingConflicts(parent_wtx, txid, /*add_conflict=*/true);
1477 }
1478 }
1479 }
1480 }
1481}
1482
1484 LOCK(cs_wallet);
1485 auto it = mapWallet.find(tx->GetHash());
1486 if (it != mapWallet.end()) {
1487 RefreshMempoolStatus(it->second, chain());
1488 }
1489 // Handle transactions that were removed from the mempool because they
1490 // conflict with transactions in a newly connected block.
1491 if (reason == MemPoolRemovalReason::CONFLICT) {
1492 // Trigger external -walletnotify notifications for these transactions.
1493 // Set Status::UNCONFIRMED instead of Status::CONFLICTED for a few reasons:
1494 //
1495 // 1. The transactionRemovedFromMempool callback does not currently
1496 // provide the conflicting block's hash and height, and for backwards
1497 // compatibility reasons it may not be not safe to store conflicted
1498 // wallet transactions with a null block hash. See
1499 // https://github.com/bitcoin/bitcoin/pull/18600#discussion_r420195993.
1500 // 2. For most of these transactions, the wallet's internal conflict
1501 // detection in the blockConnected handler will subsequently call
1502 // MarkConflicted and update them with CONFLICTED status anyway. This
1503 // applies to any wallet transaction that has inputs spent in the
1504 // block, or that has ancestors in the wallet with inputs spent by
1505 // the block.
1506 // 3. Longstanding behavior since the sync implementation in
1507 // https://github.com/bitcoin/bitcoin/pull/9371 and the prior sync
1508 // implementation before that was to mark these transactions
1509 // unconfirmed rather than conflicted.
1510 //
1511 // Nothing described above should be seen as an unchangeable requirement
1512 // when improving this code in the future. The wallet's heuristics for
1513 // distinguishing between conflicted and unconfirmed transactions are
1514 // imperfect, and could be improved in general, see
1515 // https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Transaction-Conflict-Tracking
1517 }
1518
1519 const Txid& txid = tx->GetHash();
1520
1521 for (const CTxIn& tx_in : tx->vin) {
1522 // Iterate over all wallet transactions spending txin.prev
1523 // and recursively mark them as no longer conflicting with
1524 // txid
1525 for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1526 const Txid& spent_id = range.first->second;
1527
1529 return wtx.mempool_conflicts.erase(txid) ? TxUpdate::CHANGED : TxUpdate::UNCHANGED;
1530 });
1531 }
1532 }
1533
1534 if (tx->version == TRUC_VERSION) {
1535 // If this tx has a parent, unset its truc_child_in_mempool to make it possible
1536 // to spend from the parent again. If this tx was replaced by another
1537 // child of the same parent, transactionAddedToMempool
1538 // will update truc_child_in_mempool
1539 for (const CTxIn& tx_in : tx->vin) {
1540 auto parent_it = mapWallet.find(tx_in.prevout.hash);
1541 if (parent_it != mapWallet.end()) {
1542 CWalletTx& parent_wtx = parent_it->second;
1543 if (parent_wtx.truc_child_in_mempool == tx->GetHash()) {
1544 parent_wtx.truc_child_in_mempool = std::nullopt;
1545 UpdateTrucSiblingConflicts(parent_wtx, txid, /*add_conflict=*/false);
1546 }
1547 }
1548 }
1549 }
1550}
1551
1553{
1554 if (role.historical) {
1555 return;
1556 }
1557 assert(block.data);
1558 LOCK(cs_wallet);
1559
1560 // Update the best block in memory first. This will set the best block's height, which is
1561 // needed by MarkConflicted.
1563
1564 // No need to scan block if it was created before the wallet birthday.
1565 // Uses chain max time and twice the grace period to adjust time for block time variability.
1566 if (block.chain_time_max < m_birth_time.load() - (TIMESTAMP_WINDOW * 2)) return;
1567
1568 // Scan block
1569 bool wallet_updated = false;
1570 for (size_t index = 0; index < block.data->vtx.size(); index++) {
1571 wallet_updated |= SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)});
1573 }
1574
1575 // Update on disk if this block resulted in us updating a tx, or periodically every 144 blocks (~1 day)
1576 if (wallet_updated || block.height % 144 == 0) {
1578 }
1579}
1580
1582{
1583 assert(block.data);
1584 LOCK(cs_wallet);
1585
1586 // At block disconnection, this will change an abandoned transaction to
1587 // be unconfirmed, whether or not the transaction is added back to the mempool.
1588 // User may have to call abandontransaction again. It may be addressed in the
1589 // future with a stickier abandoned state or even removing abandontransaction call.
1590 int disconnect_height = block.height;
1591
1592 for (size_t index = 0; index < block.data->vtx.size(); index++) {
1593 const CTransactionRef& ptx = block.data->vtx[index];
1594 // Coinbase transactions are not only inactive but also abandoned,
1595 // meaning they should never be relayed standalone via the p2p protocol.
1596 SyncTransaction(ptx, TxStateInactive{/*abandoned=*/index == 0});
1597
1598 for (const CTxIn& tx_in : ptx->vin) {
1599 // No other wallet transactions conflicted with this transaction
1600 if (!mapTxSpends.contains(tx_in.prevout)) continue;
1601
1602 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(tx_in.prevout);
1603
1604 // For all of the spends that conflict with this transaction
1605 for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {
1606 CWalletTx& wtx = mapWallet.find(_it->second)->second;
1607
1608 if (!wtx.isBlockConflicted()) continue;
1609
1610 auto try_updating_state = [&](CWalletTx& tx) {
1611 if (!tx.isBlockConflicted()) return TxUpdate::UNCHANGED;
1613 tx.m_state = TxStateInactive{};
1614 return TxUpdate::CHANGED;
1615 }
1616 return TxUpdate::UNCHANGED;
1617 };
1618
1620 }
1621 }
1622 }
1623
1624 // Update the best block
1625 SetLastBlockProcessed(block.height - 1, *Assert(block.prev_hash));
1626}
1627
1632
1633void CWallet::BlockUntilSyncedToCurrentChain() const {
1635 // Skip the queue-draining stuff if we know we're caught up with
1636 // chain().Tip(), otherwise put a callback in the validation interface queue and wait
1637 // for the queue to drain enough to execute it (indicating we are caught up
1638 // at least with the time we entered this function).
1641}
1642
1643// Note that this function doesn't distinguish between a 0-valued input,
1644// and a not-"is mine" input.
1646{
1647 LOCK(cs_wallet);
1648 auto txo = GetTXO(txin.prevout);
1649 if (txo) {
1650 return txo->GetTxOut().nValue;
1651 }
1652 return 0;
1653}
1654
1655bool CWallet::IsMine(const CTxOut& txout) const
1656{
1658 return IsMine(txout.scriptPubKey);
1659}
1660
1661bool CWallet::IsMine(const CTxDestination& dest) const
1662{
1664 return IsMine(GetScriptForDestination(dest));
1665}
1666
1668{
1670
1671 // Search the cache so that IsMine is called only on the relevant SPKMs instead of on everything in m_spk_managers
1672 const auto& it = m_cached_spks.find(script);
1673 if (it != m_cached_spks.end()) {
1674 bool res = false;
1675 for (const auto& spkm : it->second) {
1676 res = res || spkm->IsMine(script);
1677 }
1678 Assume(res);
1679 return res;
1680 }
1681
1682 return false;
1683}
1684
1685bool CWallet::IsMine(const CTransaction& tx) const
1686{
1688 for (const CTxOut& txout : tx.vout)
1689 if (IsMine(txout))
1690 return true;
1691 return false;
1692}
1693
1694bool CWallet::IsMine(const COutPoint& outpoint) const
1695{
1697 auto wtx = GetWalletTx(outpoint.hash);
1698 if (!wtx) {
1699 return false;
1700 }
1701 if (outpoint.n >= wtx->GetTx()->vout.size()) {
1702 return false;
1703 }
1704 return IsMine(wtx->GetTx()->vout[outpoint.n]);
1705}
1706
1707bool CWallet::IsFromMe(const CTransaction& tx) const
1708{
1709 LOCK(cs_wallet);
1710 for (const CTxIn& txin : tx.vin) {
1711 if (GetTXO(txin.prevout)) return true;
1712 }
1713 return false;
1714}
1715
1717{
1718 CAmount nDebit = 0;
1719 for (const CTxIn& txin : tx.vin)
1720 {
1721 nDebit += GetDebit(txin);
1722 if (!MoneyRange(nDebit))
1723 throw std::runtime_error(std::string(__func__) + ": value out of range");
1724 }
1725 return nDebit;
1726}
1727
1729{
1730 // All Active ScriptPubKeyMans must be HD for this to be true
1731 bool result = false;
1732 for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
1733 if (!spk_man->IsHDEnabled()) return false;
1734 result = true;
1735 }
1736 return result;
1737}
1738
1739bool CWallet::CanGetAddresses(bool internal) const
1740{
1741 LOCK(cs_wallet);
1742 if (m_spk_managers.empty()) return false;
1743 for (OutputType t : OUTPUT_TYPES) {
1744 auto spk_man = GetScriptPubKeyMan(t, internal);
1745 if (spk_man && spk_man->CanGetAddresses(internal)) {
1746 return true;
1747 }
1748 }
1749 return false;
1750}
1751
1753{
1754 WalletBatch batch(GetDatabase());
1755 return SetWalletFlagWithDB(batch, flags);
1756}
1757
1759{
1760 LOCK(cs_wallet);
1762 if (!batch.WriteWalletFlags(m_wallet_flags))
1763 throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1764}
1765
1767{
1768 WalletBatch batch(GetDatabase());
1769 UnsetWalletFlagWithDB(batch, flag);
1770}
1771
1773{
1774 LOCK(cs_wallet);
1776 if (!batch.WriteWalletFlags(m_wallet_flags))
1777 throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1778}
1779
1784
1786{
1787 return (m_wallet_flags & flag);
1788}
1789
1791{
1792 LOCK(cs_wallet);
1793 if (((flags & KNOWN_WALLET_FLAGS) >> 32) ^ (flags >> 32)) {
1794 // contains unknown non-tolerable wallet flags
1795 return false;
1796 }
1798
1799 return true;
1800}
1801
1803{
1804 LOCK(cs_wallet);
1805
1806 // We should never be writing unknown non-tolerable wallet flags
1807 assert(((flags & KNOWN_WALLET_FLAGS) >> 32) == (flags >> 32));
1808 // This should only be used once, when creating a new wallet - so current flags are expected to be blank
1809 assert(m_wallet_flags == 0);
1810
1811 if (!WalletBatch(GetDatabase()).WriteWalletFlags(flags)) {
1812 throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1813 }
1814
1815 if (!LoadWalletFlags(flags)) assert(false);
1816}
1817
1819{
1820 return m_wallet_flags;
1821}
1822
1824{
1826 if (time < birthtime) {
1827 m_birth_time = time;
1828 }
1829}
1830
1832 std::string& err_string,
1834{
1836
1837 // Can't relay if wallet is not broadcasting
1838 if (!GetBroadcastTransactions()) return false;
1839 // Don't relay abandoned transactions
1840 if (wtx.isAbandoned()) return false;
1841 // Don't try to submit coinbase transactions. These would fail anyway but would
1842 // cause log spam.
1843 if (wtx.IsCoinBase()) return false;
1844 // Don't try to submit conflicted or confirmed transactions.
1845 if (GetTxDepthInMainChain(wtx) != 0) return false;
1846
1847 const char* what{""};
1848 switch (broadcast_method) {
1850 what = "to mempool and for broadcast to peers";
1851 break;
1853 what = "to mempool without broadcast";
1854 break;
1856 what = "for private broadcast without adding to the mempool";
1857 break;
1858 }
1859 WalletLogPrintf("Submitting wtx %s %s", wtx.GetHash().ToString(), what);
1860 // We must set TxStateInMempool here. Even though it will also be set later by the
1861 // entered-mempool callback, if we did not there would be a race where a
1862 // user could call sendmoney in a loop and hit spurious out of funds errors
1863 // because we think that this newly generated transaction's change is
1864 // unavailable as we're not yet aware that it is in the mempool.
1865 //
1866 // If broadcast fails for any reason, trying to set wtx.m_state here would be incorrect.
1867 // If transaction was previously in the mempool, it should be updated when
1868 // TransactionRemovedFromMempool fires.
1870 if (ret) wtx.m_state = TxStateInMempool{};
1871 return ret;
1872}
1873
1874std::set<Txid> CWallet::GetTxConflicts(const CWalletTx& wtx) const
1875{
1877
1878 const Txid myHash{wtx.GetHash()};
1879 std::set<Txid> result{GetConflicts(myHash)};
1880 result.erase(myHash);
1881 return result;
1882}
1883
1885{
1886 // Don't attempt to resubmit if the wallet is configured to not broadcast
1887 if (!fBroadcastTransactions) return false;
1888
1889 // During reindex, importing and IBD, old wallet transactions become
1890 // unconfirmed. Don't resend them as that would spam other nodes.
1891 // We only allow forcing mempool submission when not relaying to avoid this spam.
1892 if (!chain().isReadyToBroadcast()) return false;
1893
1894 // Do this infrequently and randomly to avoid giving away
1895 // that these are our transactions.
1896 if (NodeClock::now() < m_next_resend) return false;
1897
1898 return true;
1899}
1900
1902
1903// Resubmit transactions from the wallet to the mempool, optionally asking the
1904// mempool to relay them. On startup, we will do this for all unconfirmed
1905// transactions but will not ask the mempool to relay them. We do this on startup
1906// to ensure that our own mempool is aware of our transactions. There
1907// is a privacy side effect here as not broadcasting on startup also means that we won't
1908// inform the world of our wallet's state, particularly if the wallet (or node) is not
1909// yet synced.
1910//
1911// Otherwise this function is called periodically in order to relay our unconfirmed txs.
1912// We do this on a random timer to slightly obfuscate which transactions
1913// come from our wallet.
1914//
1915// TODO: Ideally, we'd only resend transactions that we think should have been
1916// mined in the most recent block. Any transaction that wasn't in the top
1917// blockweight of transactions in the mempool shouldn't have been mined,
1918// and so is probably just sitting in the mempool waiting to be confirmed.
1919// Rebroadcasting does nothing to speed up confirmation and only damages
1920// privacy.
1921//
1922// The `force` option results in all unconfirmed transactions being submitted to
1923// the mempool. This does not necessarily result in those transactions being relayed,
1924// that depends on the `broadcast_method` option. Periodic rebroadcast uses the pattern
1925// broadcast_method=TxBroadcast::MEMPOOL_AND_BROADCAST_TO_ALL force=false, while loading into
1926// the mempool (on start, or after import) uses
1927// broadcast_method=TxBroadcast::MEMPOOL_NO_BROADCAST force=true.
1929{
1930 // Don't attempt to resubmit if the wallet is configured to not broadcast,
1931 // even if forcing.
1932 if (!fBroadcastTransactions) return;
1933
1934 int submitted_tx_count = 0;
1935
1936 { // cs_wallet scope
1937 LOCK(cs_wallet);
1938
1939 // First filter for the transactions we want to rebroadcast.
1940 // We use a set with WalletTxOrderComparator so that rebroadcasting occurs in insertion order
1941 std::set<CWalletTx*, WalletTxOrderComparator> to_submit;
1942 for (auto& [txid, wtx] : mapWallet) {
1943 // Only rebroadcast unconfirmed txs
1944 if (!wtx.isUnconfirmed()) continue;
1945
1946 // Attempt to rebroadcast all txes more than 5 minutes older than
1947 // the last block, or all txs if forcing.
1948 if (!force && wtx.nTimeReceived > m_best_block_time - 5 * 60) continue;
1949 to_submit.insert(&wtx);
1950 }
1951 // Now try submitting the transactions to the memory pool and (optionally) relay them.
1952 for (auto wtx : to_submit) {
1953 std::string unused_err_string;
1955 }
1956 } // cs_wallet
1957
1958 if (submitted_tx_count > 0) {
1959 WalletLogPrintf("%s: resubmit %u unconfirmed transactions", __func__, submitted_tx_count);
1960 }
1961}
1962
// end of mapWallet
1964
1966{
1967 for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
1968 if (!pwallet->ShouldResend()) continue;
1969 pwallet->ResubmitWalletTransactions(node::TxBroadcast::MEMPOOL_AND_BROADCAST_TO_ALL, /*force=*/false);
1970 pwallet->SetNextResend();
1971 }
1972}
1973
1974
1976{
1978
1979 // Build coins map
1980 std::map<COutPoint, Coin> coins;
1981 for (auto& input : tx.vin) {
1982 const auto mi = mapWallet.find(input.prevout.hash);
1983 if(mi == mapWallet.end() || input.prevout.n >= mi->second.GetTx()->vout.size()) {
1984 return false;
1985 }
1986 const CWalletTx& wtx = mi->second;
1988 coins[input.prevout] = Coin(wtx.GetTx()->vout[input.prevout.n], prev_height, wtx.IsCoinBase());
1989 }
1990 std::map<int, bilingual_str> input_errors;
1991 return SignTransaction(tx, coins, SIGHASH_DEFAULT, input_errors);
1992}
1993
1994bool CWallet::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
1995{
1996 // Try to sign with all ScriptPubKeyMans
1998 // spk_man->SignTransaction will return true if the transaction is complete,
1999 // so we can exit early and return true if that happens
2000 if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
2001 return true;
2002 }
2003 }
2004
2005 // At this point, one input was not fully signed otherwise we would have exited already
2006 return false;
2007}
2008
2009std::optional<PSBTError> CWallet::FillPSBT(PartiallySignedTransaction& psbtx, const common::PSBTFillOptions& options, bool& complete, size_t* n_signed) const
2010{
2011 if (n_signed) {
2012 *n_signed = 0;
2013 }
2014 LOCK(cs_wallet);
2015 // Get all of the previous transactions
2016 for (PSBTInput& input : psbtx.inputs) {
2017 if (PSBTInputSigned(input)) {
2018 continue;
2019 }
2020
2021 // If we have no utxo, grab it from the wallet.
2022 if (!input.non_witness_utxo) {
2023 const Txid& txhash = input.prev_txid;
2024 const auto it = mapWallet.find(txhash);
2025 if (it != mapWallet.end()) {
2026 const CWalletTx& wtx = it->second;
2027 // We only need the non_witness_utxo, which is a superset of the witness_utxo.
2028 // The signing code will switch to the smaller witness_utxo if this is ok.
2029 input.non_witness_utxo = wtx.GetTx();
2030 }
2031 }
2032 }
2033
2034 std::optional<PrecomputedTransactionData> txdata_res = PrecomputePSBTData(psbtx);
2035 if (!txdata_res) {
2036 return PSBTError::INVALID_TX;
2037 }
2038 const PrecomputedTransactionData& txdata = *txdata_res;
2039
2040 // Fill in information from ScriptPubKeyMans
2042 int n_signed_this_spkm = 0;
2043 const auto error{spk_man->FillPSBT(psbtx, txdata, options, &n_signed_this_spkm)};
2044 if (error) {
2045 return error;
2046 }
2047
2048 if (n_signed) {
2049 (*n_signed) += n_signed_this_spkm;
2050 }
2051 }
2052
2054
2055 // Complete if every input is now signed
2056 complete = true;
2057 for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
2058 complete &= PSBTInputSignedAndVerified(psbtx, i, &txdata);
2059 }
2060
2061 return {};
2062}
2063
2064SigningResult CWallet::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
2065{
2066 SignatureData sigdata;
2068 for (const auto& spk_man_pair : m_spk_managers) {
2069 if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
2070 LOCK(cs_wallet); // DescriptorScriptPubKeyMan calls IsLocked which can lock cs_wallet in a deadlocking order
2071 return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
2072 }
2073 }
2075}
2076
2077OutputType CWallet::TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const
2078{
2079 // If -changetype is specified, always use that change type.
2080 if (change_type) {
2081 return *change_type;
2082 }
2083
2084 // if m_default_address_type is legacy, use legacy address as change.
2086 return OutputType::LEGACY;
2087 }
2088
2089 bool any_tr{false};
2090 bool any_wpkh{false};
2091 bool any_sh{false};
2092 bool any_pkh{false};
2093
2094 for (const auto& recipient : vecSend) {
2095 if (std::get_if<WitnessV1Taproot>(&recipient.dest)) {
2096 any_tr = true;
2097 } else if (std::get_if<WitnessV0KeyHash>(&recipient.dest)) {
2098 any_wpkh = true;
2099 } else if (std::get_if<ScriptHash>(&recipient.dest)) {
2100 any_sh = true;
2101 } else if (std::get_if<PKHash>(&recipient.dest)) {
2102 any_pkh = true;
2103 }
2104 }
2105
2106 const bool has_bech32m_spkman(GetScriptPubKeyMan(OutputType::BECH32M, /*internal=*/true));
2107 if (has_bech32m_spkman && any_tr) {
2108 // Currently tr is the only type supported by the BECH32M spkman
2109 return OutputType::BECH32M;
2110 }
2111 const bool has_bech32_spkman(GetScriptPubKeyMan(OutputType::BECH32, /*internal=*/true));
2112 if (has_bech32_spkman && any_wpkh) {
2113 // Currently wpkh is the only type supported by the BECH32 spkman
2114 return OutputType::BECH32;
2115 }
2118 // Currently sh_wpkh is the only type supported by the P2SH_SEGWIT spkman
2119 // As of 2021 about 80% of all SH are wrapping WPKH, so use that
2121 }
2122 const bool has_legacy_spkman(GetScriptPubKeyMan(OutputType::LEGACY, /*internal=*/true));
2123 if (has_legacy_spkman && any_pkh) {
2124 // Currently pkh is the only type supported by the LEGACY spkman
2125 return OutputType::LEGACY;
2126 }
2127
2128 if (has_bech32m_spkman) {
2129 return OutputType::BECH32M;
2130 }
2131 if (has_bech32_spkman) {
2132 return OutputType::BECH32;
2133 }
2134 // else use m_default_address_type for change
2136}
2137
2139 CTransactionRef tx,
2140 std::optional<Txid> replaces_txid,
2141 std::optional<std::string> comment,
2142 std::optional<std::string> comment_to,
2143 const std::vector<std::string>& messages,
2144 const std::vector<std::string>& payment_requests
2145)
2146{
2147 LOCK(cs_wallet);
2148 WalletLogPrintf("CommitTransaction:\n%s", util::RemoveSuffixView(tx->ToString(), "\n"));
2149
2150 // Add tx to wallet, because if it has change it's also ours,
2151 // otherwise just for transaction history.
2152 CWalletTx* wtx = AddToWallet(tx, TxStateInactive{}, [&](CWalletTx& wtx, bool new_tx) {
2153 if (replaces_txid) wtx.m_replaces_txid = replaces_txid;
2154 if (comment) wtx.m_comment = comment;
2155 if (comment_to) wtx.m_comment_to = comment_to;
2156 if (!messages.empty()) wtx.m_messages = messages;
2158 return true;
2159 });
2160
2161 // wtx can only be null if the db write failed.
2162 if (!wtx) {
2163 throw std::runtime_error(std::string(__func__) + ": Wallet db error, transaction commit failed");
2164 }
2165
2166 // Notify that old coins are spent
2167 for (const CTxIn& txin : tx->vin) {
2168 CWalletTx &coin = mapWallet.at(txin.prevout.hash);
2169 coin.MarkDirty();
2171 }
2172
2174 // Don't submit tx to the mempool
2175 return;
2176 }
2177
2178 std::string err_string;
2180 WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast immediately, %s", err_string);
2181 // TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
2182 }
2183}
2184
2185DBErrors CWallet::PopulateWalletFromDB(bilingual_str& error, std::vector<bilingual_str>& warnings)
2186{
2187 LOCK(cs_wallet);
2188
2189 Assert(m_spk_managers.empty());
2190 Assert(m_wallet_flags == 0);
2192
2193 if (m_spk_managers.empty()) {
2196 }
2197
2198 const auto wallet_file = m_database->Filename();
2199 switch (nLoadWalletRet) {
2200 case DBErrors::LOAD_OK:
2201 break;
2203 warnings.push_back(strprintf(_("Error reading %s! All keys read correctly, but transaction data"
2204 " or address metadata may be missing or incorrect."),
2205 wallet_file));
2206 break;
2208 warnings.push_back(strprintf(_("Error reading %s! Transaction data may be missing or incorrect."
2209 " Rescanning wallet."), wallet_file));
2210 break;
2211 case DBErrors::CORRUPT:
2212 error = strprintf(_("Error loading %s: Wallet corrupted"), wallet_file);
2213 break;
2214 case DBErrors::TOO_NEW:
2215 error = strprintf(_("Error loading %s: Wallet requires newer version of %s"), wallet_file, CLIENT_NAME);
2216 break;
2218 error = strprintf(_("Error loading %s: External signer wallet being loaded without external signer support compiled"), wallet_file);
2219 break;
2221 error = strprintf(_("Unrecognized descriptor found. Loading wallet %s\n\n"
2222 "The wallet might have been created on a newer version.\n"
2223 "Please try running the latest software version.\n"), wallet_file);
2224 break;
2226 error = strprintf(_("Unexpected legacy entry in descriptor wallet found. Loading wallet %s\n\n"
2227 "The wallet might have been tampered with or created with malicious intent.\n"), wallet_file);
2228 break;
2230 error = strprintf(_("Error loading %s: Wallet is a legacy wallet. Please migrate to a descriptor wallet using the migration tool (migratewallet RPC)."), wallet_file);
2231 break;
2233 error = strprintf(_("Error loading %s"), wallet_file);
2234 break;
2235 } // no default case, so the compiler can warn about missing cases
2236 return nLoadWalletRet;
2237}
2238
2240{
2242 bilingual_str str_err; // future: make RunWithinTxn return a util::Result
2243 bool was_txn_committed = RunWithinTxn(GetDatabase(), /*process_desc=*/"remove transactions", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
2245 if (!result) str_err = util::ErrorString(result);
2246 return result.has_value();
2247 });
2248 if (!str_err.empty()) return util::Error{str_err};
2249 if (!was_txn_committed) return util::Error{_("Error starting/committing db txn for wallet transactions removal process")};
2250 return {}; // all good
2251}
2252
2254{
2256 if (!batch.HasActiveTxn()) return util::Error{strprintf(_("The transactions removal process can only be executed within a db txn"))};
2257
2258 // Check for transaction existence and remove entries from disk
2259 std::vector<decltype(mapWallet)::const_iterator> erased_txs;
2261 for (const Txid& hash : txs_to_remove) {
2262 auto it_wtx = mapWallet.find(hash);
2263 if (it_wtx == mapWallet.end()) {
2264 return util::Error{strprintf(_("Transaction %s does not belong to this wallet"), hash.GetHex())};
2265 }
2266 if (!batch.EraseTx(hash)) {
2267 return util::Error{strprintf(_("Failure removing transaction: %s"), hash.GetHex())};
2268 }
2269 erased_txs.emplace_back(it_wtx);
2270 }
2271
2272 // Register callback to update the memory state only when the db txn is actually dumped to disk
2274 // Update the in-memory state and notify upper layers about the removals
2275 for (const auto& it : erased_txs) {
2276 const Txid hash{it->first};
2277 wtxOrdered.erase(it->second.m_it_wtxOrdered);
2278 for (const auto& txin : it->second.GetTx()->vin) {
2279 auto range = mapTxSpends.equal_range(txin.prevout);
2280 for (auto iter = range.first; iter != range.second; ++iter) {
2281 if (iter->second == hash) {
2282 mapTxSpends.erase(iter);
2283 break;
2284 }
2285 }
2286 }
2287 for (unsigned int i = 0; i < it->second.GetTx()->vout.size(); ++i) {
2288 m_txos.erase(COutPoint(hash, i));
2289 }
2290 mapWallet.erase(it);
2292 }
2293
2294 MarkDirty();
2295 }, .on_abort={}});
2296
2297 return {};
2298}
2299
2301{
2303 mapWallet.clear();
2304 wtxOrdered.clear();
2305 mapTxSpends.clear();
2306 m_txos.clear();
2307 m_locked_coins.clear();
2308 nOrderPosNext = 0;
2309}
2310
2311bool CWallet::SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& new_purpose)
2312{
2313 bool fUpdated = false;
2314 bool is_mine;
2315 std::optional<AddressPurpose> purpose;
2316 {
2317 LOCK(cs_wallet);
2318 std::map<CTxDestination, CAddressBookData>::iterator mi = m_address_book.find(address);
2319 fUpdated = mi != m_address_book.end() && !mi->second.IsChange();
2320
2321 CAddressBookData& record = mi != m_address_book.end() ? mi->second : m_address_book[address];
2323 is_mine = IsMine(address);
2324 if (new_purpose) { /* update purpose only if requested */
2325 record.purpose = new_purpose;
2326 }
2327 purpose = record.purpose;
2328 }
2329
2330 const std::string& encoded_dest = EncodeDestination(address);
2332 WalletLogPrintf("Error: fail to write address book 'purpose' entry");
2333 return false;
2334 }
2335 if (!batch.WriteName(encoded_dest, strName)) {
2336 WalletLogPrintf("Error: fail to write address book 'name' entry");
2337 return false;
2338 }
2339
2340 // In very old wallets, address purpose may not be recorded so we derive it from IsMine
2341 NotifyAddressBookChanged(address, strName, is_mine,
2342 purpose.value_or(is_mine ? AddressPurpose::RECEIVE : AddressPurpose::SEND),
2343 (fUpdated ? CT_UPDATED : CT_NEW));
2344 return true;
2345}
2346
2347bool CWallet::SetAddressBook(const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& purpose)
2348{
2349 WalletBatch batch(GetDatabase());
2350 return SetAddressBookWithDB(batch, address, strName, purpose);
2351}
2352
2354{
2355 return RunWithinTxn(GetDatabase(), /*process_desc=*/"address book entry removal", [&](WalletBatch& batch){
2356 return DelAddressBookWithDB(batch, address);
2357 });
2358}
2359
2361{
2362 const std::string& dest = EncodeDestination(address);
2363 {
2364 LOCK(cs_wallet);
2365 // If we want to delete receiving addresses, we should avoid calling EraseAddressData because it will delete the previously_spent value. Could instead just erase the label so it becomes a change address, and keep the data.
2366 // NOTE: This isn't a problem for sending addresses because they don't have any data that needs to be kept.
2367 // When adding new address data, it should be considered here whether to retain or delete it.
2368 if (IsMine(address)) {
2369 WalletLogPrintf("%s called with IsMine address, NOT SUPPORTED. Please report this bug! %s", __func__, CLIENT_BUGREPORT);
2370 return false;
2371 }
2372 // Delete data rows associated with this address
2373 if (!batch.EraseAddressData(address)) {
2374 WalletLogPrintf("Error: cannot erase address book entry data");
2375 return false;
2376 }
2377
2378 // Delete purpose entry
2379 if (!batch.ErasePurpose(dest)) {
2380 WalletLogPrintf("Error: cannot erase address book entry purpose");
2381 return false;
2382 }
2383
2384 // Delete name entry
2385 if (!batch.EraseName(dest)) {
2386 WalletLogPrintf("Error: cannot erase address book entry name");
2387 return false;
2388 }
2389
2390 // finally, remove it from the map
2391 m_address_book.erase(address);
2392 }
2393
2394 // All good, signal changes
2395 NotifyAddressBookChanged(address, "", /*is_mine=*/false, AddressPurpose::SEND, CT_DELETED);
2396 return true;
2397}
2398
2400{
2402
2403 unsigned int count = 0;
2404 for (auto spk_man : m_external_spk_managers) {
2405 count += spk_man.second->GetKeyPoolSize();
2406 }
2407
2408 return count;
2409}
2410
2411unsigned int CWallet::GetKeyPoolSize() const
2412{
2414
2415 unsigned int count = 0;
2416 for (auto spk_man : GetActiveScriptPubKeyMans()) {
2417 count += spk_man->GetKeyPoolSize();
2418 }
2419 return count;
2420}
2421
2423{
2424 LOCK(cs_wallet);
2425 bool res = true;
2426 for (auto spk_man : GetActiveScriptPubKeyMans()) {
2427 res &= spk_man->TopUp(kpSize);
2428 }
2429 return res;
2430}
2431
2433{
2434 LOCK(cs_wallet);
2435 auto spk_man = GetScriptPubKeyMan(type, /*internal=*/false);
2436 if (!spk_man) {
2437 return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
2438 }
2439
2440 auto op_dest = spk_man->GetNewDestination(type);
2441 if (op_dest) {
2443 }
2444
2445 return op_dest;
2446}
2447
2449{
2450 LOCK(cs_wallet);
2451
2452 ReserveDestination reservedest(this, type);
2453 auto op_dest = reservedest.GetReservedDestination(true);
2454 if (op_dest) reservedest.KeepDestination();
2455
2456 return op_dest;
2457}
2458
2459void CWallet::MarkDestinationsDirty(const std::set<CTxDestination>& destinations) {
2460 for (auto& entry : mapWallet) {
2461 CWalletTx& wtx = entry.second;
2462 if (wtx.m_is_cache_empty) continue;
2463 for (unsigned int i = 0; i < wtx.GetTx()->vout.size(); i++) {
2465 if (ExtractDestination(wtx.GetTx()->vout[i].scriptPubKey, dst) && destinations.contains(dst)) {
2466 wtx.MarkDirty();
2467 break;
2468 }
2469 }
2470 }
2471}
2472
2474{
2476 for (const std::pair<const CTxDestination, CAddressBookData>& item : m_address_book) {
2477 const auto& entry = item.second;
2478 func(item.first, entry.GetLabel(), entry.IsChange(), entry.purpose);
2479 }
2480}
2481
2482std::vector<CTxDestination> CWallet::ListAddrBookAddresses(const std::optional<AddrBookFilter>& _filter) const
2483{
2485 std::vector<CTxDestination> result;
2487 ForEachAddrBookEntry([&result, &filter](const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose>& purpose) {
2488 // Filter by change
2489 if (filter.ignore_change && is_change) return;
2490 // Filter by label
2491 if (filter.m_op_label && *filter.m_op_label != label) return;
2492 // All good
2493 result.emplace_back(dest);
2494 });
2495 return result;
2496}
2497
2498std::set<std::string> CWallet::ListAddrBookLabels(const std::optional<AddressPurpose> purpose) const
2499{
2501 std::set<std::string> label_set;
2502 ForEachAddrBookEntry([&](const CTxDestination& _dest, const std::string& _label,
2503 bool _is_change, const std::optional<AddressPurpose>& _purpose) {
2504 if (_is_change) return;
2505 if (!purpose || purpose == _purpose) {
2506 label_set.insert(_label);
2507 }
2508 });
2509 return label_set;
2510}
2511
2513{
2515 if (!m_spk_man) {
2516 return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
2517 }
2518
2519 if (nIndex == -1) {
2520 int64_t index;
2521 auto op_address = m_spk_man->GetReservedDestination(type, internal, index);
2522 if (!op_address) return op_address;
2523 nIndex = index;
2525 }
2526 return address;
2527}
2528
2530{
2531 if (nIndex != -1) {
2533 }
2534 nIndex = -1;
2536}
2537
2539{
2540 if (nIndex != -1) {
2542 }
2543 nIndex = -1;
2545}
2546
2548{
2549 CScript scriptPubKey = GetScriptForDestination(dest);
2550 for (const auto& spk_man : GetScriptPubKeyMans(scriptPubKey)) {
2552 if (signer_spk_man == nullptr) {
2553 continue;
2554 }
2556 if (!signer) throw std::runtime_error(util::ErrorString(signer).original);
2557 return signer_spk_man->DisplayAddress(dest, *signer);
2558 }
2559 return util::Error{_("There is no ScriptPubKeyManager for this address")};
2560}
2561
2563{
2565 m_locked_coins.emplace(coin, persistent);
2566}
2567
2568bool CWallet::LockCoin(const COutPoint& output, bool persist)
2569{
2571 LoadLockedCoin(output, persist);
2572 if (persist) {
2573 WalletBatch batch(GetDatabase());
2574 return batch.WriteLockedUTXO(output);
2575 }
2576 return true;
2577}
2578
2580{
2582 auto locked_coin_it = m_locked_coins.find(output);
2583 if (locked_coin_it != m_locked_coins.end()) {
2584 bool persisted = locked_coin_it->second;
2586 if (persisted) {
2587 WalletBatch batch(GetDatabase());
2588 return batch.EraseLockedUTXO(output);
2589 }
2590 }
2591 return true;
2592}
2593
2595{
2597 bool success = true;
2598 WalletBatch batch(GetDatabase());
2599 for (const auto& [coin, persistent] : m_locked_coins) {
2600 if (persistent) success = success && batch.EraseLockedUTXO(coin);
2601 }
2602 m_locked_coins.clear();
2603 return success;
2604}
2605
2606bool CWallet::IsLockedCoin(const COutPoint& output) const
2607{
2609 return m_locked_coins.contains(output);
2610}
2611
2612void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
2613{
2615 for (const auto& [coin, _] : m_locked_coins) {
2616 vOutpts.push_back(coin);
2617 }
2618}
2619
2644{
2645 std::optional<uint256> block_hash;
2646 if (auto* conf = wtx.state<TxStateConfirmed>()) {
2647 block_hash = conf->confirmed_block_hash;
2648 } else if (auto* conf = wtx.state<TxStateBlockConflicted>()) {
2649 block_hash = conf->conflicting_block_hash;
2650 }
2651
2652 unsigned int nTimeSmart = wtx.nTimeReceived;
2653 if (block_hash) {
2656 if (chain().findBlock(*block_hash, FoundBlock().time(blocktime).maxTime(block_max_time))) {
2658 nTimeSmart = block_max_time;
2659 } else {
2661 int64_t latestEntry = 0;
2662
2663 // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
2665 const TxItems& txOrdered = wtxOrdered;
2666 for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
2667 CWalletTx* const pwtx = it->second;
2668 if (pwtx == &wtx) {
2669 continue;
2670 }
2673 if (!nSmartTime) {
2674 nSmartTime = pwtx->nTimeReceived;
2675 }
2676 if (nSmartTime <= latestTolerated) {
2678 if (nSmartTime > latestNow) {
2680 }
2681 break;
2682 }
2683 }
2684
2685 nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
2686 }
2687 } else {
2688 WalletLogPrintf("%s: found %s in block %s not in index", __func__, wtx.GetHash().ToString(), block_hash->ToString());
2689 }
2690 }
2691 return nTimeSmart;
2692}
2693
2695{
2696 if (std::get_if<CNoDestination>(&dest))
2697 return false;
2698
2699 if (!used) {
2700 if (auto* data{common::FindKey(m_address_book, dest)}) data->previously_spent = false;
2701 return batch.WriteAddressPreviouslySpent(dest, false);
2702 }
2703
2705 return batch.WriteAddressPreviouslySpent(dest, true);
2706}
2707
2709{
2710 m_address_book[dest].previously_spent = true;
2711}
2712
2713void CWallet::LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request)
2714{
2715 m_address_book[dest].receive_requests[id] = request;
2716}
2717
2719{
2720 if (auto* data{common::FindKey(m_address_book, dest)}) return data->previously_spent;
2721 return false;
2722}
2723
2724std::vector<std::string> CWallet::GetAddressReceiveRequests() const
2725{
2726 std::vector<std::string> values;
2727 for (const auto& [dest, entry] : m_address_book) {
2728 for (const auto& [id, request] : entry.receive_requests) {
2729 values.emplace_back(request);
2730 }
2731 }
2732 return values;
2733}
2734
2735bool CWallet::SetAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id, const std::string& value)
2736{
2737 if (!batch.WriteAddressReceiveRequest(dest, id, value)) return false;
2738 m_address_book[dest].receive_requests[id] = value;
2739 return true;
2740}
2741
2742bool CWallet::EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id)
2743{
2744 if (!batch.EraseAddressReceiveRequest(dest, id)) return false;
2745 m_address_book[dest].receive_requests.erase(id);
2746 return true;
2747}
2748
2750{
2751 const fs::path name_path = fs::PathFromString(name);
2752
2753 // 'name' must be a normalized path, i.e. no . or .. except at the root
2754 if (name_path != name_path.lexically_normal()) {
2755 return util::Error{Untranslated("Wallet name given as a path must be normalized")};
2756 }
2757
2758 // 'name' cannot begin with ./ or ../
2759 if (!name_path.empty() && (*name_path.begin() == fs::PathFromString(".") || *name_path.begin() == fs::PathFromString(".."))) {
2760 return util::Error{Untranslated("Wallet name given as a relative path cannot begin with ./ or ../, for wallets not in the walletdir, please use an absolute path.")};
2761 }
2762
2763 // Disallow path at root
2764 if (name_path.has_root_path() && name_path.root_path() == name_path) {
2765 return util::Error{Untranslated("Wallet name cannot be the root path")};
2766 }
2767
2768 // Do some checking on wallet path. It should be either a:
2769 //
2770 // 1. Path where a directory can be created.
2771 // 2. Path to an existing directory.
2772 // 3. Path to a symlink to a directory.
2773 // 4. For backwards compatibility, the name of a data file in -walletdir.
2775 fs::file_type path_type = fs::symlink_status(wallet_path).type();
2776 if (!(path_type == fs::file_type::not_found || path_type == fs::file_type::directory ||
2777 (path_type == fs::file_type::symlink && fs::is_directory(wallet_path)) ||
2778 (path_type == fs::file_type::regular && name_path.filename() == name_path))) {
2780 "Invalid -wallet path '%s'. -wallet path should point to a directory where wallet.dat and "
2781 "database/log.?????????? files can be stored, a location where such a directory could be created, "
2782 "or (for backwards compatibility) the name of an existing data file in -walletdir (%s)",
2784 }
2785 return wallet_path;
2786}
2787
2788std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error_string)
2789{
2790 const auto& wallet_path = GetWalletPath(name);
2791 if (!wallet_path) {
2794 return nullptr;
2795 }
2796 return MakeDatabase(*wallet_path, options, status, error_string);
2797}
2798
2799bool CWallet::LoadWalletArgs(std::shared_ptr<CWallet> wallet, const WalletContext& context, bilingual_str& error, std::vector<bilingual_str>& warnings)
2800{
2802 const ArgsManager& args = *Assert(context.args);
2803
2804 if (!args.GetArg("-addresstype", "").empty()) {
2805 std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-addresstype", ""));
2806 if (!parsed) {
2807 error = strprintf(_("Unknown address type '%s'"), args.GetArg("-addresstype", ""));
2808 return false;
2809 }
2810 wallet->m_default_address_type = parsed.value();
2811 }
2812
2813 if (!args.GetArg("-changetype", "").empty()) {
2814 std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-changetype", ""));
2815 if (!parsed) {
2816 error = strprintf(_("Unknown change type '%s'"), args.GetArg("-changetype", ""));
2817 return false;
2818 }
2819 wallet->m_default_change_type = parsed.value();
2820 }
2821
2822 if (const auto arg{args.GetArg("-mintxfee")}) {
2823 std::optional<CAmount> min_tx_fee = ParseMoney(*arg);
2824 if (!min_tx_fee) {
2825 error = AmountErrMsg("mintxfee", *arg);
2826 return false;
2827 } else if (min_tx_fee.value() > HIGH_TX_FEE_PER_KB) {
2828 warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
2829 _("This is the minimum transaction fee you pay on every transaction."));
2830 }
2831
2832 wallet->m_min_fee = CFeeRate{min_tx_fee.value()};
2833 }
2834
2835 if (const auto arg{args.GetArg("-maxapsfee")}) {
2836 const std::string& max_aps_fee_str{*arg};
2837 if (max_aps_fee_str == "-1") {
2838 wallet->m_max_aps_fee = -1;
2839 } else if (std::optional<CAmount> max_aps_fee = ParseMoney(max_aps_fee_str)) {
2840 if (max_aps_fee.value() > HIGH_APS_FEE) {
2841 warnings.push_back(AmountHighWarn("-maxapsfee") + Untranslated(" ") +
2842 _("This is the maximum transaction fee you pay (in addition to the normal fee) to prioritize partial spend avoidance over regular coin selection."));
2843 }
2844 wallet->m_max_aps_fee = max_aps_fee.value();
2845 } else {
2846 error = AmountErrMsg("maxapsfee", max_aps_fee_str);
2847 return false;
2848 }
2849 }
2850
2851 if (const auto arg{args.GetArg("-fallbackfee")}) {
2852 std::optional<CAmount> fallback_fee = ParseMoney(*arg);
2853 if (!fallback_fee) {
2854 error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-fallbackfee", *arg);
2855 return false;
2856 } else if (fallback_fee.value() > HIGH_TX_FEE_PER_KB) {
2857 warnings.push_back(AmountHighWarn("-fallbackfee") + Untranslated(" ") +
2858 _("This is the transaction fee you may pay when fee estimates are not available."));
2859 }
2860 wallet->m_fallback_fee = CFeeRate{fallback_fee.value()};
2861 }
2862
2863 // Disable fallback fee in case value was set to 0, enable if non-null value
2864 wallet->m_allow_fallback_fee = wallet->m_fallback_fee.GetFeePerK() != 0;
2865
2866 if (const auto arg{args.GetArg("-discardfee")}) {
2867 std::optional<CAmount> discard_fee = ParseMoney(*arg);
2868 if (!discard_fee) {
2869 error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-discardfee", *arg);
2870 return false;
2871 } else if (discard_fee.value() > HIGH_TX_FEE_PER_KB) {
2872 warnings.push_back(AmountHighWarn("-discardfee") + Untranslated(" ") +
2873 _("This is the transaction fee you may discard if change is smaller than dust at this level"));
2874 }
2875 wallet->m_discard_rate = CFeeRate{discard_fee.value()};
2876 }
2877
2878 if (const auto arg{args.GetArg("-maxtxfee")}) {
2879 std::optional<CAmount> max_tx_fee = ParseMoney(*arg);
2880 if (!max_tx_fee) {
2881 error = AmountErrMsg("maxtxfee", *arg);
2882 return false;
2883 } else if (max_tx_fee.value() > HIGH_MAX_TX_FEE) {
2884 warnings.push_back(strprintf(_("%s is set very high! Fees this large could be paid on a single transaction."), "-maxtxfee"));
2885 }
2886 const CFeeRate max_txfee{max_tx_fee.value(), 1000};
2887 if (chain && max_txfee < chain->relayMinFee()) {
2888 // Wallet prevents creating transactions with fee rates lower than minrelaytxfee.
2889 // Also the wallet prevents creating transactions with base fee above maxtxfee.
2890 // Warn when a 1kvb transaction, with a base fee set to maxtxfee, has a fee rate less than minrelaytxfee.
2891 // It is likely that some transactions with fee rates greater than or equal to the minrelaytxfee will exceed maxtxfee.
2892 // In such cases, the wallet won't be able to create transactions. Therefore, warn the user.
2893 warnings.push_back(strprintf(_("Invalid amount for %s=<amount>: '%s' conflicts with the minimum relay transaction feerate %s. Please set a higher %s or lower %s"),
2894 "-maxtxfee", max_txfee.ToString(), chain->relayMinFee().ToString(), "-maxtxfee", "-minrelaytxfee"));
2895 }
2896
2897 wallet->m_max_tx_fee = max_tx_fee.value();
2898 }
2899
2900 if (const auto arg{args.GetArg("-maxfeerate")}) {
2901 std::optional<CAmount> max_tx_fee_rate = ParseMoney(*arg);
2902 if (!max_tx_fee_rate) {
2903 error = AmountErrMsg("maxfeerate", *arg);
2904 return false;
2905 }
2907 error = strprintf(_("Invalid amount for %s=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions)"),
2908 "-maxfeerate", *arg, chain->relayMinFee().ToString());
2909 return false;
2910 }
2912 warnings.push_back(strprintf(_("%s is set very high! Fee rate this large could be paid on a single transaction."), "-maxfeerate"));
2913 }
2914
2915 wallet->m_max_tx_fee_rate = CFeeRate(*max_tx_fee_rate);
2916 }
2917
2918 if (const auto arg{args.GetArg("-consolidatefeerate")}) {
2919 if (std::optional<CAmount> consolidate_feerate = ParseMoney(*arg)) {
2920 wallet->m_consolidate_feerate = CFeeRate(*consolidate_feerate);
2921 } else {
2922 error = AmountErrMsg("consolidatefeerate", *arg);
2923 return false;
2924 }
2925 }
2926
2928 warnings.push_back(AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
2929 _("The wallet will avoid paying less than the minimum relay fee."));
2930 }
2931
2932 wallet->m_confirm_target = args.GetIntArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
2933 wallet->m_spend_zero_conf_change = args.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
2934 wallet->m_signal_rbf = DEFAULT_WALLET_RBF;
2935 if (auto value{args.GetBoolArg("-walletrbf")}) {
2936 warnings.push_back(_("-walletrbf is deprecated and will be fully removed in the next release."));
2937 wallet->m_signal_rbf = *value;
2938 }
2939
2940 wallet->m_keypool_size = std::max(args.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t{1});
2941 wallet->m_notify_tx_changed_script = args.GetArg("-walletnotify", "");
2942 wallet->SetBroadcastTransactions(args.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
2943
2944 return true;
2945}
2946
2947std::shared_ptr<CWallet> CWallet::CreateNew(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bool born_encrypted, bilingual_str& error, std::vector<bilingual_str>& warnings)
2948{
2950 const std::string& walletFile = database->Filename();
2951
2952 const auto start{SteadyClock::now()};
2953 // TODO: Can't use std::make_shared because we need a custom deleter but
2954 // should be possible to use std::allocate_shared.
2955 std::shared_ptr<CWallet> walletInstance(new CWallet(chain, name, std::move(database)), FlushAndDeleteWallet);
2956
2957 if (!LoadWalletArgs(walletInstance, context, error, warnings)) {
2958 return nullptr;
2959 }
2960
2961 // Initialize version key.
2962 {
2963 WalletBatch batch(walletInstance->GetDatabase());
2964 if(!batch.WriteLastOpenedVersion()) {
2965 error = strprintf(_("Error creating %s: Could not write version metadata."), walletFile);
2966 return nullptr;
2967 }
2968 if(!batch.WriteLastOpenedFeatures()) {
2969 error = strprintf(_("Error creating %s: Could not write features metadata."), walletFile);
2970 return nullptr;
2971 }
2972 }
2973 {
2974 LOCK(walletInstance->cs_wallet);
2975
2976 // Init with passed flags.
2977 // Always set the cache upgrade flag as this feature is supported from the beginning.
2979
2980 // Only descriptor wallets can be created
2982
2983 // Born encrypted wallets will have their keys generated later
2984 if (!born_encrypted) {
2985 walletInstance->SetupWalletGeneration();
2986 }
2987
2988 if (chain) {
2989 std::optional<int> tip_height = chain->getHeight();
2990 if (tip_height) {
2991 walletInstance->SetLastBlockProcessed(*tip_height, chain->getBlockHash(*tip_height));
2992 }
2993 }
2994 }
2995
2996 walletInstance->WalletLogPrintf("Wallet completed creation in %15dms", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
2997
2998 // Try to top up keypool. No-op if the wallet is locked.
2999 walletInstance->TopUpKeyPool();
3000
3001 if (chain && !AttachChain(walletInstance, *chain, /*rescan_required=*/false, error, warnings)) {
3002 walletInstance->DisconnectChainNotifications();
3003 return nullptr;
3004 }
3005
3006 return walletInstance;
3007}
3008
3009std::shared_ptr<CWallet> CWallet::LoadExisting(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, bilingual_str& error, std::vector<bilingual_str>& warnings)
3010{
3012 const std::string& walletFile = database->Filename();
3013
3014 const auto start{SteadyClock::now()};
3015 std::shared_ptr<CWallet> walletInstance(new CWallet(chain, name, std::move(database)), FlushAndDeleteWallet);
3016
3017 if (!LoadWalletArgs(walletInstance, context, error, warnings)) {
3018 return nullptr;
3019 }
3020
3021 // Load wallet
3022 auto nLoadWalletRet = walletInstance->PopulateWalletFromDB(error, warnings);
3025 return nullptr;
3026 }
3027
3028 if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
3029 for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
3030 if (spk_man->HavePrivateKeys()) {
3031 warnings.push_back(strprintf(_("Warning: Private keys detected in wallet {%s} with disabled private keys"), walletFile));
3032 break;
3033 }
3034 }
3035 }
3036
3037 walletInstance->WalletLogPrintf("Wallet completed loading in %15dms", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
3038
3039 // Try to top up keypool. No-op if the wallet is locked.
3040 walletInstance->TopUpKeyPool();
3041
3042 if (chain && !AttachChain(walletInstance, *chain, rescan_required, error, warnings)) {
3043 walletInstance->DisconnectChainNotifications();
3044 return nullptr;
3045 }
3046
3047 WITH_LOCK(walletInstance->cs_wallet, walletInstance->LogStats());
3048
3049 return walletInstance;
3050}
3051
3052
3053bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interfaces::Chain& chain, const bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings)
3054{
3055 LOCK(walletInstance->cs_wallet);
3056 // allow setting the chain if it hasn't been set already but prevent changing it
3057 assert(!walletInstance->m_chain || walletInstance->m_chain == &chain);
3058 walletInstance->m_chain = &chain;
3059
3060 // Unless allowed, ensure wallet files are not reused across chains:
3061 if (!gArgs.GetBoolArg("-walletcrosschain", DEFAULT_WALLETCROSSCHAIN)) {
3062 WalletBatch batch(walletInstance->GetDatabase());
3063 CBlockLocator locator;
3064 if (batch.ReadBestBlock(locator) && locator.vHave.size() > 0 && chain.getHeight()) {
3065 // Wallet is assumed to be from another chain, if genesis block in the active
3066 // chain differs from the genesis block known to the wallet.
3067 if (chain.getBlockHash(0) != locator.vHave.back()) {
3068 error = Untranslated("Wallet files should not be reused across chains. Restart bitcoind with -walletcrosschain to override.");
3069 return false;
3070 }
3071 }
3072 }
3073
3074 // Register wallet with validationinterface. It's done before rescan to avoid
3075 // missing block connections during the rescan.
3076 // Because of the wallet lock being held, block connection notifications are going to
3077 // be pending on the validation-side until lock release. Blocks that are connected while the
3078 // rescan is ongoing will not be processed in the rescan but with the block connected notifications,
3079 // so the wallet will only be completeley synced after the notifications delivery.
3080 walletInstance->m_chain_notifications_handler = walletInstance->chain().handleNotifications(walletInstance);
3081
3082 // If rescan_required = true, rescan_height remains equal to 0
3083 int rescan_height = 0;
3084 if (!rescan_required)
3085 {
3086 WalletBatch batch(walletInstance->GetDatabase());
3087 CBlockLocator locator;
3088 if (batch.ReadBestBlock(locator)) {
3089 if (const std::optional<int> fork_height = chain.findLocatorFork(locator)) {
3091 }
3092 }
3093 }
3094
3095 const std::optional<int> tip_height = chain.getHeight();
3096 if (tip_height) {
3097 walletInstance->SetLastBlockProcessedInMem(*tip_height, chain.getBlockHash(*tip_height));
3098 } else {
3099 walletInstance->SetLastBlockProcessedInMem(-1, uint256());
3100 }
3101
3102 if (tip_height && *tip_height != rescan_height)
3103 {
3104 // No need to read and scan block if block was created before
3105 // our wallet birthday (as adjusted for block time variability)
3106 std::optional<int64_t> time_first_key = walletInstance->m_birth_time.load();
3107 if (time_first_key) {
3110 if (!found.found) {
3111 // We were unable to find a block that had a time more recent than our earliest timestamp
3112 // or a height higher than the wallet was synced to, indicating that the wallet is newer than the
3113 // current chain tip. Skip rescanning in this case.
3114 rescan_height = *tip_height;
3115 }
3116 }
3117
3118 // Technically we could execute the code below in any case, but performing the
3119 // `while` loop below can make startup very slow, so only check blocks on disk
3120 // if necessary.
3122 int block_height = *tip_height;
3123 while (block_height > 0 && chain.haveBlockOnDisk(block_height - 1) && rescan_height != block_height) {
3124 --block_height;
3125 }
3126
3127 if (rescan_height != block_height) {
3128 // We can't rescan beyond blocks we don't have data for, stop and throw an error.
3129 // This might happen if a user uses an old wallet within a pruned node
3130 // or if they ran -disablewallet for a longer time, then decided to re-enable
3131 // Exit early and print an error.
3132 // It also may happen if an assumed-valid chain is in use and therefore not
3133 // all block data is available.
3134 // If a block is pruned after this check, we will load the wallet,
3135 // but fail the rescan with a generic error.
3136
3137 error = chain.havePruned() ?
3138 _("Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of a pruned node)") :
3139 strprintf(_(
3140 "Error loading wallet. Wallet requires blocks to be downloaded, "
3141 "and software does not currently support loading wallets while "
3142 "blocks are being downloaded out of order when using assumeutxo "
3143 "snapshots. Wallet should be able to load successfully after "
3144 "node sync reaches height %s"), block_height);
3145 return false;
3146 }
3147 }
3148
3149 chain.initMessage(_("Rescanning…"));
3150 walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...", *tip_height - rescan_height, rescan_height);
3151
3152 {
3154 if (!reserver.reserve()) {
3155 error = _("Failed to acquire rescan reserver during wallet initialization");
3156 return false;
3157 }
3158 ScanResult scan_res = walletInstance->Scanner().Scan(chain.getBlockHash(rescan_height), rescan_height, /*max_height=*/{}, reserver, /*save_progress=*/true);
3159 if (ScanResult::SUCCESS != scan_res.status) {
3160 error = _("Failed to rescan the wallet during initialization");
3161 return false;
3162 }
3163 // Set and update the best block record
3164 // Set last block scanned as the last block processed as it may be different in case of a reorg.
3165 // Also save the best block locator because rescanning only updates it intermittently.
3166 walletInstance->SetLastBlockProcessed(*scan_res.last_scanned_height, scan_res.last_scanned_block);
3167 }
3168 }
3169
3170 return true;
3171}
3172
3174{
3175 const auto& address_book_it = m_address_book.find(dest);
3176 if (address_book_it == m_address_book.end()) return nullptr;
3177 if ((!allow_change) && address_book_it->second.IsChange()) {
3178 return nullptr;
3179 }
3180 return &address_book_it->second;
3181}
3182
3184{
3185 // Add wallet transactions that aren't already in a block to mempool
3186 // Do this here as mempool requires genesis block to be loaded
3188
3189 // Update wallet transactions with current mempool transactions.
3190 WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
3191}
3192
3193bool CWallet::BackupWallet(const std::string& strDest) const
3194{
3196 return GetDatabase().Backup(strDest);
3197}
3198
3200{
3202 if (auto* conf = wtx.state<TxStateConfirmed>()) {
3203 assert(conf->confirmed_block_height >= 0);
3204 return GetLastBlockHeight() - conf->confirmed_block_height + 1;
3205 } else if (auto* conf = wtx.state<TxStateBlockConflicted>()) {
3206 assert(conf->conflicting_block_height >= 0);
3207 return -1 * (GetLastBlockHeight() - conf->conflicting_block_height + 1);
3208 } else {
3209 return 0;
3210 }
3211}
3212
3214{
3216
3217 if (!wtx.IsCoinBase()) {
3218 return 0;
3219 }
3221 assert(chain_depth >= 0); // coinbase tx should not be conflicted
3222 return std::max(0, (COINBASE_MATURITY+1) - chain_depth);
3223}
3224
3226{
3228
3229 // note GetBlocksToMaturity is 0 for non-coinbase tx
3230 return GetTxBlocksToMaturity(wtx) > 0;
3231}
3232
3234{
3235 if (!HasEncryptionKeys()) {
3236 return false;
3237 }
3238 LOCK(cs_wallet);
3239 return vMasterKey.empty();
3240}
3241
3243{
3244 if (!HasEncryptionKeys())
3245 return false;
3246
3247 {
3249 if (!vMasterKey.empty()) {
3250 memory_cleanse(vMasterKey.data(), vMasterKey.size() * sizeof(decltype(vMasterKey)::value_type));
3251 vMasterKey.clear();
3252 }
3253 }
3254
3255 NotifyStatusChanged(this);
3256 return true;
3257}
3258
3260{
3261 {
3262 LOCK(cs_wallet);
3263 for (const auto& spk_man_pair : m_spk_managers) {
3264 if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn)) {
3265 return false;
3266 }
3267 }
3269 }
3270 NotifyStatusChanged(this);
3271 return true;
3272}
3273
3274std::set<ScriptPubKeyMan*> CWallet::GetActiveScriptPubKeyMans() const
3275{
3276 std::set<ScriptPubKeyMan*> spk_mans;
3277 for (bool internal : {false, true}) {
3278 for (OutputType t : OUTPUT_TYPES) {
3279 auto spk_man = GetScriptPubKeyMan(t, internal);
3280 if (spk_man) {
3281 spk_mans.insert(spk_man);
3282 }
3283 }
3284 }
3285 return spk_mans;
3286}
3287
3289{
3290 for (const auto& [_, ext_spkm] : m_external_spk_managers) {
3291 if (ext_spkm == &spkm) return true;
3292 }
3293 for (const auto& [_, int_spkm] : m_internal_spk_managers) {
3294 if (int_spkm == &spkm) return true;
3295 }
3296 return false;
3297}
3298
3299std::set<ScriptPubKeyMan*> CWallet::GetAllScriptPubKeyMans() const
3300{
3301 std::set<ScriptPubKeyMan*> spk_mans;
3302 for (const auto& spk_man_pair : m_spk_managers) {
3303 spk_mans.insert(spk_man_pair.second.get());
3304 }
3305 return spk_mans;
3306}
3307
3309{
3310 const std::map<OutputType, ScriptPubKeyMan*>& spk_managers = internal ? m_internal_spk_managers : m_external_spk_managers;
3311 std::map<OutputType, ScriptPubKeyMan*>::const_iterator it = spk_managers.find(type);
3312 if (it == spk_managers.end()) {
3313 return nullptr;
3314 }
3315 return it->second;
3316}
3317
3318std::set<ScriptPubKeyMan*> CWallet::GetScriptPubKeyMans(const CScript& script) const
3319{
3320 std::set<ScriptPubKeyMan*> spk_mans;
3321
3322 // Search the cache for relevant SPKMs instead of iterating m_spk_managers
3323 const auto& it = m_cached_spks.find(script);
3324 if (it != m_cached_spks.end()) {
3325 spk_mans.insert(it->second.begin(), it->second.end());
3326 }
3327 SignatureData sigdata;
3328 Assume(std::all_of(spk_mans.begin(), spk_mans.end(), [&script, &sigdata](ScriptPubKeyMan* spkm) { return spkm->CanProvide(script, sigdata); }));
3329
3330 return spk_mans;
3331}
3332
3334{
3335 if (m_spk_managers.contains(id)) {
3336 return m_spk_managers.at(id).get();
3337 }
3338 return nullptr;
3339}
3340
3341std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script) const
3342{
3343 SignatureData sigdata;
3344 return GetSolvingProvider(script, sigdata);
3345}
3346
3347std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script, SignatureData& sigdata) const
3348{
3349 // Search the cache for relevant SPKMs instead of iterating m_spk_managers
3350 const auto& it = m_cached_spks.find(script);
3351 if (it != m_cached_spks.end()) {
3352 // All spkms for a given script must already be able to make a SigningProvider for the script, so just return the first one.
3353 Assume(it->second.at(0)->CanProvide(script, sigdata));
3354 return it->second.at(0)->GetSolvingProvider(script);
3355 }
3356
3357 return nullptr;
3358}
3359
3360std::vector<WalletDescriptor> CWallet::GetWalletDescriptors(const CScript& script) const
3361{
3362 std::vector<WalletDescriptor> descs;
3363 for (const auto spk_man: GetScriptPubKeyMans(script)) {
3364 if (const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man)) {
3365 LOCK(desc_spk_man->cs_desc_man);
3366 descs.push_back(desc_spk_man->GetWalletDescriptor());
3367 }
3368 }
3369 return descs;
3370}
3371
3373{
3375 return nullptr;
3376 }
3378 if (it == m_internal_spk_managers.end()) return nullptr;
3379 return dynamic_cast<LegacyDataSPKM*>(it->second);
3380}
3381
3382void CWallet::AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man)
3383{
3384 // Add spkm_man to m_spk_managers before calling any method
3385 // that might access it.
3386 const auto& spkm = m_spk_managers[id] = std::move(spkm_man);
3387
3388 // Update birth time if needed
3389 MaybeUpdateBirthTime(spkm->GetTimeFirstKey());
3390}
3391
3397
3399{
3401 return;
3402 }
3403
3404 Assert(m_database->Format() == "bdb_ro" || m_database->Format() == "sqlite-mock");
3405 std::unique_ptr<ScriptPubKeyMan> spk_manager = std::make_unique<LegacyDataSPKM>(*this);
3406
3407 for (const auto& type : LEGACY_OUTPUT_TYPES) {
3410 }
3411 uint256 id = spk_manager->GetID();
3412 AddScriptPubKeyMan(id, std::move(spk_manager));
3413}
3414
3415bool CWallet::WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const
3416{
3417 LOCK(cs_wallet);
3418 return cb(vMasterKey);
3419}
3420
3422{
3423 return !mapMasterKeys.empty();
3424}
3425
3427{
3428 for (const auto& spkm : GetAllScriptPubKeyMans()) {
3429 if (spkm->HaveCryptedKeys()) return true;
3430 }
3431 return false;
3432}
3433
3435{
3436 for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
3437 spk_man->NotifyCanGetAddressesChanged.connect([this] {
3439 });
3440 spk_man->NotifyFirstKeyTimeChanged.connect([this](const ScriptPubKeyMan*, int64_t time) {
3442 });
3443 }
3444}
3445
3447{
3448 std::unique_ptr<DescriptorScriptPubKeyMan> spk_manager;
3451 } else {
3453 }
3454 AddScriptPubKeyMan(id, std::move(spk_manager));
3455}
3456
3458{
3460 if (IsLocked()) {
3461 throw std::runtime_error(std::string(__func__) + ": Wallet is locked, cannot setup new descriptors");
3462 }
3465 uint256 id = spk_manager->GetID();
3466 AddScriptPubKeyMan(id, std::move(spk_manager));
3467 AddActiveScriptPubKeyManWithDb(batch, id, output_type, internal);
3468 return *out;
3469}
3470
3472{
3474 for (bool internal : {false, true}) {
3475 for (OutputType t : OUTPUT_TYPES) {
3476 SetupDescriptorScriptPubKeyMan(batch, master_key, t, internal);
3477 }
3478 }
3479}
3480
3482{
3485 // Make a seed
3487 CPubKey seed = seed_key.GetPubKey();
3488 assert(seed_key.VerifyPubKey(seed));
3489
3490 // Get the extended key
3491 CExtKey master_key;
3492 master_key.SetSeed(seed_key);
3493
3494 SetupDescriptorScriptPubKeyMans(batch, master_key);
3495}
3496
3498{
3500
3502 if (!RunWithinTxn(GetDatabase(), /*process_desc=*/"setup descriptors", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet){
3504 return true;
3505 })) throw std::runtime_error("Error: cannot process db transaction for descriptors setup");
3506 } else {
3508 if (!signer) throw std::runtime_error(util::ErrorString(signer).original);
3509
3510 // TODO: add account parameter
3511 int account = 0;
3512 UniValue signer_res = signer->GetDescriptors(account);
3513
3514 if (!signer_res.isObject()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
3515
3516 WalletBatch batch(GetDatabase());
3517 if (!batch.TxnBegin()) throw std::runtime_error("Error: cannot create db transaction for descriptors import");
3518
3519 for (bool internal : {false, true}) {
3520 const UniValue& descriptor_vals = signer_res.find_value(internal ? "internal" : "receive");
3521 if (!descriptor_vals.isArray()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
3522 for (const UniValue& desc_val : descriptor_vals.get_array().getValues()) {
3523 const std::string& desc_str = desc_val.getValStr();
3525 std::string desc_error;
3526 auto descs = Parse(desc_str, keys, desc_error, false);
3527 if (descs.empty()) {
3528 throw std::runtime_error(std::string(__func__) + ": Invalid descriptor \"" + desc_str + "\" (" + desc_error + ")");
3529 }
3530 auto& desc = descs.at(0);
3531 if (!desc->GetOutputType()) {
3532 continue;
3533 }
3534 OutputType t = *desc->GetOutputType();
3535 auto spk_manager = ExternalSignerScriptPubKeyMan::CreateNew(*this, batch, m_keypool_size, std::move(desc));
3536 uint256 id = spk_manager->GetID();
3537 AddScriptPubKeyMan(id, std::move(spk_manager));
3538 AddActiveScriptPubKeyManWithDb(batch, id, t, internal);
3539 }
3540 }
3541
3542 // Ensure imported descriptors are committed to disk
3543 if (!batch.TxnCommit()) throw std::runtime_error("Error: cannot commit db transaction for descriptors import");
3544 }
3545}
3546
3548{
3550 // Skip setup for non-external-signer wallets that are either blank
3551 // or have private keys disabled (not having private keys implies blank).
3554 return;
3555 }
3557}
3558
3560{
3561 WalletBatch batch(GetDatabase());
3562 return AddActiveScriptPubKeyManWithDb(batch, id, type, internal);
3563}
3564
3566{
3567 if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id, internal)) {
3568 throw std::runtime_error(std::string(__func__) + ": writing active ScriptPubKeyMan id failed");
3569 }
3570 LoadActiveScriptPubKeyMan(id, type, internal);
3571}
3572
3574{
3575 // Activating ScriptPubKeyManager for a given output and change type is incompatible with legacy wallets.
3576 // Legacy wallets have only one ScriptPubKeyManager and it's active for all output and change types.
3578
3579 WalletLogPrintf("Setting spkMan to active: id = %s, type = %s, internal = %s", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
3582 auto spk_man = m_spk_managers.at(id).get();
3583 spk_mans[type] = spk_man;
3584
3585 const auto it = spk_mans_other.find(type);
3586 if (it != spk_mans_other.end() && it->second == spk_man) {
3587 spk_mans_other.erase(type);
3588 }
3589
3591}
3592
3594{
3595 auto spk_man = GetScriptPubKeyMan(type, internal);
3596 if (spk_man != nullptr && spk_man->GetID() == id) {
3597 WalletLogPrintf("Deactivate spkMan: id = %s, type = %s, internal = %s", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
3598 WalletBatch batch(GetDatabase());
3599 if (!batch.EraseActiveScriptPubKeyMan(static_cast<uint8_t>(type), internal)) {
3600 throw std::runtime_error(std::string(__func__) + ": erasing active ScriptPubKeyMan id failed");
3601 }
3602
3604 spk_mans.erase(type);
3605 }
3606
3608}
3609
3611{
3612 auto spk_man_pair = std::find_if(m_spk_managers.begin(), m_spk_managers.end(), [&desc](const auto& item) {
3613 DescriptorScriptPubKeyMan* spk_manager = dynamic_cast<DescriptorScriptPubKeyMan*>(item.second.get());
3614 return spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc);
3615 });
3616
3617 if (spk_man_pair != m_spk_managers.end()) {
3618 return dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man_pair->second.get());
3619 }
3620
3621 return nullptr;
3622}
3623
3625{
3626 // only active ScriptPubKeyMan can be internal
3627 if (!GetActiveScriptPubKeyMans().contains(spk_man)) {
3628 return std::nullopt;
3629 }
3630
3631 const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
3632 if (!desc_spk_man) {
3633 throw std::runtime_error(std::string(__func__) + ": unexpected ScriptPubKeyMan type.");
3634 }
3635
3636 LOCK(desc_spk_man->cs_desc_man);
3637 const auto& type = desc_spk_man->GetWalletDescriptor().descriptor->GetOutputType();
3638 assert(type.has_value());
3639
3640 return GetScriptPubKeyMan(*type, /* internal= */ true) == desc_spk_man;
3641}
3642
3644{
3646
3648
3650 if (spk_man) {
3651 WalletLogPrintf("Update existing descriptor: %s", desc.descriptor->ToString());
3652 if (auto spkm_res = spk_man->UpdateWalletDescriptor(desc, signing_provider); !spkm_res) {
3654 }
3655 } else {
3657 spk_man = new_spk_man.get();
3658
3659 // Save the descriptor to memory
3660 uint256 id = new_spk_man->GetID();
3661 AddScriptPubKeyMan(id, std::move(new_spk_man));
3662
3663 // Write the existing cache to disk
3664 WalletBatch batch(GetDatabase());
3665 if (!batch.WriteDescriptorCacheItems(id, desc.cache)) {
3666 return util::Error{_("Unable to write descriptor cache")};
3667 }
3668 }
3669
3670 // Apply the label if necessary
3671 // Note: we disable labels for descriptors that are ranged or that don't produce output scripts (i.e. unused())
3672 if (!desc.descriptor->IsRange() && desc.descriptor->HasScripts()) {
3673 auto script_pub_keys = spk_man->GetScriptPubKeys();
3674 if (script_pub_keys.empty()) {
3675 return util::Error{_("Could not generate scriptPubKeys (cache is empty)")};
3676 }
3677
3678 if (!internal) {
3679 for (const auto& script : script_pub_keys) {
3680 CTxDestination dest;
3681 if (ExtractDestination(script, dest)) {
3683 }
3684 }
3685 }
3686 }
3687
3688 // Save the descriptor to DB
3689 spk_man->WriteDescriptor();
3690
3691 // Break balance caches so that outputs that are now IsMine in already known txs will be included in the balance
3692 MarkDirty();
3693
3694 return std::reference_wrapper(*spk_man);
3695}
3696
3698{
3699 LOCK(cs_wallet);
3700
3701 if (key && !key->key.IsValid()) {
3704 _("Invalid HD key"),
3705 }};
3706 }
3707
3711 _("addhdkey is not available for wallets without private keys")
3712 }};
3713 }
3714
3715 if (IsLocked()) {
3718 _("Wallet needs to be unlocked to perform this operation.")
3719 }};
3720 }
3721
3722 CExtKey hdkey;
3723 if (key) {
3724 hdkey = *key;
3725 } else {
3727 hdkey.SetSeed(seed_key);
3728 }
3729
3730 std::string desc_str = "unused(" + EncodeExtKey(hdkey) + ")";
3732 std::string parse_error;
3733 std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, parse_error, /*require_checksum=*/false);
3734 if (descs.empty()) {
3737 _("Invalid HD key")
3738 }};
3739 }
3740 WalletDescriptor w_desc(std::move(descs.at(0)), GetTime(), /*range_start=*/0, /*range_end=*/0, /*next_index=*/0);
3741
3742 if (GetDescriptorScriptPubKeyMan(w_desc) != nullptr) {
3745 _("HD key already exists")
3746 }};
3747 }
3748
3749 auto spkm = AddWalletDescriptor(w_desc, keys, /*label=*/"", /*internal=*/false);
3750 if(!spkm) {
3754 }};
3755 }
3756
3758 LOCK(desc_spkm.cs_desc_man);
3759 std::set<CPubKey> pubkeys;
3760 std::set<CExtPubKey> extpubs;
3761 desc_spkm.GetWalletDescriptor().descriptor->GetPubKeys(pubkeys, extpubs);
3762 Assume(pubkeys.empty());
3763 Assume(extpubs.size() == 1);
3764
3765 return *extpubs.begin();
3766}
3767
3769{
3771
3772 WalletLogPrintf("Migrating wallet storage database from BerkeleyDB to SQLite.");
3773
3774 if (m_database->Format() == "sqlite") {
3775 error = _("Error: This wallet already uses SQLite");
3776 return false;
3777 }
3778
3779 // Get all of the records for DB type migration
3780 std::unique_ptr<DatabaseBatch> batch = m_database->MakeBatch();
3781 std::unique_ptr<DatabaseCursor> cursor = batch->GetNewCursor();
3782 std::vector<std::pair<SerializeData, SerializeData>> records;
3783 if (!cursor) {
3784 error = _("Error: Unable to begin reading all records in the database");
3785 return false;
3786 }
3788 while (true) {
3791 status = cursor->Next(ss_key, ss_value);
3792 if (status != DatabaseCursor::Status::MORE) {
3793 break;
3794 }
3795 SerializeData key(ss_key.begin(), ss_key.end());
3796 SerializeData value(ss_value.begin(), ss_value.end());
3797 records.emplace_back(key, value);
3798 }
3799 cursor.reset();
3800 batch.reset();
3801 if (status != DatabaseCursor::Status::DONE) {
3802 error = _("Error: Unable to read all records in the database");
3803 return false;
3804 }
3805
3806 // Close this database and delete the file
3807 fs::path db_path = fs::PathFromString(m_database->Filename());
3808 m_database->Close();
3809 fs::remove(db_path);
3810
3811 // Generate the path for the location of the migrated wallet
3812 // Wallets that are plain files rather than wallet directories will be migrated to be wallet directories.
3814
3815 // Make new DB
3816 DatabaseOptions opts;
3817 opts.require_create = true;
3820 std::unique_ptr<WalletDatabase> new_db = MakeDatabase(wallet_path, opts, db_status, error);
3821 assert(new_db); // This is to prevent doing anything further with this wallet. The original file was deleted, but a backup exists.
3822 m_database.reset();
3823 m_database = std::move(new_db);
3824
3825 // Write existing records into the new DB
3826 batch = m_database->MakeBatch();
3827 bool began = batch->TxnBegin();
3828 assert(began); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
3829 for (const auto& [key, value] : records) {
3830 if (!batch->Write(std::span{key}, std::span{value})) {
3831 batch->TxnAbort();
3832 m_database->Close();
3833 fs::remove(m_database->Filename());
3834 assert(false); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
3835 }
3836 }
3837 bool committed = batch->TxnCommit();
3838 assert(committed); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
3839 return true;
3840}
3841
3842std::optional<MigrationData> CWallet::GetDescriptorsForLegacy(bilingual_str& error) const
3843{
3845
3847 if (!Assume(legacy_spkm)) {
3848 // This shouldn't happen
3849 error = Untranslated(STR_INTERNAL_BUG("Error: Legacy wallet data missing"));
3850 return std::nullopt;
3851 }
3852
3853 std::optional<MigrationData> res = legacy_spkm->MigrateToDescriptor();
3854 if (res == std::nullopt) {
3855 error = _("Error: Unable to produce descriptors for this legacy wallet. Make sure to provide the wallet's passphrase if it is encrypted.");
3856 return std::nullopt;
3857 }
3858 return res;
3859}
3860
3862{
3864
3866 if (!Assume(legacy_spkm)) {
3867 // This shouldn't happen
3868 return util::Error{Untranslated(STR_INTERNAL_BUG("Error: Legacy wallet data missing"))};
3869 }
3870
3871 // Note: when the legacy wallet has no spendable scripts, it must be empty at the end of the process.
3872 bool has_spendable_material = !data.desc_spkms.empty() || data.master_key.key.IsValid();
3873
3874 // Get all invalid or non-watched scripts that will not be migrated
3875 std::set<CTxDestination> not_migrated_dests;
3876 for (const auto& script : legacy_spkm->GetNotMineScriptPubKeys()) {
3877 CTxDestination dest;
3878 if (ExtractDestination(script, dest)) not_migrated_dests.emplace(dest);
3879 }
3880
3881 // When the legacy wallet has no spendable scripts, the main wallet will be empty, leaving its script cache empty as well.
3882 // The watch-only and/or solvable wallet(s) will contain the scripts in their respective caches.
3883 if (!data.desc_spkms.empty()) Assume(!m_cached_spks.empty());
3884 if (!data.watch_descs.empty()) Assume(!data.watchonly_wallet->m_cached_spks.empty());
3885 if (!data.solvable_descs.empty()) Assume(!data.solvable_wallet->m_cached_spks.empty());
3886
3887 for (auto& desc_spkm : data.desc_spkms) {
3888 if (m_spk_managers.contains(desc_spkm->GetID())) {
3889 return util::Error{_("Error: Duplicate descriptors created during migration. Your wallet may be corrupted.")};
3890 }
3891 uint256 id = desc_spkm->GetID();
3892 AddScriptPubKeyMan(id, std::move(desc_spkm));
3893 }
3894
3895 // Remove the LegacyDataSPKM's records from disk
3896 if (!legacy_spkm->DeleteRecordsWithDB(local_wallet_batch)) {
3897 return util::Error{_("Error: cannot remove legacy wallet records")};
3898 }
3899
3900 // Remove the LegacyDataSPKM from memory
3901 m_spk_managers.erase(legacy_spkm->GetID());
3904
3905 // Setup new descriptors (only if we are migrating any key material)
3908 // Use the existing master key if we have it
3909 if (data.master_key.key.IsValid()) {
3911 } else {
3912 // Setup with a new seed if we don't.
3914 }
3915 }
3916
3917 // Set the last opened version and features
3918 if (!local_wallet_batch.WriteLastOpenedVersion()) {
3919 return util::Error{_("Error: Unable to write last opened version")};
3920 }
3921 if (!local_wallet_batch.WriteLastOpenedFeatures()) {
3922 return util::Error{_("Error: Unable to write last opened features")};
3923 }
3924 if (HasEncryptionKeys()) {
3925 if (!local_wallet_batch.WriteLastDecryptedFeatures()) {
3926 return util::Error{_("Error: Unable to write last decrypted features")};
3927 }
3928 }
3929
3930 // Get best block locator so that we can copy it to the watchonly and solvables
3931 // Note: The best block locator was introduced in #152 so ancient wallets do not have it
3934
3935 // Update m_txos to match the descriptors remaining in this wallet
3936 m_txos.clear();
3938
3939 // Check if the transactions in the wallet are still ours. Either they belong here, or they belong in the watchonly wallet.
3940 // We need to go through these in the tx insertion order so that lookups to spends works.
3941 std::vector<Txid> txids_to_delete;
3942 std::unique_ptr<WalletBatch> watchonly_batch;
3943 if (data.watchonly_wallet) {
3944 watchonly_batch = std::make_unique<WalletBatch>(data.watchonly_wallet->GetDatabase());
3945 if (!watchonly_batch->TxnBegin()) return util::Error{strprintf(_("Error: database transaction cannot be executed for wallet %s"), data.watchonly_wallet->GetName())};
3946 // Copy the next tx order pos to the watchonly wallet
3947 LOCK(data.watchonly_wallet->cs_wallet);
3948 data.watchonly_wallet->nOrderPosNext = nOrderPosNext;
3949 watchonly_batch->WriteOrderPosNext(data.watchonly_wallet->nOrderPosNext);
3950 // Write the locator record. An empty locator is valid and triggers rescan on load.
3951 if (!watchonly_batch->WriteBestBlock(best_block_locator)) {
3952 return util::Error{_("Error: Unable to write watchonly wallet best block locator record")};
3953 }
3954 }
3955 std::unique_ptr<WalletBatch> solvables_batch;
3956 if (data.solvable_wallet) {
3957 solvables_batch = std::make_unique<WalletBatch>(data.solvable_wallet->GetDatabase());
3958 if (!solvables_batch->TxnBegin()) return util::Error{strprintf(_("Error: database transaction cannot be executed for wallet %s"), data.solvable_wallet->GetName())};
3959 // Write the locator record. An empty locator is valid and triggers rescan on load.
3960 if (!solvables_batch->WriteBestBlock(best_block_locator)) {
3961 return util::Error{_("Error: Unable to write solvable wallet best block locator record")};
3962 }
3963 }
3964 for (const auto& [_pos, wtx] : wtxOrdered) {
3965 // Check it is the watchonly wallet's
3966 // solvable_wallet doesn't need to be checked because transactions for those scripts weren't being watched for
3967 bool is_mine = IsMine(*wtx->GetTx()) || IsFromMe(*wtx->GetTx());
3968 if (data.watchonly_wallet) {
3969 LOCK(data.watchonly_wallet->cs_wallet);
3970 if (data.watchonly_wallet->IsMine(*wtx->GetTx()) || data.watchonly_wallet->IsFromMe(*wtx->GetTx())) {
3971 // Add to watchonly wallet
3972 const Txid& hash = wtx->GetHash();
3974 wtx_ser << *wtx;
3975 CWalletTx copy_wtx(deserialize, wtx_ser, wtx->GetTxs());
3976 if (!data.watchonly_wallet->LoadToWallet(std::move(copy_wtx))) {
3977 return util::Error{strprintf(_("Error: Could not add watchonly tx %s to watchonly wallet"), wtx->GetHash().GetHex())};
3978 }
3979 watchonly_batch->WriteFullTx(data.watchonly_wallet->mapWallet.at(hash));
3980 // Mark as to remove from the migrated wallet only if it does not also belong to it
3981 if (!is_mine) {
3982 txids_to_delete.push_back(hash);
3983 continue;
3984 }
3985 }
3986 }
3987 if (!is_mine) {
3988 // Both not ours and not in the watchonly wallet
3989 return util::Error{strprintf(_("Error: Transaction %s in wallet cannot be identified to belong to migrated wallets"), wtx->GetHash().GetHex())};
3990 }
3991 // Rewrite the transaction so that anything that may have changed about it in memory also persists to disk
3992 local_wallet_batch.WriteTxMetadata(*wtx);
3993 }
3994
3995 // Do the removes
3996 if (txids_to_delete.size() > 0) {
3998 return util::Error{_("Error: Could not delete watchonly transactions. ") + util::ErrorString(res)};
3999 }
4000 }
4001
4002 // Pair external wallets with their corresponding db handler
4003 std::vector<std::pair<std::shared_ptr<CWallet>, std::unique_ptr<WalletBatch>>> wallets_vec;
4004 if (data.watchonly_wallet) wallets_vec.emplace_back(data.watchonly_wallet, std::move(watchonly_batch));
4005 if (data.solvable_wallet) wallets_vec.emplace_back(data.solvable_wallet, std::move(solvables_batch));
4006
4007 // Write address book entry to disk
4008 auto func_store_addr = [](WalletBatch& batch, const CTxDestination& dest, const CAddressBookData& entry) {
4009 auto address{EncodeDestination(dest)};
4010 if (entry.purpose) batch.WritePurpose(address, PurposeToString(*entry.purpose));
4011 if (entry.label) batch.WriteName(address, *entry.label);
4012 for (const auto& [id, request] : entry.receive_requests) {
4013 batch.WriteAddressReceiveRequest(dest, id, request);
4014 }
4015 if (entry.previously_spent) batch.WriteAddressPreviouslySpent(dest, true);
4016 };
4017
4018 // Check the address book data in the same way we did for transactions
4019 std::vector<CTxDestination> dests_to_delete;
4020 for (const auto& [dest, record] : m_address_book) {
4021 // Ensure "receive" entries that are no longer part of the original wallet are transferred to another wallet
4022 // Entries for everything else ("send") will be cloned to all wallets.
4023 bool require_transfer = record.purpose == AddressPurpose::RECEIVE && !IsMine(dest);
4024 bool copied = false;
4025 for (auto& [wallet, batch] : wallets_vec) {
4026 LOCK(wallet->cs_wallet);
4027 if (require_transfer && !wallet->IsMine(dest)) continue;
4028
4029 // Copy the entire address book entry
4030 wallet->m_address_book[dest] = record;
4031 func_store_addr(*batch, dest, record);
4032
4033 copied = true;
4034 // Only delete 'receive' records that are no longer part of the original wallet
4035 if (require_transfer) {
4036 dests_to_delete.push_back(dest);
4037 break;
4038 }
4039 }
4040
4041 // Fail immediately if we ever found an entry that was ours and cannot be transferred
4042 // to any of the created wallets (watch-only, solvable).
4043 // Means that no inferred descriptor maps to the stored entry. Which mustn't happen.
4044 if (require_transfer && !copied) {
4045
4046 // Skip invalid/non-watched scripts that will not be migrated
4047 if (not_migrated_dests.contains(dest)) {
4048 dests_to_delete.push_back(dest);
4049 continue;
4050 }
4051
4052 return util::Error{_("Error: Address book data in wallet cannot be identified to belong to migrated wallets")};
4053 }
4054 }
4055
4056 // Persist external wallets address book entries
4057 for (auto& [wallet, batch] : wallets_vec) {
4058 if (!batch->TxnCommit()) {
4059 return util::Error{strprintf(_("Error: Unable to write data to disk for wallet %s"), wallet->GetName())};
4060 }
4061 }
4062
4063 // Remove the things to delete in this wallet
4064 if (dests_to_delete.size() > 0) {
4065 for (const auto& dest : dests_to_delete) {
4067 return util::Error{_("Error: Unable to remove watchonly address book data")};
4068 }
4069 }
4070 }
4071
4072 // If there was no key material in the main wallet, there should be no records on it anymore.
4073 // This wallet will be discarded at the end of the process. Only wallets that contain the
4074 // migrated records will be presented to the user.
4076 if (!m_address_book.empty()) return util::Error{_("Error: Not all address book records were migrated")};
4077 if (!mapWallet.empty()) return util::Error{_("Error: Not all transaction records were migrated")};
4078 }
4079
4080 return {}; // all good
4081}
4082
4087
4088// Returns wallet prefix for migration.
4089// Used to name the backup file and newly created wallets.
4090// E.g. a watch-only wallet is named "<prefix>_watchonly".
4092{
4093 const std::string& name{wallet.GetName()};
4094 return name.empty() ? "default_wallet" : name;
4095}
4096
4098{
4099 AssertLockHeld(wallet.cs_wallet);
4100
4101 // Get all of the descriptors from the legacy wallet
4102 std::optional<MigrationData> data = wallet.GetDescriptorsForLegacy(error);
4103 if (data == std::nullopt) return false;
4104
4105 // Create the watchonly and solvable wallets if necessary
4106 if (data->watch_descs.size() > 0 || data->solvable_descs.size() > 0) {
4107 DatabaseOptions options;
4108 options.require_existing = false;
4109 options.require_create = true;
4111
4114
4115 // Make the wallets
4117 if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
4119 }
4120 if (wallet.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
4122 }
4123 if (data->watch_descs.size() > 0) {
4124 wallet.WalletLogPrintf("Making a new watchonly wallet containing the watched scripts");
4125
4126 DatabaseStatus status;
4127 std::vector<bilingual_str> warnings;
4128 std::string wallet_name = MigrationPrefixName(wallet) + "_watchonly";
4129 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4130 if (!database) {
4131 error = strprintf(_("Wallet file creation failed: %s"), error);
4132 return false;
4133 }
4134
4135 data->watchonly_wallet = CWallet::CreateNew(empty_context, wallet_name, std::move(database), options.create_flags, /*born_encrypted=*/false, error, warnings);
4136 if (!data->watchonly_wallet) {
4137 error = _("Error: Failed to create new watchonly wallet");
4138 return false;
4139 }
4140 res.watchonly_wallet = data->watchonly_wallet;
4141 LOCK(data->watchonly_wallet->cs_wallet);
4142
4143 // Parse the descriptors and add them to the new wallet
4144 for (const auto& [desc_str, creation_time] : data->watch_descs) {
4145 // Parse the descriptor
4147 std::string parse_err;
4148 std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, parse_err, /*require_checksum=*/ true);
4149 // LegacyDataSPKM should not produce invalid, multipath, or ranged watch-only descriptors.
4150 assert(descs.size() == 1);
4151 assert(!descs.at(0)->IsRange());
4152
4153 // Add to the wallet
4154 WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
4155 if (auto spkm_res = data->watchonly_wallet->AddWalletDescriptor(w_desc, keys, "", false); !spkm_res) {
4156 throw std::runtime_error(util::ErrorString(spkm_res).original);
4157 }
4158 }
4159
4160 // Add the wallet to settings
4161 UpdateWalletSetting(*context.chain, wallet_name, load_on_startup, warnings);
4162 }
4163 if (data->solvable_descs.size() > 0) {
4164 wallet.WalletLogPrintf("Making a new watchonly wallet containing the unwatched solvable scripts");
4165
4166 DatabaseStatus status;
4167 std::vector<bilingual_str> warnings;
4168 std::string wallet_name = MigrationPrefixName(wallet) + "_solvables";
4169 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4170 if (!database) {
4171 error = strprintf(_("Wallet file creation failed: %s"), error);
4172 return false;
4173 }
4174
4175 data->solvable_wallet = CWallet::CreateNew(empty_context, wallet_name, std::move(database), options.create_flags, /*born_encrypted=*/false, error, warnings);
4176 if (!data->solvable_wallet) {
4177 error = _("Error: Failed to create new watchonly wallet");
4178 return false;
4179 }
4180 res.solvables_wallet = data->solvable_wallet;
4181 LOCK(data->solvable_wallet->cs_wallet);
4182
4183 // Parse the descriptors and add them to the new wallet
4184 for (const auto& [desc_str, creation_time] : data->solvable_descs) {
4185 // Parse the descriptor
4187 std::string parse_err;
4188 std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, parse_err, /*require_checksum=*/ true);
4189 // LegacyDataSPKM should not produce invalid, multipath, or ranged watch-only descriptors.
4190 assert(descs.size() == 1);
4191 assert(!descs.at(0)->IsRange());
4192
4193 // Add to the wallet
4194 WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
4195 if (auto spkm_res = data->solvable_wallet->AddWalletDescriptor(w_desc, keys, "", false); !spkm_res) {
4196 throw std::runtime_error(util::ErrorString(spkm_res).original);
4197 }
4198 }
4199
4200 // Add the wallet to settings
4201 UpdateWalletSetting(*context.chain, wallet_name, load_on_startup, warnings);
4202 }
4203 }
4204
4205 // Add the descriptors to the wallet, remove the LegacyDataSPKM, and clean up transactions and address book data
4206 return RunWithinTxn(wallet.GetDatabase(), /*process_desc=*/"apply migration process", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet){
4207 if (auto res_migration = wallet.ApplyMigrationData(batch, *data); !res_migration) {
4208 error = util::ErrorString(res_migration);
4209 return false;
4210 }
4211 wallet.WalletLogPrintf("Wallet migration complete.");
4212 return true;
4213 });
4214}
4215
4217{
4218 std::vector<bilingual_str> warnings;
4219 bilingual_str error;
4220
4221 // The only kind of wallets that could be loaded are descriptor ones, which don't need to be migrated.
4222 if (auto wallet = GetWallet(context, wallet_name)) {
4223 assert(wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4224 return util::Error{_("Error: This wallet is already a descriptor wallet")};
4225 } else {
4226 // Check if the wallet is BDB
4227 const auto& wallet_path = GetWalletPath(wallet_name);
4228 if (!wallet_path) {
4230 }
4231 if (!fs::exists(*wallet_path)) {
4232 return util::Error{_("Error: Wallet does not exist")};
4233 }
4235 return util::Error{_("Error: This wallet is already a descriptor wallet")};
4236 }
4237 }
4238
4239 // Load the wallet but only in the context of this function.
4240 // No signals should be connected nor should anything else be aware of this wallet
4242 empty_context.args = context.args;
4243 DatabaseOptions options;
4244 options.require_existing = true;
4245 options.require_format = DatabaseFormat::BERKELEY_RO;
4246 DatabaseStatus status;
4247 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4248 if (!database) {
4249 return util::Error{Untranslated("Wallet file verification failed.") + Untranslated(" ") + error};
4250 }
4251
4252 // Make the local wallet
4253 std::shared_ptr<CWallet> local_wallet = CWallet::LoadExisting(empty_context, wallet_name, std::move(database), error, warnings);
4254 if (!local_wallet) {
4255 return util::Error{Untranslated("Wallet loading failed.") + Untranslated(" ") + error};
4256 }
4257
4259}
4260
4262{
4264 bilingual_str error;
4265 std::vector<bilingual_str> warnings;
4266
4267 DatabaseOptions options;
4268 options.require_existing = true;
4269 DatabaseStatus status;
4270
4271 const std::string wallet_name = local_wallet->GetName();
4272
4273 // Before anything else, check if there is something to migrate.
4274 if (local_wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
4275 return util::Error{_("Error: This wallet is already a descriptor wallet")};
4276 }
4277
4278 // Make a backup of the DB in the wallet's directory with a unique filename
4279 // using the wallet name and current timestamp. The backup filename is based
4280 // on the name of the parent directory containing the wallet data in most
4281 // cases, but in the case where the wallet name is a path to a data file,
4282 // the name of the data file is used, and in the case where the wallet name
4283 // is blank, "default_wallet" is used.
4284 const std::string backup_prefix = wallet_name.empty() ? MigrationPrefixName(*local_wallet) : [&] {
4285 // fs::weakly_canonical resolves relative specifiers and remove trailing slashes.
4286 const auto legacy_wallet_path = fs::weakly_canonical(GetWalletDir() / fs::PathFromString(wallet_name));
4287 return fs::PathToString(legacy_wallet_path.filename());
4288 }();
4289
4290 fs::path backup_filename = fs::PathFromString(strprintf("%s_%d.legacy.bak", backup_prefix, GetTime()));
4291 fs::path backup_path = fsbridge::AbsPathJoin(GetWalletDir(), backup_filename);
4292 if (!local_wallet->BackupWallet(fs::PathToString(backup_path))) {
4293 return util::Error{_("Error: Unable to make a backup of your wallet")};
4294 }
4295 res.backup_path = backup_path;
4296
4297 bool success = false;
4298
4299 // Unlock the wallet if needed
4300 if (local_wallet->IsLocked()) {
4301 if (auto unlocked{local_wallet->Unlock(passphrase)}; !unlocked) return util::Error{unlocked.error().message};
4302 }
4303
4304 // Indicates whether the current wallet is empty after migration.
4305 // Notes:
4306 // When non-empty: the local wallet becomes the main spendable wallet.
4307 // When empty: The local wallet is excluded from the result, as the
4308 // user does not expect an empty spendable wallet after
4309 // migrating only watch-only scripts.
4310 bool empty_local_wallet = false;
4311
4312 {
4313 LOCK(local_wallet->cs_wallet);
4314 // First change to using SQLite
4315 if (!local_wallet->MigrateToSQLite(error)) return util::Error{error};
4316
4317 // Do the migration of keys and scripts for non-empty wallets, and cleanup if it fails
4319 success = DoMigration(*local_wallet, context, error, res, load_wallet);
4320 // No scripts mean empty wallet after migration
4321 empty_local_wallet = local_wallet->GetAllScriptPubKeyMans().empty();
4322 } else {
4323 // Make sure that descriptors flag is actually set
4324 local_wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
4325 success = true;
4326 }
4327 }
4328
4329 // In case of loading failure, we need to remember the wallet files we have created to remove.
4330 // A `set` is used as it may be populated with the same wallet directory paths multiple times,
4331 // both before and after loading. This ensures the set is complete even if one of the wallets
4332 // fails to load.
4333 std::set<fs::path> wallet_files_to_remove;
4334 std::set<fs::path> wallet_empty_dirs_to_remove;
4335
4336 // Helper to track wallet files and directories for cleanup on failure.
4337 // Only directories of wallets created during migration (not the main wallet) are tracked.
4338 auto track_for_cleanup = [&](const CWallet& wallet) {
4339 const auto files = wallet.GetDatabase().Files();
4340 wallet_files_to_remove.insert(files.begin(), files.end());
4341 if (wallet.GetName() != wallet_name) {
4342 // If this isn’t the main wallet, mark its directory for removal.
4343 // This applies to the watch-only and solvable wallets.
4344 // Wallets stored directly as files in the top-level directory
4345 // (e.g. default unnamed wallets) don’t have a removable parent directory.
4346 wallet_empty_dirs_to_remove.insert(fs::PathFromString(wallet.GetDatabase().Filename()).parent_path());
4347 }
4348 };
4349
4350
4351 if (success) {
4352 Assume(!res.wallet); // We will set it here.
4353 // Check if the local wallet is empty after migration
4354 if (empty_local_wallet) {
4355 // This wallet has no records. We can safely remove it.
4356 std::vector<fs::path> paths_to_remove = local_wallet->GetDatabase().Files();
4357 local_wallet.reset();
4358 for (const auto& path_to_remove : paths_to_remove) fs::remove(path_to_remove);
4359 }
4360
4361 if (load_wallet) {
4362 LogInfo("Loading new wallets after migration...\n");
4365 } else {
4366 UpdateWalletSetting(*context.chain, wallet_name, /*load_on_startup=*/false, warnings);
4367 }
4368 // Migration successful, if load_wallet is set load all the migrated wallets.
4369 bool main_wallet_set{false};
4370 for (std::shared_ptr<CWallet>* wallet_ptr : {&local_wallet, &res.watchonly_wallet, &res.solvables_wallet}) {
4371 if (success && *wallet_ptr) {
4372 std::shared_ptr<CWallet>& wallet = *wallet_ptr;
4373 // Track db path
4375 assert(wallet.use_count() == 1);
4376 std::string wallet_name = wallet->GetName();
4377 wallet.reset();
4378 if (load_wallet) {
4379 wallet = LoadWallet(context, wallet_name, /*load_on_start=*/std::nullopt, options, status, error, warnings);
4380 if (!wallet) {
4381 LogError("Failed to load wallet '%s' after migration. Rolling back migration to preserve consistency. "
4382 "Error cause: %s\n", wallet_name, error.original);
4383 success = false;
4384 break;
4385 }
4386 }
4387 // Set the first wallet as the main one.
4388 // The loop order is intentional and must always start with the local wallet.
4389 if (!main_wallet_set) {
4390 res.wallet_name = wallet_name;
4391 if (load_wallet) res.wallet = std::move(wallet);
4392 main_wallet_set = true;
4393 }
4394 if (wallet_ptr == &res.watchonly_wallet) {
4395 res.watchonly_wallet_name = wallet_name;
4396 } else if (wallet_ptr == &res.solvables_wallet) {
4397 res.solvables_wallet_name = wallet_name;
4398 }
4399 }
4400 }
4401 }
4402 if (!success) {
4403 // Make list of wallets to cleanup
4404 std::vector<std::shared_ptr<CWallet>> created_wallets;
4405 if (local_wallet) created_wallets.push_back(std::move(local_wallet));
4406 if (res.watchonly_wallet) created_wallets.push_back(std::move(res.watchonly_wallet));
4407 if (res.solvables_wallet) created_wallets.push_back(std::move(res.solvables_wallet));
4408
4409 // Get the directories to remove after unloading
4410 for (std::shared_ptr<CWallet>& wallet : created_wallets) {
4412 }
4413
4414 // Unload the wallets
4415 for (std::shared_ptr<CWallet>& w : created_wallets) {
4416 if (w->HaveChain()) {
4417 // Unloading for wallets that were loaded for normal use
4418 if (!RemoveWallet(context, w, /*load_on_start=*/false)) {
4419 error += _("\nUnable to cleanup failed migration");
4420 return util::Error{error};
4421 }
4422 WaitForDeleteWallet(std::move(w));
4423 } else {
4424 // Unloading for wallets in local context
4425 assert(w.use_count() == 1);
4426 w.reset();
4427 }
4428 }
4429
4430 // First, delete the db files we have created throughout this process and nothing else
4431 for (const fs::path& file : wallet_files_to_remove) {
4432 fs::remove(file);
4433 }
4434
4435 // Second, delete the created wallet directories and nothing else. They must be empty at this point.
4436 for (const fs::path& dir : wallet_empty_dirs_to_remove) {
4437 Assume(fs::is_empty(dir));
4438 fs::remove(dir);
4439 }
4440
4441 // Restore the backup
4442 // Convert the backup file to the wallet db file by renaming it and moving it into the wallet's directory.
4444 const auto& ptr_wallet = RestoreWallet(context, backup_path, wallet_name, /*load_on_start=*/std::nullopt, status, restore_error, warnings, /*load_after_restore=*/false, /*allow_unnamed=*/true);
4445 if (!restore_error.empty()) {
4446 error += restore_error + _("\nUnable to restore backup of wallet.");
4447 return util::Error{error};
4448 }
4449 // Verify that the legacy wallet is not loaded after restoring from the backup.
4451
4452 return util::Error{error};
4453 }
4454 return res;
4455}
4456
4457void CWallet::CacheNewScriptPubKeys(const std::set<CScript>& spks, ScriptPubKeyMan* spkm)
4458{
4459 for (const auto& script : spks) {
4460 m_cached_spks[script].push_back(spkm);
4461 }
4462}
4463
4464void CWallet::TopUpCallback(const std::set<CScript>& spks, ScriptPubKeyMan* spkm)
4465{
4466 // Update scriptPubKey cache
4467 CacheNewScriptPubKeys(spks, spkm);
4468}
4469
4470CWallet::HDPubKeyMap CWallet::GetHDPubKeys(HDKeyFilter filter) const
4471{
4472 AssertLockHeld(cs_wallet);
4473
4474 Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4475
4477 for (const auto& spkm : filter == HDKeyFilter::Active ? GetActiveScriptPubKeyMans() : GetAllScriptPubKeyMans()) {
4478 auto* desc_spkm = Assert(dynamic_cast<DescriptorScriptPubKeyMan*>(spkm));
4479 LOCK(desc_spkm->cs_desc_man);
4480 WalletDescriptor w_desc = desc_spkm->GetWalletDescriptor();
4481 if (filter == HDKeyFilter::UnusedKey && w_desc.descriptor->HasScripts()) continue;
4482
4483 std::set<CPubKey> desc_pubkeys;
4484 std::set<CExtPubKey> desc_xpubs;
4486 for (const CExtPubKey& xpub : desc_xpubs) {
4487 xpubs[xpub].insert(desc_spkm);
4488 }
4489 }
4490 return xpubs;
4491}
4492
4493std::optional<CKey> CWallet::GetKey(const CKeyID& keyid) const
4494{
4495 Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4496
4497 for (const auto& spkm : GetAllScriptPubKeyMans()) {
4500 LOCK(desc_spkm->cs_desc_man);
4501 if (std::optional<CKey> key = desc_spkm->GetKey(keyid)) {
4502 return key;
4503 }
4504 }
4505 return std::nullopt;
4506}
4507
4508std::optional<CExtKey> CWallet::GetExtKey(const CExtPubKey& xpub) const
4509{
4510 if (std::optional<CKey> key = GetKey(xpub.pubkey.GetID())) {
4511 return CExtKey{xpub, *key};
4512 }
4513 return std::nullopt;
4514}
4515
4516void CWallet::WriteBestBlock() const
4517{
4518 AssertLockHeld(cs_wallet);
4519
4520 if (!m_last_block_processed.IsNull()) {
4522 chain().findBlock(m_last_block_processed, FoundBlock().locator(loc));
4523
4524 if (!loc.IsNull()) {
4525 WalletBatch batch(GetDatabase());
4526 batch.WriteBestBlock(loc);
4527 }
4528 }
4529}
4530
4531void CWallet::RefreshTXOsFromTx(const CWalletTx& wtx)
4532{
4533 AssertLockHeld(cs_wallet);
4534 for (uint32_t i = 0; i < wtx.GetTx()->vout.size(); ++i) {
4535 const CTxOut& txout = wtx.GetTx()->vout.at(i);
4536 if (!IsMine(txout)) continue;
4537 COutPoint outpoint(wtx.GetHash(), i);
4538 if (m_txos.contains(outpoint)) {
4539 } else {
4540 m_txos.emplace(outpoint, WalletTXO{wtx, txout});
4541 }
4542 }
4543}
4544
4545void CWallet::RefreshAllTXOs()
4546{
4547 AssertLockHeld(cs_wallet);
4548 for (const auto& [_, wtx] : mapWallet) {
4549 RefreshTXOsFromTx(wtx);
4550 }
4551}
4552
4553std::optional<WalletTXO> CWallet::GetTXO(const COutPoint& outpoint) const
4554{
4555 AssertLockHeld(cs_wallet);
4556 const auto& it = m_txos.find(outpoint);
4557 if (it == m_txos.end()) {
4558 return std::nullopt;
4559 }
4560 return it->second;
4561}
4562
4563void CWallet::DisconnectChainNotifications()
4564{
4565 if (m_chain_notifications_handler) {
4566 m_chain_notifications_handler->disconnect();
4567 chain().waitForNotifications();
4568 m_chain_notifications_handler.reset();
4569 }
4570}
4571
4572void CWallet::SetLastDecryptedFeatures(uint64_t features)
4573{
4574 AssertLockHeld(cs_wallet);
4576}
4577} // namespace wallet
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
bool MoneyRange(const CAmount &nValue)
Definition amount.h:27
int64_t CAmount
Amount in satoshis (Can be negative)
Definition amount.h:12
ArgsManager gArgs
Definition args.cpp:39
for(unsigned int i=0;i< 256;++i)
int ret
int flags
ArgsManager & args
Definition bitcoind.cpp:280
constexpr int64_t TIMESTAMP_WINDOW
Timestamp window used as a grace period by code that compares external timestamps (such as timestamps...
Definition chain.h:37
#define Assert(val)
Identity function.
Definition check.h:119
#define STR_INTERNAL_BUG(msg)
Definition check.h:100
#define Assume(val)
Assume is the identity function.
Definition check.h:131
std::string GetArg(const std::string &strArg, const std::string &strDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return string argument or default value.
Definition args.cpp:518
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition args.h:318
bool GetBoolArg(const std::string &strArg, bool fDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return boolean argument or default value.
Definition args.cpp:561
std::vector< CTransactionRef > vtx
Definition block.h:77
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
Definition feerate.h:32
std::string ToString(FeeRateFormat fee_rate_format=FeeRateFormat::BTC_KVB) const
Definition feerate.cpp:34
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes. (Rounds down)
Definition feerate.cpp:21
An encapsulated private key.
Definition key.h:46
A reference to a CKey: the Hash160 of its serialized public key.
Definition pubkey.h:29
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition transaction.h:30
uint32_t n
Definition transaction.h:33
An encapsulated public key.
Definition pubkey.h:43
Serialized script, used inside transaction inputs and outputs.
Definition script.h:406
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
const Txid & GetHash() const LIFETIMEBOUND
const std::vector< CTxIn > vin
An input of a transaction.
Definition transaction.h:63
An output of a transaction.
CScript scriptPubKey
A UTXO entry.
Definition coins.h:46
Double ended buffer combining vector and stream-like interfaces.
Definition streams.h:165
Fast randomness source.
Definition random.h:386
Different type to mark Mutex at global scope.
Definition sync.h:142
A structure for PSBTs which contain per-input information.
Definition psbt.h:282
A version of CTransaction with the PSBT format.
Definition psbt.h:1239
Tp rand_uniform_delay(const Tp &time, typename Tp::duration range) noexcept
Return the time point advanced by a uniform random duration.
Definition random.h:329
const UniValue & find_value(std::string_view key) const
Definition univalue.cpp:232
const std::string & getValStr() const
Definition univalue.h:68
bool empty() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition btcsignals.h:302
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
Definition chain.h:117
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
virtual bool broadcastTransaction(const CTransactionRef &tx, const CAmount &max_tx_fee, const CFeeRate &max_tx_fee_rate, node::TxBroadcast broadcast_method, std::string &err_string)=0
Process a local transaction, optionally adding it to the mempool and optionally broadcasting it to th...
virtual uint256 getBlockHash(int height)=0
Get block hash. Height must be valid or this function will abort.
virtual bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock &block={})=0
Find first block in the chain with timestamp >= the given time and height >= than the given height,...
virtual bool havePruned()=0
Check if any block has been pruned.
virtual bool updateRwSetting(const std::string &name, const SettingsUpdate &update_function)=0
Updates a setting in <datadir>/settings.json.
virtual bool hasAssumedValidChain()=0
Return true if an assumed-valid snapshot is in use.
virtual bool isInMempool(const Txid &txid)=0
Check if transaction is in mempool.
virtual void waitForNotificationsIfTipChanged(const uint256 &old_tip)=0
Wait for pending notifications to be processed unless block hash points to the current chain tip.
virtual void initMessage(const std::string &message)=0
Send init message.
virtual std::optional< int > findLocatorFork(const CBlockLocator &locator)=0
Return height of the highest block on chain in common with the locator, which will either be the orig...
virtual bool haveBlockOnDisk(int height)=0
Check that the block is available on disk (i.e.
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee and -incrementalrelayfee settings).
Helper for findBlock to selectively return pieces of block data.
Definition chain.h:52
FoundBlock & height(int &height)
Definition chain.h:55
constexpr const std::byte * begin() const
256-bit opaque blob.
Definition uint256.h:196
The util::Expected class provides a standard way for low-level functions to return either error value...
Definition expected.h:44
The util::Unexpected class represents an unexpected value stored in util::Expected.
Definition expected.h:21
Encryption/decryption context with key information.
Definition crypter.h:72
Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key.
Definition crypter.h:35
std::vector< unsigned char > vchSalt
Definition crypter.h:38
unsigned int nDerivationMethod
0 = EVP_sha512()
Definition crypter.h:40
std::vector< unsigned char > vchCryptedKey
Definition crypter.h:37
unsigned int nDeriveIterations
Definition crypter.h:41
static constexpr unsigned int DEFAULT_DERIVE_ITERATIONS
Default/minimum number of key derivation rounds.
Definition crypter.h:48
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition wallet.h:318
void MarkDestinationsDirty(const std::set< CTxDestination > &destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Marks all outputs in each one of the destinations dirty, so their cache is reset and does not return ...
Definition wallet.cpp:2459
bool SetAddressBook(const CTxDestination &address, const std::string &strName, const std::optional< AddressPurpose > &purpose)
Definition wallet.cpp:2347
bool TopUpKeyPool(unsigned int kpSize=0)
Definition wallet.cpp:2422
bool HaveChain() const
Interface to assert chain access.
Definition wallet.h:478
bool GetBroadcastTransactions() const
Inquire whether this wallet broadcasts transactions.
Definition wallet.h:853
DBErrors PopulateWalletFromDB(bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:2185
unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2411
std::function< bool(CWalletTx &wtx, bool new_tx)> UpdateWalletTxFn
Callback for updating transaction metadata in mapWallet.
Definition wallet.h:604
btcsignals::signal< void()> NotifyUnload
Wallet is about to be unloaded.
Definition wallet.h:823
std::optional< WalletTXO > GetTXO(const COutPoint &outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:4553
bool IsActiveScriptPubKeyMan(const ScriptPubKeyMan &spkm) const
Definition wallet.cpp:3288
static bool AttachChain(const std::shared_ptr< CWallet > &wallet, interfaces::Chain &chain, bool rescan_required, bilingual_str &error, std::vector< bilingual_str > &warnings)
Catch wallet up to current chain, scanning new blocks, updating the best block locator and m_last_blo...
Definition wallet.cpp:3053
OutputType m_default_address_type
Definition wallet.h:718
static std::shared_ptr< CWallet > LoadExisting(WalletContext &context, const std::string &name, std::unique_ptr< WalletDatabase > database, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:3009
void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Adds the active ScriptPubKeyMan for the specified type and internal.
Definition wallet.cpp:3559
btcsignals::signal< void(const CTxDestination &address, const std::string &label, bool isMine, AddressPurpose purpose, ChangeType status)> NotifyAddressBookChanged
Address book entry changed.
Definition wallet.h:832
void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Loads an active ScriptPubKeyMan for the specified type and internal.
Definition wallet.cpp:3573
std::unique_ptr< WalletDatabase > m_database
Internal database handle.
Definition wallet.h:388
bool IsLockedCoin(const COutPoint &output) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2606
bool SignTransaction(CMutableTransaction &tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Fetch the inputs and sign with SIGHASH_ALL.
Definition wallet.cpp:1975
CWallet(interfaces::Chain *chain, const std::string &name, std::unique_ptr< WalletDatabase > database)
Construct wallet with specified name and database implementation.
Definition wallet.cpp:485
std::function< void(const CTxDestination &dest, const std::string &label, bool is_change, const std::optional< AddressPurpose > purpose)> ListAddrBookFunc
Walk-through the address book entries.
Definition wallet.h:762
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const
Get the SigningProvider for a script.
Definition wallet.cpp:3341
bool IsTxImmatureCoinBase(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:3225
void RefreshAllTXOs() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Cache outputs that belong to the wallet for all transactions in the wallet.
Definition wallet.cpp:4545
void AddActiveScriptPubKeyManWithDb(WalletBatch &batch, uint256 id, OutputType type, bool internal)
Definition wallet.cpp:3565
std::set< ScriptPubKeyMan * > GetActiveScriptPubKeyMans() const
Returns all unique ScriptPubKeyMans in m_internal_spk_managers and m_external_spk_managers.
Definition wallet.cpp:3274
const CAddressBookData * FindAddressBookEntry(const CTxDestination &, bool allow_change=false) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:3173
void postInitProcess()
Wallet post-init setup Gives the wallet a chance to register repetitive tasks and complete post-init ...
Definition wallet.cpp:3183
int GetTxDepthInMainChain(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Return depth of transaction in blockchain: <0 : conflicts with a transaction this deep in the blockch...
Definition wallet.cpp:3199
unsigned int nMasterKeyMaxID
Definition wallet.h:468
bool SetAddressReceiveRequest(WalletBatch &batch, const CTxDestination &dest, const std::string &id, const std::string &value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2735
int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get last block processed height.
Definition wallet.h:982
ChainScanner & Scanner()
Definition wallet.cpp:499
LegacyDataSPKM * GetLegacyDataSPKM() const
Get the LegacyDataSPKM used for all legacy output types and both internal and external chains.
Definition wallet.cpp:3372
std::optional< common::PSBTError > FillPSBT(PartiallySignedTransaction &psbtx, const common::PSBTFillOptions &options, bool &complete, size_t *n_signed=nullptr) const
Fills out a PSBT with information from the wallet.
Definition wallet.cpp:2009
void SetupWalletGeneration() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Setup new descriptors or seed for new address generation.
Definition wallet.cpp:3547
std::vector< CTxDestination > ListAddrBookAddresses(const std::optional< AddrBookFilter > &filter) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Filter and retrieve destinations stored in the addressbook.
Definition wallet.cpp:2482
DescriptorScriptPubKeyMan * GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const
Return the DescriptorScriptPubKeyMan for a WalletDescriptor if it is already in the wallet.
Definition wallet.cpp:3610
btcsignals::signal< void(CWallet *wallet)> NotifyStatusChanged
Wallet status (encrypted, locked) changed.
Definition wallet.h:850
std::unique_ptr< ChainScanner > m_scanner
Definition wallet.h:390
btcsignals::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
Definition wallet.h:844
std::map< OutputType, ScriptPubKeyMan * > m_external_spk_managers
Definition wallet.h:408
std::optional< MigrationData > GetDescriptorsForLegacy(bilingual_str &error) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get all of the descriptors from a legacy wallet.
Definition wallet.cpp:3842
bool HaveCryptedKeys() const
Definition wallet.cpp:3426
LegacyDataSPKM * GetOrCreateLegacyDataSPKM()
Definition wallet.cpp:3392
interfaces::Chain & chain() const
Interface for accessing chain state.
Definition wallet.h:504
const std::string & GetName() const
Get a name for this wallet for logging/debugging purposes.
Definition wallet.h:464
bool Unlock(const CKeyingMaterial &vMasterKeyIn)
Definition wallet.cpp:3259
bool MigrateToSQLite(bilingual_str &error) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Move all records from the BDB database to a new SQLite database for storage.
Definition wallet.cpp:3768
bool BackupWallet(const std::string &strDest) const
Definition wallet.cpp:3193
std::map< OutputType, ScriptPubKeyMan * > m_internal_spk_managers
Definition wallet.h:409
std::string m_name
Wallet name: relative directory name or "" for default wallet.
Definition wallet.h:385
std::map< CExtPubKey, std::set< DescriptorScriptPubKeyMan * > > HDPubKeyMap
Definition wallet.h:1083
bool SetAddressPreviouslySpent(WalletBatch &batch, const CTxDestination &dest, bool used) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2694
void LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor &desc, const KeyMap &keys, const CryptedKeyMap &ckeys)
Instantiate a descriptor ScriptPubKeyMan from the WalletDescriptor and load it.
Definition wallet.cpp:3446
util::Result< void > RemoveTxs(std::vector< Txid > &txs_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Erases the provided transactions from the wallet.
Definition wallet.cpp:2239
RecursiveMutex m_relock_mutex
Definition wallet.h:581
btcsignals::signal< void(const Txid &hashTx, ChangeType status)> NotifyTransactionChanged
Wallet transaction added, removed or updated.
Definition wallet.h:838
std::string m_notify_tx_changed_script
Notify external script when a wallet transaction comes in or is updated (handled by -walletnotify)
Definition wallet.h:735
std::vector< std::string > GetAddressReceiveRequests() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2724
std::vector< WalletDescriptor > GetWalletDescriptors(const CScript &script) const
Get the wallet descriptors for a script.
Definition wallet.cpp:3360
bool fBroadcastTransactions
Whether this wallet will submit newly created transactions to the node's mempool and prompt rebroadca...
Definition wallet.h:330
CAmount m_max_tx_fee
Absolute maximum transaction fee (in satoshis) used by the wallet.
Definition wallet.h:727
size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2399
int GetTxBlocksToMaturity(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:3213
bool HasEncryptionKeys() const override
Definition wallet.cpp:3421
bool CanGrindR() const
Whether the (external) signer performs R-value signature grinding.
Definition wallet.cpp:4083
void CommitTransaction(CTransactionRef tx, std::optional< Txid > replaces_txid=std::nullopt, std::optional< std::string > comment=std::nullopt, std::optional< std::string > comment_to=std::nullopt, const std::vector< std::string > &messages={}, const std::vector< std::string > &payment_requests={})
Submit the transaction to the node's mempool and then relay to peers.
Definition wallet.cpp:2138
util::Result< CTxDestination > GetNewChangeDestination(OutputType type)
Definition wallet.cpp:2448
std::optional< bool > IsInternalScriptPubKeyMan(ScriptPubKeyMan *spk_man) const
Returns whether the provided ScriptPubKeyMan is internal.
Definition wallet.cpp:3624
void LoadLockedCoin(const COutPoint &coin, bool persistent) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2562
void SetupLegacyDataSPKM()
Create a LegacyDataSPKM and set it for all legacy output types and both internal and external chains.
Definition wallet.cpp:3398
TxItems wtxOrdered
Definition wallet.h:485
static std::shared_ptr< CWallet > CreateNew(WalletContext &context, const std::string &name, std::unique_ptr< WalletDatabase > database, uint64_t wallet_creation_flags, bool born_encrypted, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:2947
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const
Definition wallet.cpp:2064
MasterKeyMap mapMasterKeys
Definition wallet.h:467
util::Result< void > ApplyMigrationData(WalletBatch &local_wallet_batch, MigrationData &data) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Adds the ScriptPubKeyMans from MigrationData to this wallet, removes the LegacyDataSPKM,...
Definition wallet.cpp:3861
util::Expected< CExtPubKey, WalletError > AddHDKey(const std::optional< CExtKey > &key)
Add an HD key to the wallet and return its master xpub.
Definition wallet.cpp:3697
NodeClock::time_point m_next_resend
The next scheduled rebroadcast of wallet transactions.
Definition wallet.h:327
HDKeyFilter
Which descriptors GetHDPubKeys() should consider.
Definition wallet.h:1078
WalletDatabase & GetDatabase() const override
Definition wallet.h:456
bool EraseAddressReceiveRequest(WalletBatch &batch, const CTxDestination &dest, const std::string &id) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2742
bool SetAddressBookWithDB(WalletBatch &batch, const CTxDestination &address, const std::string &strName, const std::optional< AddressPurpose > &strPurpose)
Definition wallet.cpp:2311
void WriteBestBlock() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Write the current best block to database.
Definition wallet.cpp:4516
bool DelAddressBookWithDB(WalletBatch &batch, const CTxDestination &address)
Definition wallet.cpp:2360
void LoadAddressReceiveRequest(const CTxDestination &dest, const std::string &id, const std::string &request) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Appends payment request to destination.
Definition wallet.cpp:2713
void AddScriptPubKeyMan(const uint256 &id, std::unique_ptr< ScriptPubKeyMan > spkm_man)
Definition wallet.cpp:3382
void DeactivateScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Remove specified ScriptPubKeyMan from set of active SPK managers.
Definition wallet.cpp:3593
std::atomic< uint64_t > m_wallet_flags
WalletFlags set on this wallet.
Definition wallet.h:371
bool LockCoin(const COutPoint &output, bool persist) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2568
bool IsLocked() const override
Definition wallet.cpp:3233
OutputType TransactionChangeType(const std::optional< OutputType > &change_type, const std::vector< CRecipient > &vecSend) const
Definition wallet.cpp:2077
std::set< ScriptPubKeyMan * > GetAllScriptPubKeyMans() const
Returns all unique ScriptPubKeyMans.
Definition wallet.cpp:3299
void RefreshTXOsFromTx(const CWalletTx &wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Cache outputs that belong to the wallet from a single transaction.
Definition wallet.cpp:4531
unsigned int ComputeTimeSmart(const CWalletTx &wtx, bool rescanning_old_block) const
Compute smart timestamp for a transaction being added to the wallet.
Definition wallet.cpp:2643
std::set< std::string > ListAddrBookLabels(std::optional< AddressPurpose > purpose) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Retrieve all the known labels in the address book.
Definition wallet.cpp:2498
void ListLockedCoins(std::vector< COutPoint > &vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2612
bool UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2594
util::Result< CTxDestination > GetNewDestination(OutputType type, const std::string &label)
Definition wallet.cpp:2432
ScriptPubKeyMan * GetScriptPubKeyMan(const OutputType &type, bool internal) const
Get the ScriptPubKeyMan for the given OutputType and internal/external chain.
Definition wallet.cpp:3308
bool IsAddressPreviouslySpent(const CTxDestination &dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2718
bool WithEncryptionKey(std::function< bool(const CKeyingMaterial &)> cb) const override
Pass the encryption key to cb().
Definition wallet.cpp:3415
int64_t m_keypool_size
Number of pre-generated keys/scripts by each spkm (part of the look-ahead process,...
Definition wallet.h:732
RecursiveMutex cs_wallet
Main wallet lock.
Definition wallet.h:454
void ForEachAddrBookEntry(const ListAddrBookFunc &func) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2473
void ConnectScriptPubKeyManNotifiers()
Connect the signals from ScriptPubKeyMans to the signals in CWallet.
Definition wallet.cpp:3434
void WalletLogPrintf(util::log::FormatString< sizeof...(Params)> wallet_fmt, const Params &... params) const
Prepends the wallet name in logging output to ease debugging in multi-wallet use cases.
Definition wallet.h:934
bool DelAddressBook(const CTxDestination &address)
Definition wallet.cpp:2353
std::atomic< int64_t > m_best_block_time
Definition wallet.h:332
std::unordered_map< CScript, std::vector< ScriptPubKeyMan * >, SaltedSipHasher > m_cached_spks
Cache of descriptor ScriptPubKeys used for IsMine. Maps ScriptPubKey to set of spkms.
Definition wallet.h:426
std::multimap< int64_t, CWalletTx * > TxItems
Definition wallet.h:484
void SetupOwnDescriptorScriptPubKeyMans(WalletBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Create new seed and default DescriptorScriptPubKeyMans for this wallet.
Definition wallet.cpp:3481
void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:3497
DescriptorScriptPubKeyMan & SetupDescriptorScriptPubKeyMan(WalletBatch &batch, const CExtKey &master_key, const OutputType &output_type, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Create new DescriptorScriptPubKeyMan and add it to the wallet.
Definition wallet.cpp:3457
std::map< uint256, std::unique_ptr< ScriptPubKeyMan > > m_spk_managers
Definition wallet.h:413
std::function< TxUpdate(CWalletTx &wtx)> TryUpdatingStateFn
Definition wallet.h:353
bool UnlockCoin(const COutPoint &output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:2579
std::atomic< int64_t > m_birth_time
Definition wallet.h:336
void LoadAddressPreviouslySpent(const CTxDestination &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Marks destination as previously spent.
Definition wallet.cpp:2708
util::Result< std::reference_wrapper< DescriptorScriptPubKeyMan > > AddWalletDescriptor(WalletDescriptor &desc, const FlatSigningProvider &signing_provider, const std::string &label, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Add a descriptor to the wallet, return a ScriptPubKeyMan & associated output type.
Definition wallet.cpp:3643
static bool LoadWalletArgs(std::shared_ptr< CWallet > wallet, const WalletContext &context, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:2799
CFeeRate m_max_tx_fee_rate
Maximum transaction fee rate used for the wallet.
Definition wallet.h:730
void ClearInMemoryTxStateForTest() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Drop all in-memory transaction state: the transactions themselves, the outputs derived from them,...
Definition wallet.cpp:2300
std::set< ScriptPubKeyMan * > GetScriptPubKeyMans(const CScript &script) const
Get all the ScriptPubKeyMans for a script.
Definition wallet.cpp:3318
util::Result< void > DisplayAddress(const CTxDestination &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Display address on an external signer.
Definition wallet.cpp:2547
void SetLastDecryptedFeatures(uint64_t features) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Set the features of the last client to decrypt this wallet.
Definition wallet.cpp:4572
A transaction with a bunch of additional info that only the owner cares about.
bool Update(CTransactionRef tx, const TxState &new_state, WalletBatch &batch, bool metadata_changed)
bool isBlockConflicted() const
std::vector< std::string > m_messages
const Txid & GetHash() const LIFETIMEBOUND
const T * state() const
std::set< Txid > mempool_conflicts
std::optional< Txid > m_replaces_txid
void updateState(interfaces::Chain &chain)
Update transaction state when attaching to a chain, filling in heights of conflicted and confirmed bl...
std::optional< std::string > m_comment_to
int64_t nOrderPos
position in ordered transaction list
std::optional< std::string > m_comment
unsigned int nTimeReceived
time received by this node
std::optional< Txid > m_replaced_by_txid
bool IsCoinBase() const
bool InMempool() const
bool isAbandoned() const
std::optional< Txid > truc_child_in_mempool
bool isInactive() const
std::vector< std::string > m_payment_requests
int64_t GetTxTime() const
CTransactionRef GetTx() const
bool IsMalleation(const CWalletTx &tx) const
True if tx is a malleation of this, i.e.
bool m_is_cache_empty
This flag is true if all m_amounts caches are empty.
std::multimap< int64_t, CWalletTx * >::const_iterator m_it_wtxOrdered
unsigned int nTimeSmart
Stable timestamp that never changes, and reflects the order a transaction was added to the wallet.
void MarkDirty()
make sure balances are recalculated
static std::unique_ptr< DescriptorScriptPubKeyMan > LoadFromStorage(WalletStorage &storage, const uint256 &id, WalletDescriptor &descriptor, int64_t keypool_size, const KeyMap &keys, const CryptedKeyMap &ckeys)
static std::unique_ptr< DescriptorScriptPubKeyMan > CreateFromImport(WalletStorage &storage, WalletDescriptor &descriptor, int64_t keypool_size, const FlatSigningProvider &provider)
static std::unique_ptr< DescriptorScriptPubKeyMan > GenerateNewSingleSig(WalletStorage &storage, WalletBatch &batch, int64_t keypool_size, const CExtKey &master_key, OutputType addr_type, bool internal)
static std::unique_ptr< ExternalSignerScriptPubKeyMan > CreateNew(WalletStorage &storage, WalletBatch &batch, int64_t keypool_size, std::unique_ptr< Descriptor > desc)
static std::unique_ptr< ExternalSignerScriptPubKeyMan > LoadFromStorage(WalletStorage &storage, const uint256 &id, WalletDescriptor &descriptor, int64_t keypool_size, const KeyMap &keys, const CryptedKeyMap &ckeys)
static util::Result< ExternalSigner > GetExternalSigner()
A wrapper to reserve an address from a wallet.
Definition wallet.h:206
const CWallet *const pwallet
The wallet to reserve from.
Definition wallet.h:209
void KeepDestination()
Keep the address. Do not return its key to the keypool when this object goes out of scope.
Definition wallet.cpp:2529
CTxDestination address
The destination.
Definition wallet.h:216
bool fInternal
Whether this is from the internal (change output) keypool.
Definition wallet.h:218
void ReturnDestination()
Return reserved address.
Definition wallet.cpp:2538
ScriptPubKeyMan * m_spk_man
The ScriptPubKeyMan to reserve from. Based on type when GetReservedDestination is called.
Definition wallet.h:211
int64_t nIndex
The index of the address's key in the keypool.
Definition wallet.h:214
OutputType const type
Definition wallet.h:212
util::Result< CTxDestination > GetReservedDestination(bool internal)
Reserve an address.
Definition wallet.cpp:2512
virtual void KeepDestination(int64_t index, const OutputType &type)
virtual void ReturnDestination(int64_t index, bool internal, const CTxDestination &addr)
virtual util::Result< CTxDestination > GetReservedDestination(const OutputType type, bool internal, int64_t &index)
Access to the wallet database.
Definition walletdb.h:199
bool EraseName(const std::string &strAddress)
Definition walletdb.cpp:84
DBErrors LoadWallet(CWallet *pwallet)
bool WriteBestBlock(const CBlockLocator &locator)
Definition walletdb.cpp:189
bool ReadBestBlock(CBlockLocator &locator)
Definition walletdb.cpp:195
bool WriteLastOpenedVersion()
Write the current client version in the VERSION record.
bool WriteDescriptorCacheItems(const uint256 &desc_id, const DescriptorCache &cache)
Definition walletdb.cpp:279
bool WriteMasterKey(unsigned int nID, const CMasterKey &kMasterKey)
Definition walletdb.cpp:171
bool WriteWalletFlags(uint64_t flags)
bool TxnBegin()
Begin a new transaction.
bool WriteAddressPreviouslySpent(const CTxDestination &dest, bool previously_spent)
bool EraseAddressReceiveRequest(const CTxDestination &dest, const std::string &id)
bool TxnCommit()
Commit current transaction.
bool WriteName(const std::string &strAddress, const std::string &strName)
Definition walletdb.cpp:79
bool WritePurpose(const std::string &strAddress, const std::string &purpose)
Definition walletdb.cpp:91
bool WriteLastOpenedFeatures()
Write the current client features in the LAST_OPENED_FEATURES record.
bool EraseAddressData(const CTxDestination &dest)
bool WriteOrderPosNext(int64_t nOrderPosNext)
Definition walletdb.cpp:212
bool WriteFullTx(const CWalletTx &wtx)
Definition walletdb.cpp:101
bool ErasePurpose(const std::string &strAddress)
Definition walletdb.cpp:96
bool EraseLockedUTXO(const COutPoint &output)
Definition walletdb.cpp:306
bool WriteLastDecryptedFeatures()
Write the current wallet client features to the LAST_DECRYPTED_FEATURES record.
bool WriteTxMetadata(const CWalletTx &wtx)
Definition walletdb.cpp:123
void RegisterTxnListener(DbTxnListener l)
Registers db txn callback functions.
bool WriteLockedUTXO(const COutPoint &output)
Definition walletdb.cpp:301
bool WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id, bool internal)
Definition walletdb.cpp:217
bool EraseTx(Txid hash)
Definition walletdb.cpp:111
bool WriteAddressReceiveRequest(const CTxDestination &dest, const std::string &id, const std::string &receive_request)
virtual void Close()=0
Flush to the database file and close the database.
virtual bool Backup(const std::string &strDest) const =0
Back up the entire database to a file.
virtual bool Rewrite()=0
Rewrite the entire database on disk.
Descriptor with some wallet metadata.
Definition walletutil.h:86
const std::shared_ptr< const Descriptor > descriptor
Definition walletutil.h:97
DescriptorCache cache
Definition walletutil.h:99
RAII object to check and reserve a wallet rescan.
Definition scan.h:37
void memory_cleanse(void *ptr, size_t len)
Secure overwrite a buffer (possibly containing secret data) with zero-bytes.
Definition cleanse.cpp:14
static UniValue Parse(std::string_view raw, ParamFormat format=ParamFormat::JSON)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition client.cpp:421
static const PrecomputedData data
Precomputed COutPoint and CCoins values.
std::string ShellEscape(const std::string &arg)
Definition system.cpp:37
constexpr int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
Definition consensus.h:19
static path u8path(std::string_view utf8_str)
Definition fs.h:80
static auto quoted(const std::string &s)
Definition fs.h:104
static bool exists(const path &p)
Definition fs.h:94
static bool copy_file(const path &from, const path &to, copy_options options)
Definition fs.h:137
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition fs.h:160
static path PathFromString(const std::string &string)
Convert byte string to path object.
Definition fs.h:183
bool TryCreateDirectories(const fs::path &p)
Ignores exceptions thrown by create_directories if the requested directory exists.
bool IsSpentKey(const CScript &scriptPubKey) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:1047
int64_t IncOrderPosNext(WalletBatch *batch=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Increment the next transaction order id.
Definition wallet.cpp:964
void RecursiveUpdateTxState(const Txid &tx_hash, const TryUpdatingStateFn &try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Mark a transaction (and its in-wallet descendants) as a particular tx state.
Definition wallet.cpp:1384
void MarkInputsDirty(const CTransactionRef &tx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Mark a transaction's inputs dirty, thus forcing the outputs to be recomputed.
Definition wallet.cpp:1306
bool HasWalletSpend(const CTransactionRef &tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Check if a given transaction has any of its outputs spent by another transaction in the wallet.
Definition wallet.cpp:714
bool AbandonTransaction(const Txid &hashTx)
Definition wallet.cpp:1316
void SetWalletFlagWithDB(WalletBatch &batch, uint64_t flags)
Store wallet flags.
Definition wallet.cpp:1758
static bool EncryptMasterKey(const SecureString &wallet_passphrase, const CKeyingMaterial &plain_master_key, CMasterKey &master_key)
Definition wallet.cpp:531
uint64_t GetWalletFlags() const
Retrieve all of the wallet's flags.
Definition wallet.cpp:1818
void updatedBlockTip() override
Definition wallet.cpp:1628
bool TransactionCanBeAbandoned(const Txid &hashTx) const
Return whether transaction can be abandoned.
Definition wallet.cpp:1282
void SyncMalleatedTxMetadata(WalletBatch &batch, const CWalletTx &wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:761
void BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(void SetWalletFlag(uint64_t flags)
Blocks until the wallet state is up-to-date to /at least/ the current chain at the time this function...
Definition wallet.cpp:1752
bool AddToWalletIfInvolvingMe(const CTransactionRef &tx, const SyncTxState &state, bool rescanning_old_block) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Add a transaction to the wallet, or update it.
Definition wallet.cpp:1217
void MaybeUpdateBirthTime(int64_t time)
Updates wallet birth time if 'time' is below it.
Definition wallet.cpp:1823
void blockDisconnected(const interfaces::BlockInfo &block) override
Definition wallet.cpp:1581
std::set< Txid > GetConflicts(const Txid &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get wallet transactions that conflict with given transaction (spend same outputs)
Definition wallet.cpp:691
bool IsWalletFlagSet(uint64_t flag) const override
check if a certain wallet flag is set
Definition wallet.cpp:1785
SpendType HowSpent(const COutPoint &outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:806
util::Expected< void, WalletError > ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase, const SecureString &strNewWalletPassphrase)
Definition wallet.cpp:641
static bool DecryptMasterKey(const SecureString &wallet_passphrase, const CMasterKey &master_key, CKeyingMaterial &plain_master_key)
Definition wallet.cpp:577
void AddToSpends(const COutPoint &outpoint, const Txid &txid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:829
void SetLastBlockProcessedInMem(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:675
void UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag)
Unsets a wallet flag and saves it to disk.
Definition wallet.cpp:1772
bool IsSpent(const COutPoint &outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Outpoint is spent if any non-conflicted transaction spends it:
Definition wallet.cpp:789
void ResubmitWalletTransactions(node::TxBroadcast broadcast_method, bool force)
Definition wallet.cpp:1928
std::set< Txid > GetTxConflicts(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:1874
void UnsetBlankWalletFlag(WalletBatch &batch) override
Unset the blank wallet flag and saves it to disk.
Definition wallet.cpp:1780
CWalletTx * AddToWallet(CTransactionRef tx, const TxState &state, const UpdateWalletTxFn &update_wtx=nullptr, bool rescanning_old_block=false)
Add the transaction to the wallet, wrapping it up inside a CWalletTx.
Definition wallet.cpp:1060
bool MarkReplaced(const Txid &originalHash, const Txid &newHash)
Mark a transaction as replaced by another transaction.
Definition wallet.cpp:985
bool CanGetAddresses(bool internal=false) const
Definition wallet.cpp:1739
void MarkDirty()
Definition wallet.cpp:976
bool LoadToWallet(CWalletTx &&wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:1185
void UpdateTrucSiblingConflicts(const CWalletTx &parent_wtx, const Txid &child_txid, bool add_conflict) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Update mempool conflicts for TRUC sibling transactions.
Definition wallet.cpp:1289
bool LoadWalletFlags(uint64_t flags)
Loads the flags into the wallet.
Definition wallet.cpp:1790
bool IsHDEnabled() const
Definition wallet.cpp:1728
bool SubmitTxMemoryPoolAndRelay(CWalletTx &wtx, std::string &err_string, node::TxBroadcast broadcast_method) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Pass this transaction to node for optional mempool insertion and relay to peers.
Definition wallet.cpp:1831
void blockConnected(const kernel::ChainstateRole &role, const interfaces::BlockInfo &block) override
Definition wallet.cpp:1552
void transactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason) override
Definition wallet.cpp:1483
static NodeClock::time_point GetDefaultNextResend()
Definition wallet.cpp:1901
bool ShouldResend() const
Return true if all conditions for periodically resending transactions are met.
Definition wallet.cpp:1884
bool SyncTransaction(const CTransactionRef &tx, const SyncTxState &state, bool rescanning_old_block=false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:1428
const CWalletTx * GetWalletTx(const Txid &hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:507
void InitWalletFlags(uint64_t flags)
overwrite all flags by the given uint64_t flags must be uninitialised (or 0) only known flags may be ...
Definition wallet.cpp:1802
void UnsetWalletFlag(uint64_t flag)
Unsets a single wallet flag.
Definition wallet.cpp:1766
std::set< CWalletTx *, WalletTxOrderComparator > GetMalleatedVariants(const CWalletTx &wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Collects all wallet txs that differ from wtx only in their scriptSigs (i.e.
Definition wallet.cpp:731
bool EncryptWallet(const SecureString &strWalletPassphrase)
Definition wallet.cpp:846
void SetLastBlockProcessed(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Set last block processed height, and write to database.
Definition wallet.cpp:683
bool IsFromMe(const CTransaction &tx) const
should probably be renamed to IsRelevantToMe
Definition wallet.cpp:1707
DBErrors ReorderTransactions()
Definition wallet.cpp:907
bool IsMine(const CTxDestination &dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:1661
void UpgradeDescriptorCache() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Upgrade DescriptorCaches.
Definition wallet.cpp:516
void SetSpentKeyState(WalletBatch &batch, const Txid &hash, unsigned int n, bool used, std::set< CTxDestination > &tx_destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition wallet.cpp:1028
CAmount GetDebit(const CTxIn &txin) const
Returns amount of debit, i.e.
Definition wallet.cpp:1645
void MarkConflicted(const uint256 &hashBlock, int conflicting_height, const Txid &hashTx)
Mark a transaction (and its in-wallet descendants) as conflicting with a particular block.
Definition wallet.cpp:1354
void transactionAddedToMempool(const CTransactionRef &tx) override
Definition wallet.cpp:1440
void Close()
Close wallet database.
Definition wallet.cpp:726
static util::Unexpected< WalletError > UnlockPassphraseError(const SecureString &passphrase)
Definition wallet.cpp:590
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
Definition interpreter.h:37
Home for simple enum and struct type definitions.
CKey GenerateRandomKey(bool compressed) noexcept
Definition key.cpp:354
std::string EncodeExtKey(const CExtKey &key)
Definition key_io.cpp:302
std::string EncodeDestination(const CTxDestination &dest)
Definition key_io.cpp:311
#define LogInfo(...)
Definition log.h:136
#define LogError(...)
Definition log.h:138
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
@ BLOCK
Removed for block.
@ CONFLICT
Removed for conflict with in-block transaction.
Home for simple string functions returning descriptive messages.
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
Definition moneystr.cpp:45
Money parsing/formatting utilities.
PSBTError
Definition types.h:21
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
Definition settings.h:109
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
Definition messages.cpp:171
bilingual_str AmountHighWarn(const std::string &optname)
Definition messages.cpp:166
fs::path AbsPathJoin(const fs::path &base, const fs::path &path)
Helper function for joining two paths.
Definition fs.cpp:32
std::unique_ptr< Handler > MakeCleanupHandler(std::function< void()> cleanup)
Return handler wrapping a cleanup function.
std::unique_ptr< Wallet > MakeWallet(wallet::WalletContext &context, const std::shared_ptr< wallet::CWallet > &wallet)
Return implementation of Wallet interface.
TxBroadcast
How to broadcast a local transaction.
Definition types.h:38
@ MEMPOOL_AND_BROADCAST_TO_ALL
Add the transaction to the mempool and broadcast to all peers for which tx relay is enabled.
@ MEMPOOL_NO_BROADCAST
Add the transaction to the mempool, but don't broadcast to anybody.
@ NO_MEMPOOL_PRIVATE_BROADCAST
Omit the mempool and directly send the transaction via a few dedicated connections to peers on privac...
bilingual_str ErrorString(const Result< T > &result)
Definition result.h:93
std::string_view RemoveSuffixView(std::string_view str LIFETIMEBOUND, std::string_view suffix)
Definition string.h:178
void ReplaceAll(std::string &in_out, std::string_view search, std::string_view substitute)
Replace every non-overlapping occurrence of search with substitute, treating both literally; the repl...
Definition string.cpp:14
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition string.h:250
constexpr bool DEFAULT_WALLET_RBF
-walletrbf default
Definition wallet.h:135
constexpr bool DEFAULT_WALLETCROSSCHAIN
Definition wallet.h:138
constexpr CAmount HIGH_APS_FEE
discourage APS fee higher than this amount
Definition wallet.h:125
void ReadDatabaseArgs(const ArgsManager &args, DatabaseOptions &options)
Definition db.cpp:153
std::shared_ptr< CWallet > LoadWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:321
constexpr unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
std::unique_ptr< WalletDatabase > MakeDatabase(const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error)
void MaybeResendWalletTxs(WalletContext &context)
Called periodically by the schedule thread.
Definition wallet.cpp:1965
std::variant< TxStateConfirmed, TxStateInMempool, TxStateInactive > SyncTxState
Subset of states transaction sync logic is implemented to handle.
Definition transaction.h:84
std::function< void(std::unique_ptr< interfaces::Wallet > wallet)> LoadWalletFn
Definition context.h:24
std::vector< std::shared_ptr< CWallet > > GetWallets(WalletContext &context)
Definition wallet.cpp:206
util::Result< MigrationResult > MigrateLegacyToDescriptor(const std::string &wallet_name, const SecureString &passphrase, WalletContext &context, bool load_wallet)
Do all steps to migrate a legacy wallet to a descriptor wallet.
Definition wallet.cpp:4216
static bool RunWithinTxn(WalletBatch &batch, std::string_view process_desc, const std::function< bool(WalletBatch &)> &func)
std::variant< TxStateConfirmed, TxStateInMempool, TxStateBlockConflicted, TxStateInactive, TxStateUnrecognized > TxState
All possible CWalletTx states.
Definition transaction.h:81
std::vector< unsigned char, secure_allocator< unsigned char > > CKeyingMaterial
Definition crypter.h:63
std::map< CKeyID, std::pair< CPubKey, std::vector< unsigned char > > > CryptedKeyMap
DBErrors
Overview of wallet database classes:
Definition walletdb.h:46
@ EXTERNAL_SIGNER_SUPPORT_REQUIRED
bool AddWalletSetting(interfaces::Chain &chain, const std::string &wallet_name)
Add wallet name to persistent configuration so it will be loaded on startup.
Definition wallet.cpp:101
@ PassphraseIncorrect
The passphrase does not decrypt the wallet. Callers may ask the user to enter it again.
@ UnlockNeeded
The wallet is locked and the operation requires access to private keys.
@ GenericError
Generic wallet error.
static GlobalMutex g_wallet_release_mutex
Definition wallet.cpp:244
bool RemoveWalletSetting(interfaces::Chain &chain, const std::string &wallet_name)
Remove wallet name from persistent configuration so it will not be loaded on startup.
Definition wallet.cpp:114
static void RefreshMempoolStatus(CWalletTx &tx, interfaces::Chain &chain)
Refresh mempool status so the wallet is in an internally consistent state and immediately knows the t...
Definition wallet.cpp:154
std::unique_ptr< interfaces::Handler > HandleLoadWallet(WalletContext &context, LoadWalletFn load_wallet)
Definition wallet.cpp:228
bool HasLegacyRecords(CWallet &wallet)
Returns true if there are any DBKeys::LEGACY_TYPES record in the wallet db.
Definition walletdb.cpp:525
fs::path GetWalletDir()
Get the path of the wallet directory.
const std::unordered_set< OutputType > LEGACY_OUTPUT_TYPES
Output types associated with LegacyDataSPKM.
constexpr CFeeRate HIGH_MAX_TX_FEERATE
A warning will be emitted if -maxfeerate is set higher than this fee rate (in satoshis per kB).
Definition wallet.h:148
constexpr CAmount HIGH_TX_FEE_PER_KB
Discourage users to set fees higher than this amount (in satoshis) per kB.
Definition wallet.h:144
static std::condition_variable g_wallet_release_cv
Definition wallet.cpp:245
std::unique_ptr< WalletDatabase > MakeWalletDatabase(const std::string &name, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error_string)
Definition wallet.cpp:2788
bool IsBDBFile(const fs::path &path)
Definition db.cpp:94
void NotifyWalletLoaded(WalletContext &context, const std::shared_ptr< CWallet > &wallet)
Definition wallet.cpp:235
fs::path BDBDataFile(const fs::path &wallet_path)
Definition db.cpp:75
constexpr CAmount HIGH_MAX_TX_FEE
-maxtxfee will warn if called with a higher fee than this amount (in satoshis)
Definition wallet.h:146
std::shared_ptr< CWallet > RestoreWallet(WalletContext &context, const fs::path &backup_file, const std::string &wallet_name, std::optional< bool > load_on_start, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings, bool load_after_restore, bool allow_unnamed)
Definition wallet.cpp:406
std::string PurposeToString(AddressPurpose p)
Definition wallet.h:288
bool AddWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet)
Definition wallet.cpp:163
constexpr uint64_t KNOWN_WALLET_FLAGS
Definition wallet.h:158
static void UpdateWalletSetting(interfaces::Chain &chain, const std::string &wallet_name, std::optional< bool > load_on_startup, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:136
static std::string MigrationPrefixName(CWallet &wallet)
Definition wallet.cpp:4091
static GlobalMutex g_loading_wallet_mutex
Definition wallet.cpp:243
bool DoMigration(CWallet &wallet, WalletContext &context, bilingual_str &error, MigrationResult &res, const bool load_on_startup=true) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
Definition wallet.cpp:4097
std::shared_ptr< CWallet > CreateWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:334
static void FlushAndDeleteWallet(CWallet *wallet)
Definition wallet.cpp:250
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
Definition walletutil.h:56
@ WALLET_FLAG_LAST_HARDENED_XPUB_CACHED
Definition walletutil.h:27
@ WALLET_FLAG_KEY_ORIGIN_METADATA
Definition walletutil.h:24
@ WALLET_FLAG_AVOID_REUSE
Definition walletutil.h:21
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition walletutil.h:53
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition walletutil.h:30
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
Definition walletutil.h:50
void WaitForDeleteWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly delete the wallet.
Definition wallet.cpp:266
std::string TxStateString(const T &state)
Return TxState or SyncTxState as a string for logging or debugging.
std::map< CKeyID, CKey > KeyMap
std::shared_ptr< CWallet > GetWallet(WalletContext &context, const std::string &name)
Definition wallet.cpp:219
util::Result< fs::path > GetWalletPath(const std::string &name)
Determine the path that the wallet is stored in.
Definition wallet.cpp:2749
constexpr unsigned int WALLET_CRYPTO_KEY_SIZE
Definition crypter.h:14
constexpr bool DEFAULT_WALLETBROADCAST
Definition wallet.h:136
constexpr unsigned int WALLET_CRYPTO_SALT_SIZE
Definition crypter.h:15
DatabaseStatus
Definition db.h:180
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start, std::vector< bilingual_str > &warnings)
Definition wallet.cpp:175
@ WALLET_CLIENT_FEATURES
Definition walletutil.h:78
std::shared_ptr< CWallet > GetDefaultWallet(WalletContext &context, size_t &count)
Definition wallet.cpp:212
constexpr bool DEFAULT_SPEND_ZEROCONF_CHANGE
Default for -spendzeroconfchange.
Definition wallet.h:129
constexpr unsigned int DEFAULT_TX_CONFIRM_TARGET
-txconfirmtarget default
Definition wallet.h:133
Home for public enum and struct type definitions.
std::optional< OutputType > ParseOutputType(std::string_view type)
const std::string & FormatOutputType(OutputType type)
OutputType
Definition outputtype.h:18
constexpr auto OUTPUT_TYPES
Definition outputtype.h:26
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
bool PSBTInputSignedAndVerified(const PartiallySignedTransaction &psbt, unsigned int input_index, const PrecomputedTransactionData *txdata)
Checks whether a PSBTInput is already signed by doing script verification using final fields.
Definition psbt.cpp:552
void RemoveUnnecessaryTransactions(PartiallySignedTransaction &psbtx)
Reduces the size of the PSBT by dropping unnecessary non_witness_utxos (i.e.
Definition psbt.cpp:760
std::optional< PrecomputedTransactionData > PrecomputePSBTData(const PartiallySignedTransaction &psbt)
Compute a PrecomputedTransactionData object from a psbt.
Definition psbt.cpp:622
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed by checking for non-null finalized fields.
Definition psbt.cpp:547
void GetStrongRandBytes(std::span< unsigned char > bytes) noexcept
Gather entropy from various sources, feed it into the internal PRNG, and generate random data using i...
Definition random.cpp:607
const char * name
Definition rest.cpp:71
static const int64_t values[]
A selection of numbers that do not trigger int64_t overflow when added/subtracted.
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
Definition secure.h:53
constexpr deserialize_type deserialize
Definition serialize.h:52
SigningResult
Definition signmessage.h:43
@ PRIVATE_KEY_NOT_AVAILABLE
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Definition block.h:117
std::vector< uint256 > vHave
Definition block.h:127
Definition key.h:238
void SetSeed(std::span< const std::byte > seed)
Definition key.cpp:381
A mutable version of CTransaction.
std::vector< CTxIn > vin
static time_point now() noexcept
Return current system time or mocked time, if set.
Definition time.cpp:38
std::chrono::time_point< NodeClock > time_point
Definition time.h:28
Bilingual messages:
Definition translation.h:24
bool empty() const
Definition translation.h:35
std::string original
Definition translation.h:25
Instructions for how a PSBT should be signed or filled with information.
Definition types.h:33
Block data sent with blockConnected, blockDisconnected notifications.
Definition chain.h:20
const uint256 * prev_hash
Definition chain.h:22
const CBlock * data
Definition chain.h:26
const uint256 & hash
Definition chain.h:21
unsigned int chain_time_max
Definition chain.h:30
Information about chainstate that notifications are sent from.
Definition types.h:20
bool historical
Whether this is a historical chainstate downloading old blocks to validate an assumeutxo snapshot,...
Definition types.h:28
Definition musig.c:31
bilingual_str message
Definition result.h:16
Address book data.
Definition wallet.h:247
void SetLabel(std::string name)
Definition wallet.h:285
std::optional< std::string > m_op_label
Definition wallet.h:743
SecureString create_passphrase
Definition db.h:173
std::optional< DatabaseFormat > require_format
Definition db.h:171
uint64_t create_flags
Definition db.h:172
struct containing information needed for migrating legacy wallets to descriptor wallets
Result of a wallet scan.
Definition scan.h:19
State of rejected transaction that conflicts with a confirmed block.
Definition transaction.h:49
State of transaction confirmed in a block.
Definition transaction.h:34
State of transaction added to mempool.
Definition transaction.h:44
State of transaction not confirmed or conflicting with a known block and not in the mempool.
Definition transaction.h:61
WalletContext struct containing references to state shared between CWallet instances,...
Definition context.h:36
interfaces::Chain * chain
Definition context.h:37
ArgsManager * args
Definition context.h:39
Wallet-layer error with both programmatic and user-facing information.
Definition types.h:92
#define WAIT_LOCK(cs, name)
Definition sync.h:274
#define AssertLockNotHeld(cs)
Definition sync.h:149
#define LOCK2(cs1, cs2)
Definition sync.h:269
#define LOCK(cs)
Definition sync.h:268
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition sync.h:299
#define AssertLockHeld(cs)
Definition sync.h:144
std::vector< uint16_t > keys
static int count
#define EXCLUSIVE_LOCKS_REQUIRED(...)
#define GUARDED_BY(x)
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
consteval auto _(util::TranslatedLiteral str)
Definition translation.h:79
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition translation.h:82
constexpr decltype(CTransaction::version) TRUC_VERSION
Definition truc_policy.h:20
@ CT_UPDATED
@ CT_DELETED
@ CT_NEW
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
Definition time.cpp:88
std::chrono::duration< double, std::chrono::milliseconds::period > MillisecondsDouble
Definition time.h:103
constexpr auto Ticks(Dur2 d)
Helper to count the seconds of a duration/time_point.
Definition time.h:82
assert(!tx.IsCoinBase())
Home for public enum and struct type definitions.
WalletContext context
std::vector< std::byte, zero_after_free_allocator< std::byte > > SerializeData
Byte-vector that clears its contents before deletion.