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