Bitcoin Core 29.99.0
P2P Digital Currency
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#include <addresstype.h>
10#include <blockfilter.h>
11#include <chain.h>
12#include <coins.h>
13#include <common/args.h>
14#include <common/messages.h>
15#include <common/settings.h>
16#include <common/signmessage.h>
17#include <common/system.h>
18#include <consensus/amount.h>
19#include <consensus/consensus.h>
21#include <external_signer.h>
22#include <interfaces/chain.h>
23#include <interfaces/handler.h>
24#include <interfaces/wallet.h>
25#include <kernel/chain.h>
27#include <key.h>
28#include <key_io.h>
29#include <logging.h>
30#include <node/types.h>
31#include <outputtype.h>
32#include <policy/feerate.h>
33#include <primitives/block.h>
35#include <psbt.h>
36#include <pubkey.h>
37#include <random.h>
38#include <script/descriptor.h>
39#include <script/interpreter.h>
40#include <script/script.h>
41#include <script/sign.h>
43#include <script/solver.h>
44#include <serialize.h>
45#include <span.h>
46#include <streams.h>
49#include <support/cleanse.h>
50#include <sync.h>
51#include <tinyformat.h>
52#include <uint256.h>
53#include <univalue.h>
54#include <util/check.h>
55#include <util/fs.h>
56#include <util/fs_helpers.h>
57#include <util/moneystr.h>
58#include <util/result.h>
59#include <util/string.h>
60#include <util/time.h>
61#include <util/translation.h>
62#include <wallet/coincontrol.h>
63#include <wallet/context.h>
64#include <wallet/crypter.h>
65#include <wallet/db.h>
68#include <wallet/transaction.h>
69#include <wallet/types.h>
70#include <wallet/walletdb.h>
71#include <wallet/walletutil.h>
72
73#include <algorithm>
74#include <cassert>
75#include <condition_variable>
76#include <exception>
77#include <optional>
78#include <stdexcept>
79#include <thread>
80#include <tuple>
81#include <variant>
82
83struct KeyOriginInfo;
84
90using util::ToString;
91
92namespace wallet {
93
94bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
95{
96 const auto update_function = [&wallet_name](common::SettingsValue& setting_value) {
97 if (!setting_value.isArray()) setting_value.setArray();
98 for (const auto& value : setting_value.getValues()) {
99 if (value.isStr() && value.get_str() == wallet_name) return interfaces::SettingsAction::SKIP_WRITE;
100 }
101 setting_value.push_back(wallet_name);
103 };
104 return chain.updateRwSetting("wallet", update_function);
105}
106
107bool RemoveWalletSetting(interfaces::Chain& chain, const std::string& wallet_name)
108{
109 const auto update_function = [&wallet_name](common::SettingsValue& setting_value) {
110 if (!setting_value.isArray()) return interfaces::SettingsAction::SKIP_WRITE;
112 for (const auto& value : setting_value.getValues()) {
113 if (!value.isStr() || value.get_str() != wallet_name) new_value.push_back(value);
114 }
115 if (new_value.size() == setting_value.size()) return interfaces::SettingsAction::SKIP_WRITE;
116 setting_value = std::move(new_value);
118 };
119 return chain.updateRwSetting("wallet", update_function);
120}
121
123 const std::string& wallet_name,
124 std::optional<bool> load_on_startup,
125 std::vector<bilingual_str>& warnings)
126{
127 if (!load_on_startup) return;
128 if (load_on_startup.value() && !AddWalletSetting(chain, wallet_name)) {
129 warnings.emplace_back(Untranslated("Wallet load on startup setting could not be updated, so wallet may not be loaded next node startup."));
130 } else if (!load_on_startup.value() && !RemoveWalletSetting(chain, wallet_name)) {
131 warnings.emplace_back(Untranslated("Wallet load on startup setting could not be updated, so wallet may still be loaded next node startup."));
132 }
133}
134
141{
142 if (chain.isInMempool(tx.GetHash())) {
144 } else if (tx.state<TxStateInMempool>()) {
146 }
147}
148
149bool AddWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
150{
151 LOCK(context.wallets_mutex);
152 assert(wallet);
153 std::vector<std::shared_ptr<CWallet>>::const_iterator i = std::find(context.wallets.begin(), context.wallets.end(), wallet);
154 if (i != context.wallets.end()) return false;
155 context.wallets.push_back(wallet);
156 wallet->ConnectScriptPubKeyManNotifiers();
157 wallet->NotifyCanGetAddressesChanged();
158 return true;
159}
160
161bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start, std::vector<bilingual_str>& warnings)
162{
163 assert(wallet);
164
165 interfaces::Chain& chain = wallet->chain();
166 std::string name = wallet->GetName();
167
168 // Unregister with the validation interface which also drops shared pointers.
169 wallet->m_chain_notifications_handler.reset();
170 {
171 LOCK(context.wallets_mutex);
172 std::vector<std::shared_ptr<CWallet>>::iterator i = std::find(context.wallets.begin(), context.wallets.end(), wallet);
173 if (i == context.wallets.end()) return false;
174 context.wallets.erase(i);
175 }
176 // Notify unload so that upper layers release the shared pointer.
177 wallet->NotifyUnload();
178
179 // Write the wallet setting
180 UpdateWalletSetting(chain, name, load_on_start, warnings);
181
182 return true;
183}
184
185bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start)
186{
187 std::vector<bilingual_str> warnings;
188 return RemoveWallet(context, wallet, load_on_start, warnings);
189}
190
191std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext& context)
192{
193 LOCK(context.wallets_mutex);
194 return context.wallets;
195}
196
197std::shared_ptr<CWallet> GetDefaultWallet(WalletContext& context, size_t& count)
198{
199 LOCK(context.wallets_mutex);
200 count = context.wallets.size();
201 return count == 1 ? context.wallets[0] : nullptr;
202}
203
204std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& name)
205{
206 LOCK(context.wallets_mutex);
207 for (const std::shared_ptr<CWallet>& wallet : context.wallets) {
208 if (wallet->GetName() == name) return wallet;
209 }
210 return nullptr;
211}
212
213std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet)
214{
215 LOCK(context.wallets_mutex);
216 auto it = context.wallet_load_fns.emplace(context.wallet_load_fns.end(), std::move(load_wallet));
217 return interfaces::MakeCleanupHandler([&context, it] { LOCK(context.wallets_mutex); context.wallet_load_fns.erase(it); });
218}
219
220void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
221{
222 LOCK(context.wallets_mutex);
223 for (auto& load_wallet : context.wallet_load_fns) {
224 load_wallet(interfaces::MakeWallet(context, wallet));
225 }
226}
227
230static std::condition_variable g_wallet_release_cv;
231static std::set<std::string> g_loading_wallet_set GUARDED_BY(g_loading_wallet_mutex);
232static std::set<std::string> g_unloading_wallet_set GUARDED_BY(g_wallet_release_mutex);
233
234// Custom deleter for shared_ptr<CWallet>.
236{
237 const std::string name = wallet->GetName();
238 wallet->WalletLogPrintf("Releasing wallet %s..\n", name);
239 delete wallet;
240 // Wallet is now released, notify WaitForDeleteWallet, if any.
241 {
243 if (g_unloading_wallet_set.erase(name) == 0) {
244 // WaitForDeleteWallet was not called for this wallet, all done.
245 return;
246 }
247 }
248 g_wallet_release_cv.notify_all();
249}
250
251void WaitForDeleteWallet(std::shared_ptr<CWallet>&& wallet)
252{
253 // Mark wallet for unloading.
254 const std::string name = wallet->GetName();
255 {
257 g_unloading_wallet_set.insert(name);
258 // Do not expect to be the only one removing this wallet.
259 // Multiple threads could simultaneously be waiting for deletion.
260 }
261
262 // Time to ditch our shared_ptr and wait for FlushAndDeleteWallet call.
263 wallet.reset();
264 {
266 while (g_unloading_wallet_set.count(name) == 1) {
267 g_wallet_release_cv.wait(lock);
268 }
269 }
270}
271
272namespace {
273std::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)
274{
275 try {
276 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
277 if (!database) {
278 error = Untranslated("Wallet file verification failed.") + Untranslated(" ") + error;
279 return nullptr;
280 }
281
282 context.chain->initMessage(_("Loading wallet…"));
283 std::shared_ptr<CWallet> wallet = CWallet::Create(context, name, std::move(database), options.create_flags, error, warnings);
284 if (!wallet) {
285 error = Untranslated("Wallet loading failed.") + Untranslated(" ") + error;
287 return nullptr;
288 }
289
290 // Legacy wallets are being deprecated, warn if the loaded wallet is legacy
291 if (!wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
292 warnings.emplace_back(_("Wallet loaded successfully. The legacy wallet type is being deprecated and support for creating and opening legacy wallets will be removed in the future. Legacy wallets can be migrated to a descriptor wallet with migratewallet."));
293 }
294
295 NotifyWalletLoaded(context, wallet);
296 AddWallet(context, wallet);
297 wallet->postInitProcess();
298
299 // Write the wallet setting
300 UpdateWalletSetting(*context.chain, name, load_on_start, warnings);
301
302 return wallet;
303 } catch (const std::runtime_error& e) {
304 error = Untranslated(e.what());
306 return nullptr;
307 }
308}
309
310class FastWalletRescanFilter
311{
312public:
313 FastWalletRescanFilter(const CWallet& wallet) : m_wallet(wallet)
314 {
315 // create initial filter with scripts from all ScriptPubKeyMans
316 for (auto spkm : m_wallet.GetAllScriptPubKeyMans()) {
317 auto desc_spkm{dynamic_cast<DescriptorScriptPubKeyMan*>(spkm)};
318 assert(desc_spkm != nullptr);
319 AddScriptPubKeys(desc_spkm);
320 // save each range descriptor's end for possible future filter updates
321 if (desc_spkm->IsHDEnabled()) {
322 m_last_range_ends.emplace(desc_spkm->GetID(), desc_spkm->GetEndRange());
323 }
324 }
325 }
326
327 void UpdateIfNeeded()
328 {
329 // repopulate filter with new scripts if top-up has happened since last iteration
330 for (const auto& [desc_spkm_id, last_range_end] : m_last_range_ends) {
331 auto desc_spkm{dynamic_cast<DescriptorScriptPubKeyMan*>(m_wallet.GetScriptPubKeyMan(desc_spkm_id))};
332 assert(desc_spkm != nullptr);
333 int32_t current_range_end{desc_spkm->GetEndRange()};
334 if (current_range_end > last_range_end) {
335 AddScriptPubKeys(desc_spkm, last_range_end);
336 m_last_range_ends.at(desc_spkm->GetID()) = current_range_end;
337 }
338 }
339 }
340
341 std::optional<bool> MatchesBlock(const uint256& block_hash) const
342 {
343 return m_wallet.chain().blockFilterMatchesAny(BlockFilterType::BASIC, block_hash, m_filter_set);
344 }
345
346private:
347 const CWallet& m_wallet;
354 std::map<uint256, int32_t> m_last_range_ends;
356
357 void AddScriptPubKeys(const DescriptorScriptPubKeyMan* desc_spkm, int32_t last_range_end = 0)
358 {
359 for (const auto& script_pub_key : desc_spkm->GetScriptPubKeys(last_range_end)) {
360 m_filter_set.emplace(script_pub_key.begin(), script_pub_key.end());
361 }
362 }
363};
364} // namespace
365
366std::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)
367{
368 auto result = WITH_LOCK(g_loading_wallet_mutex, return g_loading_wallet_set.insert(name));
369 if (!result.second) {
370 error = Untranslated("Wallet already loading.");
372 return nullptr;
373 }
374 auto wallet = LoadWalletInternal(context, name, load_on_start, options, status, error, warnings);
375 WITH_LOCK(g_loading_wallet_mutex, g_loading_wallet_set.erase(result.first));
376 return wallet;
377}
378
379std::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)
380{
381 uint64_t wallet_creation_flags = options.create_flags;
382 const SecureString& passphrase = options.create_passphrase;
383
384 if (wallet_creation_flags & WALLET_FLAG_DESCRIPTORS) options.require_format = DatabaseFormat::SQLITE;
385 else {
386 error = Untranslated("Legacy wallets can no longer be created");
388 return nullptr;
389 }
390
391 // Indicate that the wallet is actually supposed to be blank and not just blank to make it encrypted
392 bool create_blank = (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET);
393
394 // Born encrypted wallets need to be created blank first.
395 if (!passphrase.empty()) {
396 wallet_creation_flags |= WALLET_FLAG_BLANK_WALLET;
397 }
398
399 // Private keys must be disabled for an external signer wallet
400 if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) && !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
401 error = Untranslated("Private keys must be disabled when using an external signer");
403 return nullptr;
404 }
405
406 // Descriptor support must be enabled for an external signer wallet
407 if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) && !(wallet_creation_flags & WALLET_FLAG_DESCRIPTORS)) {
408 error = Untranslated("Descriptor support must be enabled when using an external signer");
410 return nullptr;
411 }
412
413 // Do not allow a passphrase when private keys are disabled
414 if (!passphrase.empty() && (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
415 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.");
417 return nullptr;
418 }
419
420 // Wallet::Verify will check if we're trying to create a wallet with a duplicate name.
421 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(name, options, status, error);
422 if (!database) {
423 error = Untranslated("Wallet file verification failed.") + Untranslated(" ") + error;
425 return nullptr;
426 }
427
428 // Make the wallet
429 context.chain->initMessage(_("Loading wallet…"));
430 std::shared_ptr<CWallet> wallet = CWallet::Create(context, name, std::move(database), wallet_creation_flags, error, warnings);
431 if (!wallet) {
432 error = Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
434 return nullptr;
435 }
436
437 // Encrypt the wallet
438 if (!passphrase.empty() && !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
439 if (!wallet->EncryptWallet(passphrase)) {
440 error = Untranslated("Error: Wallet created but failed to encrypt.");
442 return nullptr;
443 }
444 if (!create_blank) {
445 // Unlock the wallet
446 if (!wallet->Unlock(passphrase)) {
447 error = Untranslated("Error: Wallet was encrypted but could not be unlocked");
449 return nullptr;
450 }
451
452 // Set a seed for the wallet
453 {
454 LOCK(wallet->cs_wallet);
455 if (wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
456 wallet->SetupDescriptorScriptPubKeyMans();
457 } else {
458 for (auto spk_man : wallet->GetActiveScriptPubKeyMans()) {
459 if (!spk_man->SetupGeneration()) {
460 error = Untranslated("Unable to generate initial keys");
462 return nullptr;
463 }
464 }
465 }
466 }
467
468 // Relock the wallet
469 wallet->Lock();
470 }
471 }
472
473 NotifyWalletLoaded(context, wallet);
474 AddWallet(context, wallet);
475 wallet->postInitProcess();
476
477 // Write the wallet settings
478 UpdateWalletSetting(*context.chain, name, load_on_start, warnings);
479
480 // Legacy wallets are being deprecated, warn if a newly created wallet is legacy
481 if (!(wallet_creation_flags & WALLET_FLAG_DESCRIPTORS)) {
482 warnings.emplace_back(_("Wallet created successfully. The legacy wallet type is being deprecated and support for creating and opening legacy wallets will be removed in the future."));
483 }
484
486 return wallet;
487}
488
489// Re-creates wallet from the backup file by renaming and moving it into the wallet's directory.
490// If 'load_after_restore=true', the wallet object will be fully initialized and appended to the context.
491std::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)
492{
493 DatabaseOptions options;
494 ReadDatabaseArgs(*context.args, options);
495 options.require_existing = true;
496
497 const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::u8path(wallet_name));
498 auto wallet_file = wallet_path / "wallet.dat";
499 std::shared_ptr<CWallet> wallet;
500
501 try {
502 if (!fs::exists(backup_file)) {
503 error = Untranslated("Backup file does not exist");
505 return nullptr;
506 }
507
508 if (fs::exists(wallet_path) || !TryCreateDirectories(wallet_path)) {
509 error = Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(wallet_path)));
511 return nullptr;
512 }
513
514 fs::copy_file(backup_file, wallet_file, fs::copy_options::none);
515
516 if (load_after_restore) {
517 wallet = LoadWallet(context, wallet_name, load_on_start, options, status, error, warnings);
518 }
519 } catch (const std::exception& e) {
520 assert(!wallet);
521 if (!error.empty()) error += Untranslated("\n");
522 error += Untranslated(strprintf("Unexpected exception: %s", e.what()));
523 }
524
525 // Remove created wallet path only when loading fails
526 if (load_after_restore && !wallet) {
527 fs::remove_all(wallet_path);
528 }
529
530 return wallet;
531}
532
538const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
539{
541 const auto it = mapWallet.find(hash);
542 if (it == mapWallet.end())
543 return nullptr;
544 return &(it->second);
545}
546
548{
550 return;
551 }
552
554 DescriptorScriptPubKeyMan* desc_spkm = dynamic_cast<DescriptorScriptPubKeyMan*>(spkm);
555 desc_spkm->UpgradeDescriptorCache();
556 }
558}
559
560/* Given a wallet passphrase string and an unencrypted master key, determine the proper key
561 * derivation parameters (should take at least 100ms) and encrypt the master key. */
562static bool EncryptMasterKey(const SecureString& wallet_passphrase, const CKeyingMaterial& plain_master_key, CMasterKey& master_key)
563{
564 constexpr MillisecondsDouble target{100};
565 auto start{SteadyClock::now()};
566 CCrypter crypter;
567
568 crypter.SetKeyFromPassphrase(wallet_passphrase, master_key.vchSalt, master_key.nDeriveIterations, master_key.nDerivationMethod);
569 master_key.nDeriveIterations = static_cast<unsigned int>(master_key.nDeriveIterations * target / (SteadyClock::now() - start));
570
571 start = SteadyClock::now();
572 crypter.SetKeyFromPassphrase(wallet_passphrase, master_key.vchSalt, master_key.nDeriveIterations, master_key.nDerivationMethod);
573 master_key.nDeriveIterations = (master_key.nDeriveIterations + static_cast<unsigned int>(master_key.nDeriveIterations * target / (SteadyClock::now() - start))) / 2;
574
577 }
578
579 if (!crypter.SetKeyFromPassphrase(wallet_passphrase, master_key.vchSalt, master_key.nDeriveIterations, master_key.nDerivationMethod)) {
580 return false;
581 }
582 if (!crypter.Encrypt(plain_master_key, master_key.vchCryptedKey)) {
583 return false;
584 }
585
586 return true;
587}
588
589static bool DecryptMasterKey(const SecureString& wallet_passphrase, const CMasterKey& master_key, CKeyingMaterial& plain_master_key)
590{
591 CCrypter crypter;
592 if (!crypter.SetKeyFromPassphrase(wallet_passphrase, master_key.vchSalt, master_key.nDeriveIterations, master_key.nDerivationMethod)) {
593 return false;
594 }
595 if (!crypter.Decrypt(master_key.vchCryptedKey, plain_master_key)) {
596 return false;
597 }
598
599 return true;
600}
601
602bool CWallet::Unlock(const SecureString& strWalletPassphrase)
603{
604 CKeyingMaterial plain_master_key;
605
606 {
608 for (const auto& [_, master_key] : mapMasterKeys)
609 {
610 if (!DecryptMasterKey(strWalletPassphrase, master_key, plain_master_key)) {
611 continue; // try another master key
612 }
613 if (Unlock(plain_master_key)) {
614 // Now that we've unlocked, upgrade the descriptor cache
616 return true;
617 }
618 }
619 }
620 return false;
621}
622
623bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
624{
625 bool fWasLocked = IsLocked();
626
627 {
629 Lock();
630
631 CKeyingMaterial plain_master_key;
632 for (auto& [master_key_id, master_key] : mapMasterKeys)
633 {
634 if (!DecryptMasterKey(strOldWalletPassphrase, master_key, plain_master_key)) {
635 return false;
636 }
637 if (Unlock(plain_master_key))
638 {
639 if (!EncryptMasterKey(strNewWalletPassphrase, plain_master_key, master_key)) {
640 return false;
641 }
642 WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", master_key.nDeriveIterations);
643
644 WalletBatch(GetDatabase()).WriteMasterKey(master_key_id, master_key);
645 if (fWasLocked)
646 Lock();
647 return true;
648 }
649 }
650 }
651
652 return false;
653}
654
656{
657 // Don't update the best block until the chain is attached so that in case of a shutdown,
658 // the rescan will be restarted at next startup.
660 return;
661 }
662 WalletBatch batch(GetDatabase());
663 batch.WriteBestBlock(loc);
664}
665
667{
669 if (nWalletVersion >= nVersion)
670 return;
671 WalletLogPrintf("Setting minversion to %d\n", nVersion);
672 nWalletVersion = nVersion;
673
674 {
675 WalletBatch* batch = batch_in ? batch_in : new WalletBatch(GetDatabase());
676 if (nWalletVersion > 40000)
677 batch->WriteMinVersion(nWalletVersion);
678 if (!batch_in)
679 delete batch;
680 }
681}
682
683std::set<uint256> CWallet::GetConflicts(const uint256& txid) const
684{
685 std::set<uint256> result;
687
688 const auto it = mapWallet.find(txid);
689 if (it == mapWallet.end())
690 return result;
691 const CWalletTx& wtx = it->second;
692
693 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
694
695 for (const CTxIn& txin : wtx.tx->vin)
696 {
697 if (mapTxSpends.count(txin.prevout) <= 1)
698 continue; // No conflict if zero or one spends
699 range = mapTxSpends.equal_range(txin.prevout);
700 for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it)
701 result.insert(_it->second);
702 }
703 return result;
704}
705
707{
709 const Txid& txid = tx->GetHash();
710 for (unsigned int i = 0; i < tx->vout.size(); ++i) {
711 if (IsSpent(COutPoint(txid, i))) {
712 return true;
713 }
714 }
715 return false;
716}
717
719{
720 GetDatabase().Close();
721}
722
723void CWallet::SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator> range)
724{
725 // We want all the wallet transactions in range to have the same metadata as
726 // the oldest (smallest nOrderPos).
727 // So: find smallest nOrderPos:
728
729 int nMinOrderPos = std::numeric_limits<int>::max();
730 const CWalletTx* copyFrom = nullptr;
731 for (TxSpends::iterator it = range.first; it != range.second; ++it) {
732 const CWalletTx* wtx = &mapWallet.at(it->second);
733 if (wtx->nOrderPos < nMinOrderPos) {
734 nMinOrderPos = wtx->nOrderPos;
735 copyFrom = wtx;
736 }
737 }
738
739 if (!copyFrom) {
740 return;
741 }
742
743 // Now copy data from copyFrom to rest:
744 for (TxSpends::iterator it = range.first; it != range.second; ++it)
745 {
746 const uint256& hash = it->second;
747 CWalletTx* copyTo = &mapWallet.at(hash);
748 if (copyFrom == copyTo) continue;
749 assert(copyFrom && "Oldest wallet transaction in range assumed to have been found.");
750 if (!copyFrom->IsEquivalentTo(*copyTo)) continue;
751 copyTo->mapValue = copyFrom->mapValue;
752 copyTo->vOrderForm = copyFrom->vOrderForm;
753 // fTimeReceivedIsTxTime not copied on purpose
754 // nTimeReceived not copied on purpose
755 copyTo->nTimeSmart = copyFrom->nTimeSmart;
756 copyTo->fFromMe = copyFrom->fFromMe;
757 // nOrderPos not copied on purpose
758 // cached members not copied on purpose
759 }
760}
761
766bool CWallet::IsSpent(const COutPoint& outpoint) const
767{
768 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
769 range = mapTxSpends.equal_range(outpoint);
770
771 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
772 const uint256& wtxid = it->second;
773 const auto mit = mapWallet.find(wtxid);
774 if (mit != mapWallet.end()) {
775 const auto& wtx = mit->second;
776 if (!wtx.isAbandoned() && !wtx.isBlockConflicted() && !wtx.isMempoolConflicted())
777 return true; // Spent
778 }
779 }
780 return false;
781}
782
783void CWallet::AddToSpends(const COutPoint& outpoint, const uint256& wtxid, WalletBatch* batch)
784{
785 mapTxSpends.insert(std::make_pair(outpoint, wtxid));
786
787 if (batch) {
788 UnlockCoin(outpoint, batch);
789 } else {
790 WalletBatch temp_batch(GetDatabase());
791 UnlockCoin(outpoint, &temp_batch);
792 }
793
794 std::pair<TxSpends::iterator, TxSpends::iterator> range;
795 range = mapTxSpends.equal_range(outpoint);
796 SyncMetaData(range);
797}
798
799
801{
802 if (wtx.IsCoinBase()) // Coinbases don't spend anything!
803 return;
804
805 for (const CTxIn& txin : wtx.tx->vin)
806 AddToSpends(txin.prevout, wtx.GetHash(), batch);
807}
808
809bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
810{
811 if (IsCrypted())
812 return false;
813
814 CKeyingMaterial plain_master_key;
815
816 plain_master_key.resize(WALLET_CRYPTO_KEY_SIZE);
817 GetStrongRandBytes(plain_master_key);
818
819 CMasterKey master_key;
820
821 master_key.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
822 GetStrongRandBytes(master_key.vchSalt);
823
824 if (!EncryptMasterKey(strWalletPassphrase, plain_master_key, master_key)) {
825 return false;
826 }
827 WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n", master_key.nDeriveIterations);
828
829 {
831 mapMasterKeys[++nMasterKeyMaxID] = master_key;
832 WalletBatch* encrypted_batch = new WalletBatch(GetDatabase());
833 if (!encrypted_batch->TxnBegin()) {
834 delete encrypted_batch;
835 encrypted_batch = nullptr;
836 return false;
837 }
838 encrypted_batch->WriteMasterKey(nMasterKeyMaxID, master_key);
839
840 for (const auto& spk_man_pair : m_spk_managers) {
841 auto spk_man = spk_man_pair.second.get();
842 if (!spk_man->Encrypt(plain_master_key, encrypted_batch)) {
843 encrypted_batch->TxnAbort();
844 delete encrypted_batch;
845 encrypted_batch = nullptr;
846 // We now probably have half of our keys encrypted in memory, and half not...
847 // die and let the user reload the unencrypted wallet.
848 assert(false);
849 }
850 }
851
852 // Encryption was introduced in version 0.4.0
853 SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch);
854
855 if (!encrypted_batch->TxnCommit()) {
856 delete encrypted_batch;
857 encrypted_batch = nullptr;
858 // We now have keys encrypted in memory, but not on disk...
859 // die to avoid confusion and let the user reload the unencrypted wallet.
860 assert(false);
861 }
862
863 delete encrypted_batch;
864 encrypted_batch = nullptr;
865
866 Lock();
867 Unlock(strWalletPassphrase);
868
869 // If we are using descriptors, make new descriptors with a new seed
872 }
873 Lock();
874
875 // Need to completely rewrite the wallet file; if we don't, the database might keep
876 // bits of the unencrypted private key in slack space in the database file.
878 }
880
881 return true;
882}
883
885{
887 WalletBatch batch(GetDatabase());
888
889 // Old wallets didn't have any defined order for transactions
890 // Probably a bad idea to change the output of this
891
892 // First: get all CWalletTx into a sorted-by-time multimap.
893 typedef std::multimap<int64_t, CWalletTx*> TxItems;
894 TxItems txByTime;
895
896 for (auto& entry : mapWallet)
897 {
898 CWalletTx* wtx = &entry.second;
899 txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
900 }
901
902 nOrderPosNext = 0;
903 std::vector<int64_t> nOrderPosOffsets;
904 for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
905 {
906 CWalletTx *const pwtx = (*it).second;
907 int64_t& nOrderPos = pwtx->nOrderPos;
908
909 if (nOrderPos == -1)
910 {
911 nOrderPos = nOrderPosNext++;
912 nOrderPosOffsets.push_back(nOrderPos);
913
914 if (!batch.WriteTx(*pwtx))
915 return DBErrors::LOAD_FAIL;
916 }
917 else
918 {
919 int64_t nOrderPosOff = 0;
920 for (const int64_t& nOffsetStart : nOrderPosOffsets)
921 {
922 if (nOrderPos >= nOffsetStart)
923 ++nOrderPosOff;
924 }
925 nOrderPos += nOrderPosOff;
926 nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
927
928 if (!nOrderPosOff)
929 continue;
930
931 // Since we're changing the order, write it back
932 if (!batch.WriteTx(*pwtx))
933 return DBErrors::LOAD_FAIL;
934 }
935 }
936 batch.WriteOrderPosNext(nOrderPosNext);
937
938 return DBErrors::LOAD_OK;
939}
940
942{
944 int64_t nRet = nOrderPosNext++;
945 if (batch) {
946 batch->WriteOrderPosNext(nOrderPosNext);
947 } else {
948 WalletBatch(GetDatabase()).WriteOrderPosNext(nOrderPosNext);
949 }
950 return nRet;
951}
952
954{
955 {
957 for (std::pair<const uint256, CWalletTx>& item : mapWallet)
958 item.second.MarkDirty();
959 }
960}
961
962bool CWallet::MarkReplaced(const uint256& originalHash, const uint256& newHash)
963{
965
966 auto mi = mapWallet.find(originalHash);
967
968 // There is a bug if MarkReplaced is not called on an existing wallet transaction.
969 assert(mi != mapWallet.end());
970
971 CWalletTx& wtx = (*mi).second;
972
973 // Ensure for now that we're not overwriting data
974 assert(wtx.mapValue.count("replaced_by_txid") == 0);
975
976 wtx.mapValue["replaced_by_txid"] = newHash.ToString();
977
978 // Refresh mempool status without waiting for transactionRemovedFromMempool or transactionAddedToMempool
980
981 WalletBatch batch(GetDatabase());
982
983 bool success = true;
984 if (!batch.WriteTx(wtx)) {
985 WalletLogPrintf("%s: Updating batch tx %s failed\n", __func__, wtx.GetHash().ToString());
986 success = false;
987 }
988
990
991 return success;
992}
993
994void CWallet::SetSpentKeyState(WalletBatch& batch, const uint256& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations)
995{
997 const CWalletTx* srctx = GetWalletTx(hash);
998 if (!srctx) return;
999
1000 CTxDestination dst;
1001 if (ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst)) {
1002 if (IsMine(dst)) {
1003 if (used != IsAddressPreviouslySpent(dst)) {
1004 if (used) {
1005 tx_destinations.insert(dst);
1006 }
1007 SetAddressPreviouslySpent(batch, dst, used);
1008 }
1009 }
1010 }
1011}
1012
1013bool CWallet::IsSpentKey(const CScript& scriptPubKey) const
1014{
1016 CTxDestination dest;
1017 if (!ExtractDestination(scriptPubKey, dest)) {
1018 return false;
1019 }
1020 if (IsAddressPreviouslySpent(dest)) {
1021 return true;
1022 }
1023 return false;
1024}
1025
1026CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx, bool rescanning_old_block)
1027{
1028 LOCK(cs_wallet);
1029
1030 WalletBatch batch(GetDatabase());
1031
1032 uint256 hash = tx->GetHash();
1033
1035 // Mark used destinations
1036 std::set<CTxDestination> tx_destinations;
1037
1038 for (const CTxIn& txin : tx->vin) {
1039 const COutPoint& op = txin.prevout;
1040 SetSpentKeyState(batch, op.hash, op.n, true, tx_destinations);
1041 }
1042
1043 MarkDestinationsDirty(tx_destinations);
1044 }
1045
1046 // Inserts only if not already there, returns tx inserted or tx found
1047 auto ret = mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(tx, state));
1048 CWalletTx& wtx = (*ret.first).second;
1049 bool fInsertedNew = ret.second;
1050 bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
1051 if (fInsertedNew) {
1052 wtx.nTimeReceived = GetTime();
1053 wtx.nOrderPos = IncOrderPosNext(&batch);
1054 wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
1055 wtx.nTimeSmart = ComputeTimeSmart(wtx, rescanning_old_block);
1056 AddToSpends(wtx, &batch);
1057
1058 // Update birth time when tx time is older than it.
1060 }
1061
1062 if (!fInsertedNew)
1063 {
1064 if (state.index() != wtx.m_state.index()) {
1065 wtx.m_state = state;
1066 fUpdated = true;
1067 } else {
1070 }
1071 // If we have a witness-stripped version of this transaction, and we
1072 // see a new version with a witness, then we must be upgrading a pre-segwit
1073 // wallet. Store the new version of the transaction with the witness,
1074 // as the stripped-version must be invalid.
1075 // TODO: Store all versions of the transaction, instead of just one.
1076 if (tx->HasWitness() && !wtx.tx->HasWitness()) {
1077 wtx.SetTx(tx);
1078 fUpdated = true;
1079 }
1080 }
1081
1082 // Mark inactive coinbase transactions and their descendants as abandoned
1083 if (wtx.IsCoinBase() && wtx.isInactive()) {
1084 std::vector<CWalletTx*> txs{&wtx};
1085
1086 TxStateInactive inactive_state = TxStateInactive{/*abandoned=*/true};
1087
1088 while (!txs.empty()) {
1089 CWalletTx* desc_tx = txs.back();
1090 txs.pop_back();
1091 desc_tx->m_state = inactive_state;
1092 // Break caches since we have changed the state
1093 desc_tx->MarkDirty();
1094 batch.WriteTx(*desc_tx);
1095 MarkInputsDirty(desc_tx->tx);
1096 for (unsigned int i = 0; i < desc_tx->tx->vout.size(); ++i) {
1097 COutPoint outpoint(desc_tx->GetHash(), i);
1098 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(outpoint);
1099 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
1100 const auto wit = mapWallet.find(it->second);
1101 if (wit != mapWallet.end()) {
1102 txs.push_back(&wit->second);
1103 }
1104 }
1105 }
1106 }
1107 }
1108
1110 WalletLogPrintf("AddToWallet %s %s%s %s\n", hash.ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""), TxStateString(state));
1111
1112 // Write to disk
1113 if (fInsertedNew || fUpdated)
1114 if (!batch.WriteTx(wtx))
1115 return nullptr;
1116
1117 // Break debit/credit balance caches:
1118 wtx.MarkDirty();
1119
1120 // Notify UI of new or updated transaction
1121 NotifyTransactionChanged(hash, fInsertedNew ? CT_NEW : CT_UPDATED);
1122
1123#if HAVE_SYSTEM
1124 // notify an external script when a wallet transaction comes in or is updated
1125 std::string strCmd = m_notify_tx_changed_script;
1126
1127 if (!strCmd.empty())
1128 {
1129 ReplaceAll(strCmd, "%s", hash.GetHex());
1130 if (auto* conf = wtx.state<TxStateConfirmed>())
1131 {
1132 ReplaceAll(strCmd, "%b", conf->confirmed_block_hash.GetHex());
1133 ReplaceAll(strCmd, "%h", ToString(conf->confirmed_block_height));
1134 } else {
1135 ReplaceAll(strCmd, "%b", "unconfirmed");
1136 ReplaceAll(strCmd, "%h", "-1");
1137 }
1138#ifndef WIN32
1139 // Substituting the wallet name isn't currently supported on windows
1140 // because windows shell escaping has not been implemented yet:
1141 // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
1142 // A few ways it could be implemented in the future are described in:
1143 // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
1144 ReplaceAll(strCmd, "%w", ShellEscape(GetName()));
1145#endif
1146 std::thread t(runCommand, strCmd);
1147 t.detach(); // thread runs free
1148 }
1149#endif
1150
1151 return &wtx;
1152}
1153
1154bool CWallet::LoadToWallet(const uint256& hash, const UpdateWalletTxFn& fill_wtx)
1155{
1156 const auto& ins = mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(hash), std::forward_as_tuple(nullptr, TxStateInactive{}));
1157 CWalletTx& wtx = ins.first->second;
1158 if (!fill_wtx(wtx, ins.second)) {
1159 return false;
1160 }
1161 // If wallet doesn't have a chain (e.g when using bitcoin-wallet tool),
1162 // don't bother to update txn.
1163 if (HaveChain()) {
1164 wtx.updateState(chain());
1165 }
1166 if (/* insertion took place */ ins.second) {
1167 wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
1168 }
1169 AddToSpends(wtx);
1170 for (const CTxIn& txin : wtx.tx->vin) {
1171 auto it = mapWallet.find(txin.prevout.hash);
1172 if (it != mapWallet.end()) {
1173 CWalletTx& prevtx = it->second;
1174 if (auto* prev = prevtx.state<TxStateBlockConflicted>()) {
1175 MarkConflicted(prev->conflicting_block_hash, prev->conflicting_block_height, wtx.GetHash());
1176 }
1177 }
1178 }
1179
1180 // Update birth time when tx time is older than it.
1182
1183 return true;
1184}
1185
1186bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef& ptx, const SyncTxState& state, bool fUpdate, bool rescanning_old_block)
1187{
1188 const CTransaction& tx = *ptx;
1189 {
1191
1192 if (auto* conf = std::get_if<TxStateConfirmed>(&state)) {
1193 for (const CTxIn& txin : tx.vin) {
1194 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(txin.prevout);
1195 while (range.first != range.second) {
1196 if (range.first->second != tx.GetHash()) {
1197 WalletLogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)\n", tx.GetHash().ToString(), conf->confirmed_block_hash.ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);
1198 MarkConflicted(conf->confirmed_block_hash, conf->confirmed_block_height, range.first->second);
1199 }
1200 range.first++;
1201 }
1202 }
1203 }
1204
1205 bool fExisted = mapWallet.count(tx.GetHash()) != 0;
1206 if (fExisted && !fUpdate) return false;
1207 if (fExisted || IsMine(tx) || IsFromMe(tx))
1208 {
1209 /* Check if any keys in the wallet keypool that were supposed to be unused
1210 * have appeared in a new transaction. If so, remove those keys from the keypool.
1211 * This can happen when restoring an old wallet backup that does not contain
1212 * the mostly recently created transactions from newer versions of the wallet.
1213 */
1214
1215 // loop though all outputs
1216 for (const CTxOut& txout: tx.vout) {
1217 for (const auto& spk_man : GetScriptPubKeyMans(txout.scriptPubKey)) {
1218 for (auto &dest : spk_man->MarkUnusedAddresses(txout.scriptPubKey)) {
1219 // If internal flag is not defined try to infer it from the ScriptPubKeyMan
1220 if (!dest.internal.has_value()) {
1221 dest.internal = IsInternalScriptPubKeyMan(spk_man);
1222 }
1223
1224 // skip if can't determine whether it's a receiving address or not
1225 if (!dest.internal.has_value()) continue;
1226
1227 // If this is a receiving address and it's not in the address book yet
1228 // (e.g. it wasn't generated on this node or we're restoring from backup)
1229 // add it to the address book for proper transaction accounting
1230 if (!*dest.internal && !FindAddressBookEntry(dest.dest, /* allow_change= */ false)) {
1232 }
1233 }
1234 }
1235 }
1236
1237 // Block disconnection override an abandoned tx as unconfirmed
1238 // which means user may have to call abandontransaction again
1239 TxState tx_state = std::visit([](auto&& s) -> TxState { return s; }, state);
1240 CWalletTx* wtx = AddToWallet(MakeTransactionRef(tx), tx_state, /*update_wtx=*/nullptr, rescanning_old_block);
1241 if (!wtx) {
1242 // Can only be nullptr if there was a db write error (missing db, read-only db or a db engine internal writing error).
1243 // As we only store arriving transaction in this process, and we don't want an inconsistent state, let's throw an error.
1244 throw std::runtime_error("DB error adding transaction to wallet, write failed");
1245 }
1246 return true;
1247 }
1248 }
1249 return false;
1250}
1251
1253{
1254 LOCK(cs_wallet);
1255 const CWalletTx* wtx = GetWalletTx(hashTx);
1256 return wtx && !wtx->isAbandoned() && GetTxDepthInMainChain(*wtx) == 0 && !wtx->InMempool();
1257}
1258
1260{
1261 for (const CTxIn& txin : tx->vin) {
1262 auto it = mapWallet.find(txin.prevout.hash);
1263 if (it != mapWallet.end()) {
1264 it->second.MarkDirty();
1265 }
1266 }
1267}
1268
1270{
1271 LOCK(cs_wallet);
1272 auto it = mapWallet.find(hashTx);
1273 assert(it != mapWallet.end());
1274 return AbandonTransaction(it->second);
1275}
1276
1278{
1279 // Can't mark abandoned if confirmed or in mempool
1280 if (GetTxDepthInMainChain(tx) != 0 || tx.InMempool()) {
1281 return false;
1282 }
1283
1284 auto try_updating_state = [](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1285 // If the orig tx was not in block/mempool, none of its spends can be.
1286 assert(!wtx.isConfirmed());
1287 assert(!wtx.InMempool());
1288 // If already conflicted or abandoned, no need to set abandoned
1289 if (!wtx.isBlockConflicted() && !wtx.isAbandoned()) {
1290 wtx.m_state = TxStateInactive{/*abandoned=*/true};
1292 }
1293 return TxUpdate::UNCHANGED;
1294 };
1295
1296 // Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too.
1297 // States are not permanent, so these transactions can become unabandoned if they are re-added to the
1298 // mempool, or confirmed in a block, or conflicted.
1299 // Note: If the reorged coinbase is re-added to the main chain, the descendants that have not had their
1300 // states change will remain abandoned and will require manual broadcast if the user wants them.
1301
1302 RecursiveUpdateTxState(tx.GetHash(), try_updating_state);
1303
1304 return true;
1305}
1306
1307void CWallet::MarkConflicted(const uint256& hashBlock, int conflicting_height, const uint256& hashTx)
1308{
1309 LOCK(cs_wallet);
1310
1311 // If number of conflict confirms cannot be determined, this means
1312 // that the block is still unknown or not yet part of the main chain,
1313 // for example when loading the wallet during a reindex. Do nothing in that
1314 // case.
1315 if (m_last_block_processed_height < 0 || conflicting_height < 0) {
1316 return;
1317 }
1318 int conflictconfirms = (m_last_block_processed_height - conflicting_height + 1) * -1;
1319 if (conflictconfirms >= 0)
1320 return;
1321
1322 auto try_updating_state = [&](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1323 if (conflictconfirms < GetTxDepthInMainChain(wtx)) {
1324 // Block is 'more conflicted' than current confirm; update.
1325 // Mark transaction as conflicted with this block.
1326 wtx.m_state = TxStateBlockConflicted{hashBlock, conflicting_height};
1327 return TxUpdate::CHANGED;
1328 }
1329 return TxUpdate::UNCHANGED;
1330 };
1331
1332 // Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too.
1333 RecursiveUpdateTxState(hashTx, try_updating_state);
1334
1335}
1336
1337void CWallet::RecursiveUpdateTxState(const uint256& tx_hash, const TryUpdatingStateFn& try_updating_state) {
1338 WalletBatch batch(GetDatabase());
1339 RecursiveUpdateTxState(&batch, tx_hash, try_updating_state);
1340}
1341
1342void CWallet::RecursiveUpdateTxState(WalletBatch* batch, const uint256& tx_hash, const TryUpdatingStateFn& try_updating_state) {
1343 std::set<uint256> todo;
1344 std::set<uint256> done;
1345
1346 todo.insert(tx_hash);
1347
1348 while (!todo.empty()) {
1349 uint256 now = *todo.begin();
1350 todo.erase(now);
1351 done.insert(now);
1352 auto it = mapWallet.find(now);
1353 assert(it != mapWallet.end());
1354 CWalletTx& wtx = it->second;
1355
1356 TxUpdate update_state = try_updating_state(wtx);
1357 if (update_state != TxUpdate::UNCHANGED) {
1358 wtx.MarkDirty();
1359 if (batch) batch->WriteTx(wtx);
1360 // Iterate over all its outputs, and update those tx states as well (if applicable)
1361 for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
1362 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(COutPoint(Txid::FromUint256(now), i));
1363 for (TxSpends::const_iterator iter = range.first; iter != range.second; ++iter) {
1364 if (!done.count(iter->second)) {
1365 todo.insert(iter->second);
1366 }
1367 }
1368 }
1369
1370 if (update_state == TxUpdate::NOTIFY_CHANGED) {
1372 }
1373
1374 // If a transaction changes its tx state, that usually changes the balance
1375 // available of the outputs it spends. So force those to be recomputed
1376 MarkInputsDirty(wtx.tx);
1377 }
1378 }
1379}
1380
1381void CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& state, bool update_tx, bool rescanning_old_block)
1382{
1383 if (!AddToWalletIfInvolvingMe(ptx, state, update_tx, rescanning_old_block))
1384 return; // Not one of ours
1385
1386 // If a transaction changes 'conflicted' state, that changes the balance
1387 // available of the outputs it spends. So force those to be
1388 // recomputed, also:
1389 MarkInputsDirty(ptx);
1390}
1391
1393 LOCK(cs_wallet);
1395
1396 auto it = mapWallet.find(tx->GetHash());
1397 if (it != mapWallet.end()) {
1398 RefreshMempoolStatus(it->second, chain());
1399 }
1400
1401 const Txid& txid = tx->GetHash();
1402
1403 for (const CTxIn& tx_in : tx->vin) {
1404 // For each wallet transaction spending this prevout..
1405 for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1406 const uint256& spent_id = range.first->second;
1407 // Skip the recently added tx
1408 if (spent_id == txid) continue;
1409 RecursiveUpdateTxState(/*batch=*/nullptr, spent_id, [&txid](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1410 return wtx.mempool_conflicts.insert(txid).second ? TxUpdate::CHANGED : TxUpdate::UNCHANGED;
1411 });
1412 }
1413 }
1414}
1415
1417 LOCK(cs_wallet);
1418 auto it = mapWallet.find(tx->GetHash());
1419 if (it != mapWallet.end()) {
1420 RefreshMempoolStatus(it->second, chain());
1421 }
1422 // Handle transactions that were removed from the mempool because they
1423 // conflict with transactions in a newly connected block.
1424 if (reason == MemPoolRemovalReason::CONFLICT) {
1425 // Trigger external -walletnotify notifications for these transactions.
1426 // Set Status::UNCONFIRMED instead of Status::CONFLICTED for a few reasons:
1427 //
1428 // 1. The transactionRemovedFromMempool callback does not currently
1429 // provide the conflicting block's hash and height, and for backwards
1430 // compatibility reasons it may not be not safe to store conflicted
1431 // wallet transactions with a null block hash. See
1432 // https://github.com/bitcoin/bitcoin/pull/18600#discussion_r420195993.
1433 // 2. For most of these transactions, the wallet's internal conflict
1434 // detection in the blockConnected handler will subsequently call
1435 // MarkConflicted and update them with CONFLICTED status anyway. This
1436 // applies to any wallet transaction that has inputs spent in the
1437 // block, or that has ancestors in the wallet with inputs spent by
1438 // the block.
1439 // 3. Longstanding behavior since the sync implementation in
1440 // https://github.com/bitcoin/bitcoin/pull/9371 and the prior sync
1441 // implementation before that was to mark these transactions
1442 // unconfirmed rather than conflicted.
1443 //
1444 // Nothing described above should be seen as an unchangeable requirement
1445 // when improving this code in the future. The wallet's heuristics for
1446 // distinguishing between conflicted and unconfirmed transactions are
1447 // imperfect, and could be improved in general, see
1448 // https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Transaction-Conflict-Tracking
1450 }
1451
1452 const Txid& txid = tx->GetHash();
1453
1454 for (const CTxIn& tx_in : tx->vin) {
1455 // Iterate over all wallet transactions spending txin.prev
1456 // and recursively mark them as no longer conflicting with
1457 // txid
1458 for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1459 const uint256& spent_id = range.first->second;
1460
1461 RecursiveUpdateTxState(/*batch=*/nullptr, spent_id, [&txid](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1462 return wtx.mempool_conflicts.erase(txid) ? TxUpdate::CHANGED : TxUpdate::UNCHANGED;
1463 });
1464 }
1465 }
1466}
1467
1469{
1470 if (role == ChainstateRole::BACKGROUND) {
1471 return;
1472 }
1473 assert(block.data);
1474 LOCK(cs_wallet);
1475
1476 m_last_block_processed_height = block.height;
1477 m_last_block_processed = block.hash;
1478
1479 // No need to scan block if it was created before the wallet birthday.
1480 // Uses chain max time and twice the grace period to adjust time for block time variability.
1481 if (block.chain_time_max < m_birth_time.load() - (TIMESTAMP_WINDOW * 2)) return;
1482
1483 // Scan block
1484 for (size_t index = 0; index < block.data->vtx.size(); index++) {
1485 SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)});
1487 }
1488}
1489
1491{
1492 assert(block.data);
1493 LOCK(cs_wallet);
1494
1495 // At block disconnection, this will change an abandoned transaction to
1496 // be unconfirmed, whether or not the transaction is added back to the mempool.
1497 // User may have to call abandontransaction again. It may be addressed in the
1498 // future with a stickier abandoned state or even removing abandontransaction call.
1499 m_last_block_processed_height = block.height - 1;
1500 m_last_block_processed = *Assert(block.prev_hash);
1501
1502 int disconnect_height = block.height;
1503
1504 for (size_t index = 0; index < block.data->vtx.size(); index++) {
1505 const CTransactionRef& ptx = block.data->vtx[index];
1506 // Coinbase transactions are not only inactive but also abandoned,
1507 // meaning they should never be relayed standalone via the p2p protocol.
1508 SyncTransaction(ptx, TxStateInactive{/*abandoned=*/index == 0});
1509
1510 for (const CTxIn& tx_in : ptx->vin) {
1511 // No other wallet transactions conflicted with this transaction
1512 if (mapTxSpends.count(tx_in.prevout) < 1) continue;
1513
1514 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(tx_in.prevout);
1515
1516 // For all of the spends that conflict with this transaction
1517 for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {
1518 CWalletTx& wtx = mapWallet.find(_it->second)->second;
1519
1520 if (!wtx.isBlockConflicted()) continue;
1521
1522 auto try_updating_state = [&](CWalletTx& tx) {
1523 if (!tx.isBlockConflicted()) return TxUpdate::UNCHANGED;
1524 if (tx.state<TxStateBlockConflicted>()->conflicting_block_height >= disconnect_height) {
1525 tx.m_state = TxStateInactive{};
1526 return TxUpdate::CHANGED;
1527 }
1528 return TxUpdate::UNCHANGED;
1529 };
1530
1531 RecursiveUpdateTxState(wtx.tx->GetHash(), try_updating_state);
1532 }
1533 }
1534 }
1535}
1536
1538{
1540}
1541
1542void CWallet::BlockUntilSyncedToCurrentChain() const {
1544 // Skip the queue-draining stuff if we know we're caught up with
1545 // chain().Tip(), otherwise put a callback in the validation interface queue and wait
1546 // for the queue to drain enough to execute it (indicating we are caught up
1547 // at least with the time we entered this function).
1548 uint256 last_block_hash = WITH_LOCK(cs_wallet, return m_last_block_processed);
1549 chain().waitForNotificationsIfTipChanged(last_block_hash);
1550}
1551
1552// Note that this function doesn't distinguish between a 0-valued input,
1553// and a not-"is mine" (according to the filter) input.
1554CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
1555{
1556 {
1557 LOCK(cs_wallet);
1558 const auto mi = mapWallet.find(txin.prevout.hash);
1559 if (mi != mapWallet.end())
1560 {
1561 const CWalletTx& prev = (*mi).second;
1562 if (txin.prevout.n < prev.tx->vout.size())
1563 if (IsMine(prev.tx->vout[txin.prevout.n]) & filter)
1564 return prev.tx->vout[txin.prevout.n].nValue;
1565 }
1566 }
1567 return 0;
1568}
1569
1571{
1573 return IsMine(txout.scriptPubKey);
1574}
1575
1577{
1579 return IsMine(GetScriptForDestination(dest));
1580}
1581
1583{
1585
1586 // Search the cache so that IsMine is called only on the relevant SPKMs instead of on everything in m_spk_managers
1587 const auto& it = m_cached_spks.find(script);
1588 if (it != m_cached_spks.end()) {
1589 isminetype res = ISMINE_NO;
1590 for (const auto& spkm : it->second) {
1591 res = std::max(res, spkm->IsMine(script));
1592 }
1593 Assume(res == ISMINE_SPENDABLE);
1594 return res;
1595 }
1596
1597 return ISMINE_NO;
1598}
1599
1600bool CWallet::IsMine(const CTransaction& tx) const
1601{
1603 for (const CTxOut& txout : tx.vout)
1604 if (IsMine(txout))
1605 return true;
1606 return false;
1607}
1608
1610{
1612 auto wtx = GetWalletTx(outpoint.hash);
1613 if (!wtx) {
1614 return ISMINE_NO;
1615 }
1616 if (outpoint.n >= wtx->tx->vout.size()) {
1617 return ISMINE_NO;
1618 }
1619 return IsMine(wtx->tx->vout[outpoint.n]);
1620}
1621
1622bool CWallet::IsFromMe(const CTransaction& tx) const
1623{
1624 return (GetDebit(tx, ISMINE_ALL) > 0);
1625}
1626
1628{
1629 CAmount nDebit = 0;
1630 for (const CTxIn& txin : tx.vin)
1631 {
1632 nDebit += GetDebit(txin, filter);
1633 if (!MoneyRange(nDebit))
1634 throw std::runtime_error(std::string(__func__) + ": value out of range");
1635 }
1636 return nDebit;
1637}
1638
1640{
1641 // All Active ScriptPubKeyMans must be HD for this to be true
1642 bool result = false;
1643 for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
1644 if (!spk_man->IsHDEnabled()) return false;
1645 result = true;
1646 }
1647 return result;
1648}
1649
1650bool CWallet::CanGetAddresses(bool internal) const
1651{
1652 LOCK(cs_wallet);
1653 if (m_spk_managers.empty()) return false;
1654 for (OutputType t : OUTPUT_TYPES) {
1655 auto spk_man = GetScriptPubKeyMan(t, internal);
1656 if (spk_man && spk_man->CanGetAddresses(internal)) {
1657 return true;
1658 }
1659 }
1660 return false;
1661}
1662
1664{
1665 WalletBatch batch(GetDatabase());
1666 return SetWalletFlagWithDB(batch, flags);
1667}
1668
1670{
1671 LOCK(cs_wallet);
1673 if (!batch.WriteWalletFlags(m_wallet_flags))
1674 throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1675}
1676
1677void CWallet::UnsetWalletFlag(uint64_t flag)
1678{
1679 WalletBatch batch(GetDatabase());
1680 UnsetWalletFlagWithDB(batch, flag);
1681}
1682
1684{
1685 LOCK(cs_wallet);
1686 m_wallet_flags &= ~flag;
1687 if (!batch.WriteWalletFlags(m_wallet_flags))
1688 throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1689}
1690
1692{
1694}
1695
1696bool CWallet::IsWalletFlagSet(uint64_t flag) const
1697{
1698 return (m_wallet_flags & flag);
1699}
1700
1702{
1703 LOCK(cs_wallet);
1704 if (((flags & KNOWN_WALLET_FLAGS) >> 32) ^ (flags >> 32)) {
1705 // contains unknown non-tolerable wallet flags
1706 return false;
1707 }
1709
1710 return true;
1711}
1712
1714{
1715 LOCK(cs_wallet);
1716
1717 // We should never be writing unknown non-tolerable wallet flags
1718 assert(((flags & KNOWN_WALLET_FLAGS) >> 32) == (flags >> 32));
1719 // This should only be used once, when creating a new wallet - so current flags are expected to be blank
1720 assert(m_wallet_flags == 0);
1721
1722 if (!WalletBatch(GetDatabase()).WriteWalletFlags(flags)) {
1723 throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
1724 }
1725
1726 if (!LoadWalletFlags(flags)) assert(false);
1727}
1728
1730{
1731 int64_t birthtime = m_birth_time.load();
1732 if (time < birthtime) {
1733 m_birth_time = time;
1734 }
1735}
1736
1745int64_t CWallet::RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver, bool update)
1746{
1747 // Find starting block. May be null if nCreateTime is greater than the
1748 // highest blockchain timestamp, in which case there is nothing that needs
1749 // to be scanned.
1750 int start_height = 0;
1751 uint256 start_block;
1752 bool start = chain().findFirstBlockWithTimeAndHeight(startTime - TIMESTAMP_WINDOW, 0, FoundBlock().hash(start_block).height(start_height));
1753 WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__, start ? WITH_LOCK(cs_wallet, return GetLastBlockHeight()) - start_height + 1 : 0);
1754
1755 if (start) {
1756 // TODO: this should take into account failure by ScanResult::USER_ABORT
1757 ScanResult result = ScanForWalletTransactions(start_block, start_height, /*max_height=*/{}, reserver, /*fUpdate=*/update, /*save_progress=*/false);
1758 if (result.status == ScanResult::FAILURE) {
1759 int64_t time_max;
1760 CHECK_NONFATAL(chain().findBlock(result.last_failed_block, FoundBlock().maxTime(time_max)));
1761 return time_max + TIMESTAMP_WINDOW + 1;
1762 }
1763 }
1764 return startTime;
1765}
1766
1789CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, bool fUpdate, const bool save_progress)
1790{
1791 constexpr auto INTERVAL_TIME{60s};
1792 auto current_time{reserver.now()};
1793 auto start_time{reserver.now()};
1794
1795 assert(reserver.isReserved());
1796
1797 uint256 block_hash = start_block;
1798 ScanResult result;
1799
1800 std::unique_ptr<FastWalletRescanFilter> fast_rescan_filter;
1801 if (chain().hasBlockFilterIndex(BlockFilterType::BASIC)) fast_rescan_filter = std::make_unique<FastWalletRescanFilter>(*this);
1802
1803 WalletLogPrintf("Rescan started from block %s... (%s)\n", start_block.ToString(),
1804 fast_rescan_filter ? "fast variant using block filters" : "slow variant inspecting all blocks");
1805
1806 fAbortRescan = false;
1807 ShowProgress(strprintf("%s %s", GetDisplayName(), _("Rescanning…")), 0); // show rescan progress in GUI as dialog or on splashscreen, if rescan required on startup (e.g. due to corruption)
1808 uint256 tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
1809 uint256 end_hash = tip_hash;
1810 if (max_height) chain().findAncestorByHeight(tip_hash, *max_height, FoundBlock().hash(end_hash));
1811 double progress_begin = chain().guessVerificationProgress(block_hash);
1812 double progress_end = chain().guessVerificationProgress(end_hash);
1813 double progress_current = progress_begin;
1814 int block_height = start_height;
1815 while (!fAbortRescan && !chain().shutdownRequested()) {
1816 if (progress_end - progress_begin > 0.0) {
1817 m_scanning_progress = (progress_current - progress_begin) / (progress_end - progress_begin);
1818 } else { // avoid divide-by-zero for single block scan range (i.e. start and stop hashes are equal)
1820 }
1821 if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
1822 ShowProgress(strprintf("%s %s", GetDisplayName(), _("Rescanning…")), std::max(1, std::min(99, (int)(m_scanning_progress * 100))));
1823 }
1824
1825 bool next_interval = reserver.now() >= current_time + INTERVAL_TIME;
1826 if (next_interval) {
1827 current_time = reserver.now();
1828 WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n", block_height, progress_current);
1829 }
1830
1831 bool fetch_block{true};
1832 if (fast_rescan_filter) {
1833 fast_rescan_filter->UpdateIfNeeded();
1834 auto matches_block{fast_rescan_filter->MatchesBlock(block_hash)};
1835 if (matches_block.has_value()) {
1836 if (*matches_block) {
1837 LogDebug(BCLog::SCAN, "Fast rescan: inspect block %d [%s] (filter matched)\n", block_height, block_hash.ToString());
1838 } else {
1839 result.last_scanned_block = block_hash;
1840 result.last_scanned_height = block_height;
1841 fetch_block = false;
1842 }
1843 } else {
1844 LogDebug(BCLog::SCAN, "Fast rescan: inspect block %d [%s] (WARNING: block filter not found!)\n", block_height, block_hash.ToString());
1845 }
1846 }
1847
1848 // Find next block separately from reading data above, because reading
1849 // is slow and there might be a reorg while it is read.
1850 bool block_still_active = false;
1851 bool next_block = false;
1852 uint256 next_block_hash;
1853 chain().findBlock(block_hash, FoundBlock().inActiveChain(block_still_active).nextBlock(FoundBlock().inActiveChain(next_block).hash(next_block_hash)));
1854
1855 if (fetch_block) {
1856 // Read block data
1857 CBlock block;
1858 chain().findBlock(block_hash, FoundBlock().data(block));
1859
1860 if (!block.IsNull()) {
1861 LOCK(cs_wallet);
1862 if (!block_still_active) {
1863 // Abort scan if current block is no longer active, to prevent
1864 // marking transactions as coming from the wrong block.
1865 result.last_failed_block = block_hash;
1866 result.status = ScanResult::FAILURE;
1867 break;
1868 }
1869 for (size_t posInBlock = 0; posInBlock < block.vtx.size(); ++posInBlock) {
1870 SyncTransaction(block.vtx[posInBlock], TxStateConfirmed{block_hash, block_height, static_cast<int>(posInBlock)}, fUpdate, /*rescanning_old_block=*/true);
1871 }
1872 // scan succeeded, record block as most recent successfully scanned
1873 result.last_scanned_block = block_hash;
1874 result.last_scanned_height = block_height;
1875
1876 if (save_progress && next_interval) {
1877 CBlockLocator loc = m_chain->getActiveChainLocator(block_hash);
1878
1879 if (!loc.IsNull()) {
1880 WalletLogPrintf("Saving scan progress %d.\n", block_height);
1881 WalletBatch batch(GetDatabase());
1882 batch.WriteBestBlock(loc);
1883 }
1884 }
1885 } else {
1886 // could not scan block, keep scanning but record this block as the most recent failure
1887 result.last_failed_block = block_hash;
1888 result.status = ScanResult::FAILURE;
1889 }
1890 }
1891 if (max_height && block_height >= *max_height) {
1892 break;
1893 }
1894 // If rescanning was triggered with cs_wallet permanently locked (AttachChain), additional blocks that were connected during the rescan
1895 // aren't processed here but will be processed with the pending blockConnected notifications after the lock is released.
1896 // If rescanning without a permanent cs_wallet lock, additional blocks that were added during the rescan will be re-processed if
1897 // the notification was processed and the last block height was updated.
1898 if (block_height >= WITH_LOCK(cs_wallet, return GetLastBlockHeight())) {
1899 break;
1900 }
1901
1902 {
1903 if (!next_block) {
1904 // break successfully when rescan has reached the tip, or
1905 // previous block is no longer on the chain due to a reorg
1906 break;
1907 }
1908
1909 // increment block and verification progress
1910 block_hash = next_block_hash;
1911 ++block_height;
1912 progress_current = chain().guessVerificationProgress(block_hash);
1913
1914 // handle updated tip hash
1915 const uint256 prev_tip_hash = tip_hash;
1916 tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
1917 if (!max_height && prev_tip_hash != tip_hash) {
1918 // in case the tip has changed, update progress max
1919 progress_end = chain().guessVerificationProgress(tip_hash);
1920 }
1921 }
1922 }
1923 if (!max_height) {
1924 WalletLogPrintf("Scanning current mempool transactions.\n");
1925 WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
1926 }
1927 ShowProgress(strprintf("%s %s", GetDisplayName(), _("Rescanning…")), 100); // hide progress dialog in GUI
1928 if (block_height && fAbortRescan) {
1929 WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n", block_height, progress_current);
1931 } else if (block_height && chain().shutdownRequested()) {
1932 WalletLogPrintf("Rescan interrupted by shutdown request at block %d. Progress=%f\n", block_height, progress_current);
1934 } else {
1935 WalletLogPrintf("Rescan completed in %15dms\n", Ticks<std::chrono::milliseconds>(reserver.now() - start_time));
1936 }
1937 return result;
1938}
1939
1940bool CWallet::SubmitTxMemoryPoolAndRelay(CWalletTx& wtx, std::string& err_string, bool relay) const
1941{
1943
1944 // Can't relay if wallet is not broadcasting
1945 if (!GetBroadcastTransactions()) return false;
1946 // Don't relay abandoned transactions
1947 if (wtx.isAbandoned()) return false;
1948 // Don't try to submit coinbase transactions. These would fail anyway but would
1949 // cause log spam.
1950 if (wtx.IsCoinBase()) return false;
1951 // Don't try to submit conflicted or confirmed transactions.
1952 if (GetTxDepthInMainChain(wtx) != 0) return false;
1953
1954 // Submit transaction to mempool for relay
1955 WalletLogPrintf("Submitting wtx %s to mempool for relay\n", wtx.GetHash().ToString());
1956 // We must set TxStateInMempool here. Even though it will also be set later by the
1957 // entered-mempool callback, if we did not there would be a race where a
1958 // user could call sendmoney in a loop and hit spurious out of funds errors
1959 // because we think that this newly generated transaction's change is
1960 // unavailable as we're not yet aware that it is in the mempool.
1961 //
1962 // If broadcast fails for any reason, trying to set wtx.m_state here would be incorrect.
1963 // If transaction was previously in the mempool, it should be updated when
1964 // TransactionRemovedFromMempool fires.
1965 bool ret = chain().broadcastTransaction(wtx.tx, m_default_max_tx_fee, relay, err_string);
1966 if (ret) wtx.m_state = TxStateInMempool{};
1967 return ret;
1968}
1969
1970std::set<uint256> CWallet::GetTxConflicts(const CWalletTx& wtx) const
1971{
1973
1974 const uint256 myHash{wtx.GetHash()};
1975 std::set<uint256> result{GetConflicts(myHash)};
1976 result.erase(myHash);
1977 return result;
1978}
1979
1981{
1982 // Don't attempt to resubmit if the wallet is configured to not broadcast
1983 if (!fBroadcastTransactions) return false;
1984
1985 // During reindex, importing and IBD, old wallet transactions become
1986 // unconfirmed. Don't resend them as that would spam other nodes.
1987 // We only allow forcing mempool submission when not relaying to avoid this spam.
1988 if (!chain().isReadyToBroadcast()) return false;
1989
1990 // Do this infrequently and randomly to avoid giving away
1991 // that these are our transactions.
1992 if (NodeClock::now() < m_next_resend) return false;
1993
1994 return true;
1995}
1996
1998
1999// Resubmit transactions from the wallet to the mempool, optionally asking the
2000// mempool to relay them. On startup, we will do this for all unconfirmed
2001// transactions but will not ask the mempool to relay them. We do this on startup
2002// to ensure that our own mempool is aware of our transactions. There
2003// is a privacy side effect here as not broadcasting on startup also means that we won't
2004// inform the world of our wallet's state, particularly if the wallet (or node) is not
2005// yet synced.
2006//
2007// Otherwise this function is called periodically in order to relay our unconfirmed txs.
2008// We do this on a random timer to slightly obfuscate which transactions
2009// come from our wallet.
2010//
2011// TODO: Ideally, we'd only resend transactions that we think should have been
2012// mined in the most recent block. Any transaction that wasn't in the top
2013// blockweight of transactions in the mempool shouldn't have been mined,
2014// and so is probably just sitting in the mempool waiting to be confirmed.
2015// Rebroadcasting does nothing to speed up confirmation and only damages
2016// privacy.
2017//
2018// The `force` option results in all unconfirmed transactions being submitted to
2019// the mempool. This does not necessarily result in those transactions being relayed,
2020// that depends on the `relay` option. Periodic rebroadcast uses the pattern
2021// relay=true force=false, while loading into the mempool
2022// (on start, or after import) uses relay=false force=true.
2023void CWallet::ResubmitWalletTransactions(bool relay, bool force)
2024{
2025 // Don't attempt to resubmit if the wallet is configured to not broadcast,
2026 // even if forcing.
2027 if (!fBroadcastTransactions) return;
2028
2029 int submitted_tx_count = 0;
2030
2031 { // cs_wallet scope
2032 LOCK(cs_wallet);
2033
2034 // First filter for the transactions we want to rebroadcast.
2035 // We use a set with WalletTxOrderComparator so that rebroadcasting occurs in insertion order
2036 std::set<CWalletTx*, WalletTxOrderComparator> to_submit;
2037 for (auto& [txid, wtx] : mapWallet) {
2038 // Only rebroadcast unconfirmed txs
2039 if (!wtx.isUnconfirmed()) continue;
2040
2041 // Attempt to rebroadcast all txes more than 5 minutes older than
2042 // the last block, or all txs if forcing.
2043 if (!force && wtx.nTimeReceived > m_best_block_time - 5 * 60) continue;
2044 to_submit.insert(&wtx);
2045 }
2046 // Now try submitting the transactions to the memory pool and (optionally) relay them.
2047 for (auto wtx : to_submit) {
2048 std::string unused_err_string;
2049 if (SubmitTxMemoryPoolAndRelay(*wtx, unused_err_string, relay)) ++submitted_tx_count;
2050 }
2051 } // cs_wallet
2052
2053 if (submitted_tx_count > 0) {
2054 WalletLogPrintf("%s: resubmit %u unconfirmed transactions\n", __func__, submitted_tx_count);
2055 }
2056}
2057 // end of mapWallet
2059
2061{
2062 for (const std::shared_ptr<CWallet>& pwallet : GetWallets(context)) {
2063 if (!pwallet->ShouldResend()) continue;
2064 pwallet->ResubmitWalletTransactions(/*relay=*/true, /*force=*/false);
2065 pwallet->SetNextResend();
2066 }
2067}
2068
2069
2071{
2073
2074 // Build coins map
2075 std::map<COutPoint, Coin> coins;
2076 for (auto& input : tx.vin) {
2077 const auto mi = mapWallet.find(input.prevout.hash);
2078 if(mi == mapWallet.end() || input.prevout.n >= mi->second.tx->vout.size()) {
2079 return false;
2080 }
2081 const CWalletTx& wtx = mi->second;
2082 int prev_height = wtx.state<TxStateConfirmed>() ? wtx.state<TxStateConfirmed>()->confirmed_block_height : 0;
2083 coins[input.prevout] = Coin(wtx.tx->vout[input.prevout.n], prev_height, wtx.IsCoinBase());
2084 }
2085 std::map<int, bilingual_str> input_errors;
2086 return SignTransaction(tx, coins, SIGHASH_DEFAULT, input_errors);
2087}
2088
2089bool CWallet::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
2090{
2091 // Try to sign with all ScriptPubKeyMans
2092 for (ScriptPubKeyMan* spk_man : GetAllScriptPubKeyMans()) {
2093 // spk_man->SignTransaction will return true if the transaction is complete,
2094 // so we can exit early and return true if that happens
2095 if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
2096 return true;
2097 }
2098 }
2099
2100 // At this point, one input was not fully signed otherwise we would have exited already
2101 return false;
2102}
2103
2104std::optional<PSBTError> CWallet::FillPSBT(PartiallySignedTransaction& psbtx, bool& complete, int sighash_type, bool sign, bool bip32derivs, size_t * n_signed, bool finalize) const
2105{
2106 if (n_signed) {
2107 *n_signed = 0;
2108 }
2109 LOCK(cs_wallet);
2110 // Get all of the previous transactions
2111 for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
2112 const CTxIn& txin = psbtx.tx->vin[i];
2113 PSBTInput& input = psbtx.inputs.at(i);
2114
2115 if (PSBTInputSigned(input)) {
2116 continue;
2117 }
2118
2119 // If we have no utxo, grab it from the wallet.
2120 if (!input.non_witness_utxo) {
2121 const uint256& txhash = txin.prevout.hash;
2122 const auto it = mapWallet.find(txhash);
2123 if (it != mapWallet.end()) {
2124 const CWalletTx& wtx = it->second;
2125 // We only need the non_witness_utxo, which is a superset of the witness_utxo.
2126 // The signing code will switch to the smaller witness_utxo if this is ok.
2127 input.non_witness_utxo = wtx.tx;
2128 }
2129 }
2130 }
2131
2132 const PrecomputedTransactionData txdata = PrecomputePSBTData(psbtx);
2133
2134 // Fill in information from ScriptPubKeyMans
2135 for (ScriptPubKeyMan* spk_man : GetAllScriptPubKeyMans()) {
2136 int n_signed_this_spkm = 0;
2137 const auto error{spk_man->FillPSBT(psbtx, txdata, sighash_type, sign, bip32derivs, &n_signed_this_spkm, finalize)};
2138 if (error) {
2139 return error;
2140 }
2141
2142 if (n_signed) {
2143 (*n_signed) += n_signed_this_spkm;
2144 }
2145 }
2146
2147 RemoveUnnecessaryTransactions(psbtx, sighash_type);
2148
2149 // Complete if every input is now signed
2150 complete = true;
2151 for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
2152 complete &= PSBTInputSignedAndVerified(psbtx, i, &txdata);
2153 }
2154
2155 return {};
2156}
2157
2158SigningResult CWallet::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
2159{
2160 SignatureData sigdata;
2161 CScript script_pub_key = GetScriptForDestination(pkhash);
2162 for (const auto& spk_man_pair : m_spk_managers) {
2163 if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
2164 LOCK(cs_wallet); // DescriptorScriptPubKeyMan calls IsLocked which can lock cs_wallet in a deadlocking order
2165 return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
2166 }
2167 }
2169}
2170
2171OutputType CWallet::TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const
2172{
2173 // If -changetype is specified, always use that change type.
2174 if (change_type) {
2175 return *change_type;
2176 }
2177
2178 // if m_default_address_type is legacy, use legacy address as change.
2180 return OutputType::LEGACY;
2181 }
2182
2183 bool any_tr{false};
2184 bool any_wpkh{false};
2185 bool any_sh{false};
2186 bool any_pkh{false};
2187
2188 for (const auto& recipient : vecSend) {
2189 if (std::get_if<WitnessV1Taproot>(&recipient.dest)) {
2190 any_tr = true;
2191 } else if (std::get_if<WitnessV0KeyHash>(&recipient.dest)) {
2192 any_wpkh = true;
2193 } else if (std::get_if<ScriptHash>(&recipient.dest)) {
2194 any_sh = true;
2195 } else if (std::get_if<PKHash>(&recipient.dest)) {
2196 any_pkh = true;
2197 }
2198 }
2199
2200 const bool has_bech32m_spkman(GetScriptPubKeyMan(OutputType::BECH32M, /*internal=*/true));
2201 if (has_bech32m_spkman && any_tr) {
2202 // Currently tr is the only type supported by the BECH32M spkman
2203 return OutputType::BECH32M;
2204 }
2205 const bool has_bech32_spkman(GetScriptPubKeyMan(OutputType::BECH32, /*internal=*/true));
2206 if (has_bech32_spkman && any_wpkh) {
2207 // Currently wpkh is the only type supported by the BECH32 spkman
2208 return OutputType::BECH32;
2209 }
2210 const bool has_p2sh_segwit_spkman(GetScriptPubKeyMan(OutputType::P2SH_SEGWIT, /*internal=*/true));
2211 if (has_p2sh_segwit_spkman && any_sh) {
2212 // Currently sh_wpkh is the only type supported by the P2SH_SEGWIT spkman
2213 // As of 2021 about 80% of all SH are wrapping WPKH, so use that
2215 }
2216 const bool has_legacy_spkman(GetScriptPubKeyMan(OutputType::LEGACY, /*internal=*/true));
2217 if (has_legacy_spkman && any_pkh) {
2218 // Currently pkh is the only type supported by the LEGACY spkman
2219 return OutputType::LEGACY;
2220 }
2221
2222 if (has_bech32m_spkman) {
2223 return OutputType::BECH32M;
2224 }
2225 if (has_bech32_spkman) {
2226 return OutputType::BECH32;
2227 }
2228 // else use m_default_address_type for change
2230}
2231
2232void CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm)
2233{
2234 LOCK(cs_wallet);
2235 WalletLogPrintf("CommitTransaction:\n%s\n", util::RemoveSuffixView(tx->ToString(), "\n"));
2236
2237 // Add tx to wallet, because if it has change it's also ours,
2238 // otherwise just for transaction history.
2239 CWalletTx* wtx = AddToWallet(tx, TxStateInactive{}, [&](CWalletTx& wtx, bool new_tx) {
2240 CHECK_NONFATAL(wtx.mapValue.empty());
2241 CHECK_NONFATAL(wtx.vOrderForm.empty());
2242 wtx.mapValue = std::move(mapValue);
2243 wtx.vOrderForm = std::move(orderForm);
2244 wtx.fTimeReceivedIsTxTime = true;
2245 wtx.fFromMe = true;
2246 return true;
2247 });
2248
2249 // wtx can only be null if the db write failed.
2250 if (!wtx) {
2251 throw std::runtime_error(std::string(__func__) + ": Wallet db error, transaction commit failed");
2252 }
2253
2254 // Notify that old coins are spent
2255 for (const CTxIn& txin : tx->vin) {
2256 CWalletTx &coin = mapWallet.at(txin.prevout.hash);
2257 coin.MarkDirty();
2259 }
2260
2262 // Don't submit tx to the mempool
2263 return;
2264 }
2265
2266 std::string err_string;
2267 if (!SubmitTxMemoryPoolAndRelay(*wtx, err_string, true)) {
2268 WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast immediately, %s\n", err_string);
2269 // TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
2270 }
2271}
2272
2274{
2275 LOCK(cs_wallet);
2276
2277 Assert(m_spk_managers.empty());
2278 Assert(m_wallet_flags == 0);
2279 DBErrors nLoadWalletRet = WalletBatch(GetDatabase()).LoadWallet(this);
2280 if (nLoadWalletRet == DBErrors::NEED_REWRITE)
2281 {
2282 if (GetDatabase().Rewrite("\x04pool"))
2283 {
2284 for (const auto& spk_man_pair : m_spk_managers) {
2285 spk_man_pair.second->RewriteDB();
2286 }
2287 }
2288 }
2289
2290 if (m_spk_managers.empty()) {
2293 }
2294
2295 return nLoadWalletRet;
2296}
2297
2298util::Result<void> CWallet::RemoveTxs(std::vector<uint256>& txs_to_remove)
2299{
2301 bilingual_str str_err; // future: make RunWithinTxn return a util::Result
2302 bool was_txn_committed = RunWithinTxn(GetDatabase(), /*process_desc=*/"remove transactions", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
2303 util::Result<void> result{RemoveTxs(batch, txs_to_remove)};
2304 if (!result) str_err = util::ErrorString(result);
2305 return result.has_value();
2306 });
2307 if (!str_err.empty()) return util::Error{str_err};
2308 if (!was_txn_committed) return util::Error{_("Error starting/committing db txn for wallet transactions removal process")};
2309 return {}; // all good
2310}
2311
2312util::Result<void> CWallet::RemoveTxs(WalletBatch& batch, std::vector<uint256>& txs_to_remove)
2313{
2315 if (!batch.HasActiveTxn()) return util::Error{strprintf(_("The transactions removal process can only be executed within a db txn"))};
2316
2317 // Check for transaction existence and remove entries from disk
2318 using TxIterator = std::unordered_map<uint256, CWalletTx, SaltedTxidHasher>::const_iterator;
2319 std::vector<TxIterator> erased_txs;
2320 bilingual_str str_err;
2321 for (const uint256& hash : txs_to_remove) {
2322 auto it_wtx = mapWallet.find(hash);
2323 if (it_wtx == mapWallet.end()) {
2324 return util::Error{strprintf(_("Transaction %s does not belong to this wallet"), hash.GetHex())};
2325 }
2326 if (!batch.EraseTx(hash)) {
2327 return util::Error{strprintf(_("Failure removing transaction: %s"), hash.GetHex())};
2328 }
2329 erased_txs.emplace_back(it_wtx);
2330 }
2331
2332 // Register callback to update the memory state only when the db txn is actually dumped to disk
2333 batch.RegisterTxnListener({.on_commit=[&, erased_txs]() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
2334 // Update the in-memory state and notify upper layers about the removals
2335 for (const auto& it : erased_txs) {
2336 const uint256 hash{it->first};
2337 wtxOrdered.erase(it->second.m_it_wtxOrdered);
2338 for (const auto& txin : it->second.tx->vin)
2339 mapTxSpends.erase(txin.prevout);
2340 mapWallet.erase(it);
2342 }
2343
2344 MarkDirty();
2345 }, .on_abort={}});
2346
2347 return {};
2348}
2349
2350bool CWallet::SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& new_purpose)
2351{
2352 bool fUpdated = false;
2353 bool is_mine;
2354 std::optional<AddressPurpose> purpose;
2355 {
2356 LOCK(cs_wallet);
2357 std::map<CTxDestination, CAddressBookData>::iterator mi = m_address_book.find(address);
2358 fUpdated = mi != m_address_book.end() && !mi->second.IsChange();
2359
2360 CAddressBookData& record = mi != m_address_book.end() ? mi->second : m_address_book[address];
2361 record.SetLabel(strName);
2362 is_mine = IsMine(address) != ISMINE_NO;
2363 if (new_purpose) { /* update purpose only if requested */
2364 record.purpose = new_purpose;
2365 }
2366 purpose = record.purpose;
2367 }
2368
2369 const std::string& encoded_dest = EncodeDestination(address);
2370 if (new_purpose && !batch.WritePurpose(encoded_dest, PurposeToString(*new_purpose))) {
2371 WalletLogPrintf("Error: fail to write address book 'purpose' entry\n");
2372 return false;
2373 }
2374 if (!batch.WriteName(encoded_dest, strName)) {
2375 WalletLogPrintf("Error: fail to write address book 'name' entry\n");
2376 return false;
2377 }
2378
2379 // In very old wallets, address purpose may not be recorded so we derive it from IsMine
2380 NotifyAddressBookChanged(address, strName, is_mine,
2381 purpose.value_or(is_mine ? AddressPurpose::RECEIVE : AddressPurpose::SEND),
2382 (fUpdated ? CT_UPDATED : CT_NEW));
2383 return true;
2384}
2385
2386bool CWallet::SetAddressBook(const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& purpose)
2387{
2388 WalletBatch batch(GetDatabase());
2389 return SetAddressBookWithDB(batch, address, strName, purpose);
2390}
2391
2393{
2394 return RunWithinTxn(GetDatabase(), /*process_desc=*/"address book entry removal", [&](WalletBatch& batch){
2395 return DelAddressBookWithDB(batch, address);
2396 });
2397}
2398
2400{
2401 const std::string& dest = EncodeDestination(address);
2402 {
2403 LOCK(cs_wallet);
2404 // 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.
2405 // NOTE: This isn't a problem for sending addresses because they don't have any data that needs to be kept.
2406 // When adding new address data, it should be considered here whether to retain or delete it.
2407 if (IsMine(address)) {
2408 WalletLogPrintf("%s called with IsMine address, NOT SUPPORTED. Please report this bug! %s\n", __func__, CLIENT_BUGREPORT);
2409 return false;
2410 }
2411 // Delete data rows associated with this address
2412 if (!batch.EraseAddressData(address)) {
2413 WalletLogPrintf("Error: cannot erase address book entry data\n");
2414 return false;
2415 }
2416
2417 // Delete purpose entry
2418 if (!batch.ErasePurpose(dest)) {
2419 WalletLogPrintf("Error: cannot erase address book entry purpose\n");
2420 return false;
2421 }
2422
2423 // Delete name entry
2424 if (!batch.EraseName(dest)) {
2425 WalletLogPrintf("Error: cannot erase address book entry name\n");
2426 return false;
2427 }
2428
2429 // finally, remove it from the map
2430 m_address_book.erase(address);
2431 }
2432
2433 // All good, signal changes
2434 NotifyAddressBookChanged(address, "", /*is_mine=*/false, AddressPurpose::SEND, CT_DELETED);
2435 return true;
2436}
2437
2439{
2441
2442 unsigned int count = 0;
2443 for (auto spk_man : m_external_spk_managers) {
2444 count += spk_man.second->GetKeyPoolSize();
2445 }
2446
2447 return count;
2448}
2449
2450unsigned int CWallet::GetKeyPoolSize() const
2451{
2453
2454 unsigned int count = 0;
2455 for (auto spk_man : GetActiveScriptPubKeyMans()) {
2456 count += spk_man->GetKeyPoolSize();
2457 }
2458 return count;
2459}
2460
2461bool CWallet::TopUpKeyPool(unsigned int kpSize)
2462{
2463 LOCK(cs_wallet);
2464 bool res = true;
2465 for (auto spk_man : GetActiveScriptPubKeyMans()) {
2466 res &= spk_man->TopUp(kpSize);
2467 }
2468 return res;
2469}
2470
2472{
2473 LOCK(cs_wallet);
2474 auto spk_man = GetScriptPubKeyMan(type, /*internal=*/false);
2475 if (!spk_man) {
2476 return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
2477 }
2478
2479 auto op_dest = spk_man->GetNewDestination(type);
2480 if (op_dest) {
2481 SetAddressBook(*op_dest, label, AddressPurpose::RECEIVE);
2482 }
2483
2484 return op_dest;
2485}
2486
2488{
2489 LOCK(cs_wallet);
2490
2491 ReserveDestination reservedest(this, type);
2492 auto op_dest = reservedest.GetReservedDestination(true);
2493 if (op_dest) reservedest.KeepDestination();
2494
2495 return op_dest;
2496}
2497
2498std::optional<int64_t> CWallet::GetOldestKeyPoolTime() const
2499{
2500 LOCK(cs_wallet);
2501 if (m_spk_managers.empty()) {
2502 return std::nullopt;
2503 }
2504
2505 std::optional<int64_t> oldest_key{std::numeric_limits<int64_t>::max()};
2506 for (const auto& spk_man_pair : m_spk_managers) {
2507 oldest_key = std::min(oldest_key, spk_man_pair.second->GetOldestKeyPoolTime());
2508 }
2509 return oldest_key;
2510}
2511
2512void CWallet::MarkDestinationsDirty(const std::set<CTxDestination>& destinations) {
2513 for (auto& entry : mapWallet) {
2514 CWalletTx& wtx = entry.second;
2515 if (wtx.m_is_cache_empty) continue;
2516 for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
2517 CTxDestination dst;
2518 if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) && destinations.count(dst)) {
2519 wtx.MarkDirty();
2520 break;
2521 }
2522 }
2523 }
2524}
2525
2527{
2529 for (const std::pair<const CTxDestination, CAddressBookData>& item : m_address_book) {
2530 const auto& entry = item.second;
2531 func(item.first, entry.GetLabel(), entry.IsChange(), entry.purpose);
2532 }
2533}
2534
2535std::vector<CTxDestination> CWallet::ListAddrBookAddresses(const std::optional<AddrBookFilter>& _filter) const
2536{
2538 std::vector<CTxDestination> result;
2539 AddrBookFilter filter = _filter ? *_filter : AddrBookFilter();
2540 ForEachAddrBookEntry([&result, &filter](const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose>& purpose) {
2541 // Filter by change
2542 if (filter.ignore_change && is_change) return;
2543 // Filter by label
2544 if (filter.m_op_label && *filter.m_op_label != label) return;
2545 // All good
2546 result.emplace_back(dest);
2547 });
2548 return result;
2549}
2550
2551std::set<std::string> CWallet::ListAddrBookLabels(const std::optional<AddressPurpose> purpose) const
2552{
2554 std::set<std::string> label_set;
2555 ForEachAddrBookEntry([&](const CTxDestination& _dest, const std::string& _label,
2556 bool _is_change, const std::optional<AddressPurpose>& _purpose) {
2557 if (_is_change) return;
2558 if (!purpose || purpose == _purpose) {
2559 label_set.insert(_label);
2560 }
2561 });
2562 return label_set;
2563}
2564
2566{
2568 if (!m_spk_man) {
2569 return util::Error{strprintf(_("Error: No %s addresses available."), FormatOutputType(type))};
2570 }
2571
2572 if (nIndex == -1) {
2573 int64_t index;
2574 auto op_address = m_spk_man->GetReservedDestination(type, internal, index);
2575 if (!op_address) return op_address;
2576 nIndex = index;
2577 address = *op_address;
2578 }
2579 return address;
2580}
2581
2583{
2584 if (nIndex != -1) {
2586 }
2587 nIndex = -1;
2589}
2590
2592{
2593 if (nIndex != -1) {
2595 }
2596 nIndex = -1;
2598}
2599
2601{
2602 CScript scriptPubKey = GetScriptForDestination(dest);
2603 for (const auto& spk_man : GetScriptPubKeyMans(scriptPubKey)) {
2604 auto signer_spk_man = dynamic_cast<ExternalSignerScriptPubKeyMan *>(spk_man);
2605 if (signer_spk_man == nullptr) {
2606 continue;
2607 }
2609 return signer_spk_man->DisplayAddress(dest, signer);
2610 }
2611 return util::Error{_("There is no ScriptPubKeyManager for this address")};
2612}
2613
2614bool CWallet::LockCoin(const COutPoint& output, WalletBatch* batch)
2615{
2617 setLockedCoins.insert(output);
2618 if (batch) {
2619 return batch->WriteLockedUTXO(output);
2620 }
2621 return true;
2622}
2623
2624bool CWallet::UnlockCoin(const COutPoint& output, WalletBatch* batch)
2625{
2627 bool was_locked = setLockedCoins.erase(output);
2628 if (batch && was_locked) {
2629 return batch->EraseLockedUTXO(output);
2630 }
2631 return true;
2632}
2633
2635{
2637 bool success = true;
2638 WalletBatch batch(GetDatabase());
2639 for (auto it = setLockedCoins.begin(); it != setLockedCoins.end(); ++it) {
2640 success &= batch.EraseLockedUTXO(*it);
2641 }
2642 setLockedCoins.clear();
2643 return success;
2644}
2645
2646bool CWallet::IsLockedCoin(const COutPoint& output) const
2647{
2649 return setLockedCoins.count(output) > 0;
2650}
2651
2652void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
2653{
2655 for (std::set<COutPoint>::iterator it = setLockedCoins.begin();
2656 it != setLockedCoins.end(); it++) {
2657 COutPoint outpt = (*it);
2658 vOutpts.push_back(outpt);
2659 }
2660}
2661
2685unsigned int CWallet::ComputeTimeSmart(const CWalletTx& wtx, bool rescanning_old_block) const
2686{
2687 std::optional<uint256> block_hash;
2688 if (auto* conf = wtx.state<TxStateConfirmed>()) {
2689 block_hash = conf->confirmed_block_hash;
2690 } else if (auto* conf = wtx.state<TxStateBlockConflicted>()) {
2691 block_hash = conf->conflicting_block_hash;
2692 }
2693
2694 unsigned int nTimeSmart = wtx.nTimeReceived;
2695 if (block_hash) {
2696 int64_t blocktime;
2697 int64_t block_max_time;
2698 if (chain().findBlock(*block_hash, FoundBlock().time(blocktime).maxTime(block_max_time))) {
2699 if (rescanning_old_block) {
2700 nTimeSmart = block_max_time;
2701 } else {
2702 int64_t latestNow = wtx.nTimeReceived;
2703 int64_t latestEntry = 0;
2704
2705 // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
2706 int64_t latestTolerated = latestNow + 300;
2707 const TxItems& txOrdered = wtxOrdered;
2708 for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
2709 CWalletTx* const pwtx = it->second;
2710 if (pwtx == &wtx) {
2711 continue;
2712 }
2713 int64_t nSmartTime;
2714 nSmartTime = pwtx->nTimeSmart;
2715 if (!nSmartTime) {
2716 nSmartTime = pwtx->nTimeReceived;
2717 }
2718 if (nSmartTime <= latestTolerated) {
2719 latestEntry = nSmartTime;
2720 if (nSmartTime > latestNow) {
2721 latestNow = nSmartTime;
2722 }
2723 break;
2724 }
2725 }
2726
2727 nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
2728 }
2729 } else {
2730 WalletLogPrintf("%s: found %s in block %s not in index\n", __func__, wtx.GetHash().ToString(), block_hash->ToString());
2731 }
2732 }
2733 return nTimeSmart;
2734}
2735
2737{
2738 if (std::get_if<CNoDestination>(&dest))
2739 return false;
2740
2741 if (!used) {
2742 if (auto* data{common::FindKey(m_address_book, dest)}) data->previously_spent = false;
2743 return batch.WriteAddressPreviouslySpent(dest, false);
2744 }
2745
2747 return batch.WriteAddressPreviouslySpent(dest, true);
2748}
2749
2751{
2752 m_address_book[dest].previously_spent = true;
2753}
2754
2755void CWallet::LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request)
2756{
2757 m_address_book[dest].receive_requests[id] = request;
2758}
2759
2761{
2762 if (auto* data{common::FindKey(m_address_book, dest)}) return data->previously_spent;
2763 return false;
2764}
2765
2766std::vector<std::string> CWallet::GetAddressReceiveRequests() const
2767{
2768 std::vector<std::string> values;
2769 for (const auto& [dest, entry] : m_address_book) {
2770 for (const auto& [id, request] : entry.receive_requests) {
2771 values.emplace_back(request);
2772 }
2773 }
2774 return values;
2775}
2776
2777bool CWallet::SetAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id, const std::string& value)
2778{
2779 if (!batch.WriteAddressReceiveRequest(dest, id, value)) return false;
2780 m_address_book[dest].receive_requests[id] = value;
2781 return true;
2782}
2783
2784bool CWallet::EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id)
2785{
2786 if (!batch.EraseAddressReceiveRequest(dest, id)) return false;
2787 m_address_book[dest].receive_requests.erase(id);
2788 return true;
2789}
2790
2792{
2793 // Do some checking on wallet path. It should be either a:
2794 //
2795 // 1. Path where a directory can be created.
2796 // 2. Path to an existing directory.
2797 // 3. Path to a symlink to a directory.
2798 // 4. For backwards compatibility, the name of a data file in -walletdir.
2799 const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(name));
2800 fs::file_type path_type = fs::symlink_status(wallet_path).type();
2801 if (!(path_type == fs::file_type::not_found || path_type == fs::file_type::directory ||
2802 (path_type == fs::file_type::symlink && fs::is_directory(wallet_path)) ||
2803 (path_type == fs::file_type::regular && fs::PathFromString(name).filename() == fs::PathFromString(name)))) {
2805 "Invalid -wallet path '%s'. -wallet path should point to a directory where wallet.dat and "
2806 "database/log.?????????? files can be stored, a location where such a directory could be created, "
2807 "or (for backwards compatibility) the name of an existing data file in -walletdir (%s)",
2809 }
2810 return wallet_path;
2811}
2812
2813std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error_string)
2814{
2815 const auto& wallet_path = GetWalletPath(name);
2816 if (!wallet_path) {
2817 error_string = util::ErrorString(wallet_path);
2819 return nullptr;
2820 }
2821 return MakeDatabase(*wallet_path, options, status, error_string);
2822}
2823
2824std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings)
2825{
2826 interfaces::Chain* chain = context.chain;
2827 ArgsManager& args = *Assert(context.args);
2828 const std::string& walletFile = database->Filename();
2829
2830 const auto start{SteadyClock::now()};
2831 // TODO: Can't use std::make_shared because we need a custom deleter but
2832 // should be possible to use std::allocate_shared.
2833 std::shared_ptr<CWallet> walletInstance(new CWallet(chain, name, std::move(database)), FlushAndDeleteWallet);
2834 walletInstance->m_keypool_size = std::max(args.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t{1});
2835 walletInstance->m_notify_tx_changed_script = args.GetArg("-walletnotify", "");
2836
2837 // Load wallet
2838 bool rescan_required = false;
2839 DBErrors nLoadWalletRet = walletInstance->LoadWallet();
2840 if (nLoadWalletRet != DBErrors::LOAD_OK) {
2841 if (nLoadWalletRet == DBErrors::CORRUPT) {
2842 error = strprintf(_("Error loading %s: Wallet corrupted"), walletFile);
2843 return nullptr;
2844 }
2845 else if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR)
2846 {
2847 warnings.push_back(strprintf(_("Error reading %s! All keys read correctly, but transaction data"
2848 " or address metadata may be missing or incorrect."),
2849 walletFile));
2850 }
2851 else if (nLoadWalletRet == DBErrors::TOO_NEW) {
2852 error = strprintf(_("Error loading %s: Wallet requires newer version of %s"), walletFile, CLIENT_NAME);
2853 return nullptr;
2854 }
2855 else if (nLoadWalletRet == DBErrors::EXTERNAL_SIGNER_SUPPORT_REQUIRED) {
2856 error = strprintf(_("Error loading %s: External signer wallet being loaded without external signer support compiled"), walletFile);
2857 return nullptr;
2858 }
2859 else if (nLoadWalletRet == DBErrors::NEED_REWRITE)
2860 {
2861 error = strprintf(_("Wallet needed to be rewritten: restart %s to complete"), CLIENT_NAME);
2862 return nullptr;
2863 } else if (nLoadWalletRet == DBErrors::NEED_RESCAN) {
2864 warnings.push_back(strprintf(_("Error reading %s! Transaction data may be missing or incorrect."
2865 " Rescanning wallet."), walletFile));
2866 rescan_required = true;
2867 } else if (nLoadWalletRet == DBErrors::UNKNOWN_DESCRIPTOR) {
2868 error = strprintf(_("Unrecognized descriptor found. Loading wallet %s\n\n"
2869 "The wallet might had been created on a newer version.\n"
2870 "Please try running the latest software version.\n"), walletFile);
2871 return nullptr;
2872 } else if (nLoadWalletRet == DBErrors::UNEXPECTED_LEGACY_ENTRY) {
2873 error = strprintf(_("Unexpected legacy entry in descriptor wallet found. Loading wallet %s\n\n"
2874 "The wallet might have been tampered with or created with malicious intent.\n"), walletFile);
2875 return nullptr;
2876 } else if (nLoadWalletRet == DBErrors::LEGACY_WALLET) {
2877 error = strprintf(_("Error loading %s: Wallet is a legacy wallet. Please migrate to a descriptor wallet using the migration tool (migratewallet RPC)."), walletFile);
2878 return nullptr;
2879 } else {
2880 error = strprintf(_("Error loading %s"), walletFile);
2881 return nullptr;
2882 }
2883 }
2884
2885 // This wallet is in its first run if there are no ScriptPubKeyMans and it isn't blank or no privkeys
2886 const bool fFirstRun = walletInstance->m_spk_managers.empty() &&
2887 !walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
2888 !walletInstance->IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
2889 if (fFirstRun)
2890 {
2891 // ensure this wallet.dat can only be opened by clients supporting HD with chain split and expects no default key
2892 walletInstance->SetMinVersion(FEATURE_LATEST);
2893
2894 walletInstance->InitWalletFlags(wallet_creation_flags);
2895
2896 // Only descriptor wallets can be created
2897 assert(walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
2898
2899 if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) || !(wallet_creation_flags & (WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET))) {
2900 LOCK(walletInstance->cs_wallet);
2901 if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
2902 walletInstance->SetupDescriptorScriptPubKeyMans();
2903 // SetupDescriptorScriptPubKeyMans already calls SetupGeneration for us so we don't need to call SetupGeneration separately
2904 } else {
2905 // Legacy wallets need SetupGeneration here.
2906 for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
2907 if (!spk_man->SetupGeneration()) {
2908 error = _("Unable to generate initial keys");
2909 return nullptr;
2910 }
2911 }
2912 }
2913 }
2914
2915 if (chain) {
2916 walletInstance->chainStateFlushed(ChainstateRole::NORMAL, chain->getTipLocator());
2917 }
2918 } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
2919 // Make it impossible to disable private keys after creation
2920 error = strprintf(_("Error loading %s: Private keys can only be disabled during creation"), walletFile);
2921 return nullptr;
2922 } else if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
2923 for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
2924 if (spk_man->HavePrivateKeys()) {
2925 warnings.push_back(strprintf(_("Warning: Private keys detected in wallet {%s} with disabled private keys"), walletFile));
2926 break;
2927 }
2928 }
2929 }
2930
2931 if (!args.GetArg("-addresstype", "").empty()) {
2932 std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-addresstype", ""));
2933 if (!parsed) {
2934 error = strprintf(_("Unknown address type '%s'"), args.GetArg("-addresstype", ""));
2935 return nullptr;
2936 }
2937 walletInstance->m_default_address_type = parsed.value();
2938 }
2939
2940 if (!args.GetArg("-changetype", "").empty()) {
2941 std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-changetype", ""));
2942 if (!parsed) {
2943 error = strprintf(_("Unknown change type '%s'"), args.GetArg("-changetype", ""));
2944 return nullptr;
2945 }
2946 walletInstance->m_default_change_type = parsed.value();
2947 }
2948
2949 if (const auto arg{args.GetArg("-mintxfee")}) {
2950 std::optional<CAmount> min_tx_fee = ParseMoney(*arg);
2951 if (!min_tx_fee) {
2952 error = AmountErrMsg("mintxfee", *arg);
2953 return nullptr;
2954 } else if (min_tx_fee.value() > HIGH_TX_FEE_PER_KB) {
2955 warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
2956 _("This is the minimum transaction fee you pay on every transaction."));
2957 }
2958
2959 walletInstance->m_min_fee = CFeeRate{min_tx_fee.value()};
2960 }
2961
2962 if (const auto arg{args.GetArg("-maxapsfee")}) {
2963 const std::string& max_aps_fee{*arg};
2964 if (max_aps_fee == "-1") {
2965 walletInstance->m_max_aps_fee = -1;
2966 } else if (std::optional<CAmount> max_fee = ParseMoney(max_aps_fee)) {
2967 if (max_fee.value() > HIGH_APS_FEE) {
2968 warnings.push_back(AmountHighWarn("-maxapsfee") + Untranslated(" ") +
2969 _("This is the maximum transaction fee you pay (in addition to the normal fee) to prioritize partial spend avoidance over regular coin selection."));
2970 }
2971 walletInstance->m_max_aps_fee = max_fee.value();
2972 } else {
2973 error = AmountErrMsg("maxapsfee", max_aps_fee);
2974 return nullptr;
2975 }
2976 }
2977
2978 if (const auto arg{args.GetArg("-fallbackfee")}) {
2979 std::optional<CAmount> fallback_fee = ParseMoney(*arg);
2980 if (!fallback_fee) {
2981 error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-fallbackfee", *arg);
2982 return nullptr;
2983 } else if (fallback_fee.value() > HIGH_TX_FEE_PER_KB) {
2984 warnings.push_back(AmountHighWarn("-fallbackfee") + Untranslated(" ") +
2985 _("This is the transaction fee you may pay when fee estimates are not available."));
2986 }
2987 walletInstance->m_fallback_fee = CFeeRate{fallback_fee.value()};
2988 }
2989
2990 // Disable fallback fee in case value was set to 0, enable if non-null value
2991 walletInstance->m_allow_fallback_fee = walletInstance->m_fallback_fee.GetFeePerK() != 0;
2992
2993 if (const auto arg{args.GetArg("-discardfee")}) {
2994 std::optional<CAmount> discard_fee = ParseMoney(*arg);
2995 if (!discard_fee) {
2996 error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-discardfee", *arg);
2997 return nullptr;
2998 } else if (discard_fee.value() > HIGH_TX_FEE_PER_KB) {
2999 warnings.push_back(AmountHighWarn("-discardfee") + Untranslated(" ") +
3000 _("This is the transaction fee you may discard if change is smaller than dust at this level"));
3001 }
3002 walletInstance->m_discard_rate = CFeeRate{discard_fee.value()};
3003 }
3004
3005 if (const auto arg{args.GetArg("-paytxfee")}) {
3006 warnings.push_back(_("-paytxfee is deprecated and will be fully removed in v31.0."));
3007
3008 std::optional<CAmount> pay_tx_fee = ParseMoney(*arg);
3009 if (!pay_tx_fee) {
3010 error = AmountErrMsg("paytxfee", *arg);
3011 return nullptr;
3012 } else if (pay_tx_fee.value() > HIGH_TX_FEE_PER_KB) {
3013 warnings.push_back(AmountHighWarn("-paytxfee") + Untranslated(" ") +
3014 _("This is the transaction fee you will pay if you send a transaction."));
3015 }
3016
3017 walletInstance->m_pay_tx_fee = CFeeRate{pay_tx_fee.value(), 1000};
3018
3019 if (chain && walletInstance->m_pay_tx_fee < chain->relayMinFee()) {
3020 error = strprintf(_("Invalid amount for %s=<amount>: '%s' (must be at least %s)"),
3021 "-paytxfee", *arg, chain->relayMinFee().ToString());
3022 return nullptr;
3023 }
3024 }
3025
3026 if (const auto arg{args.GetArg("-maxtxfee")}) {
3027 std::optional<CAmount> max_fee = ParseMoney(*arg);
3028 if (!max_fee) {
3029 error = AmountErrMsg("maxtxfee", *arg);
3030 return nullptr;
3031 } else if (max_fee.value() > HIGH_MAX_TX_FEE) {
3032 warnings.push_back(strprintf(_("%s is set very high! Fees this large could be paid on a single transaction."), "-maxtxfee"));
3033 }
3034
3035 if (chain && CFeeRate{max_fee.value(), 1000} < chain->relayMinFee()) {
3036 error = strprintf(_("Invalid amount for %s=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions)"),
3037 "-maxtxfee", *arg, chain->relayMinFee().ToString());
3038 return nullptr;
3039 }
3040
3041 walletInstance->m_default_max_tx_fee = max_fee.value();
3042 }
3043
3044 if (const auto arg{args.GetArg("-consolidatefeerate")}) {
3045 if (std::optional<CAmount> consolidate_feerate = ParseMoney(*arg)) {
3046 walletInstance->m_consolidate_feerate = CFeeRate(*consolidate_feerate);
3047 } else {
3048 error = AmountErrMsg("consolidatefeerate", *arg);
3049 return nullptr;
3050 }
3051 }
3052
3054 warnings.push_back(AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
3055 _("The wallet will avoid paying less than the minimum relay fee."));
3056 }
3057
3058 walletInstance->m_confirm_target = args.GetIntArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
3059 walletInstance->m_spend_zero_conf_change = args.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
3060 walletInstance->m_signal_rbf = args.GetBoolArg("-walletrbf", DEFAULT_WALLET_RBF);
3061
3062 walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
3063
3064 // Try to top up keypool. No-op if the wallet is locked.
3065 walletInstance->TopUpKeyPool();
3066
3067 // Cache the first key time
3068 std::optional<int64_t> time_first_key;
3069 for (auto spk_man : walletInstance->GetAllScriptPubKeyMans()) {
3070 int64_t time = spk_man->GetTimeFirstKey();
3071 if (!time_first_key || time < *time_first_key) time_first_key = time;
3072 }
3073 if (time_first_key) walletInstance->MaybeUpdateBirthTime(*time_first_key);
3074
3075 if (chain && !AttachChain(walletInstance, *chain, rescan_required, error, warnings)) {
3076 walletInstance->m_chain_notifications_handler.reset(); // Reset this pointer so that the wallet will actually be unloaded
3077 return nullptr;
3078 }
3079
3080 {
3081 LOCK(walletInstance->cs_wallet);
3082 walletInstance->SetBroadcastTransactions(args.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
3083 walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n", walletInstance->GetKeyPoolSize());
3084 walletInstance->WalletLogPrintf("mapWallet.size() = %u\n", walletInstance->mapWallet.size());
3085 walletInstance->WalletLogPrintf("m_address_book.size() = %u\n", walletInstance->m_address_book.size());
3086 }
3087
3088 return walletInstance;
3089}
3090
3091bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interfaces::Chain& chain, const bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings)
3092{
3093 LOCK(walletInstance->cs_wallet);
3094 // allow setting the chain if it hasn't been set already but prevent changing it
3095 assert(!walletInstance->m_chain || walletInstance->m_chain == &chain);
3096 walletInstance->m_chain = &chain;
3097
3098 // Unless allowed, ensure wallet files are not reused across chains:
3099 if (!gArgs.GetBoolArg("-walletcrosschain", DEFAULT_WALLETCROSSCHAIN)) {
3100 WalletBatch batch(walletInstance->GetDatabase());
3101 CBlockLocator locator;
3102 if (batch.ReadBestBlock(locator) && locator.vHave.size() > 0 && chain.getHeight()) {
3103 // Wallet is assumed to be from another chain, if genesis block in the active
3104 // chain differs from the genesis block known to the wallet.
3105 if (chain.getBlockHash(0) != locator.vHave.back()) {
3106 error = Untranslated("Wallet files should not be reused across chains. Restart bitcoind with -walletcrosschain to override.");
3107 return false;
3108 }
3109 }
3110 }
3111
3112 // Register wallet with validationinterface. It's done before rescan to avoid
3113 // missing block connections during the rescan.
3114 // Because of the wallet lock being held, block connection notifications are going to
3115 // be pending on the validation-side until lock release. Blocks that are connected while the
3116 // rescan is ongoing will not be processed in the rescan but with the block connected notifications,
3117 // so the wallet will only be completeley synced after the notifications delivery.
3118 // chainStateFlushed notifications are ignored until the rescan is finished
3119 // so that in case of a shutdown event, the rescan will be repeated at the next start.
3120 // This is temporary until rescan and notifications delivery are unified under same
3121 // interface.
3122 walletInstance->m_attaching_chain = true; //ignores chainStateFlushed notifications
3123 walletInstance->m_chain_notifications_handler = walletInstance->chain().handleNotifications(walletInstance);
3124
3125 // If rescan_required = true, rescan_height remains equal to 0
3126 int rescan_height = 0;
3127 if (!rescan_required)
3128 {
3129 WalletBatch batch(walletInstance->GetDatabase());
3130 CBlockLocator locator;
3131 if (batch.ReadBestBlock(locator)) {
3132 if (const std::optional<int> fork_height = chain.findLocatorFork(locator)) {
3133 rescan_height = *fork_height;
3134 }
3135 }
3136 }
3137
3138 const std::optional<int> tip_height = chain.getHeight();
3139 if (tip_height) {
3140 walletInstance->m_last_block_processed = chain.getBlockHash(*tip_height);
3141 walletInstance->m_last_block_processed_height = *tip_height;
3142 } else {
3143 walletInstance->m_last_block_processed.SetNull();
3144 walletInstance->m_last_block_processed_height = -1;
3145 }
3146
3147 if (tip_height && *tip_height != rescan_height)
3148 {
3149 // No need to read and scan block if block was created before
3150 // our wallet birthday (as adjusted for block time variability)
3151 std::optional<int64_t> time_first_key = walletInstance->m_birth_time.load();
3152 if (time_first_key) {
3153 FoundBlock found = FoundBlock().height(rescan_height);
3154 chain.findFirstBlockWithTimeAndHeight(*time_first_key - TIMESTAMP_WINDOW, rescan_height, found);
3155 if (!found.found) {
3156 // We were unable to find a block that had a time more recent than our earliest timestamp
3157 // or a height higher than the wallet was synced to, indicating that the wallet is newer than the
3158 // current chain tip. Skip rescanning in this case.
3159 rescan_height = *tip_height;
3160 }
3161 }
3162
3163 // Technically we could execute the code below in any case, but performing the
3164 // `while` loop below can make startup very slow, so only check blocks on disk
3165 // if necessary.
3167 int block_height = *tip_height;
3168 while (block_height > 0 && chain.haveBlockOnDisk(block_height - 1) && rescan_height != block_height) {
3169 --block_height;
3170 }
3171
3172 if (rescan_height != block_height) {
3173 // We can't rescan beyond blocks we don't have data for, stop and throw an error.
3174 // This might happen if a user uses an old wallet within a pruned node
3175 // or if they ran -disablewallet for a longer time, then decided to re-enable
3176 // Exit early and print an error.
3177 // It also may happen if an assumed-valid chain is in use and therefore not
3178 // all block data is available.
3179 // If a block is pruned after this check, we will load the wallet,
3180 // but fail the rescan with a generic error.
3181
3182 error = chain.havePruned() ?
3183 _("Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of pruned node)") :
3184 strprintf(_(
3185 "Error loading wallet. Wallet requires blocks to be downloaded, "
3186 "and software does not currently support loading wallets while "
3187 "blocks are being downloaded out of order when using assumeutxo "
3188 "snapshots. Wallet should be able to load successfully after "
3189 "node sync reaches height %s"), block_height);
3190 return false;
3191 }
3192 }
3193
3194 chain.initMessage(_("Rescanning…"));
3195 walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...\n", *tip_height - rescan_height, rescan_height);
3196
3197 {
3198 WalletRescanReserver reserver(*walletInstance);
3199 if (!reserver.reserve() || (ScanResult::SUCCESS != walletInstance->ScanForWalletTransactions(chain.getBlockHash(rescan_height), rescan_height, /*max_height=*/{}, reserver, /*fUpdate=*/true, /*save_progress=*/true).status)) {
3200 error = _("Failed to rescan the wallet during initialization");
3201 return false;
3202 }
3203 }
3204 walletInstance->m_attaching_chain = false;
3205 walletInstance->chainStateFlushed(ChainstateRole::NORMAL, chain.getTipLocator());
3206 }
3207 walletInstance->m_attaching_chain = false;
3208
3209 return true;
3210}
3211
3212const CAddressBookData* CWallet::FindAddressBookEntry(const CTxDestination& dest, bool allow_change) const
3213{
3214 const auto& address_book_it = m_address_book.find(dest);
3215 if (address_book_it == m_address_book.end()) return nullptr;
3216 if ((!allow_change) && address_book_it->second.IsChange()) {
3217 return nullptr;
3218 }
3219 return &address_book_it->second;
3220}
3221
3222bool CWallet::UpgradeWallet(int version, bilingual_str& error)
3223{
3224 int prev_version = GetVersion();
3225 if (version == 0) {
3226 WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
3227 version = FEATURE_LATEST;
3228 } else {
3229 WalletLogPrintf("Allowing wallet upgrade up to %i\n", version);
3230 }
3231 if (version < prev_version) {
3232 error = strprintf(_("Cannot downgrade wallet from version %i to version %i. Wallet version unchanged."), prev_version, version);
3233 return false;
3234 }
3235
3236 LOCK(cs_wallet);
3237
3238 // Do not upgrade versions to any version between HD_SPLIT and FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
3240 error = strprintf(_("Cannot upgrade a non HD split wallet from version %i to version %i without upgrading to support pre-split keypool. Please use version %i or no version specified."), prev_version, version, FEATURE_PRE_SPLIT_KEYPOOL);
3241 return false;
3242 }
3243
3244 // Permanently upgrade to the version
3246
3247 for (auto spk_man : GetActiveScriptPubKeyMans()) {
3248 if (!spk_man->Upgrade(prev_version, version, error)) {
3249 return false;
3250 }
3251 }
3252 return true;
3253}
3254
3256{
3257 // Add wallet transactions that aren't already in a block to mempool
3258 // Do this here as mempool requires genesis block to be loaded
3259 ResubmitWalletTransactions(/*relay=*/false, /*force=*/true);
3260
3261 // Update wallet transactions with current mempool transactions.
3262 WITH_LOCK(cs_wallet, chain().requestMempoolTransactions(*this));
3263}
3264
3265bool CWallet::BackupWallet(const std::string& strDest) const
3266{
3267 if (m_chain) {
3268 CBlockLocator loc;
3269 WITH_LOCK(cs_wallet, chain().findBlock(m_last_block_processed, FoundBlock().locator(loc)));
3270 if (!loc.IsNull()) {
3271 WalletBatch batch(GetDatabase());
3272 batch.WriteBestBlock(loc);
3273 }
3274 }
3275 return GetDatabase().Backup(strDest);
3276}
3277
3279{
3281 if (auto* conf = wtx.state<TxStateConfirmed>()) {
3282 assert(conf->confirmed_block_height >= 0);
3283 return GetLastBlockHeight() - conf->confirmed_block_height + 1;
3284 } else if (auto* conf = wtx.state<TxStateBlockConflicted>()) {
3285 assert(conf->conflicting_block_height >= 0);
3286 return -1 * (GetLastBlockHeight() - conf->conflicting_block_height + 1);
3287 } else {
3288 return 0;
3289 }
3290}
3291
3293{
3295
3296 if (!wtx.IsCoinBase()) {
3297 return 0;
3298 }
3299 int chain_depth = GetTxDepthInMainChain(wtx);
3300 assert(chain_depth >= 0); // coinbase tx should not be conflicted
3301 return std::max(0, (COINBASE_MATURITY+1) - chain_depth);
3302}
3303
3305{
3307
3308 // note GetBlocksToMaturity is 0 for non-coinbase tx
3309 return GetTxBlocksToMaturity(wtx) > 0;
3310}
3311
3313{
3314 return HasEncryptionKeys();
3315}
3316
3318{
3319 if (!IsCrypted()) {
3320 return false;
3321 }
3322 LOCK(cs_wallet);
3323 return vMasterKey.empty();
3324}
3325
3327{
3328 if (!IsCrypted())
3329 return false;
3330
3331 {
3333 if (!vMasterKey.empty()) {
3334 memory_cleanse(vMasterKey.data(), vMasterKey.size() * sizeof(decltype(vMasterKey)::value_type));
3335 vMasterKey.clear();
3336 }
3337 }
3338
3339 NotifyStatusChanged(this);
3340 return true;
3341}
3342
3343bool CWallet::Unlock(const CKeyingMaterial& vMasterKeyIn)
3344{
3345 {
3346 LOCK(cs_wallet);
3347 for (const auto& spk_man_pair : m_spk_managers) {
3348 if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn)) {
3349 return false;
3350 }
3351 }
3352 vMasterKey = vMasterKeyIn;
3353 }
3354 NotifyStatusChanged(this);
3355 return true;
3356}
3357
3358std::set<ScriptPubKeyMan*> CWallet::GetActiveScriptPubKeyMans() const
3359{
3360 std::set<ScriptPubKeyMan*> spk_mans;
3361 for (bool internal : {false, true}) {
3362 for (OutputType t : OUTPUT_TYPES) {
3363 auto spk_man = GetScriptPubKeyMan(t, internal);
3364 if (spk_man) {
3365 spk_mans.insert(spk_man);
3366 }
3367 }
3368 }
3369 return spk_mans;
3370}
3371
3373{
3374 for (const auto& [_, ext_spkm] : m_external_spk_managers) {
3375 if (ext_spkm == &spkm) return true;
3376 }
3377 for (const auto& [_, int_spkm] : m_internal_spk_managers) {
3378 if (int_spkm == &spkm) return true;
3379 }
3380 return false;
3381}
3382
3383std::set<ScriptPubKeyMan*> CWallet::GetAllScriptPubKeyMans() const
3384{
3385 std::set<ScriptPubKeyMan*> spk_mans;
3386 for (const auto& spk_man_pair : m_spk_managers) {
3387 spk_mans.insert(spk_man_pair.second.get());
3388 }
3389 return spk_mans;
3390}
3391
3393{
3394 const std::map<OutputType, ScriptPubKeyMan*>& spk_managers = internal ? m_internal_spk_managers : m_external_spk_managers;
3395 std::map<OutputType, ScriptPubKeyMan*>::const_iterator it = spk_managers.find(type);
3396 if (it == spk_managers.end()) {
3397 return nullptr;
3398 }
3399 return it->second;
3400}
3401
3402std::set<ScriptPubKeyMan*> CWallet::GetScriptPubKeyMans(const CScript& script) const
3403{
3404 std::set<ScriptPubKeyMan*> spk_mans;
3405
3406 // Search the cache for relevant SPKMs instead of iterating m_spk_managers
3407 const auto& it = m_cached_spks.find(script);
3408 if (it != m_cached_spks.end()) {
3409 spk_mans.insert(it->second.begin(), it->second.end());
3410 }
3411 SignatureData sigdata;
3412 Assume(std::all_of(spk_mans.begin(), spk_mans.end(), [&script, &sigdata](ScriptPubKeyMan* spkm) { return spkm->CanProvide(script, sigdata); }));
3413
3414 return spk_mans;
3415}
3416
3418{
3419 if (m_spk_managers.count(id) > 0) {
3420 return m_spk_managers.at(id).get();
3421 }
3422 return nullptr;
3423}
3424
3425std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script) const
3426{
3427 SignatureData sigdata;
3428 return GetSolvingProvider(script, sigdata);
3429}
3430
3431std::unique_ptr<SigningProvider> CWallet::GetSolvingProvider(const CScript& script, SignatureData& sigdata) const
3432{
3433 // Search the cache for relevant SPKMs instead of iterating m_spk_managers
3434 const auto& it = m_cached_spks.find(script);
3435 if (it != m_cached_spks.end()) {
3436 // All spkms for a given script must already be able to make a SigningProvider for the script, so just return the first one.
3437 Assume(it->second.at(0)->CanProvide(script, sigdata));
3438 return it->second.at(0)->GetSolvingProvider(script);
3439 }
3440
3441 return nullptr;
3442}
3443
3444std::vector<WalletDescriptor> CWallet::GetWalletDescriptors(const CScript& script) const
3445{
3446 std::vector<WalletDescriptor> descs;
3447 for (const auto spk_man: GetScriptPubKeyMans(script)) {
3448 if (const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man)) {
3449 LOCK(desc_spk_man->cs_desc_man);
3450 descs.push_back(desc_spk_man->GetWalletDescriptor());
3451 }
3452 }
3453 return descs;
3454}
3455
3457{
3459 return nullptr;
3460 }
3462 if (it == m_internal_spk_managers.end()) return nullptr;
3463 return dynamic_cast<LegacyDataSPKM*>(it->second);
3464}
3465
3466void CWallet::AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man)
3467{
3468 // Add spkm_man to m_spk_managers before calling any method
3469 // that might access it.
3470 const auto& spkm = m_spk_managers[id] = std::move(spkm_man);
3471
3472 // Update birth time if needed
3473 MaybeUpdateBirthTime(spkm->GetTimeFirstKey());
3474}
3475
3477{
3479 return GetLegacyDataSPKM();
3480}
3481
3483{
3485 return;
3486 }
3487
3488 Assert(m_database->Format() == "bdb_ro" || m_database->Format() == "mock");
3489 std::unique_ptr<ScriptPubKeyMan> spk_manager = std::make_unique<LegacyDataSPKM>(*this);
3490
3491 for (const auto& type : LEGACY_OUTPUT_TYPES) {
3492 m_internal_spk_managers[type] = spk_manager.get();
3493 m_external_spk_managers[type] = spk_manager.get();
3494 }
3495 uint256 id = spk_manager->GetID();
3496 AddScriptPubKeyMan(id, std::move(spk_manager));
3497}
3498
3499bool CWallet::WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const
3500{
3501 LOCK(cs_wallet);
3502 return cb(vMasterKey);
3503}
3504
3506{
3507 return !mapMasterKeys.empty();
3508}
3509
3511{
3512 for (const auto& spkm : GetAllScriptPubKeyMans()) {
3513 if (spkm->HaveCryptedKeys()) return true;
3514 }
3515 return false;
3516}
3517
3519{
3520 for (const auto& spk_man : GetActiveScriptPubKeyMans()) {
3521 spk_man->NotifyWatchonlyChanged.connect(NotifyWatchonlyChanged);
3522 spk_man->NotifyCanGetAddressesChanged.connect(NotifyCanGetAddressesChanged);
3523 spk_man->NotifyFirstKeyTimeChanged.connect(std::bind(&CWallet::MaybeUpdateBirthTime, this, std::placeholders::_2));
3524 }
3525}
3526
3528{
3529 DescriptorScriptPubKeyMan* spk_manager;
3531 spk_manager = new ExternalSignerScriptPubKeyMan(*this, desc, m_keypool_size);
3532 } else {
3533 spk_manager = new DescriptorScriptPubKeyMan(*this, desc, m_keypool_size);
3534 }
3535 AddScriptPubKeyMan(id, std::unique_ptr<ScriptPubKeyMan>(spk_manager));
3536 return *spk_manager;
3537}
3538
3539DescriptorScriptPubKeyMan& CWallet::SetupDescriptorScriptPubKeyMan(WalletBatch& batch, const CExtKey& master_key, const OutputType& output_type, bool internal)
3540{
3542 auto spk_manager = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(*this, m_keypool_size));
3543 if (IsCrypted()) {
3544 if (IsLocked()) {
3545 throw std::runtime_error(std::string(__func__) + ": Wallet is locked, cannot setup new descriptors");
3546 }
3547 if (!spk_manager->CheckDecryptionKey(vMasterKey) && !spk_manager->Encrypt(vMasterKey, &batch)) {
3548 throw std::runtime_error(std::string(__func__) + ": Could not encrypt new descriptors");
3549 }
3550 }
3551 spk_manager->SetupDescriptorGeneration(batch, master_key, output_type, internal);
3552 DescriptorScriptPubKeyMan* out = spk_manager.get();
3553 uint256 id = spk_manager->GetID();
3554 AddScriptPubKeyMan(id, std::move(spk_manager));
3555 AddActiveScriptPubKeyManWithDb(batch, id, output_type, internal);
3556 return *out;
3557}
3558
3560{
3562 for (bool internal : {false, true}) {
3563 for (OutputType t : OUTPUT_TYPES) {
3564 SetupDescriptorScriptPubKeyMan(batch, master_key, t, internal);
3565 }
3566 }
3567}
3568
3570{
3573 // Make a seed
3574 CKey seed_key = GenerateRandomKey();
3575 CPubKey seed = seed_key.GetPubKey();
3576 assert(seed_key.VerifyPubKey(seed));
3577
3578 // Get the extended key
3579 CExtKey master_key;
3580 master_key.SetSeed(seed_key);
3581
3582 SetupDescriptorScriptPubKeyMans(batch, master_key);
3583}
3584
3586{
3588
3590 if (!RunWithinTxn(GetDatabase(), /*process_desc=*/"setup descriptors", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet){
3592 return true;
3593 })) throw std::runtime_error("Error: cannot process db transaction for descriptors setup");
3594 } else {
3596
3597 // TODO: add account parameter
3598 int account = 0;
3599 UniValue signer_res = signer.GetDescriptors(account);
3600
3601 if (!signer_res.isObject()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
3602
3603 WalletBatch batch(GetDatabase());
3604 if (!batch.TxnBegin()) throw std::runtime_error("Error: cannot create db transaction for descriptors import");
3605
3606 for (bool internal : {false, true}) {
3607 const UniValue& descriptor_vals = signer_res.find_value(internal ? "internal" : "receive");
3608 if (!descriptor_vals.isArray()) throw std::runtime_error(std::string(__func__) + ": Unexpected result");
3609 for (const UniValue& desc_val : descriptor_vals.get_array().getValues()) {
3610 const std::string& desc_str = desc_val.getValStr();
3612 std::string desc_error;
3613 auto descs = Parse(desc_str, keys, desc_error, false);
3614 if (descs.empty()) {
3615 throw std::runtime_error(std::string(__func__) + ": Invalid descriptor \"" + desc_str + "\" (" + desc_error + ")");
3616 }
3617 auto& desc = descs.at(0);
3618 if (!desc->GetOutputType()) {
3619 continue;
3620 }
3621 OutputType t = *desc->GetOutputType();
3622 auto spk_manager = std::unique_ptr<ExternalSignerScriptPubKeyMan>(new ExternalSignerScriptPubKeyMan(*this, m_keypool_size));
3623 spk_manager->SetupDescriptor(batch, std::move(desc));
3624 uint256 id = spk_manager->GetID();
3625 AddScriptPubKeyMan(id, std::move(spk_manager));
3626 AddActiveScriptPubKeyManWithDb(batch, id, t, internal);
3627 }
3628 }
3629
3630 // Ensure imported descriptors are committed to disk
3631 if (!batch.TxnCommit()) throw std::runtime_error("Error: cannot commit db transaction for descriptors import");
3632 }
3633}
3634
3636{
3637 WalletBatch batch(GetDatabase());
3638 return AddActiveScriptPubKeyManWithDb(batch, id, type, internal);
3639}
3640
3642{
3643 if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id, internal)) {
3644 throw std::runtime_error(std::string(__func__) + ": writing active ScriptPubKeyMan id failed");
3645 }
3646 LoadActiveScriptPubKeyMan(id, type, internal);
3647}
3648
3650{
3651 // Activating ScriptPubKeyManager for a given output and change type is incompatible with legacy wallets.
3652 // Legacy wallets have only one ScriptPubKeyManager and it's active for all output and change types.
3654
3655 WalletLogPrintf("Setting spkMan to active: id = %s, type = %s, internal = %s\n", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
3656 auto& spk_mans = internal ? m_internal_spk_managers : m_external_spk_managers;
3657 auto& spk_mans_other = internal ? m_external_spk_managers : m_internal_spk_managers;
3658 auto spk_man = m_spk_managers.at(id).get();
3659 spk_mans[type] = spk_man;
3660
3661 const auto it = spk_mans_other.find(type);
3662 if (it != spk_mans_other.end() && it->second == spk_man) {
3663 spk_mans_other.erase(type);
3664 }
3665
3667}
3668
3670{
3671 auto spk_man = GetScriptPubKeyMan(type, internal);
3672 if (spk_man != nullptr && spk_man->GetID() == id) {
3673 WalletLogPrintf("Deactivate spkMan: id = %s, type = %s, internal = %s\n", id.ToString(), FormatOutputType(type), internal ? "true" : "false");
3674 WalletBatch batch(GetDatabase());
3675 if (!batch.EraseActiveScriptPubKeyMan(static_cast<uint8_t>(type), internal)) {
3676 throw std::runtime_error(std::string(__func__) + ": erasing active ScriptPubKeyMan id failed");
3677 }
3678
3679 auto& spk_mans = internal ? m_internal_spk_managers : m_external_spk_managers;
3680 spk_mans.erase(type);
3681 }
3682
3684}
3685
3687{
3688 auto spk_man_pair = m_spk_managers.find(desc.id);
3689
3690 if (spk_man_pair != m_spk_managers.end()) {
3691 // Try to downcast to DescriptorScriptPubKeyMan then check if the descriptors match
3692 DescriptorScriptPubKeyMan* spk_manager = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man_pair->second.get());
3693 if (spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc)) {
3694 return spk_manager;
3695 }
3696 }
3697
3698 return nullptr;
3699}
3700
3701std::optional<bool> CWallet::IsInternalScriptPubKeyMan(ScriptPubKeyMan* spk_man) const
3702{
3703 // only active ScriptPubKeyMan can be internal
3704 if (!GetActiveScriptPubKeyMans().count(spk_man)) {
3705 return std::nullopt;
3706 }
3707
3708 const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
3709 if (!desc_spk_man) {
3710 throw std::runtime_error(std::string(__func__) + ": unexpected ScriptPubKeyMan type.");
3711 }
3712
3713 LOCK(desc_spk_man->cs_desc_man);
3714 const auto& type = desc_spk_man->GetWalletDescriptor().descriptor->GetOutputType();
3715 assert(type.has_value());
3716
3717 return GetScriptPubKeyMan(*type, /* internal= */ true) == desc_spk_man;
3718}
3719
3720util::Result<ScriptPubKeyMan*> CWallet::AddWalletDescriptor(WalletDescriptor& desc, const FlatSigningProvider& signing_provider, const std::string& label, bool internal)
3721{
3723
3725 WalletLogPrintf("Cannot add WalletDescriptor to a non-descriptor wallet\n");
3726 return nullptr;
3727 }
3728
3729 auto spk_man = GetDescriptorScriptPubKeyMan(desc);
3730 if (spk_man) {
3731 WalletLogPrintf("Update existing descriptor: %s\n", desc.descriptor->ToString());
3732 if (auto spkm_res = spk_man->UpdateWalletDescriptor(desc); !spkm_res) {
3733 return util::Error{util::ErrorString(spkm_res)};
3734 }
3735 } else {
3736 auto new_spk_man = std::unique_ptr<DescriptorScriptPubKeyMan>(new DescriptorScriptPubKeyMan(*this, desc, m_keypool_size));
3737 spk_man = new_spk_man.get();
3738
3739 // Save the descriptor to memory
3740 uint256 id = new_spk_man->GetID();
3741 AddScriptPubKeyMan(id, std::move(new_spk_man));
3742 }
3743
3744 // Add the private keys to the descriptor
3745 for (const auto& entry : signing_provider.keys) {
3746 const CKey& key = entry.second;
3747 spk_man->AddDescriptorKey(key, key.GetPubKey());
3748 }
3749
3750 // Top up key pool, the manager will generate new scriptPubKeys internally
3751 if (!spk_man->TopUp()) {
3752 WalletLogPrintf("Could not top up scriptPubKeys\n");
3753 return nullptr;
3754 }
3755
3756 // Apply the label if necessary
3757 // Note: we disable labels for ranged descriptors
3758 if (!desc.descriptor->IsRange()) {
3759 auto script_pub_keys = spk_man->GetScriptPubKeys();
3760 if (script_pub_keys.empty()) {
3761 WalletLogPrintf("Could not generate scriptPubKeys (cache is empty)\n");
3762 return nullptr;
3763 }
3764
3765 if (!internal) {
3766 for (const auto& script : script_pub_keys) {
3767 CTxDestination dest;
3768 if (ExtractDestination(script, dest)) {
3770 }
3771 }
3772 }
3773 }
3774
3775 // Save the descriptor to DB
3776 spk_man->WriteDescriptor();
3777
3778 return spk_man;
3779}
3780
3782{
3784
3785 WalletLogPrintf("Migrating wallet storage database from BerkeleyDB to SQLite.\n");
3786
3787 if (m_database->Format() == "sqlite") {
3788 error = _("Error: This wallet already uses SQLite");
3789 return false;
3790 }
3791
3792 // Get all of the records for DB type migration
3793 std::unique_ptr<DatabaseBatch> batch = m_database->MakeBatch();
3794 std::unique_ptr<DatabaseCursor> cursor = batch->GetNewCursor();
3795 std::vector<std::pair<SerializeData, SerializeData>> records;
3796 if (!cursor) {
3797 error = _("Error: Unable to begin reading all records in the database");
3798 return false;
3799 }
3801 while (true) {
3802 DataStream ss_key{};
3803 DataStream ss_value{};
3804 status = cursor->Next(ss_key, ss_value);
3805 if (status != DatabaseCursor::Status::MORE) {
3806 break;
3807 }
3808 SerializeData key(ss_key.begin(), ss_key.end());
3809 SerializeData value(ss_value.begin(), ss_value.end());
3810 records.emplace_back(key, value);
3811 }
3812 cursor.reset();
3813 batch.reset();
3814 if (status != DatabaseCursor::Status::DONE) {
3815 error = _("Error: Unable to read all records in the database");
3816 return false;
3817 }
3818
3819 // Close this database and delete the file
3820 fs::path db_path = fs::PathFromString(m_database->Filename());
3821 m_database->Close();
3822 fs::remove(db_path);
3823
3824 // Generate the path for the location of the migrated wallet
3825 // Wallets that are plain files rather than wallet directories will be migrated to be wallet directories.
3826 const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(m_name));
3827
3828 // Make new DB
3829 DatabaseOptions opts;
3830 opts.require_create = true;
3832 DatabaseStatus db_status;
3833 std::unique_ptr<WalletDatabase> new_db = MakeDatabase(wallet_path, opts, db_status, error);
3834 assert(new_db); // This is to prevent doing anything further with this wallet. The original file was deleted, but a backup exists.
3835 m_database.reset();
3836 m_database = std::move(new_db);
3837
3838 // Write existing records into the new DB
3839 batch = m_database->MakeBatch();
3840 bool began = batch->TxnBegin();
3841 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.
3842 for (const auto& [key, value] : records) {
3843 if (!batch->Write(std::span{key}, std::span{value})) {
3844 batch->TxnAbort();
3845 m_database->Close();
3846 fs::remove(m_database->Filename());
3847 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.
3848 }
3849 }
3850 bool committed = batch->TxnCommit();
3851 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.
3852 return true;
3853}
3854
3855std::optional<MigrationData> CWallet::GetDescriptorsForLegacy(bilingual_str& error) const
3856{
3858
3859 LegacyDataSPKM* legacy_spkm = GetLegacyDataSPKM();
3860 if (!Assume(legacy_spkm)) {
3861 // This shouldn't happen
3862 error = Untranslated(STR_INTERNAL_BUG("Error: Legacy wallet data missing"));
3863 return std::nullopt;
3864 }
3865
3866 std::optional<MigrationData> res = legacy_spkm->MigrateToDescriptor();
3867 if (res == std::nullopt) {
3868 error = _("Error: Unable to produce descriptors for this legacy wallet. Make sure to provide the wallet's passphrase if it is encrypted.");
3869 return std::nullopt;
3870 }
3871 return res;
3872}
3873
3875{
3877
3878 LegacyDataSPKM* legacy_spkm = GetLegacyDataSPKM();
3879 if (!Assume(legacy_spkm)) {
3880 // This shouldn't happen
3881 return util::Error{Untranslated(STR_INTERNAL_BUG("Error: Legacy wallet data missing"))};
3882 }
3883
3884 // Get all invalid or non-watched scripts that will not be migrated
3885 std::set<CTxDestination> not_migrated_dests;
3886 for (const auto& script : legacy_spkm->GetNotMineScriptPubKeys()) {
3887 CTxDestination dest;
3888 if (ExtractDestination(script, dest)) not_migrated_dests.emplace(dest);
3889 }
3890
3891 // When the legacy wallet has no spendable scripts, the main wallet will be empty, leaving its script cache empty as well.
3892 // The watch-only and/or solvable wallet(s) will contain the scripts in their respective caches.
3893 if (!data.desc_spkms.empty()) Assume(!m_cached_spks.empty());
3894 if (!data.watch_descs.empty()) Assume(!data.watchonly_wallet->m_cached_spks.empty());
3895 if (!data.solvable_descs.empty()) Assume(!data.solvable_wallet->m_cached_spks.empty());
3896
3897 for (auto& desc_spkm : data.desc_spkms) {
3898 if (m_spk_managers.count(desc_spkm->GetID()) > 0) {
3899 return util::Error{_("Error: Duplicate descriptors created during migration. Your wallet may be corrupted.")};
3900 }
3901 uint256 id = desc_spkm->GetID();
3902 AddScriptPubKeyMan(id, std::move(desc_spkm));
3903 }
3904
3905 // Remove the LegacyScriptPubKeyMan from disk
3906 if (!legacy_spkm->DeleteRecordsWithDB(local_wallet_batch)) {
3907 return util::Error{_("Error: cannot remove legacy wallet records")};
3908 }
3909
3910 // Remove the LegacyScriptPubKeyMan from memory
3911 m_spk_managers.erase(legacy_spkm->GetID());
3914
3915 // Setup new descriptors
3916 SetWalletFlagWithDB(local_wallet_batch, WALLET_FLAG_DESCRIPTORS);
3918 // Use the existing master key if we have it
3919 if (data.master_key.key.IsValid()) {
3920 SetupDescriptorScriptPubKeyMans(local_wallet_batch, data.master_key);
3921 } else {
3922 // Setup with a new seed if we don't.
3923 SetupOwnDescriptorScriptPubKeyMans(local_wallet_batch);
3924 }
3925 }
3926
3927 // Get best block locator so that we can copy it to the watchonly and solvables
3928 CBlockLocator best_block_locator;
3929 if (!local_wallet_batch.ReadBestBlock(best_block_locator)) {
3930 return util::Error{_("Error: Unable to read wallet's best block locator record")};
3931 }
3932
3933 // Check if the transactions in the wallet are still ours. Either they belong here, or they belong in the watchonly wallet.
3934 // We need to go through these in the tx insertion order so that lookups to spends works.
3935 std::vector<uint256> txids_to_delete;
3936 std::unique_ptr<WalletBatch> watchonly_batch;
3937 if (data.watchonly_wallet) {
3938 watchonly_batch = std::make_unique<WalletBatch>(data.watchonly_wallet->GetDatabase());
3939 if (!watchonly_batch->TxnBegin()) return util::Error{strprintf(_("Error: database transaction cannot be executed for wallet %s"), data.watchonly_wallet->GetName())};
3940 // Copy the next tx order pos to the watchonly wallet
3941 LOCK(data.watchonly_wallet->cs_wallet);
3942 data.watchonly_wallet->nOrderPosNext = nOrderPosNext;
3943 watchonly_batch->WriteOrderPosNext(data.watchonly_wallet->nOrderPosNext);
3944 // Write the best block locator to avoid rescanning on reload
3945 if (!watchonly_batch->WriteBestBlock(best_block_locator)) {
3946 return util::Error{_("Error: Unable to write watchonly wallet best block locator record")};
3947 }
3948 }
3949 std::unique_ptr<WalletBatch> solvables_batch;
3950 if (data.solvable_wallet) {
3951 solvables_batch = std::make_unique<WalletBatch>(data.solvable_wallet->GetDatabase());
3952 if (!solvables_batch->TxnBegin()) return util::Error{strprintf(_("Error: database transaction cannot be executed for wallet %s"), data.solvable_wallet->GetName())};
3953 // Write the best block locator to avoid rescanning on reload
3954 if (!solvables_batch->WriteBestBlock(best_block_locator)) {
3955 return util::Error{_("Error: Unable to write solvable wallet best block locator record")};
3956 }
3957 }
3958 for (const auto& [_pos, wtx] : wtxOrdered) {
3959 // Check it is the watchonly wallet's
3960 // solvable_wallet doesn't need to be checked because transactions for those scripts weren't being watched for
3961 bool is_mine = IsMine(*wtx->tx) || IsFromMe(*wtx->tx);
3962 if (data.watchonly_wallet) {
3963 LOCK(data.watchonly_wallet->cs_wallet);
3964 if (data.watchonly_wallet->IsMine(*wtx->tx) || data.watchonly_wallet->IsFromMe(*wtx->tx)) {
3965 // Add to watchonly wallet
3966 const uint256& hash = wtx->GetHash();
3967 const CWalletTx& to_copy_wtx = *wtx;
3968 if (!data.watchonly_wallet->LoadToWallet(hash, [&](CWalletTx& ins_wtx, bool new_tx) EXCLUSIVE_LOCKS_REQUIRED(data.watchonly_wallet->cs_wallet) {
3969 if (!new_tx) return false;
3970 ins_wtx.SetTx(to_copy_wtx.tx);
3971 ins_wtx.CopyFrom(to_copy_wtx);
3972 return true;
3973 })) {
3974 return util::Error{strprintf(_("Error: Could not add watchonly tx %s to watchonly wallet"), wtx->GetHash().GetHex())};
3975 }
3976 watchonly_batch->WriteTx(data.watchonly_wallet->mapWallet.at(hash));
3977 // Mark as to remove from the migrated wallet only if it does not also belong to it
3978 if (!is_mine) {
3979 txids_to_delete.push_back(hash);
3980 }
3981 continue;
3982 }
3983 }
3984 if (!is_mine) {
3985 // Both not ours and not in the watchonly wallet
3986 return util::Error{strprintf(_("Error: Transaction %s in wallet cannot be identified to belong to migrated wallets"), wtx->GetHash().GetHex())};
3987 }
3988 }
3989
3990 // Do the removes
3991 if (txids_to_delete.size() > 0) {
3992 if (auto res = RemoveTxs(local_wallet_batch, txids_to_delete); !res) {
3993 return util::Error{_("Error: Could not delete watchonly transactions. ") + util::ErrorString(res)};
3994 }
3995 }
3996
3997 // Pair external wallets with their corresponding db handler
3998 std::vector<std::pair<std::shared_ptr<CWallet>, std::unique_ptr<WalletBatch>>> wallets_vec;
3999 if (data.watchonly_wallet) wallets_vec.emplace_back(data.watchonly_wallet, std::move(watchonly_batch));
4000 if (data.solvable_wallet) wallets_vec.emplace_back(data.solvable_wallet, std::move(solvables_batch));
4001
4002 // Write address book entry to disk
4003 auto func_store_addr = [](WalletBatch& batch, const CTxDestination& dest, const CAddressBookData& entry) {
4004 auto address{EncodeDestination(dest)};
4005 if (entry.purpose) batch.WritePurpose(address, PurposeToString(*entry.purpose));
4006 if (entry.label) batch.WriteName(address, *entry.label);
4007 for (const auto& [id, request] : entry.receive_requests) {
4008 batch.WriteAddressReceiveRequest(dest, id, request);
4009 }
4010 if (entry.previously_spent) batch.WriteAddressPreviouslySpent(dest, true);
4011 };
4012
4013 // Check the address book data in the same way we did for transactions
4014 std::vector<CTxDestination> dests_to_delete;
4015 for (const auto& [dest, record] : m_address_book) {
4016 // Ensure "receive" entries that are no longer part of the original wallet are transferred to another wallet
4017 // Entries for everything else ("send") will be cloned to all wallets.
4018 bool require_transfer = record.purpose == AddressPurpose::RECEIVE && !IsMine(dest);
4019 bool copied = false;
4020 for (auto& [wallet, batch] : wallets_vec) {
4021 LOCK(wallet->cs_wallet);
4022 if (require_transfer && !wallet->IsMine(dest)) continue;
4023
4024 // Copy the entire address book entry
4025 wallet->m_address_book[dest] = record;
4026 func_store_addr(*batch, dest, record);
4027
4028 copied = true;
4029 // Only delete 'receive' records that are no longer part of the original wallet
4030 if (require_transfer) {
4031 dests_to_delete.push_back(dest);
4032 break;
4033 }
4034 }
4035
4036 // Fail immediately if we ever found an entry that was ours and cannot be transferred
4037 // to any of the created wallets (watch-only, solvable).
4038 // Means that no inferred descriptor maps to the stored entry. Which mustn't happen.
4039 if (require_transfer && !copied) {
4040
4041 // Skip invalid/non-watched scripts that will not be migrated
4042 if (not_migrated_dests.count(dest) > 0) {
4043 dests_to_delete.push_back(dest);
4044 continue;
4045 }
4046
4047 return util::Error{_("Error: Address book data in wallet cannot be identified to belong to migrated wallets")};
4048 }
4049 }
4050
4051 // Persist external wallets address book entries
4052 for (auto& [wallet, batch] : wallets_vec) {
4053 if (!batch->TxnCommit()) {
4054 return util::Error{strprintf(_("Error: Unable to write data to disk for wallet %s"), wallet->GetName())};
4055 }
4056 }
4057
4058 // Remove the things to delete in this wallet
4059 if (dests_to_delete.size() > 0) {
4060 for (const auto& dest : dests_to_delete) {
4061 if (!DelAddressBookWithDB(local_wallet_batch, dest)) {
4062 return util::Error{_("Error: Unable to remove watchonly address book data")};
4063 }
4064 }
4065 }
4066
4067 return {}; // all good
4068}
4069
4071{
4073}
4074
4076{
4077 AssertLockHeld(wallet.cs_wallet);
4078
4079 // Get all of the descriptors from the legacy wallet
4080 std::optional<MigrationData> data = wallet.GetDescriptorsForLegacy(error);
4081 if (data == std::nullopt) return false;
4082
4083 // Create the watchonly and solvable wallets if necessary
4084 if (data->watch_descs.size() > 0 || data->solvable_descs.size() > 0) {
4085 DatabaseOptions options;
4086 options.require_existing = false;
4087 options.require_create = true;
4089
4090 WalletContext empty_context;
4091 empty_context.args = context.args;
4092
4093 // Make the wallets
4095 if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
4097 }
4098 if (wallet.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
4100 }
4101 if (data->watch_descs.size() > 0) {
4102 wallet.WalletLogPrintf("Making a new watchonly wallet containing the watched scripts\n");
4103
4104 DatabaseStatus status;
4105 std::vector<bilingual_str> warnings;
4106 std::string wallet_name = wallet.GetName() + "_watchonly";
4107 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4108 if (!database) {
4109 error = strprintf(_("Wallet file creation failed: %s"), error);
4110 return false;
4111 }
4112
4113 data->watchonly_wallet = CWallet::Create(empty_context, wallet_name, std::move(database), options.create_flags, error, warnings);
4114 if (!data->watchonly_wallet) {
4115 error = _("Error: Failed to create new watchonly wallet");
4116 return false;
4117 }
4118 res.watchonly_wallet = data->watchonly_wallet;
4119 LOCK(data->watchonly_wallet->cs_wallet);
4120
4121 // Parse the descriptors and add them to the new wallet
4122 for (const auto& [desc_str, creation_time] : data->watch_descs) {
4123 // Parse the descriptor
4125 std::string parse_err;
4126 std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, parse_err, /* require_checksum */ true);
4127 assert(descs.size() == 1); // It shouldn't be possible to have the LegacyScriptPubKeyMan make an invalid descriptor or a multipath descriptors
4128 assert(!descs.at(0)->IsRange()); // It shouldn't be possible to have LegacyScriptPubKeyMan make a ranged watchonly descriptor
4129
4130 // Add to the wallet
4131 WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
4132 if (auto spkm_res = data->watchonly_wallet->AddWalletDescriptor(w_desc, keys, "", false); !spkm_res) {
4133 throw std::runtime_error(util::ErrorString(spkm_res).original);
4134 }
4135 }
4136
4137 // Add the wallet to settings
4138 UpdateWalletSetting(*context.chain, wallet_name, /*load_on_startup=*/true, warnings);
4139 }
4140 if (data->solvable_descs.size() > 0) {
4141 wallet.WalletLogPrintf("Making a new watchonly wallet containing the unwatched solvable scripts\n");
4142
4143 DatabaseStatus status;
4144 std::vector<bilingual_str> warnings;
4145 std::string wallet_name = wallet.GetName() + "_solvables";
4146 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4147 if (!database) {
4148 error = strprintf(_("Wallet file creation failed: %s"), error);
4149 return false;
4150 }
4151
4152 data->solvable_wallet = CWallet::Create(empty_context, wallet_name, std::move(database), options.create_flags, error, warnings);
4153 if (!data->solvable_wallet) {
4154 error = _("Error: Failed to create new watchonly wallet");
4155 return false;
4156 }
4157 res.solvables_wallet = data->solvable_wallet;
4158 LOCK(data->solvable_wallet->cs_wallet);
4159
4160 // Parse the descriptors and add them to the new wallet
4161 for (const auto& [desc_str, creation_time] : data->solvable_descs) {
4162 // Parse the descriptor
4164 std::string parse_err;
4165 std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, parse_err, /* require_checksum */ true);
4166 assert(descs.size() == 1); // It shouldn't be possible to have the LegacyScriptPubKeyMan make an invalid descriptor or a multipath descriptors
4167 assert(!descs.at(0)->IsRange()); // It shouldn't be possible to have LegacyScriptPubKeyMan make a ranged watchonly descriptor
4168
4169 // Add to the wallet
4170 WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
4171 if (auto spkm_res = data->solvable_wallet->AddWalletDescriptor(w_desc, keys, "", false); !spkm_res) {
4172 throw std::runtime_error(util::ErrorString(spkm_res).original);
4173 }
4174 }
4175
4176 // Add the wallet to settings
4177 UpdateWalletSetting(*context.chain, wallet_name, /*load_on_startup=*/true, warnings);
4178 }
4179 }
4180
4181 // Add the descriptors to wallet, remove LegacyScriptPubKeyMan, and cleanup txs and address book data
4182 return RunWithinTxn(wallet.GetDatabase(), /*process_desc=*/"apply migration process", [&](WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet){
4183 if (auto res_migration = wallet.ApplyMigrationData(batch, *data); !res_migration) {
4184 error = util::ErrorString(res_migration);
4185 return false;
4186 }
4187 wallet.WalletLogPrintf("Wallet migration complete.\n");
4188 return true;
4189 });
4190}
4191
4192util::Result<MigrationResult> MigrateLegacyToDescriptor(const std::string& wallet_name, const SecureString& passphrase, WalletContext& context)
4193{
4194 std::vector<bilingual_str> warnings;
4195 bilingual_str error;
4196
4197 // If the wallet is still loaded, unload it so that nothing else tries to use it while we're changing it
4198 bool was_loaded = false;
4199 if (auto wallet = GetWallet(context, wallet_name)) {
4200 if (wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
4201 return util::Error{_("Error: This wallet is already a descriptor wallet")};
4202 }
4203
4204 // Flush chain state before unloading wallet
4205 CBlockLocator locator;
4206 WITH_LOCK(wallet->cs_wallet, context.chain->findBlock(wallet->GetLastBlockHash(), FoundBlock().locator(locator)));
4207 if (!locator.IsNull()) wallet->chainStateFlushed(ChainstateRole::NORMAL, locator);
4208
4209 if (!RemoveWallet(context, wallet, /*load_on_start=*/std::nullopt, warnings)) {
4210 return util::Error{_("Unable to unload the wallet before migrating")};
4211 }
4212 WaitForDeleteWallet(std::move(wallet));
4213 was_loaded = true;
4214 } else {
4215 // Check if the wallet is BDB
4216 const auto& wallet_path = GetWalletPath(wallet_name);
4217 if (!wallet_path) {
4218 return util::Error{util::ErrorString(wallet_path)};
4219 }
4220 if (!fs::exists(*wallet_path)) {
4221 return util::Error{_("Error: Wallet does not exist")};
4222 }
4223 if (!IsBDBFile(BDBDataFile(*wallet_path))) {
4224 return util::Error{_("Error: This wallet is already a descriptor wallet")};
4225 }
4226 }
4227
4228 // Load the wallet but only in the context of this function.
4229 // No signals should be connected nor should anything else be aware of this wallet
4230 WalletContext empty_context;
4231 empty_context.args = context.args;
4232 DatabaseOptions options;
4233 options.require_existing = true;
4234 options.require_format = DatabaseFormat::BERKELEY_RO;
4235 DatabaseStatus status;
4236 std::unique_ptr<WalletDatabase> database = MakeWalletDatabase(wallet_name, options, status, error);
4237 if (!database) {
4238 return util::Error{Untranslated("Wallet file verification failed.") + Untranslated(" ") + error};
4239 }
4240
4241 // Make the local wallet
4242 std::shared_ptr<CWallet> local_wallet = CWallet::Create(empty_context, wallet_name, std::move(database), options.create_flags, error, warnings);
4243 if (!local_wallet) {
4244 return util::Error{Untranslated("Wallet loading failed.") + Untranslated(" ") + error};
4245 }
4246
4247 return MigrateLegacyToDescriptor(std::move(local_wallet), passphrase, context, was_loaded);
4248}
4249
4250util::Result<MigrationResult> MigrateLegacyToDescriptor(std::shared_ptr<CWallet> local_wallet, const SecureString& passphrase, WalletContext& context, bool was_loaded)
4251{
4252 MigrationResult res;
4253 bilingual_str error;
4254 std::vector<bilingual_str> warnings;
4255
4256 DatabaseOptions options;
4257 options.require_existing = true;
4258 DatabaseStatus status;
4259
4260 const std::string wallet_name = local_wallet->GetName();
4261
4262 // Helper to reload as normal for some of our exit scenarios
4263 const auto& reload_wallet = [&](std::shared_ptr<CWallet>& to_reload) {
4264 assert(to_reload.use_count() == 1);
4265 std::string name = to_reload->GetName();
4266 to_reload.reset();
4267 to_reload = LoadWallet(context, name, /*load_on_start=*/std::nullopt, options, status, error, warnings);
4268 return to_reload != nullptr;
4269 };
4270
4271 // Before anything else, check if there is something to migrate.
4272 if (local_wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
4273 if (was_loaded) {
4274 reload_wallet(local_wallet);
4275 }
4276 return util::Error{_("Error: This wallet is already a descriptor wallet")};
4277 }
4278
4279 // Make a backup of the DB
4280 fs::path this_wallet_dir = fs::absolute(fs::PathFromString(local_wallet->GetDatabase().Filename())).parent_path();
4281 fs::path backup_filename = fs::PathFromString(strprintf("%s_%d.legacy.bak", (wallet_name.empty() ? "default_wallet" : wallet_name), GetTime()));
4282 fs::path backup_path = this_wallet_dir / backup_filename;
4283 if (!local_wallet->BackupWallet(fs::PathToString(backup_path))) {
4284 if (was_loaded) {
4285 reload_wallet(local_wallet);
4286 }
4287 return util::Error{_("Error: Unable to make a backup of your wallet")};
4288 }
4289 res.backup_path = backup_path;
4290
4291 bool success = false;
4292
4293 // Unlock the wallet if needed
4294 if (local_wallet->IsLocked() && !local_wallet->Unlock(passphrase)) {
4295 if (was_loaded) {
4296 reload_wallet(local_wallet);
4297 }
4298 if (passphrase.find('\0') == std::string::npos) {
4299 return util::Error{Untranslated("Error: Wallet decryption failed, the wallet passphrase was not provided or was incorrect.")};
4300 } else {
4301 return util::Error{Untranslated("Error: Wallet decryption failed, the wallet passphrase entered was incorrect. "
4302 "The passphrase contains a null character (ie - a zero byte). "
4303 "If this passphrase was set with a version of this software prior to 25.0, "
4304 "please try again with only the characters up to — but not including — "
4305 "the first null character.")};
4306 }
4307 }
4308
4309 {
4310 LOCK(local_wallet->cs_wallet);
4311 // First change to using SQLite
4312 if (!local_wallet->MigrateToSQLite(error)) return util::Error{error};
4313
4314 // Do the migration of keys and scripts for non-empty wallets, and cleanup if it fails
4315 if (HasLegacyRecords(*local_wallet)) {
4316 success = DoMigration(*local_wallet, context, error, res);
4317 } else {
4318 // Make sure that descriptors flag is actually set
4319 local_wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
4320 success = true;
4321 }
4322 }
4323
4324 // In case of reloading failure, we need to remember the wallet dirs to remove
4325 // Set is used as it may be populated with the same wallet directory paths multiple times,
4326 // both before and after reloading. This ensures the set is complete even if one of the wallets
4327 // fails to reload.
4328 std::set<fs::path> wallet_dirs;
4329 if (success) {
4330 // Migration successful, unload all wallets locally, then reload them.
4331 // Reload the main wallet
4332 wallet_dirs.insert(fs::PathFromString(local_wallet->GetDatabase().Filename()).parent_path());
4333 success = reload_wallet(local_wallet);
4334 res.wallet = local_wallet;
4335 res.wallet_name = wallet_name;
4336 if (success && res.watchonly_wallet) {
4337 // Reload watchonly
4338 wallet_dirs.insert(fs::PathFromString(res.watchonly_wallet->GetDatabase().Filename()).parent_path());
4339 success = reload_wallet(res.watchonly_wallet);
4340 }
4341 if (success && res.solvables_wallet) {
4342 // Reload solvables
4343 wallet_dirs.insert(fs::PathFromString(res.solvables_wallet->GetDatabase().Filename()).parent_path());
4344 success = reload_wallet(res.solvables_wallet);
4345 }
4346 }
4347 if (!success) {
4348 // Migration failed, cleanup
4349 // Before deleting the wallet's directory, copy the backup file to the top-level wallets dir
4350 fs::path temp_backup_location = fsbridge::AbsPathJoin(GetWalletDir(), backup_filename);
4351 fs::copy_file(backup_path, temp_backup_location, fs::copy_options::none);
4352
4353 // Make list of wallets to cleanup
4354 std::vector<std::shared_ptr<CWallet>> created_wallets;
4355 if (local_wallet) created_wallets.push_back(std::move(local_wallet));
4356 if (res.watchonly_wallet) created_wallets.push_back(std::move(res.watchonly_wallet));
4357 if (res.solvables_wallet) created_wallets.push_back(std::move(res.solvables_wallet));
4358
4359 // Get the directories to remove after unloading
4360 for (std::shared_ptr<CWallet>& w : created_wallets) {
4361 wallet_dirs.emplace(fs::PathFromString(w->GetDatabase().Filename()).parent_path());
4362 }
4363
4364 // Unload the wallets
4365 for (std::shared_ptr<CWallet>& w : created_wallets) {
4366 if (w->HaveChain()) {
4367 // Unloading for wallets that were loaded for normal use
4368 if (!RemoveWallet(context, w, /*load_on_start=*/false)) {
4369 error += _("\nUnable to cleanup failed migration");
4370 return util::Error{error};
4371 }
4372 WaitForDeleteWallet(std::move(w));
4373 } else {
4374 // Unloading for wallets in local context
4375 assert(w.use_count() == 1);
4376 w.reset();
4377 }
4378 }
4379
4380 // Delete the wallet directories
4381 for (const fs::path& dir : wallet_dirs) {
4382 fs::remove_all(dir);
4383 }
4384
4385 // Restore the backup
4386 // Convert the backup file to the wallet db file by renaming it and moving it into the wallet's directory.
4387 // Reload it into memory if the wallet was previously loaded.
4388 bilingual_str restore_error;
4389 const auto& ptr_wallet = RestoreWallet(context, temp_backup_location, wallet_name, /*load_on_start=*/std::nullopt, status, restore_error, warnings, /*load_after_restore=*/was_loaded);
4390 if (!restore_error.empty()) {
4391 error += restore_error + _("\nUnable to restore backup of wallet.");
4392 return util::Error{error};
4393 }
4394
4395 // The wallet directory has been restored, but just in case, copy the previously created backup to the wallet dir
4396 fs::copy_file(temp_backup_location, backup_path, fs::copy_options::none);
4397 fs::remove(temp_backup_location);
4398
4399 // Verify that there is no dangling wallet: when the wallet wasn't loaded before, expect null.
4400 // This check is performed after restoration to avoid an early error before saving the backup.
4401 bool wallet_reloaded = ptr_wallet != nullptr;
4402 assert(was_loaded == wallet_reloaded);
4403
4404 return util::Error{error};
4405 }
4406 return res;
4407}
4408
4409void CWallet::CacheNewScriptPubKeys(const std::set<CScript>& spks, ScriptPubKeyMan* spkm)
4410{
4411 for (const auto& script : spks) {
4412 m_cached_spks[script].push_back(spkm);
4413 }
4414}
4415
4416void CWallet::TopUpCallback(const std::set<CScript>& spks, ScriptPubKeyMan* spkm)
4417{
4418 // Update scriptPubKey cache
4419 CacheNewScriptPubKeys(spks, spkm);
4420}
4421
4422std::set<CExtPubKey> CWallet::GetActiveHDPubKeys() const
4423{
4424 AssertLockHeld(cs_wallet);
4425
4426 Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4427
4428 std::set<CExtPubKey> active_xpubs;
4429 for (const auto& spkm : GetActiveScriptPubKeyMans()) {
4430 const DescriptorScriptPubKeyMan* desc_spkm = dynamic_cast<DescriptorScriptPubKeyMan*>(spkm);
4431 assert(desc_spkm);
4432 LOCK(desc_spkm->cs_desc_man);
4433 WalletDescriptor w_desc = desc_spkm->GetWalletDescriptor();
4434
4435 std::set<CPubKey> desc_pubkeys;
4436 std::set<CExtPubKey> desc_xpubs;
4437 w_desc.descriptor->GetPubKeys(desc_pubkeys, desc_xpubs);
4438 active_xpubs.merge(std::move(desc_xpubs));
4439 }
4440 return active_xpubs;
4441}
4442
4443std::optional<CKey> CWallet::GetKey(const CKeyID& keyid) const
4444{
4445 Assert(IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
4446
4447 for (const auto& spkm : GetAllScriptPubKeyMans()) {
4448 const DescriptorScriptPubKeyMan* desc_spkm = dynamic_cast<DescriptorScriptPubKeyMan*>(spkm);
4449 assert(desc_spkm);
4450 LOCK(desc_spkm->cs_desc_man);
4451 if (std::optional<CKey> key = desc_spkm->GetKey(keyid)) {
4452 return key;
4453 }
4454 }
4455 return std::nullopt;
4456}
4457} // namespace wallet
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
Definition: addresstype.cpp:49
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.
Definition: addresstype.h:143
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:42
int ret
if(!SetupNetworking())
int flags
Definition: bitcoin-tx.cpp:536
ArgsManager & args
Definition: bitcoind.cpp:277
static 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 CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:102
#define Assert(val)
Identity function.
Definition: check.h:106
#define STR_INTERNAL_BUG(msg)
Definition: check.h:89
#define Assume(val)
Assume is the identity function.
Definition: check.h:118
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
Definition: args.cpp:482
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: args.cpp:457
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: args.cpp:507
bool IsNull() const
Definition: block.h:49
Definition: block.h:69
std::vector< CTransactionRef > vtx
Definition: block.h:72
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
std::string ToString(const FeeEstimateMode &fee_estimate_mode=FeeEstimateMode::BTC_KVB) const
Definition: feerate.cpp:39
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes.
Definition: feerate.h:63
An encapsulated private key.
Definition: key.h:35
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:182
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
Definition: key.cpp:236
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:24
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
uint32_t n
Definition: transaction.h:32
Txid hash
Definition: transaction.h:31
An encapsulated public key.
Definition: pubkey.h:34
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
const std::vector< CTxOut > vout
Definition: transaction.h:307
const Txid & GetHash() const LIFETIMEBOUND
Definition: transaction.h:343
const std::vector< CTxIn > vin
Definition: transaction.h:306
An input of a transaction.
Definition: transaction.h:67
COutPoint prevout
Definition: transaction.h:69
An output of a transaction.
Definition: transaction.h:150
CScript scriptPubKey
Definition: transaction.h:153
A UTXO entry.
Definition: coins.h:33
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:147
Enables interaction with an external signing device or service, such as a hardware wallet.
Fast randomness source.
Definition: random.h:377
std::unordered_set< Element, ByteVectorHash > ElementSet
Definition: blockfilter.h:32
Different type to mark Mutex at global scope.
Definition: sync.h:140
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:320
void push_back(UniValue val)
Definition: univalue.cpp:104
bool isArray() const
Definition: univalue.h:85
const UniValue & find_value(std::string_view key) const
Definition: univalue.cpp:233
@ VARR
Definition: univalue.h:24
size_t size() const
Definition: univalue.h:71
const std::vector< UniValue > & getValues() const
const UniValue & get_array() const
bool isObject() const
Definition: univalue.h:86
std::string ToString() const
Definition: uint256.cpp:21
constexpr unsigned char * begin()
Definition: uint256.h:101
constexpr void SetNull()
Definition: uint256.h:55
std::string GetHex() const
Definition: uint256.cpp:11
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
Definition: chain.h:129
virtual CBlockLocator getTipLocator()=0
Get locator for the current chain tip.
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
virtual CBlockLocator getActiveChainLocator(const uint256 &block_hash)=0
Return a locator that refers to a block in the active chain.
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 chain is in use.
virtual bool findAncestorByHeight(const uint256 &block_hash, int ancestor_height, const FoundBlock &ancestor_out={})=0
Find ancestor of block at specified height and optionally return ancestor information.
virtual bool findBlock(const uint256 &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
virtual double guessVerificationProgress(const uint256 &block_hash)=0
Estimate fraction of total transactions verified if blocks up to the specified block hash are verifie...
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 bool isInMempool(const uint256 &txid)=0
Check if transaction is in mempool.
virtual bool broadcastTransaction(const CTransactionRef &tx, const CAmount &max_tx_fee, bool relay, std::string &err_string)=0
Transaction is added to memory pool, if the transaction fee is below the amount specified by max_tx_f...
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:48
FoundBlock & height(int &height)
Definition: chain.h:51
std::string ToString() const
static transaction_identifier FromUint256(const uint256 &id)
256-bit opaque blob.
Definition: uint256.h:196
Encryption/decryption context with key information.
Definition: crypter.h:72
bool Decrypt(std::span< const unsigned char > ciphertext, CKeyingMaterial &plaintext) const
Definition: crypter.cpp:94
bool SetKeyFromPassphrase(const SecureString &key_data, std::span< const unsigned char > salt, const unsigned int rounds, const unsigned int derivation_method)
Definition: crypter.cpp:41
bool Encrypt(const CKeyingMaterial &vchPlaintext, std::vector< unsigned char > &vchCiphertext) const
Definition: crypter.cpp:76
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:300
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:2512
bool SetAddressBook(const CTxDestination &address, const std::string &strName, const std::optional< AddressPurpose > &purpose)
Definition: wallet.cpp:2386
std::atomic< bool > fAbortRescan
Definition: wallet.h:306
bool TopUpKeyPool(unsigned int kpSize=0)
Definition: wallet.cpp:2461
bool HaveChain() const
Interface to assert chain access.
Definition: wallet.h:480
std::optional< common::PSBTError > FillPSBT(PartiallySignedTransaction &psbtx, bool &complete, int sighash_type=SIGHASH_DEFAULT, bool sign=true, bool bip32derivs=true, size_t *n_signed=nullptr, bool finalize=true) const
Fills out a PSBT with information from the wallet.
Definition: wallet.cpp:2104
bool GetBroadcastTransactions() const
Inquire whether this wallet broadcasts transactions.
Definition: wallet.h:858
bool IsCrypted() const
Definition: wallet.cpp:3312
bool UnlockCoin(const COutPoint &output, WalletBatch *batch=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2624
unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2450
std::function< bool(CWalletTx &wtx, bool new_tx)> UpdateWalletTxFn
Callback for updating transaction metadata in mapWallet.
Definition: wallet.h:600
CAmount m_default_max_tx_fee
Absolute maximum transaction fee (in satoshis) used by default for the wallet.
Definition: wallet.h:727
bool IsActiveScriptPubKeyMan(const ScriptPubKeyMan &spkm) const
Definition: wallet.cpp:3372
OutputType m_default_address_type
Definition: wallet.h:718
void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Adds the active ScriptPubKeyMan for the specified type and internal.
Definition: wallet.cpp:3635
void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Loads an active ScriptPubKeyMan for the specified type and internal.
Definition: wallet.cpp:3649
std::unique_ptr< WalletDatabase > m_database
Internal database handle.
Definition: wallet.h:393
bool IsLockedCoin(const COutPoint &output) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2646
bool SignTransaction(CMutableTransaction &tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Fetch the inputs and sign with SIGHASH_ALL.
Definition: wallet.cpp:2070
CWallet(interfaces::Chain *chain, const std::string &name, std::unique_ptr< WalletDatabase > database)
Construct wallet with specified name and database implementation.
Definition: wallet.h:462
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:3425
bool IsTxImmatureCoinBase(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:3304
void AddActiveScriptPubKeyManWithDb(WalletBatch &batch, uint256 id, OutputType type, bool internal)
Definition: wallet.cpp:3641
DBErrors LoadWallet()
Definition: wallet.cpp:2273
util::Result< ScriptPubKeyMan * > 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:3720
std::set< ScriptPubKeyMan * > GetActiveScriptPubKeyMans() const
Returns all unique ScriptPubKeyMans in m_internal_spk_managers and m_external_spk_managers.
Definition: wallet.cpp:3358
const CAddressBookData * FindAddressBookEntry(const CTxDestination &, bool allow_change=false) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:3212
void postInitProcess()
Wallet post-init setup Gives the wallet a chance to register repetitive tasks and complete post-init ...
Definition: wallet.cpp:3255
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:3278
unsigned int nMasterKeyMaxID
Definition: wallet.h:459
bool SetAddressReceiveRequest(WalletBatch &batch, const CTxDestination &dest, const std::string &id, const std::string &value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2777
int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get last block processed height.
Definition: wallet.h:968
std::atomic< double > m_scanning_progress
Definition: wallet.h:311
LegacyDataSPKM * GetLegacyDataSPKM() const
Get the LegacyScriptPubKeyMan which is used for all types, internal, and external.
Definition: wallet.cpp:3456
boost::signals2::signal< void(bool fHaveWatchOnly)> NotifyWatchonlyChanged
Watch-only address added.
Definition: wallet.h:846
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:2535
DescriptorScriptPubKeyMan * GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const
Return the DescriptorScriptPubKeyMan for a WalletDescriptor if it is already in the wallet.
Definition: wallet.cpp:3686
std::map< OutputType, ScriptPubKeyMan * > m_external_spk_managers
Definition: wallet.h:411
DescriptorScriptPubKeyMan & LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor &desc)
Instantiate a descriptor ScriptPubKeyMan from the WalletDescriptor and load it.
Definition: wallet.cpp:3527
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:3855
bool HaveCryptedKeys() const
Definition: wallet.cpp:3510
LegacyDataSPKM * GetOrCreateLegacyDataSPKM()
Definition: wallet.cpp:3476
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:455
bool Unlock(const CKeyingMaterial &vMasterKeyIn)
Definition: wallet.cpp:3343
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:3781
bool BackupWallet(const std::string &strDest) const
Definition: wallet.cpp:3265
std::map< OutputType, ScriptPubKeyMan * > m_internal_spk_managers
Definition: wallet.h:412
std::string m_name
Wallet name: relative directory name or "" for default wallet.
Definition: wallet.h:390
bool SetAddressPreviouslySpent(WalletBatch &batch, const CTxDestination &dest, bool used) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2736
util::Result< CTxDestination > GetNewDestination(const OutputType type, const std::string label)
Definition: wallet.cpp:2471
RecursiveMutex m_relock_mutex
Definition: wallet.h:577
util::Result< void > RemoveTxs(std::vector< uint256 > &txs_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Erases the provided transactions from the wallet.
Definition: wallet.cpp:2298
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:733
std::string GetDisplayName() const override
Returns a bracketed wallet name for displaying in logs, will return [default wallet] if the wallet ha...
Definition: wallet.h:917
std::vector< std::string > GetAddressReceiveRequests() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2766
std::vector< WalletDescriptor > GetWalletDescriptors(const CScript &script) const
Get the wallet descriptors for a script.
Definition: wallet.cpp:3444
std::atomic< bool > m_attaching_chain
Definition: wallet.h:308
bool fBroadcastTransactions
Whether this wallet will submit newly created transactions to the node's mempool and prompt rebroadca...
Definition: wallet.h:321
size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2438
int GetTxBlocksToMaturity(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:3292
void WalletLogPrintf(util::ConstevalFormatString< 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:925
bool HasEncryptionKeys() const override
Definition: wallet.cpp:3505
static std::shared_ptr< CWallet > Create(WalletContext &context, const std::string &name, std::unique_ptr< WalletDatabase > database, uint64_t wallet_creation_flags, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition: wallet.cpp:2824
int GetVersion() const
get the current wallet format (the oldest client version guaranteed to understand this wallet)
Definition: wallet.h:813
bool CanGrindR() const
Whether the (external) signer performs R-value signature grinding.
Definition: wallet.cpp:4070
bool LockCoin(const COutPoint &output, WalletBatch *batch=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2614
std::optional< bool > IsInternalScriptPubKeyMan(ScriptPubKeyMan *spk_man) const
Returns whether the provided ScriptPubKeyMan is internal.
Definition: wallet.cpp:3701
TxItems wtxOrdered
Definition: wallet.h:487
bool CanSupportFeature(enum WalletFeature wf) const override EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
check whether we support the named feature
Definition: wallet.h:534
std::optional< int64_t > GetOldestKeyPoolTime() const
Definition: wallet.cpp:2498
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const
Definition: wallet.cpp:2158
MasterKeyMap mapMasterKeys
Definition: wallet.h:458
util::Result< void > ApplyMigrationData(WalletBatch &local_wallet_batch, MigrationData &data) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Adds the ScriptPubKeyMans given in MigrationData to this wallet, removes LegacyScriptPubKeyMan,...
Definition: wallet.cpp:3874
NodeClock::time_point m_next_resend
The next scheduled rebroadcast of wallet transactions.
Definition: wallet.h:318
WalletDatabase & GetDatabase() const override
Definition: wallet.h:447
bool EraseAddressReceiveRequest(WalletBatch &batch, const CTxDestination &dest, const std::string &id) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2784
bool SetAddressBookWithDB(WalletBatch &batch, const CTxDestination &address, const std::string &strName, const std::optional< AddressPurpose > &strPurpose)
Definition: wallet.cpp:2350
boost::signals2::signal< void(const std::string &title, int nProgress)> ShowProgress
Show progress e.g.
Definition: wallet.h:843
bool DelAddressBookWithDB(WalletBatch &batch, const CTxDestination &address)
Definition: wallet.cpp:2399
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:2755
void AddScriptPubKeyMan(const uint256 &id, std::unique_ptr< ScriptPubKeyMan > spkm_man)
Definition: wallet.cpp:3466
void DeactivateScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Remove specified ScriptPubKeyMan from set of active SPK managers.
Definition: wallet.cpp:3669
bool UpgradeWallet(int version, bilingual_str &error)
Upgrade the wallet.
Definition: wallet.cpp:3222
std::atomic< uint64_t > m_wallet_flags
WalletFlags set on this wallet.
Definition: wallet.h:376
interfaces::Chain * m_chain
Interface for accessing chain state.
Definition: wallet.h:387
std::set< std::string > ListAddrBookLabels(const std::optional< AddressPurpose > purpose) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Retrieve all the known labels in the address book.
Definition: wallet.cpp:2551
bool IsLocked() const override
Definition: wallet.cpp:3317
boost::signals2::signal< void(const uint256 &hashTx, ChangeType status)> NotifyTransactionChanged
Wallet transaction added, removed or updated.
Definition: wallet.h:840
OutputType TransactionChangeType(const std::optional< OutputType > &change_type, const std::vector< CRecipient > &vecSend) const
Definition: wallet.cpp:2171
boost::signals2::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
Definition: wallet.h:849
std::set< ScriptPubKeyMan * > GetAllScriptPubKeyMans() const
Returns all unique ScriptPubKeyMans.
Definition: wallet.cpp:3383
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:2685
void ListLockedCoins(std::vector< COutPoint > &vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2652
void CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector< std::pair< std::string, std::string > > orderForm)
Submit the transaction to the node's mempool and then relay to peers.
Definition: wallet.cpp:2232
bool UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2634
util::Result< CTxDestination > GetNewChangeDestination(const OutputType type)
Definition: wallet.cpp:2487
ScriptPubKeyMan * GetScriptPubKeyMan(const OutputType &type, bool internal) const
Get the ScriptPubKeyMan for the given OutputType and internal/external chain.
Definition: wallet.cpp:3392
bool IsAddressPreviouslySpent(const CTxDestination &dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2760
bool WithEncryptionKey(std::function< bool(const CKeyingMaterial &)> cb) const override
Pass the encryption key to cb().
Definition: wallet.cpp:3499
uint256 GetLastBlockHash() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.h:974
int64_t m_keypool_size
Number of pre-generated keys/scripts by each spkm (part of the look-ahead process,...
Definition: wallet.h:730
RecursiveMutex cs_wallet
Main wallet lock.
Definition: wallet.h:445
void ForEachAddrBookEntry(const ListAddrBookFunc &func) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:2526
void ConnectScriptPubKeyManNotifiers()
Connect the signals from ScriptPubKeyMans to the signals in CWallet.
Definition: wallet.cpp:3518
bool DelAddressBook(const CTxDestination &address)
Definition: wallet.cpp:2392
std::atomic< int64_t > m_best_block_time
Definition: wallet.h:323
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:429
void SetupLegacyScriptPubKeyMan()
Make a Legacy(Data)SPKM and set it for all types, internal, and external.
Definition: wallet.cpp:3482
static bool AttachChain(const std::shared_ptr< CWallet > &wallet, interfaces::Chain &chain, const 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:3091
boost::signals2::signal< void(const CTxDestination &address, const std::string &label, bool isMine, AddressPurpose purpose, ChangeType status)> NotifyAddressBookChanged
Address book entry changed.
Definition: wallet.h:834
std::multimap< int64_t, CWalletTx * > TxItems
Definition: wallet.h:486
void SetupOwnDescriptorScriptPubKeyMans(WalletBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Create new seed and default DescriptorScriptPubKeyMans for this wallet.
Definition: wallet.cpp:3569
boost::signals2::signal< void(CWallet *wallet)> NotifyStatusChanged
Wallet status (encrypted, locked) changed.
Definition: wallet.h:855
void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:3585
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:3539
std::map< uint256, std::unique_ptr< ScriptPubKeyMan > > m_spk_managers
Definition: wallet.h:416
std::function< TxUpdate(CWalletTx &wtx)> TryUpdatingStateFn
Definition: wallet.h:362
std::atomic< int64_t > m_birth_time
Definition: wallet.h:327
void LoadAddressPreviouslySpent(const CTxDestination &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Marks destination as previously spent.
Definition: wallet.cpp:2750
std::set< ScriptPubKeyMan * > GetScriptPubKeyMans(const CScript &script) const
Get all the ScriptPubKeyMans for a script.
Definition: wallet.cpp:3402
util::Result< void > DisplayAddress(const CTxDestination &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Display address on an external signer.
Definition: wallet.cpp:2600
A transaction with a bunch of additional info that only the owner cares about.
Definition: transaction.h:177
bool isBlockConflicted() const
Definition: transaction.h:347
const Txid & GetHash() const LIFETIMEBOUND
Definition: transaction.h:351
const T * state() const
Definition: transaction.h:338
bool IsEquivalentTo(const CWalletTx &tx) const
True if only scriptSigs are different.
Definition: transaction.cpp:12
std::vector< std::pair< std::string, std::string > > vOrderForm
Definition: transaction.h:205
std::set< Txid > mempool_conflicts
Definition: transaction.h:267
mapValue_t mapValue
Key/value map with information about the transaction.
Definition: transaction.h:204
void updateState(interfaces::Chain &chain)
Update transaction state when attaching to a chain, filling in heights of conflicted and confirmed bl...
Definition: transaction.cpp:32
int64_t nOrderPos
position in ordered transaction list
Definition: transaction.h:224
bool fFromMe
From me flag is set to 1 for transactions that were created by the wallet on this bitcoin node,...
Definition: transaction.h:223
unsigned int nTimeReceived
time received by this node
Definition: transaction.h:207
CTransactionRef tx
Definition: transaction.h:258
void SetTx(CTransactionRef arg)
Definition: transaction.h:315
bool IsCoinBase() const
Definition: transaction.h:353
unsigned int fTimeReceivedIsTxTime
Definition: transaction.h:206
bool InMempool() const
Definition: transaction.cpp:21
bool isAbandoned() const
Definition: transaction.h:345
bool isInactive() const
Definition: transaction.h:348
int64_t GetTxTime() const
Definition: transaction.cpp:26
bool m_is_cache_empty
This flag is true if all m_amounts caches are empty.
Definition: transaction.h:236
std::multimap< int64_t, CWalletTx * >::const_iterator m_it_wtxOrdered
Definition: transaction.h:225
unsigned int nTimeSmart
Stable timestamp that never changes, and reflects the order a transaction was added to the wallet.
Definition: transaction.h:217
void MarkDirty()
make sure balances are recalculated
Definition: transaction.h:321
WalletDescriptor GetWalletDescriptor() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
std::optional< CKey > GetKey(const CKeyID &keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
Retrieve the particular key if it is available. Returns nullopt if the key is not in the wallet,...
bool HasWalletDescriptor(const WalletDescriptor &desc) const
bool DeleteRecordsWithDB(WalletBatch &batch)
std::optional< MigrationData > MigrateToDescriptor()
Get the DescriptorScriptPubKeyMans (with private keys) that have the same scriptPubKeys as this Legac...
uint256 GetID() const override
std::unordered_set< CScript, SaltedSipHasher > GetNotMineScriptPubKeys() const
Retrieves scripts that were imported by bugs into the legacy spkm and are simply invalid,...
A wrapper to reserve an address from a wallet.
Definition: wallet.h:188
const CWallet *const pwallet
The wallet to reserve from.
Definition: wallet.h:191
void KeepDestination()
Keep the address. Do not return its key to the keypool when this object goes out of scope.
Definition: wallet.cpp:2582
CTxDestination address
The destination.
Definition: wallet.h:198
bool fInternal
Whether this is from the internal (change output) keypool.
Definition: wallet.h:200
void ReturnDestination()
Return reserved address.
Definition: wallet.cpp:2591
ScriptPubKeyMan * m_spk_man
The ScriptPubKeyMan to reserve from. Based on type when GetReservedDestination is called.
Definition: wallet.h:193
int64_t nIndex
The index of the address's key in the keypool.
Definition: wallet.h:196
OutputType const type
Definition: wallet.h:194
util::Result< CTxDestination > GetReservedDestination(bool internal)
Reserve an address.
Definition: wallet.cpp:2565
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:189
bool TxnAbort()
Abort current transaction.
Definition: walletdb.cpp:1323
bool EraseName(const std::string &strAddress)
Definition: walletdb.cpp:74
DBErrors LoadWallet(CWallet *pwallet)
Definition: walletdb.cpp:1147
bool WriteBestBlock(const CBlockLocator &locator)
Definition: walletdb.cpp:173
void RegisterTxnListener(const DbTxnListener &l)
Registers db txn callback functions.
Definition: walletdb.cpp:1336
bool ReadBestBlock(CBlockLocator &locator)
Definition: walletdb.cpp:179
bool EraseTx(uint256 hash)
Definition: walletdb.cpp:96
bool WriteMasterKey(unsigned int nID, const CMasterKey &kMasterKey)
Definition: walletdb.cpp:147
bool WriteMinVersion(int nVersion)
Definition: walletdb.cpp:201
bool TxnBegin()
Begin a new transaction.
Definition: walletdb.cpp:1305
bool WriteAddressPreviouslySpent(const CTxDestination &dest, bool previously_spent)
Definition: walletdb.cpp:1270
bool EraseAddressReceiveRequest(const CTxDestination &dest, const std::string &id)
Definition: walletdb.cpp:1281
bool TxnCommit()
Commit current transaction.
Definition: walletdb.cpp:1310
bool WriteName(const std::string &strAddress, const std::string &strName)
Definition: walletdb.cpp:69
bool WritePurpose(const std::string &strAddress, const std::string &purpose)
Definition: walletdb.cpp:81
bool WriteWalletFlags(const uint64_t flags)
Definition: walletdb.cpp:1293
bool EraseAddressData(const CTxDestination &dest)
Definition: walletdb.cpp:1286
bool WriteOrderPosNext(int64_t nOrderPosNext)
Definition: walletdb.cpp:196
bool WriteTx(const CWalletTx &wtx)
Definition: walletdb.cpp:91
bool ErasePurpose(const std::string &strAddress)
Definition: walletdb.cpp:86
bool EraseLockedUTXO(const COutPoint &output)
Definition: walletdb.cpp:291
bool WriteLockedUTXO(const COutPoint &output)
Definition: walletdb.cpp:286
bool WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id, bool internal)
Definition: walletdb.cpp:206
bool EraseActiveScriptPubKeyMan(uint8_t type, bool internal)
Definition: walletdb.cpp:212
bool WriteAddressReceiveRequest(const CTxDestination &dest, const std::string &id, const std::string &receive_request)
Definition: walletdb.cpp:1276
virtual bool Rewrite(const char *pszSkip=nullptr)=0
Rewrite the entire database on disk, with the exception of key pszSkip if non-zero.
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.
Descriptor with some wallet metadata.
Definition: walletutil.h:85
std::shared_ptr< Descriptor > descriptor
Definition: walletutil.h:87
RAII object to check and reserve a wallet rescan.
Definition: wallet.h:1070
Clock::time_point now() const
Definition: wallet.h:1098
bool reserve(bool with_passphrase=false)
Definition: wallet.h:1080
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)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:317
std::string ShellEscape(const std::string &arg)
Definition: system.cpp:37
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
Definition: consensus.h:19
static path absolute(const path &p)
Definition: fs.h:82
static path u8path(const std::string &utf8_str)
Definition: fs.h:75
static auto quoted(const std::string &s)
Definition: fs.h:95
static bool exists(const path &p)
Definition: fs.h:89
static bool copy_file(const path &from, const path &to, copy_options options)
Definition: fs.h:128
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition: fs.h:151
static path PathFromString(const std::string &string)
Convert byte string to path object.
Definition: fs.h:174
bool TryCreateDirectories(const fs::path &p)
Ignores exceptions thrown by create_directories if the requested directory exists.
Definition: fs_helpers.cpp:261
bool IsSpentKey(const CScript &scriptPubKey) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:1013
void SyncTransaction(const CTransactionRef &tx, const SyncTxState &state, bool update_tx=true, bool rescanning_old_block=false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:1381
bool LoadToWallet(const uint256 &hash, const UpdateWalletTxFn &fill_wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:1154
int64_t IncOrderPosNext(WalletBatch *batch=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Increment the next transaction order id.
Definition: wallet.cpp:941
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:1259
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:706
void SetMinVersion(enum WalletFeature, WalletBatch *batch_in=nullptr) override
signify that a particular wallet feature is now used.
Definition: wallet.cpp:666
bool ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase, const SecureString &strNewWalletPassphrase)
Definition: wallet.cpp:623
void SyncMetaData(std::pair< TxSpends::iterator, TxSpends::iterator >) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:723
void SetWalletFlagWithDB(WalletBatch &batch, uint64_t flags)
Store wallet flags.
Definition: wallet.cpp:1669
static bool EncryptMasterKey(const SecureString &wallet_passphrase, const CKeyingMaterial &plain_master_key, CMasterKey &master_key)
Definition: wallet.cpp:562
void MarkConflicted(const uint256 &hashBlock, int conflicting_height, const uint256 &hashTx)
Mark a transaction (and its in-wallet descendants) as conflicting with a particular block.
Definition: wallet.cpp:1307
void updatedBlockTip() override
Definition: wallet.cpp:1537
bool TransactionCanBeAbandoned(const uint256 &hashTx) const
Return whether transaction can be abandoned.
Definition: wallet.cpp:1252
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:1663
void blockConnected(ChainstateRole role, const interfaces::BlockInfo &block) override
Definition: wallet.cpp:1468
void MaybeUpdateBirthTime(int64_t time)
Updates wallet birth time if 'time' is below it.
Definition: wallet.cpp:1729
void blockDisconnected(const interfaces::BlockInfo &block) override
Definition: wallet.cpp:1490
bool IsWalletFlagSet(uint64_t flag) const override
check if a certain wallet flag is set
Definition: wallet.cpp:1696
static bool DecryptMasterKey(const SecureString &wallet_passphrase, const CMasterKey &master_key, CKeyingMaterial &plain_master_key)
Definition: wallet.cpp:589
std::set< uint256 > GetConflicts(const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get wallet transactions that conflict with given transaction (spend same outputs)
Definition: wallet.cpp:683
void UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag)
Unsets a wallet flag and saves it to disk.
Definition: wallet.cpp:1683
bool IsSpent(const COutPoint &outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Outpoint is spent if any non-conflicted transaction spends it:
Definition: wallet.cpp:766
void UnsetBlankWalletFlag(WalletBatch &batch) override
Unset the blank wallet flag and saves it to disk.
Definition: wallet.cpp:1691
void ResubmitWalletTransactions(bool relay, bool force)
Definition: wallet.cpp:2023
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:1026
void SetSpentKeyState(WalletBatch &batch, const uint256 &hash, unsigned int n, bool used, std::set< CTxDestination > &tx_destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:994
void RecursiveUpdateTxState(const uint256 &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:1337
bool CanGetAddresses(bool internal=false) const
Definition: wallet.cpp:1650
void MarkDirty()
Definition: wallet.cpp:953
ScanResult ScanForWalletTransactions(const uint256 &start_block, int start_height, std::optional< int > max_height, const WalletRescanReserver &reserver, bool fUpdate, const bool save_progress)
Scan the block chain (starting in start_block) for transactions from or to us.
Definition: wallet.cpp:1789
bool LoadWalletFlags(uint64_t flags)
Loads the flags into the wallet.
Definition: wallet.cpp:1701
std::set< uint256 > GetTxConflicts(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:1970
bool IsHDEnabled() const
Definition: wallet.cpp:1639
void transactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason) override
Definition: wallet.cpp:1416
static NodeClock::time_point GetDefaultNextResend()
Definition: wallet.cpp:1997
bool ShouldResend() const
Return true if all conditions for periodically resending transactions are met.
Definition: wallet.cpp:1980
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:1713
void UnsetWalletFlag(uint64_t flag)
Unsets a single wallet flag.
Definition: wallet.cpp:1677
bool AbandonTransaction(const uint256 &hashTx)
Definition: wallet.cpp:1269
CAmount GetDebit(const CTxIn &txin, const isminefilter &filter) const
Returns amount of debit if the input matches the filter, otherwise returns 0.
Definition: wallet.cpp:1554
bool EncryptWallet(const SecureString &strWalletPassphrase)
Definition: wallet.cpp:809
void AddToSpends(const COutPoint &outpoint, const uint256 &wtxid, WalletBatch *batch=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:783
bool MarkReplaced(const uint256 &originalHash, const uint256 &newHash)
Mark a transaction as replaced by another transaction.
Definition: wallet.cpp:962
int64_t RescanFromTime(int64_t startTime, const WalletRescanReserver &reserver, bool update)
Scan active chain for relevant transactions after importing keys.
Definition: wallet.cpp:1745
isminetype IsMine(const CTxDestination &dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:1576
bool IsFromMe(const CTransaction &tx) const
should probably be renamed to IsRelevantToMe
Definition: wallet.cpp:1622
DBErrors ReorderTransactions()
Definition: wallet.cpp:884
bool AddToWalletIfInvolvingMe(const CTransactionRef &tx, const SyncTxState &state, bool fUpdate, bool rescanning_old_block) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Add a transaction to the wallet, or update it.
Definition: wallet.cpp:1186
void chainStateFlushed(ChainstateRole role, const CBlockLocator &loc) override
Definition: wallet.cpp:655
void UpgradeDescriptorCache() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Upgrade DescriptorCaches.
Definition: wallet.cpp:547
const CWalletTx * GetWalletTx(const uint256 &hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.cpp:538
void transactionAddedToMempool(const CTransactionRef &tx) override
Definition: wallet.cpp:1392
void Close()
Close wallet database.
Definition: wallet.cpp:718
bool SubmitTxMemoryPoolAndRelay(CWalletTx &wtx, std::string &err_string, bool relay) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Pass this transaction to node for mempool insertion and relay to peers if flag set to true.
Definition: wallet.cpp:1940
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
Definition: interpreter.h:35
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
Definition: chain.h:25
CKey GenerateRandomKey(bool compressed) noexcept
Definition: key.cpp:352
std::string EncodeDestination(const CTxDestination &dest)
Definition: key_io.cpp:294
#define LogDebug(category,...)
Definition: logging.h:280
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.
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
Definition: moneystr.cpp:45
static int sign(const secp256k1_context *ctx, struct signer_secrets *signer_secrets, struct signer *signer, const secp256k1_musig_keyagg_cache *cache, const unsigned char *msg32, unsigned char *sig64)
Definition: musig.c:105
@ SCAN
Definition: logging.h:72
PSBTError
Definition: types.h:17
auto FindKey(Map &&map, Key &&key) -> decltype(&map.at(key))
Map lookup helper.
Definition: settings.h:107
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
Definition: messages.cpp:163
bilingual_str AmountHighWarn(const std::string &optname)
Definition: messages.cpp:158
fs::path AbsPathJoin(const fs::path &base, const fs::path &path)
Helper function for joining two paths.
Definition: fs.cpp:36
std::unique_ptr< Handler > MakeCleanupHandler(std::function< void()> cleanup)
Return handler wrapping a cleanup function.
Definition: interfaces.cpp:42
std::unique_ptr< Wallet > MakeWallet(wallet::WalletContext &context, const std::shared_ptr< wallet::CWallet > &wallet)
Return implementation of Wallet interface.
Definition: interfaces.cpp:690
bilingual_str ErrorString(const Result< T > &result)
Definition: result.h:93
std::string_view RemoveSuffixView(std::string_view str, std::string_view suffix)
Definition: string.h:161
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:233
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
Definition: string.cpp:11
constexpr CAmount HIGH_APS_FEE
discourage APS fee higher than this amount
Definition: wallet.h:122
void ReadDatabaseArgs(const ArgsManager &args, DatabaseOptions &options)
Definition: db.cpp:154
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:366
static std::set< std::string > g_loading_wallet_set GUARDED_BY(g_loading_wallet_mutex)
std::unique_ptr< WalletDatabase > MakeDatabase(const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error)
Definition: walletdb.cpp:1342
void MaybeResendWalletTxs(WalletContext &context)
Called periodically by the schedule thread.
Definition: wallet.cpp:2060
std::variant< TxStateConfirmed, TxStateInMempool, TxStateInactive > SyncTxState
Subset of states transaction sync logic is implemented to handle.
Definition: transaction.h:81
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:191
static bool RunWithinTxn(WalletBatch &batch, std::string_view process_desc, const std::function< bool(WalletBatch &)> &func)
Definition: walletdb.cpp:1241
std::variant< TxStateConfirmed, TxStateInMempool, TxStateBlockConflicted, TxStateInactive, TxStateUnrecognized > TxState
All possible CWalletTx states.
Definition: transaction.h:78
std::map< std::string, std::string > mapValue_t
Definition: transaction.h:149
std::vector< unsigned char, secure_allocator< unsigned char > > CKeyingMaterial
Definition: crypter.h:63
DBErrors
Overview of wallet database classes:
Definition: walletdb.h:40
@ EXTERNAL_SIGNER_SUPPORT_REQUIRED
static int TxStateSerializedIndex(const TxState &state)
Get TxState serialized block index. Inverse of TxStateInterpretSerialized.
Definition: transaction.h:111
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:94
static GlobalMutex g_wallet_release_mutex
Definition: wallet.cpp:229
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:107
const unsigned int WALLET_CRYPTO_KEY_SIZE
Definition: crypter.h:14
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)
Definition: wallet.cpp:491
util::Result< MigrationResult > MigrateLegacyToDescriptor(std::shared_ptr< CWallet > local_wallet, const SecureString &passphrase, WalletContext &context, bool was_loaded)
Requirement: The wallet provided to this function must be isolated, with no attachment to the node's ...
Definition: wallet.cpp:4250
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:140
std::underlying_type_t< isminetype > isminefilter
used for bitflags of isminetype
Definition: wallet.h:48
static const bool DEFAULT_WALLETCROSSCHAIN
Definition: wallet.h:135
std::unique_ptr< interfaces::Handler > HandleLoadWallet(WalletContext &context, LoadWalletFn load_wallet)
Definition: wallet.cpp:213
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start)
Definition: wallet.cpp:185
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.
Definition: walletutil.cpp:13
static const unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
static const std::unordered_set< OutputType > LEGACY_OUTPUT_TYPES
OutputTypes supported by the LegacyScriptPubKeyMan.
static const bool DEFAULT_WALLET_RBF
-walletrbf default
Definition: wallet.h:132
constexpr CAmount HIGH_TX_FEE_PER_KB
Discourage users to set fees higher than this amount (in satoshis) per kB.
Definition: wallet.h:139
static std::condition_variable g_wallet_release_cv
Definition: wallet.cpp:230
std::unique_ptr< WalletDatabase > MakeWalletDatabase(const std::string &name, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error_string)
Definition: wallet.cpp:2813
bool IsBDBFile(const fs::path &path)
Definition: db.cpp:95
void NotifyWalletLoaded(WalletContext &context, const std::shared_ptr< CWallet > &wallet)
Definition: wallet.cpp:220
fs::path BDBDataFile(const fs::path &wallet_path)
Definition: db.cpp:76
constexpr CAmount HIGH_MAX_TX_FEE
-maxtxfee will warn if called with a higher fee than this amount (in satoshis)
Definition: wallet.h:141
static const unsigned int DEFAULT_TX_CONFIRM_TARGET
-txconfirmtarget default
Definition: wallet.h:130
isminetype
IsMine() return codes, which depend on ScriptPubKeyMan implementation.
Definition: types.h:41
@ ISMINE_NO
Definition: types.h:42
@ ISMINE_SPENDABLE
Definition: types.h:44
@ ISMINE_ALL
Definition: types.h:46
std::string PurposeToString(AddressPurpose p)
Definition: wallet.h:270
static const bool DEFAULT_WALLETBROADCAST
Definition: wallet.h:133
bool AddWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet)
Definition: wallet.cpp:149
bool DoMigration(CWallet &wallet, WalletContext &context, bilingual_str &error, MigrationResult &res) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
Definition: wallet.cpp:4075
WalletFeature
(client) version numbers for particular wallet features
Definition: walletutil.h:16
@ FEATURE_HD_SPLIT
Definition: walletutil.h:24
@ FEATURE_WALLETCRYPT
Definition: walletutil.h:19
@ FEATURE_LATEST
Definition: walletutil.h:30
@ FEATURE_PRE_SPLIT_KEYPOOL
Definition: walletutil.h:28
static uint256 TxStateSerializedBlockHash(const TxState &state)
Get TxState serialized block hash. Inverse of TxStateInterpretSerialized.
Definition: transaction.h:99
static constexpr uint64_t KNOWN_WALLET_FLAGS
Definition: wallet.h:150
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:122
static GlobalMutex g_loading_wallet_mutex
Definition: wallet.cpp:228
const unsigned int WALLET_CRYPTO_SALT_SIZE
Definition: crypter.h:15
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:379
static void FlushAndDeleteWallet(CWallet *wallet)
Definition: wallet.cpp:235
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
Definition: walletutil.h:77
@ WALLET_FLAG_LAST_HARDENED_XPUB_CACHED
Definition: walletutil.h:48
@ WALLET_FLAG_KEY_ORIGIN_METADATA
Definition: walletutil.h:45
@ WALLET_FLAG_AVOID_REUSE
Definition: walletutil.h:42
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition: walletutil.h:74
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition: walletutil.h:51
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
Definition: walletutil.h:71
void WaitForDeleteWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly delete the wallet.
Definition: wallet.cpp:251
std::string TxStateString(const T &state)
Return TxState or SyncTxState as a string for logging or debugging.
Definition: transaction.h:124
std::shared_ptr< CWallet > GetWallet(WalletContext &context, const std::string &name)
Definition: wallet.cpp:204
static const bool DEFAULT_SPEND_ZEROCONF_CHANGE
Default for -spendzeroconfchange.
Definition: wallet.h:126
WalletFeature GetClosestWalletFeature(int version)
Definition: walletutil.cpp:40
static util::Result< fs::path > GetWalletPath(const std::string &name)
Definition: wallet.cpp:2791
DatabaseStatus
Definition: db.h:183
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start, std::vector< bilingual_str > &warnings)
Definition: wallet.cpp:161
std::shared_ptr< CWallet > GetDefaultWallet(WalletContext &context, size_t &count)
Definition: wallet.cpp:197
is a home for public enum and struct type definitions that are used internally by node code,...
std::optional< OutputType > ParseOutputType(const std::string &type)
Definition: outputtype.cpp:24
const std::string & FormatOutputType(OutputType type)
Definition: outputtype.cpp:38
OutputType
Definition: outputtype.h:17
static constexpr auto OUTPUT_TYPES
Definition: outputtype.h:25
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
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:298
void RemoveUnnecessaryTransactions(PartiallySignedTransaction &psbtx, const int &sighash_type)
Reduces the size of the PSBT by dropping unnecessary non_witness_utxos (i.e.
Definition: psbt.cpp:448
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed by checking for non-null finalized fields.
Definition: psbt.cpp:293
PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction &psbt)
Compute a PrecomputedTransactionData object from a psbt.
Definition: psbt.cpp:358
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:609
const char * name
Definition: rest.cpp:49
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:58
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:124
std::vector< uint256 > vHave
Definition: block.h:134
bool IsNull() const
Definition: block.h:152
Definition: key.h:227
void SetSeed(std::span< const std::byte > seed)
Definition: key.cpp:368
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxIn > vin
Definition: transaction.h:379
std::map< CKeyID, CKey > keys
static time_point now() noexcept
Return current system time or mocked time, if set.
Definition: time.cpp:26
std::chrono::time_point< NodeClock > time_point
Definition: time.h:19
A structure for PSBTs which contain per-input information.
Definition: psbt.h:245
CTransactionRef non_witness_utxo
Definition: psbt.h:246
A version of CTransaction with the PSBT format.
Definition: psbt.h:1111
std::vector< PSBTInput > inputs
Definition: psbt.h:1116
std::optional< CMutableTransaction > tx
Definition: psbt.h:1112
Bilingual messages:
Definition: translation.h:24
bool empty() const
Definition: translation.h:35
Block data sent with blockConnected, blockDisconnected notifications.
Definition: chain.h:78
const uint256 * prev_hash
Definition: chain.h:80
const CBlock * data
Definition: chain.h:84
const uint256 & hash
Definition: chain.h:79
unsigned int chain_time_max
Definition: chain.h:88
Definition: musig.c:30
Address book data.
Definition: wallet.h:229
std::optional< AddressPurpose > purpose
Address purpose which was originally recorded for payment protocol support but now serves as a cached...
Definition: wallet.h:244
void SetLabel(std::string name)
Definition: wallet.h:267
std::optional< std::string > m_op_label
Definition: wallet.h:743
std::optional< int > last_scanned_height
Definition: wallet.h:621
enum wallet::CWallet::ScanResult::@19 status
uint256 last_scanned_block
Hash and height of most recent block that was successfully scanned.
Definition: wallet.h:620
uint256 last_failed_block
Height of the most recent block that could not be scanned due to read errors or pruning.
Definition: wallet.h:627
bool require_existing
Definition: db.h:170
SecureString create_passphrase
Definition: db.h:174
std::optional< DatabaseFormat > require_format
Definition: db.h:172
uint64_t create_flags
Definition: db.h:173
struct containing information needed for migrating legacy wallets to descriptor wallets
std::shared_ptr< CWallet > watchonly_wallet
Definition: wallet.h:1120
std::string wallet_name
Definition: wallet.h:1118
std::shared_ptr< CWallet > solvables_wallet
Definition: wallet.h:1121
std::shared_ptr< CWallet > wallet
Definition: wallet.h:1119
State of rejected transaction that conflicts with a confirmed block.
Definition: transaction.h:46
State of transaction confirmed in a block.
Definition: transaction.h:31
State of transaction added to mempool.
Definition: transaction.h:41
State of transaction not confirmed or conflicting with a known block and not in the mempool.
Definition: transaction.h:58
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
#define WAIT_LOCK(cs, name)
Definition: sync.h:262
#define AssertLockNotHeld(cs)
Definition: sync.h:147
#define LOCK2(cs1, cs2)
Definition: sync.h:258
#define LOCK(cs)
Definition: sync.h:257
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:301
static int count
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
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
@ 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:76
std::chrono::duration< double, std::chrono::milliseconds::period > MillisecondsDouble
Definition: time.h:88
AssertLockHeld(pool.cs)
assert(!tx.IsCoinBase())
is a home for public enum and struct type definitions that are used by internally by wallet code,...
GCSFilter::ElementSet m_filter_set
Definition: wallet.cpp:355
std::map< uint256, int32_t > m_last_range_ends
Map for keeping track of each range descriptor's last seen end range.
Definition: wallet.cpp:354
const CWallet & m_wallet
Definition: wallet.cpp:347
std::vector< std::byte, zero_after_free_allocator< std::byte > > SerializeData
Byte-vector that clears its contents before deletion.
Definition: zeroafterfree.h:49