Bitcoin Core  27.99.0
P2P Digital Currency
wallet.h
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2022 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 #ifndef BITCOIN_WALLET_WALLET_H
7 #define BITCOIN_WALLET_WALLET_H
8 
9 #include <addresstype.h>
10 #include <consensus/amount.h>
11 #include <interfaces/chain.h>
12 #include <interfaces/handler.h>
13 #include <kernel/cs_main.h>
14 #include <logging.h>
15 #include <outputtype.h>
16 #include <policy/feerate.h>
17 #include <primitives/transaction.h>
18 #include <script/interpreter.h>
19 #include <script/script.h>
21 #include <sync.h>
22 #include <tinyformat.h>
23 #include <uint256.h>
24 #include <util/fs.h>
25 #include <util/hasher.h>
26 #include <util/result.h>
27 #include <util/string.h>
28 #include <util/time.h>
29 #include <util/ui_change_type.h>
30 #include <wallet/crypter.h>
31 #include <wallet/db.h>
32 #include <wallet/scriptpubkeyman.h>
33 #include <wallet/transaction.h>
34 #include <wallet/types.h>
35 #include <wallet/walletutil.h>
36 
37 #include <atomic>
38 #include <cassert>
39 #include <cstddef>
40 #include <cstdint>
41 #include <functional>
42 #include <limits>
43 #include <map>
44 #include <memory>
45 #include <optional>
46 #include <set>
47 #include <string>
48 #include <unordered_map>
49 #include <utility>
50 #include <vector>
51 
52 #include <boost/signals2/signal.hpp>
53 
54 class CKey;
55 class CKeyID;
56 class CPubKey;
57 class Coin;
58 class SigningProvider;
59 enum class MemPoolRemovalReason;
60 enum class SigningResult;
61 namespace common {
62 enum class PSBTError;
63 } // namespace common
64 namespace interfaces {
65 class Wallet;
66 }
67 namespace wallet {
68 class CWallet;
69 class WalletBatch;
70 enum class DBErrors : int;
71 } // namespace wallet
72 struct CBlockLocator;
73 struct CExtKey;
74 struct FlatSigningProvider;
75 struct KeyOriginInfo;
77 struct SignatureData;
78 
79 using LoadWalletFn = std::function<void(std::unique_ptr<interfaces::Wallet> wallet)>;
80 
81 struct bilingual_str;
82 
83 namespace wallet {
84 struct WalletContext;
85 
91 void UnloadWallet(std::shared_ptr<CWallet>&& wallet);
92 
93 bool AddWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet);
94 bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start, std::vector<bilingual_str>& warnings);
95 bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start);
96 std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext& context);
97 std::shared_ptr<CWallet> GetDefaultWallet(WalletContext& context, size_t& count);
98 std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& name);
99 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);
100 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);
101 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);
102 std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet);
103 void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet);
104 std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error);
105 
109 static const CAmount DEFAULT_FALLBACK_FEE = 0;
111 static const CAmount DEFAULT_DISCARD_FEE = 10000;
115 static const CAmount DEFAULT_CONSOLIDATE_FEERATE{10000}; // 10 sat/vbyte
125 constexpr CAmount HIGH_APS_FEE{COIN / 10000};
129 static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true;
131 static const bool DEFAULT_WALLET_REJECT_LONG_CHAINS{true};
133 static const unsigned int DEFAULT_TX_CONFIRM_TARGET = 6;
135 static const bool DEFAULT_WALLET_RBF = true;
136 static const bool DEFAULT_WALLETBROADCAST = true;
137 static const bool DEFAULT_DISABLE_WALLET = false;
138 static const bool DEFAULT_WALLETCROSSCHAIN = false;
142 constexpr CAmount HIGH_TX_FEE_PER_KB{COIN / 100};
146 static constexpr size_t DUMMY_NESTED_P2WPKH_INPUT_SIZE = 91;
147 
148 class CCoinControl;
149 
152 
153 static constexpr uint64_t KNOWN_WALLET_FLAGS =
161 
162 static constexpr uint64_t MUTABLE_WALLET_FLAGS =
164 
165 static const std::map<std::string,WalletFlags> WALLET_FLAG_MAP{
166  {"avoid_reuse", WALLET_FLAG_AVOID_REUSE},
167  {"blank", WALLET_FLAG_BLANK_WALLET},
168  {"key_origin_metadata", WALLET_FLAG_KEY_ORIGIN_METADATA},
169  {"last_hardened_xpub_cached", WALLET_FLAG_LAST_HARDENED_XPUB_CACHED},
170  {"disable_private_keys", WALLET_FLAG_DISABLE_PRIVATE_KEYS},
171  {"descriptor_wallet", WALLET_FLAG_DESCRIPTORS},
172  {"external_signer", WALLET_FLAG_EXTERNAL_SIGNER}
173 };
174 
191 {
192 protected:
194  const CWallet* const pwallet;
196  ScriptPubKeyMan* m_spk_man{nullptr};
199  int64_t nIndex{-1};
203  bool fInternal{false};
204 
205 public:
207  explicit ReserveDestination(CWallet* pwallet, OutputType type)
208  : pwallet(pwallet)
209  , type(type) { }
210 
213 
216  {
217  ReturnDestination();
218  }
219 
221  util::Result<CTxDestination> GetReservedDestination(bool internal);
223  void ReturnDestination();
225  void KeepDestination();
226 };
227 
232 {
240  std::optional<std::string> label;
241 
247  std::optional<AddressPurpose> purpose;
248 
256  bool previously_spent{false};
257 
265  std::map<std::string, std::string> receive_requests{};
266 
268  bool IsChange() const { return !label.has_value(); }
269  std::string GetLabel() const { return label ? *label : std::string{}; }
270  void SetLabel(std::string name) { label = std::move(name); }
271 };
272 
273 inline std::string PurposeToString(AddressPurpose p)
274 {
275  switch(p) {
276  case AddressPurpose::RECEIVE: return "receive";
277  case AddressPurpose::SEND: return "send";
278  case AddressPurpose::REFUND: return "refund";
279  } // no default case so the compiler will warn when a new enum as added
280  assert(false);
281 }
282 
283 inline std::optional<AddressPurpose> PurposeFromString(std::string_view s)
284 {
285  if (s == "receive") return AddressPurpose::RECEIVE;
286  else if (s == "send") return AddressPurpose::SEND;
287  else if (s == "refund") return AddressPurpose::REFUND;
288  return {};
289 }
290 
292 {
296 };
297 
298 class WalletRescanReserver; //forward declarations for ScanForWalletTransactions/RescanFromTime
303 {
304 private:
305  CKeyingMaterial vMasterKey GUARDED_BY(cs_wallet);
306 
307  bool Unlock(const CKeyingMaterial& vMasterKeyIn);
308 
309  std::atomic<bool> fAbortRescan{false};
310  std::atomic<bool> fScanningWallet{false}; // controlled by WalletRescanReserver
311  std::atomic<bool> m_attaching_chain{false};
312  std::atomic<bool> m_scanning_with_passphrase{false};
313  std::atomic<SteadyClock::time_point> m_scanning_start{SteadyClock::time_point{}};
314  std::atomic<double> m_scanning_progress{0};
315  friend class WalletRescanReserver;
316 
318  int nWalletVersion GUARDED_BY(cs_wallet){FEATURE_BASE};
319 
321  NodeClock::time_point m_next_resend{GetDefaultNextResend()};
324  bool fBroadcastTransactions = false;
325  // Local time that the tip block was received. Used to schedule wallet rebroadcasts.
326  std::atomic<int64_t> m_best_block_time {0};
327 
328  // First created key time. Used to skip blocks prior to this time.
329  // 'std::numeric_limits<int64_t>::max()' if wallet is blank.
330  std::atomic<int64_t> m_birth_time{std::numeric_limits<int64_t>::max()};
331 
337  typedef std::unordered_multimap<COutPoint, uint256, SaltedOutpointHasher> TxSpends;
338  TxSpends mapTxSpends GUARDED_BY(cs_wallet);
339  void AddToSpends(const COutPoint& outpoint, const uint256& wtxid, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
340  void AddToSpends(const CWalletTx& wtx, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
341 
358  bool AddToWalletIfInvolvingMe(const CTransactionRef& tx, const SyncTxState& state, bool fUpdate, bool rescanning_old_block) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
359 
361  void MarkConflicted(const uint256& hashBlock, int conflicting_height, const uint256& hashTx);
362 
363  enum class TxUpdate { UNCHANGED, CHANGED, NOTIFY_CHANGED };
364 
365  using TryUpdatingStateFn = std::function<TxUpdate(CWalletTx& wtx)>;
366 
368  void RecursiveUpdateTxState(const uint256& tx_hash, const TryUpdatingStateFn& try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
369  void RecursiveUpdateTxState(WalletBatch* batch, const uint256& tx_hash, const TryUpdatingStateFn& try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
370 
372  void MarkInputsDirty(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
373 
374  void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
375 
376  void SyncTransaction(const CTransactionRef& tx, const SyncTxState& state, bool update_tx = true, bool rescanning_old_block = false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
377 
379  std::atomic<uint64_t> m_wallet_flags{0};
380 
381  bool SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& strPurpose);
382 
384  void UnsetWalletFlagWithDB(WalletBatch& batch, uint64_t flag);
385 
387  void UnsetBlankWalletFlag(WalletBatch& batch) override;
388 
391 
393  std::string m_name;
394 
396  std::unique_ptr<WalletDatabase> m_database;
397 
405  uint256 m_last_block_processed GUARDED_BY(cs_wallet);
406 
412  int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1;
413 
414  std::map<OutputType, ScriptPubKeyMan*> m_external_spk_managers;
415  std::map<OutputType, ScriptPubKeyMan*> m_internal_spk_managers;
416 
417  // Indexed by a unique identifier produced by each ScriptPubKeyMan using
418  // ScriptPubKeyMan::GetID. In many cases it will be the hash of an internal structure
419  std::map<uint256, std::unique_ptr<ScriptPubKeyMan>> m_spk_managers;
420 
421  // Appends spk managers into the main 'm_spk_managers'.
422  // Must be the only method adding data to it.
423  void AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man);
424 
425  // Same as 'AddActiveScriptPubKeyMan' but designed for use within a batch transaction context
426  void AddActiveScriptPubKeyManWithDb(WalletBatch& batch, uint256 id, OutputType type, bool internal);
427 
429  std::unordered_map<CScript, std::vector<ScriptPubKeyMan*>, SaltedSipHasher> m_cached_spks;
430 
436  static bool AttachChain(const std::shared_ptr<CWallet>& wallet, interfaces::Chain& chain, const bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings);
437 
438  static NodeClock::time_point GetDefaultNextResend();
439 
440 public:
446 
447  WalletDatabase& GetDatabase() const override
448  {
449  assert(static_cast<bool>(m_database));
450  return *m_database;
451  }
452 
455  const std::string& GetName() const { return m_name; }
456 
457  typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
459  unsigned int nMasterKeyMaxID = 0;
460 
462  CWallet(interfaces::Chain* chain, const std::string& name, std::unique_ptr<WalletDatabase> database)
463  : m_chain(chain),
464  m_name(name),
465  m_database(std::move(database))
466  {
467  }
468 
470  {
471  // Should not have slots connected at this point.
472  assert(NotifyUnload.empty());
473  }
474 
475  bool IsCrypted() const;
476  bool IsLocked() const override;
477  bool Lock();
478 
480  bool HaveChain() const { return m_chain ? true : false; }
481 
484  std::unordered_map<uint256, CWalletTx, SaltedTxidHasher> mapWallet GUARDED_BY(cs_wallet);
485 
486  typedef std::multimap<int64_t, CWalletTx*> TxItems;
488 
489  int64_t nOrderPosNext GUARDED_BY(cs_wallet) = 0;
490 
491  std::map<CTxDestination, CAddressBookData> m_address_book GUARDED_BY(cs_wallet);
492  const CAddressBookData* FindAddressBookEntry(const CTxDestination&, bool allow_change = false) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
493 
498  std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet);
499 
501  std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
502 
504  interfaces::Chain& chain() const { assert(m_chain); return *m_chain; }
505 
506  const CWalletTx* GetWalletTx(const uint256& hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
507 
508  std::set<uint256> GetTxConflicts(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
509 
523  int GetTxDepthInMainChain(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
524 
530  int GetTxBlocksToMaturity(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
531  bool IsTxImmatureCoinBase(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
532 
534  bool CanSupportFeature(enum WalletFeature wf) const override EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) { AssertLockHeld(cs_wallet); return IsFeatureSupported(nWalletVersion, wf); }
535 
536  bool IsSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
537 
538  // Whether this or any known scriptPubKey with the same single key has been spent.
539  bool IsSpentKey(const CScript& scriptPubKey) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
540  void SetSpentKeyState(WalletBatch& batch, const uint256& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
541 
543  util::Result<void> DisplayAddress(const CTxDestination& dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
544 
545  bool IsLockedCoin(const COutPoint& output) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
546  bool LockCoin(const COutPoint& output, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
547  bool UnlockCoin(const COutPoint& output, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
548  bool UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
549  void ListLockedCoins(std::vector<COutPoint>& vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
550 
551  /*
552  * Rescan abort properties
553  */
554  void AbortRescan() { fAbortRescan = true; }
555  bool IsAbortingRescan() const { return fAbortRescan; }
556  bool IsScanning() const { return fScanningWallet; }
557  bool IsScanningWithPassphrase() const { return m_scanning_with_passphrase; }
558  SteadyClock::duration ScanningDuration() const { return fScanningWallet ? SteadyClock::now() - m_scanning_start.load() : SteadyClock::duration{}; }
559  double ScanningProgress() const { return fScanningWallet ? (double) m_scanning_progress : 0; }
560 
562  void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
563 
565  void UpgradeDescriptorCache() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
566 
567  bool LoadMinVersion(int nVersion) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) { AssertLockHeld(cs_wallet); nWalletVersion = nVersion; return true; }
568 
570  void LoadAddressPreviouslySpent(const CTxDestination& dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
572  void LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
573 
575  int64_t nRelockTime GUARDED_BY(cs_wallet){0};
576 
577  // Used to prevent concurrent calls to walletpassphrase RPC.
579  // Used to prevent deleting the passphrase from memory when it is still in use.
581 
582  bool Unlock(const SecureString& strWalletPassphrase);
583  bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase);
584  bool EncryptWallet(const SecureString& strWalletPassphrase);
585 
586  void GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
587  unsigned int ComputeTimeSmart(const CWalletTx& wtx, bool rescanning_old_block) const;
588 
593  int64_t IncOrderPosNext(WalletBatch *batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
594  DBErrors ReorderTransactions();
595 
596  void MarkDirty();
597 
604  using UpdateWalletTxFn = std::function<bool(CWalletTx& wtx, bool new_tx)>;
605 
610  CWalletTx* AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx=nullptr, bool fFlushOnClose=true, bool rescanning_old_block = false);
611  bool LoadToWallet(const uint256& hash, const UpdateWalletTxFn& fill_wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
612  void transactionAddedToMempool(const CTransactionRef& tx) override;
613  void blockConnected(ChainstateRole role, const interfaces::BlockInfo& block) override;
614  void blockDisconnected(const interfaces::BlockInfo& block) override;
615  void updatedBlockTip() override;
616  int64_t RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver, bool update);
617 
618  struct ScanResult {
619  enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS;
620 
625  std::optional<int> last_scanned_height;
626 
632  };
633  ScanResult ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, bool fUpdate, const bool save_progress);
634  void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) override;
636  void SetNextResend() { m_next_resend = GetDefaultNextResend(); }
638  bool ShouldResend() const;
639  void ResubmitWalletTransactions(bool relay, bool force);
640 
641  OutputType TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const;
642 
646  bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const;
647  SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const;
648 
664  std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbtx,
665  bool& complete,
666  int sighash_type = SIGHASH_DEFAULT,
667  bool sign = true,
668  bool bip32derivs = true,
669  size_t* n_signed = nullptr,
670  bool finalize = true) const;
671 
681  void CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm);
682 
684  bool SubmitTxMemoryPoolAndRelay(CWalletTx& wtx, std::string& err_string, bool relay) const
685  EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
686 
687  bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
688  bool ImportPrivKeys(const std::map<CKeyID, CKey>& privkey_map, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
689  bool ImportPubKeys(const std::vector<CKeyID>& ordered_pubkeys, const std::map<CKeyID, CPubKey>& pubkey_map, const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& key_origins, const bool add_keypool, const bool internal, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
690  bool ImportScriptPubKeys(const std::string& label, const std::set<CScript>& script_pub_keys, const bool have_solving_data, const bool apply_label, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
691 
693  void MaybeUpdateBirthTime(int64_t time);
694 
696  unsigned int m_confirm_target{DEFAULT_TX_CONFIRM_TARGET};
699  bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE};
700  bool m_signal_rbf{DEFAULT_WALLET_RBF};
701  bool m_allow_fallback_fee{true};
709 
712  CFeeRate m_discard_rate{DEFAULT_DISCARD_FEE};
713 
718  CFeeRate m_consolidate_feerate{DEFAULT_CONSOLIDATE_FEERATE};
719 
722  OutputType m_default_address_type{DEFAULT_ADDRESS_TYPE};
729  std::optional<OutputType> m_default_change_type{};
731  CAmount m_default_max_tx_fee{DEFAULT_TRANSACTION_MAXFEE};
732 
734  int64_t m_keypool_size{DEFAULT_KEYPOOL_SIZE};
735 
738 
739  size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
740  bool TopUpKeyPool(unsigned int kpSize = 0);
741 
742  std::optional<int64_t> GetOldestKeyPoolTime() const;
743 
744  // Filter struct for 'ListAddrBookAddresses'
745  struct AddrBookFilter {
746  // Fetch addresses with the provided label
747  std::optional<std::string> m_op_label{std::nullopt};
748  // Don't include change addresses by default
749  bool ignore_change{true};
750  };
751 
755  std::vector<CTxDestination> ListAddrBookAddresses(const std::optional<AddrBookFilter>& filter) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
756 
760  std::set<std::string> ListAddrBookLabels(const std::optional<AddressPurpose> purpose) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
761 
766  using ListAddrBookFunc = std::function<void(const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose> purpose)>;
767  void ForEachAddrBookEntry(const ListAddrBookFunc& func) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
768 
773  void MarkDestinationsDirty(const std::set<CTxDestination>& destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
774 
775  util::Result<CTxDestination> GetNewDestination(const OutputType type, const std::string label);
776  util::Result<CTxDestination> GetNewChangeDestination(const OutputType type);
777 
778  isminetype IsMine(const CTxDestination& dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
779  isminetype IsMine(const CScript& script) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
784  CAmount GetDebit(const CTxIn& txin, const isminefilter& filter) const;
785  isminetype IsMine(const CTxOut& txout) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
786  bool IsMine(const CTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
787  isminetype IsMine(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
789  bool IsFromMe(const CTransaction& tx) const;
790  CAmount GetDebit(const CTransaction& tx, const isminefilter& filter) const;
791  void chainStateFlushed(ChainstateRole role, const CBlockLocator& loc) override;
792 
794 
796  util::Result<void> RemoveTxs(std::vector<uint256>& txs_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
797 
798  bool SetAddressBook(const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& purpose);
799 
800  bool DelAddressBook(const CTxDestination& address);
801  bool DelAddressBookWithDB(WalletBatch& batch, const CTxDestination& address);
802 
803  bool IsAddressPreviouslySpent(const CTxDestination& dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
804  bool SetAddressPreviouslySpent(WalletBatch& batch, const CTxDestination& dest, bool used) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
805 
806  std::vector<std::string> GetAddressReceiveRequests() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
807  bool SetAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id, const std::string& value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
808  bool EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
809 
810  unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
811 
813  void SetMinVersion(enum WalletFeature, WalletBatch* batch_in = nullptr) override;
814 
816  int GetVersion() const { LOCK(cs_wallet); return nWalletVersion; }
817 
819  std::set<uint256> GetConflicts(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
820 
822  bool HasWalletSpend(const CTransactionRef& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
823 
825  void Flush();
826 
828  void Close();
829 
831  boost::signals2::signal<void ()> NotifyUnload;
832 
837  boost::signals2::signal<void(const CTxDestination& address,
838  const std::string& label, bool isMine,
839  AddressPurpose purpose, ChangeType status)>
841 
846  boost::signals2::signal<void(const uint256& hashTx, ChangeType status)> NotifyTransactionChanged;
847 
849  boost::signals2::signal<void (const std::string &title, int nProgress)> ShowProgress;
850 
852  boost::signals2::signal<void (bool fHaveWatchOnly)> NotifyWatchonlyChanged;
853 
855  boost::signals2::signal<void ()> NotifyCanGetAddressesChanged;
856 
861  boost::signals2::signal<void (CWallet* wallet)> NotifyStatusChanged;
862 
864  bool GetBroadcastTransactions() const { return fBroadcastTransactions; }
866  void SetBroadcastTransactions(bool broadcast) { fBroadcastTransactions = broadcast; }
867 
869  bool TransactionCanBeAbandoned(const uint256& hashTx) const;
870 
871  /* Mark a transaction (and it in-wallet descendants) as abandoned so its inputs may be respent. */
872  bool AbandonTransaction(const uint256& hashTx);
873 
875  bool MarkReplaced(const uint256& originalHash, const uint256& newHash);
876 
877  /* Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error */
878  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);
879 
884  void postInitProcess();
885 
886  bool BackupWallet(const std::string& strDest) const;
887 
888  /* Returns true if HD is enabled */
889  bool IsHDEnabled() const;
890 
891  /* Returns true if the wallet can give out new addresses. This means it has keys in the keypool or can generate new keys */
892  bool CanGetAddresses(bool internal = false) const;
893 
894  /* Returns the time of the first created key or, in case of an import, it could be the time of the first received transaction */
895  int64_t GetBirthTime() const { return m_birth_time; }
896 
903  void BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(::cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet);
904 
906  void SetWalletFlag(uint64_t flags);
907 
909  void UnsetWalletFlag(uint64_t flag);
910 
912  bool IsWalletFlagSet(uint64_t flag) const override;
913 
917  void InitWalletFlags(uint64_t flags);
919  bool LoadWalletFlags(uint64_t flags);
920 
922  bool IsLegacy() const;
923 
925  std::string GetDisplayName() const override
926  {
927  std::string wallet_name = GetName().length() == 0 ? "default wallet" : GetName();
928  return strprintf("[%s]", wallet_name);
929  };
930 
932  template <typename... Params>
933  void WalletLogPrintf(const char* fmt, Params... parameters) const
934  {
935  LogPrintf(("%s " + std::string{fmt}).c_str(), GetDisplayName(), parameters...);
936  };
937 
939  bool UpgradeWallet(int version, bilingual_str& error);
940 
942  std::set<ScriptPubKeyMan*> GetActiveScriptPubKeyMans() const;
943  bool IsActiveScriptPubKeyMan(const ScriptPubKeyMan& spkm) const;
944 
946  std::set<ScriptPubKeyMan*> GetAllScriptPubKeyMans() const;
947 
949  ScriptPubKeyMan* GetScriptPubKeyMan(const OutputType& type, bool internal) const;
950 
952  std::set<ScriptPubKeyMan*> GetScriptPubKeyMans(const CScript& script) const;
954  ScriptPubKeyMan* GetScriptPubKeyMan(const uint256& id) const;
955 
957  std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const;
958  std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script, SignatureData& sigdata) const;
959 
961  std::vector<WalletDescriptor> GetWalletDescriptors(const CScript& script) const;
962 
964  LegacyScriptPubKeyMan* GetLegacyScriptPubKeyMan() const;
965  LegacyScriptPubKeyMan* GetOrCreateLegacyScriptPubKeyMan();
966 
968  void SetupLegacyScriptPubKeyMan();
969 
970  bool WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const override;
971 
972  bool HasEncryptionKeys() const override;
973 
976  {
977  AssertLockHeld(cs_wallet);
978  assert(m_last_block_processed_height >= 0);
979  return m_last_block_processed_height;
980  };
982  {
983  AssertLockHeld(cs_wallet);
984  assert(m_last_block_processed_height >= 0);
985  return m_last_block_processed;
986  }
988  void SetLastBlockProcessed(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
989  {
990  AssertLockHeld(cs_wallet);
991  m_last_block_processed_height = block_height;
992  m_last_block_processed = block_hash;
993  };
994 
996  void ConnectScriptPubKeyManNotifiers();
997 
999  DescriptorScriptPubKeyMan& LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor& desc);
1000 
1005  void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal);
1006 
1011  void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal);
1012 
1017  void DeactivateScriptPubKeyMan(uint256 id, OutputType type, bool internal);
1018 
1020  DescriptorScriptPubKeyMan& SetupDescriptorScriptPubKeyMan(WalletBatch& batch, const CExtKey& master_key, const OutputType& output_type, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1022  void SetupDescriptorScriptPubKeyMans(const CExtKey& master_key) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1023  void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1024 
1026  DescriptorScriptPubKeyMan* GetDescriptorScriptPubKeyMan(const WalletDescriptor& desc) const;
1027 
1031  std::optional<bool> IsInternalScriptPubKeyMan(ScriptPubKeyMan* spk_man) const;
1032 
1034  ScriptPubKeyMan* AddWalletDescriptor(WalletDescriptor& desc, const FlatSigningProvider& signing_provider, const std::string& label, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1035 
1041  bool MigrateToSQLite(bilingual_str& error) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1042 
1044  std::optional<MigrationData> GetDescriptorsForLegacy(bilingual_str& error) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1045 
1048  bool ApplyMigrationData(MigrationData& data, bilingual_str& error) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1049 
1051  bool CanGrindR() const;
1052 
1054  void CacheNewScriptPubKeys(const std::set<CScript>& spks, ScriptPubKeyMan* spkm);
1055 
1056  void TopUpCallback(const std::set<CScript>& spks, ScriptPubKeyMan* spkm) override;
1057 
1059  std::set<CExtPubKey> GetActiveHDPubKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
1060 
1063  std::optional<CKey> GetKey(const CKeyID& keyid) const;
1064 };
1065 
1070 void MaybeResendWalletTxs(WalletContext& context);
1071 
1074 {
1075 private:
1076  using Clock = std::chrono::steady_clock;
1077  using NowFn = std::function<Clock::time_point()>;
1079  bool m_could_reserve{false};
1081 public:
1083 
1084  bool reserve(bool with_passphrase = false)
1085  {
1086  assert(!m_could_reserve);
1087  if (m_wallet.fScanningWallet.exchange(true)) {
1088  return false;
1089  }
1090  m_wallet.m_scanning_with_passphrase.exchange(with_passphrase);
1091  m_wallet.m_scanning_start = SteadyClock::now();
1092  m_wallet.m_scanning_progress = 0;
1093  m_could_reserve = true;
1094  return true;
1095  }
1096 
1097  bool isReserved() const
1098  {
1099  return (m_could_reserve && m_wallet.fScanningWallet);
1100  }
1101 
1102  Clock::time_point now() const { return m_now ? m_now() : Clock::now(); };
1103 
1104  void setNow(NowFn now) { m_now = std::move(now); }
1105 
1107  {
1108  if (m_could_reserve) {
1109  m_wallet.fScanningWallet = false;
1110  m_wallet.m_scanning_with_passphrase = false;
1111  }
1112  }
1113 };
1114 
1116 bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name);
1117 
1119 bool RemoveWalletSetting(interfaces::Chain& chain, const std::string& wallet_name);
1120 
1122  std::string wallet_name;
1123  std::shared_ptr<CWallet> wallet;
1124  std::shared_ptr<CWallet> watchonly_wallet;
1125  std::shared_ptr<CWallet> solvables_wallet;
1127 };
1128 
1130 [[nodiscard]] util::Result<MigrationResult> MigrateLegacyToDescriptor(const std::string& wallet_name, const SecureString& passphrase, WalletContext& context);
1131 } // namespace wallet
1132 
1133 #endif // BITCOIN_WALLET_WALLET_H
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:131
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition: amount.h:15
int flags
Definition: bitcoin-tx.cpp:533
const CChainParams & Params()
Return the currently selected parameters.
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
An encapsulated private key.
Definition: key.h:33
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
An encapsulated public key.
Definition: pubkey.h:34
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:414
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
An input of a transaction.
Definition: transaction.h:67
An output of a transaction.
Definition: transaction.h:150
A UTXO entry.
Definition: coins.h:32
An interface to be implemented by keystores that support signing.
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:33
Chain notifications.
Definition: chain.h:310
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
Definition: chain.h:124
256-bit opaque blob.
Definition: uint256.h:106
Coin Control Features.
Definition: coincontrol.h:81
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition: wallet.h:303
const std::string & GetName() const
Get a name for this wallet for logging/debugging purposes.
Definition: wallet.h:455
bool HaveChain() const
Interface to assert chain access.
Definition: wallet.h:480
bool GetBroadcastTransactions() const
Inquire whether this wallet broadcasts transactions.
Definition: wallet.h:864
int64_t GetBirthTime() const
Definition: wallet.h:895
std::function< bool(CWalletTx &wtx, bool new_tx)> UpdateWalletTxFn
Callback for updating transaction metadata in mapWallet.
Definition: wallet.h:604
boost::signals2::signal< void()> NotifyUnload
Wallet is about to be unloaded.
Definition: wallet.h:831
int m_last_block_processed_height GUARDED_BY(cs_wallet)
Height of last block processed is used by wallet to know depth of transactions without relying on Cha...
std::unique_ptr< WalletDatabase > m_database
Internal database handle.
Definition: wallet.h:396
CWallet(interfaces::Chain *chain, const std::string &name, std::unique_ptr< WalletDatabase > database)
Construct wallet with specified name and database implementation.
Definition: wallet.h:462
std::function< void(const CTxDestination &dest, const std::string &label, bool is_change, const std::optional< AddressPurpose > purpose)> ListAddrBookFunc
Walk-through the address book entries.
Definition: wallet.h:766
bool IsScanning() const
Definition: wallet.h:556
std::map< CTxDestination, CAddressBookData > m_address_book GUARDED_BY(cs_wallet)
int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get last block processed height.
Definition: wallet.h:975
boost::signals2::signal< void(bool fHaveWatchOnly)> NotifyWatchonlyChanged
Watch-only address added.
Definition: wallet.h:852
WalletDatabase & GetDatabase() const override
Definition: wallet.h:447
std::map< OutputType, ScriptPubKeyMan * > m_external_spk_managers
Definition: wallet.h:414
uint256 m_last_block_processed GUARDED_BY(cs_wallet)
The following is used to keep track of how far behind the wallet is from the chain sync,...
CKeyingMaterial vMasterKey GUARDED_BY(cs_wallet)
void SetBroadcastTransactions(bool broadcast)
Set whether this wallet broadcasts transactions.
Definition: wallet.h:866
int64_t nOrderPosNext GUARDED_BY(cs_wallet)=0
std::map< OutputType, ScriptPubKeyMan * > m_internal_spk_managers
Definition: wallet.h:415
std::string m_name
Wallet name: relative directory name or "" for default wallet.
Definition: wallet.h:393
double ScanningProgress() const
Definition: wallet.h:559
SteadyClock::duration ScanningDuration() const
Definition: wallet.h:558
RecursiveMutex m_relock_mutex
Definition: wallet.h:580
std::string m_notify_tx_changed_script
Notify external script when a wallet transaction comes in or is updated (handled by -walletnotify)
Definition: wallet.h:737
void SetNextResend()
Set the next time this wallet should resend transactions to 12-36 hours from now, ~1 day on average.
Definition: wallet.h:636
TxItems wtxOrdered
Definition: wallet.h:487
bool CanSupportFeature(enum WalletFeature wf) const override EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
check whether we support the named feature
Definition: wallet.h:534
MasterKeyMap mapMasterKeys
Definition: wallet.h:458
void WalletLogPrintf(const char *fmt, Params... parameters) const
Prepends the wallet name in logging output to ease debugging in multi-wallet use cases.
Definition: wallet.h:933
int64_t nRelockTime GUARDED_BY(cs_wallet)
Holds a timestamp at which point the wallet is scheduled (externally) to be relocked....
Definition: wallet.h:575
std::unordered_multimap< COutPoint, uint256, SaltedOutpointHasher > TxSpends
Used to keep track of spent outpoints, and detect and report conflicts (double-spends or mutated tran...
Definition: wallet.h:337
boost::signals2::signal< void(const std::string &title, int nProgress)> ShowProgress
Show progress e.g.
Definition: wallet.h:849
Mutex m_unlock_mutex
Definition: wallet.h:575
interfaces::Chain * m_chain
Interface for accessing chain state.
Definition: wallet.h:390
boost::signals2::signal< void(const uint256 &hashTx, ChangeType status)> NotifyTransactionChanged
Wallet transaction added, removed or updated.
Definition: wallet.h:846
std::map< unsigned int, CMasterKey > MasterKeyMap
Definition: wallet.h:457
boost::signals2::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
Definition: wallet.h:855
TxSpends mapTxSpends GUARDED_BY(cs_wallet)
int nWalletVersion GUARDED_BY(cs_wallet)
the current wallet version: clients below this version are not able to load the wallet
Definition: wallet.h:318
bool IsAbortingRescan() const
Definition: wallet.h:555
void SetLastBlockProcessed(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Set last block processed height, currently only use in unit test.
Definition: wallet.h:988
uint256 GetLastBlockHash() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Definition: wallet.h:981
RecursiveMutex cs_wallet
Main wallet lock.
Definition: wallet.h:445
std::unordered_map< CScript, std::vector< ScriptPubKeyMan * >, SaltedSipHasher > m_cached_spks
Cache of descriptor ScriptPubKeys used for IsMine. Maps ScriptPubKey to set of spkms.
Definition: wallet.h:429
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:840
std::multimap< int64_t, CWalletTx * > TxItems
Definition: wallet.h:486
boost::signals2::signal< void(CWallet *wallet)> NotifyStatusChanged
Wallet status (encrypted, locked) changed.
Definition: wallet.h:861
std::map< uint256, std::unique_ptr< ScriptPubKeyMan > > m_spk_managers
Definition: wallet.h:419
std::function< TxUpdate(CWalletTx &wtx)> TryUpdatingStateFn
Definition: wallet.h:365
std::unordered_map< uint256, CWalletTx, SaltedTxidHasher > mapWallet GUARDED_BY(cs_wallet)
Map from txid to CWalletTx for all transactions this wallet is interested in, including received and ...
bool IsScanningWithPassphrase() const
Definition: wallet.h:557
A transaction with a bunch of additional info that only the owner cares about.
Definition: transaction.h:177
A wrapper to reserve an address from a wallet.
Definition: wallet.h:191
const CWallet *const pwallet
The wallet to reserve from.
Definition: wallet.h:194
CTxDestination address
The destination.
Definition: wallet.h:201
ReserveDestination & operator=(const ReserveDestination &)=delete
~ReserveDestination()
Destructor. If a key has been reserved and not KeepKey'ed, it will be returned to the keypool.
Definition: wallet.h:215
ReserveDestination(CWallet *pwallet, OutputType type)
Construct a ReserveDestination object. This does NOT reserve an address yet.
Definition: wallet.h:207
OutputType const type
Definition: wallet.h:197
ReserveDestination(const ReserveDestination &)=delete
Access to the wallet database.
Definition: walletdb.h:191
An instance of this class represents one database.
Definition: db.h:130
Descriptor with some wallet metadata.
Definition: walletutil.h:85
RAII object to check and reserve a wallet rescan.
Definition: wallet.h:1074
std::function< Clock::time_point()> NowFn
Definition: wallet.h:1077
std::chrono::steady_clock Clock
Definition: wallet.h:1076
WalletRescanReserver(CWallet &w)
Definition: wallet.h:1082
Clock::time_point now() const
Definition: wallet.h:1102
void setNow(NowFn now)
Definition: wallet.h:1104
bool reserve(bool with_passphrase=false)
Definition: wallet.h:1084
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
@ 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
#define LogPrintf(...)
Definition: logging.h:244
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
Definition: args.cpp:840
PSBTError
Definition: types.h:17
Result CommitTransaction(CWallet &wallet, const uint256 &txid, CMutableTransaction &&mtx, std::vector< bilingual_str > &errors, uint256 &bumped_txid)
Commit the bumpfee transaction.
Definition: feebumper.cpp:356
static constexpr size_t DUMMY_NESTED_P2WPKH_INPUT_SIZE
Pre-calculated constants for input size estimation in virtual size
Definition: wallet.h:146
void UnloadWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly unload and delete the wallet.
Definition: wallet.cpp:243
constexpr CAmount HIGH_APS_FEE
discourage APS fee higher than this amount
Definition: wallet.h:125
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:364
static const CAmount DEFAULT_FALLBACK_FEE
-fallbackfee default
Definition: wallet.h:109
void MaybeResendWalletTxs(WalletContext &context)
Called periodically by the schedule thread.
Definition: wallet.cpp:2132
std::variant< TxStateConfirmed, TxStateInMempool, TxStateInactive > SyncTxState
Subset of states transaction sync logic is implemented to handle.
Definition: transaction.h:81
std::vector< std::shared_ptr< CWallet > > GetWallets(WalletContext &context)
Definition: wallet.cpp:182
constexpr CAmount DEFAULT_TRANSACTION_MAXFEE
-maxtxfee default
Definition: wallet.h:140
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:62
static const CAmount DEFAULT_DISCARD_FEE
-discardfee default
Definition: wallet.h:111
DBErrors
Error statuses for the wallet database.
Definition: walletdb.h:48
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
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:105
static DBErrors LoadWalletFlags(CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet)
Definition: walletdb.cpp:465
static std::set< std::string > g_loading_wallet_set GUARDED_BY(g_loading_wallet_mutex)
static const bool DEFAULT_WALLETCROSSCHAIN
Definition: wallet.h:138
std::unique_ptr< interfaces::Handler > HandleLoadWallet(WalletContext &context, LoadWalletFn load_wallet)
Definition: wallet.cpp:204
std::underlying_type< isminetype >::type isminefilter
used for bitflags of isminetype
Definition: wallet.h:48
static const CAmount DEFAULT_TRANSACTION_MINFEE
-mintxfee default
Definition: wallet.h:113
static const unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
util::Result< MigrationResult > MigrateLegacyToDescriptor(const std::string &wallet_name, const SecureString &passphrase, WalletContext &context)
Do all steps to migrate a legacy wallet to a descriptor wallet.
Definition: wallet.cpp:4346
static const bool DEFAULT_WALLET_RBF
-walletrbf default
Definition: wallet.h:135
constexpr CAmount HIGH_TX_FEE_PER_KB
Discourage users to set fees higher than this amount (in satoshis) per kB.
Definition: wallet.h:142
constexpr OutputType DEFAULT_ADDRESS_TYPE
Default for -addresstype.
Definition: wallet.h:151
std::unique_ptr< WalletDatabase > MakeWalletDatabase(const std::string &name, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error_string)
Definition: wallet.cpp:2932
void NotifyWalletLoaded(WalletContext &context, const std::shared_ptr< CWallet > &wallet)
Definition: wallet.cpp:211
constexpr CAmount HIGH_MAX_TX_FEE
-maxtxfee will warn if called with a higher fee than this amount (in satoshis)
Definition: wallet.h:144
constexpr CAmount DEFAULT_PAY_TX_FEE
-paytxfee default
Definition: wallet.h:107
static const bool DEFAULT_DISABLE_WALLET
Definition: wallet.h:137
static const std::map< std::string, WalletFlags > WALLET_FLAG_MAP
Definition: wallet.h:165
static const CAmount DEFAULT_MAX_AVOIDPARTIALSPEND_FEE
maximum fee increase allowed to do partial spend avoidance, even for nodes with this feature disabled...
Definition: wallet.h:123
static const unsigned int DEFAULT_TX_CONFIRM_TARGET
-txconfirmtarget default
Definition: wallet.h:133
isminetype
IsMine() return codes, which depend on ScriptPubKeyMan implementation.
Definition: types.h:41
std::string PurposeToString(AddressPurpose p)
Definition: wallet.h:273
AddressPurpose
Address purpose field that has been been stored with wallet sending and receiving addresses since BIP...
Definition: types.h:61
@ REFUND
Never set in current code may be present in older wallet databases.
static const bool DEFAULT_WALLETBROADCAST
Definition: wallet.h:136
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)
Definition: wallet.cpp:487
bool AddWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet)
Definition: wallet.cpp:144
static const CAmount WALLET_INCREMENTAL_RELAY_FEE
minimum recommended increment for replacement txs
Definition: wallet.h:127
WalletFeature
(client) version numbers for particular wallet features
Definition: walletutil.h:16
@ FEATURE_BASE
Definition: walletutil.h:17
static constexpr uint64_t KNOWN_WALLET_FLAGS
Definition: wallet.h:153
static const CAmount DEFAULT_CONSOLIDATE_FEERATE
-consolidatefeerate default
Definition: wallet.h:115
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:377
bool IsFeatureSupported(int wallet_version, int feature_version)
Definition: walletutil.cpp:35
@ 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
static constexpr uint64_t MUTABLE_WALLET_FLAGS
Definition: wallet.h:162
std::shared_ptr< CWallet > GetWallet(WalletContext &context, const std::string &name)
Definition: wallet.cpp:195
static const bool DEFAULT_SPEND_ZEROCONF_CHANGE
Default for -spendzeroconfchange.
Definition: wallet.h:129
std::optional< AddressPurpose > PurposeFromString(std::string_view s)
Definition: wallet.h:283
static const bool DEFAULT_WALLET_REJECT_LONG_CHAINS
Default for -walletrejectlongchains.
Definition: wallet.h:131
DatabaseStatus
Definition: db.h:204
static DBErrors LoadMinVersion(CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet)
Definition: walletdb.cpp:453
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start, std::vector< bilingual_str > &warnings)
Definition: wallet.cpp:156
std::shared_ptr< CWallet > GetDefaultWallet(WalletContext &context, size_t &count)
Definition: wallet.cpp:188
OutputType
Definition: outputtype.h:17
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
void SignTransaction(CMutableTransaction &mtx, const SigningProvider *keystore, const std::map< COutPoint, Coin > &coins, const UniValue &hashType, UniValue &result)
Sign a transaction with the given keystore and previous transactions.
const char * name
Definition: rest.cpp:49
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
Definition: secure.h:58
SigningResult
Definition: signmessage.h:43
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
Definition: key.h:207
A mutable version of CTransaction.
Definition: transaction.h:378
std::chrono::time_point< NodeClock > time_point
Definition: time.h:17
A version of CTransaction with the PSBT format.
Definition: psbt.h:951
Bilingual messages:
Definition: translation.h:18
Address book data.
Definition: wallet.h:232
std::optional< AddressPurpose > purpose
Address purpose which was originally recorded for payment protocol support but now serves as a cached...
Definition: wallet.h:247
void SetLabel(std::string name)
Definition: wallet.h:270
std::string GetLabel() const
Definition: wallet.h:269
std::optional< std::string > label
Address label which is always nullopt for change addresses.
Definition: wallet.h:240
bool IsChange() const
Accessor methods.
Definition: wallet.h:268
CAmount nAmount
Definition: wallet.h:294
bool fSubtractFeeFromAmount
Definition: wallet.h:295
CTxDestination dest
Definition: wallet.h:293
std::optional< int > last_scanned_height
Definition: wallet.h:625
uint256 last_scanned_block
Hash and height of most recent block that was successfully scanned.
Definition: wallet.h:624
uint256 last_failed_block
Height of the most recent block that could not be scanned due to read errors or pruning.
Definition: wallet.h:631
struct containing information needed for migrating legacy wallets to descriptor wallets
std::shared_ptr< CWallet > watchonly_wallet
Definition: wallet.h:1124
std::string wallet_name
Definition: wallet.h:1122
std::shared_ptr< CWallet > solvables_wallet
Definition: wallet.h:1125
std::shared_ptr< CWallet > wallet
Definition: wallet.h:1123
WalletContext struct containing references to state shared between CWallet instances,...
Definition: context.h:36
#define LOCK(cs)
Definition: sync.h:257
static int count
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
#define LOCKS_EXCLUDED(...)
Definition: threadsafety.h:48
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1162
ChangeType
General change type (added, updated, removed).
Definition: ui_change_type.h:9
AssertLockHeld(pool.cs)
assert(!tx.IsCoinBase())
std::shared_ptr< CWallet > m_wallet
Definition: interfaces.cpp:564
is a home for public enum and struct type definitions that are used by internally by wallet code,...
std::function< void(std::unique_ptr< interfaces::Wallet > wallet)> LoadWalletFn
Definition: wallet.h:79
static void NotifyUnload(WalletModel *walletModel)