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