wallet.h
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 #ifndef BITCOIN_WALLET_WALLET_H 7 #define BITCOIN_WALLET_WALLET_H 8 9 #include <addresstype.h> 10 #include <btcsignals.h> 11 #include <consensus/amount.h> 12 #include <interfaces/chain.h> 13 #include <interfaces/handler.h> 14 #include <kernel/cs_main.h> 15 #include <logging.h> 16 #include <node/types.h> 17 #include <outputtype.h> 18 #include <policy/feerate.h> 19 #include <primitives/transaction.h> 20 #include <primitives/transaction_identifier.h> 21 #include <script/interpreter.h> 22 #include <script/script.h> 23 #include <support/allocators/secure.h> 24 #include <sync.h> 25 #include <tinyformat.h> 26 #include <uint256.h> 27 #include <util/fs.h> 28 #include <util/hasher.h> 29 #include <util/result.h> 30 #include <util/string.h> 31 #include <util/time.h> 32 #include <util/ui_change_type.h> 33 #include <wallet/crypter.h> 34 #include <wallet/db.h> 35 #include <wallet/scriptpubkeyman.h> 36 #include <wallet/transaction.h> 37 #include <wallet/types.h> 38 #include <wallet/walletutil.h> 39 40 #include <atomic> 41 #include <cassert> 42 #include <cstddef> 43 #include <cstdint> 44 #include <functional> 45 #include <limits> 46 #include <map> 47 #include <memory> 48 #include <optional> 49 #include <set> 50 #include <string> 51 #include <unordered_map> 52 #include <utility> 53 #include <vector> 54 55 class CKey; 56 class CKeyID; 57 class CPubKey; 58 class Coin; 59 class SigningProvider; 60 enum class MemPoolRemovalReason; 61 enum class SigningResult; 62 namespace common { 63 enum class PSBTError; 64 } // namespace common 65 namespace interfaces { 66 class Wallet; 67 } 68 namespace wallet { 69 class CWallet; 70 class WalletBatch; 71 enum class DBErrors : int; 72 } // namespace wallet 73 struct CBlockLocator; 74 struct CExtKey; 75 struct FlatSigningProvider; 76 struct KeyOriginInfo; 77 struct PartiallySignedTransaction; 78 struct SignatureData; 79 80 using LoadWalletFn = std::function<void(std::unique_ptr<interfaces::Wallet> wallet)>; 81 82 struct bilingual_str; 83 84 namespace wallet { 85 struct WalletContext; 86 87 //! Explicitly delete the wallet. 88 //! Blocks the current thread until the wallet is destructed. 89 void WaitForDeleteWallet(std::shared_ptr<CWallet>&& wallet); 90 91 bool AddWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet); 92 bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start, std::vector<bilingual_str>& warnings); 93 bool RemoveWallet(WalletContext& context, const std::shared_ptr<CWallet>& wallet, std::optional<bool> load_on_start); 94 std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext& context); 95 std::shared_ptr<CWallet> GetDefaultWallet(WalletContext& context, size_t& count); 96 std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& name); 97 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); 98 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); 99 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 = true, bool allow_unnamed = false); 100 std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet); 101 void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet); 102 std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error); 103 104 //! -fallbackfee default 105 static const CAmount DEFAULT_FALLBACK_FEE = 0; 106 //! -discardfee default 107 static const CAmount DEFAULT_DISCARD_FEE = 10000; 108 //! -mintxfee default 109 static const CAmount DEFAULT_TRANSACTION_MINFEE = 1000; 110 //! -consolidatefeerate default 111 static const CAmount DEFAULT_CONSOLIDATE_FEERATE{10000}; // 10 sat/vbyte 112 /** 113 * maximum fee increase allowed to do partial spend avoidance, even for nodes with this feature disabled by default 114 * 115 * A value of -1 disables this feature completely. 116 * A value of 0 (current default) means to attempt to do partial spend avoidance, and use its results if the fees remain *unchanged* 117 * A value > 0 means to do partial spend avoidance if the fee difference against a regular coin selection instance is in the range [0..value]. 118 */ 119 static const CAmount DEFAULT_MAX_AVOIDPARTIALSPEND_FEE = 0; 120 //! discourage APS fee higher than this amount 121 constexpr CAmount HIGH_APS_FEE{COIN / 10000}; 122 //! minimum recommended increment for replacement txs 123 static const CAmount WALLET_INCREMENTAL_RELAY_FEE = 5000; 124 //! Default for -spendzeroconfchange 125 static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true; 126 //! Default for -walletrejectlongchains 127 static const bool DEFAULT_WALLET_REJECT_LONG_CHAINS{true}; 128 //! -txconfirmtarget default 129 static const unsigned int DEFAULT_TX_CONFIRM_TARGET = 6; 130 //! -walletrbf default 131 static const bool DEFAULT_WALLET_RBF = true; 132 static const bool DEFAULT_WALLETBROADCAST = true; 133 static const bool DEFAULT_DISABLE_WALLET = false; 134 static const bool DEFAULT_WALLETCROSSCHAIN = false; 135 //! -maxtxfee default 136 constexpr CAmount DEFAULT_TRANSACTION_MAXFEE{COIN / 10}; 137 //! Discourage users to set fees higher than this amount (in satoshis) per kB 138 constexpr CAmount HIGH_TX_FEE_PER_KB{COIN / 100}; 139 //! -maxtxfee will warn if called with a higher fee than this amount (in satoshis) 140 constexpr CAmount HIGH_MAX_TX_FEE{100 * HIGH_TX_FEE_PER_KB}; 141 //! Pre-calculated constants for input size estimation in *virtual size* 142 static constexpr size_t DUMMY_NESTED_P2WPKH_INPUT_SIZE = 91; 143 144 class CCoinControl; 145 146 //! Default for -addresstype 147 constexpr OutputType DEFAULT_ADDRESS_TYPE{OutputType::BECH32}; 148 149 static constexpr uint64_t KNOWN_WALLET_FLAGS = 150 WALLET_FLAG_AVOID_REUSE 151 | WALLET_FLAG_BLANK_WALLET 152 | WALLET_FLAG_KEY_ORIGIN_METADATA 153 | WALLET_FLAG_LAST_HARDENED_XPUB_CACHED 154 | WALLET_FLAG_DISABLE_PRIVATE_KEYS 155 | WALLET_FLAG_DESCRIPTORS 156 | WALLET_FLAG_EXTERNAL_SIGNER; 157 158 static constexpr uint64_t MUTABLE_WALLET_FLAGS = 159 WALLET_FLAG_AVOID_REUSE; 160 161 static const std::map<WalletFlags, std::string> WALLET_FLAG_TO_STRING{ 162 {WALLET_FLAG_AVOID_REUSE, "avoid_reuse"}, 163 {WALLET_FLAG_BLANK_WALLET, "blank"}, 164 {WALLET_FLAG_KEY_ORIGIN_METADATA, "key_origin_metadata"}, 165 {WALLET_FLAG_LAST_HARDENED_XPUB_CACHED, "last_hardened_xpub_cached"}, 166 {WALLET_FLAG_DISABLE_PRIVATE_KEYS, "disable_private_keys"}, 167 {WALLET_FLAG_DESCRIPTORS, "descriptor_wallet"}, 168 {WALLET_FLAG_EXTERNAL_SIGNER, "external_signer"} 169 }; 170 171 static const std::map<std::string, WalletFlags> STRING_TO_WALLET_FLAG{ 172 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_AVOID_REUSE), WALLET_FLAG_AVOID_REUSE}, 173 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_BLANK_WALLET), WALLET_FLAG_BLANK_WALLET}, 174 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_KEY_ORIGIN_METADATA), WALLET_FLAG_KEY_ORIGIN_METADATA}, 175 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED), WALLET_FLAG_LAST_HARDENED_XPUB_CACHED}, 176 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_DISABLE_PRIVATE_KEYS), WALLET_FLAG_DISABLE_PRIVATE_KEYS}, 177 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_DESCRIPTORS), WALLET_FLAG_DESCRIPTORS}, 178 {WALLET_FLAG_TO_STRING.at(WALLET_FLAG_EXTERNAL_SIGNER), WALLET_FLAG_EXTERNAL_SIGNER} 179 }; 180 181 /** A wrapper to reserve an address from a wallet 182 * 183 * ReserveDestination is used to reserve an address. 184 * It is currently only used inside of CreateTransaction. 185 * 186 * Instantiating a ReserveDestination does not reserve an address. To do so, 187 * GetReservedDestination() needs to be called on the object. Once an address has been 188 * reserved, call KeepDestination() on the ReserveDestination object to make sure it is not 189 * returned. Call ReturnDestination() to return the address so it can be reused (for 190 * example, if the address was used in a new transaction 191 * and that transaction was not completed and needed to be aborted). 192 * 193 * If an address is reserved and KeepDestination() is not called, then the address will be 194 * returned when the ReserveDestination goes out of scope. 195 */ 196 class ReserveDestination 197 { 198 protected: 199 //! The wallet to reserve from 200 const CWallet* const pwallet; 201 //! The ScriptPubKeyMan to reserve from. Based on type when GetReservedDestination is called 202 ScriptPubKeyMan* m_spk_man{nullptr}; 203 OutputType const type; 204 //! The index of the address's key in the keypool 205 int64_t nIndex{-1}; 206 //! The destination 207 CTxDestination address; 208 //! Whether this is from the internal (change output) keypool 209 bool fInternal{false}; 210 211 public: 212 //! Construct a ReserveDestination object. This does NOT reserve an address yet 213 explicit ReserveDestination(CWallet* pwallet, OutputType type) 214 : pwallet(pwallet) 215 , type(type) { } 216 217 ReserveDestination(const ReserveDestination&) = delete; 218 ReserveDestination& operator=(const ReserveDestination&) = delete; 219 220 //! Destructor. If a key has been reserved and not KeepKey'ed, it will be returned to the keypool 221 ~ReserveDestination() 222 { 223 ReturnDestination(); 224 } 225 226 //! Reserve an address 227 util::Result<CTxDestination> GetReservedDestination(bool internal); 228 //! Return reserved address 229 void ReturnDestination(); 230 //! Keep the address. Do not return its key to the keypool when this object goes out of scope 231 void KeepDestination(); 232 }; 233 234 /** 235 * Address book data. 236 */ 237 struct CAddressBookData 238 { 239 /** 240 * Address label which is always nullopt for change addresses. For sending 241 * and receiving addresses, it will be set to an arbitrary label string 242 * provided by the user, or to "", which is the default label. The presence 243 * or absence of a label is used to distinguish change addresses from 244 * non-change addresses by wallet transaction listing and fee bumping code. 245 */ 246 std::optional<std::string> label; 247 248 /** 249 * Address purpose which was originally recorded for payment protocol 250 * support but now serves as a cached IsMine value. Wallet code should 251 * not rely on this field being set. 252 */ 253 std::optional<AddressPurpose> purpose; 254 255 /** 256 * Whether coins with this address have previously been spent. Set when the 257 * the wallet avoid_reuse option is enabled and this is an IsMine address 258 * that has already received funds and spent them. This is used during coin 259 * selection to increase privacy by not creating different transactions 260 * that spend from the same addresses. 261 */ 262 bool previously_spent{false}; 263 264 /** 265 * Map containing data about previously generated receive requests 266 * requesting funds to be sent to this address. Only present for IsMine 267 * addresses. Map keys are decimal numbers uniquely identifying each 268 * request, and map values are serialized RecentRequestEntry objects 269 * containing BIP21 URI information including message and amount. 270 */ 271 std::map<std::string, std::string> receive_requests{}; 272 273 /** Accessor methods. */ 274 bool IsChange() const { return !label.has_value(); } 275 std::string GetLabel() const { return label ? *label : std::string{}; } 276 void SetLabel(std::string name) { label = std::move(name); } 277 }; 278 279 inline std::string PurposeToString(AddressPurpose p) 280 { 281 switch(p) { 282 case AddressPurpose::RECEIVE: return "receive"; 283 case AddressPurpose::SEND: return "send"; 284 case AddressPurpose::REFUND: return "refund"; 285 } // no default case, so the compiler can warn about missing cases 286 assert(false); 287 } 288 289 inline std::optional<AddressPurpose> PurposeFromString(std::string_view s) 290 { 291 if (s == "receive") return AddressPurpose::RECEIVE; 292 else if (s == "send") return AddressPurpose::SEND; 293 else if (s == "refund") return AddressPurpose::REFUND; 294 return {}; 295 } 296 297 struct CRecipient 298 { 299 CTxDestination dest; 300 CAmount nAmount; 301 bool fSubtractFeeFromAmount; 302 }; 303 304 class WalletRescanReserver; //forward declarations for ScanForWalletTransactions/RescanFromTime 305 /** 306 * A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions. 307 */ 308 class CWallet final : public WalletStorage, public interfaces::Chain::Notifications 309 { 310 private: 311 CKeyingMaterial vMasterKey GUARDED_BY(cs_wallet); 312 313 bool Unlock(const CKeyingMaterial& vMasterKeyIn); 314 315 std::atomic<bool> fAbortRescan{false}; 316 std::atomic<bool> fScanningWallet{false}; // controlled by WalletRescanReserver 317 std::atomic<bool> m_scanning_with_passphrase{false}; 318 std::atomic<SteadyClock::time_point> m_scanning_start{SteadyClock::time_point{}}; 319 std::atomic<double> m_scanning_progress{0}; 320 friend class WalletRescanReserver; 321 322 /** The next scheduled rebroadcast of wallet transactions. */ 323 NodeClock::time_point m_next_resend{GetDefaultNextResend()}; 324 /** Whether this wallet will submit newly created transactions to the node's mempool and 325 * prompt rebroadcasts (see ResendWalletTransactions()). */ 326 bool fBroadcastTransactions = false; 327 // Local time that the tip block was received. Used to schedule wallet rebroadcasts. 328 std::atomic<int64_t> m_best_block_time {0}; 329 330 // First created key time. Used to skip blocks prior to this time. 331 // 'std::numeric_limits<int64_t>::max()' if wallet is blank. 332 std::atomic<int64_t> m_birth_time{std::numeric_limits<int64_t>::max()}; 333 334 /** 335 * Used to keep track of spent outpoints, and 336 * detect and report conflicts (double-spends or 337 * mutated transactions where the mutant gets mined). 338 */ 339 typedef std::unordered_multimap<COutPoint, Txid, SaltedOutpointHasher> TxSpends; 340 TxSpends mapTxSpends GUARDED_BY(cs_wallet); 341 void AddToSpends(const COutPoint& outpoint, const Txid& txid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 342 void AddToSpends(const CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 343 344 /** 345 * Add a transaction to the wallet, or update it. confirm.block_* should 346 * be set when the transaction was known to be included in a block. When 347 * block_hash.IsNull(), then wallet state is not updated in AddToWallet, but 348 * notifications happen and cached balances are marked dirty. 349 * 350 * If fUpdate is true, existing transactions will be updated. 351 * TODO: One exception to this is that the abandoned state is cleared under the 352 * assumption that any further notification of a transaction that was considered 353 * abandoned is an indication that it is not safe to be considered abandoned. 354 * Abandoned state should probably be more carefully tracked via different 355 * chain notifications or by checking mempool presence when necessary. 356 * 357 * Should be called with rescanning_old_block set to true, if the transaction is 358 * not discovered in real time, but during a rescan of old blocks. 359 */ 360 bool AddToWalletIfInvolvingMe(const CTransactionRef& tx, const SyncTxState& state, bool fUpdate, bool rescanning_old_block) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 361 362 /** Mark a transaction (and its in-wallet descendants) as conflicting with a particular block. */ 363 void MarkConflicted(const uint256& hashBlock, int conflicting_height, const Txid& hashTx); 364 365 enum class TxUpdate { UNCHANGED, CHANGED, NOTIFY_CHANGED }; 366 367 using TryUpdatingStateFn = std::function<TxUpdate(CWalletTx& wtx)>; 368 369 /** Mark a transaction (and its in-wallet descendants) as a particular tx state. */ 370 void RecursiveUpdateTxState(const Txid& tx_hash, const TryUpdatingStateFn& try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 371 void RecursiveUpdateTxState(WalletBatch* batch, const Txid& tx_hash, const TryUpdatingStateFn& try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 372 373 /** Mark a transaction's inputs dirty, thus forcing the outputs to be recomputed */ 374 void MarkInputsDirty(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 375 376 void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 377 378 bool SyncTransaction(const CTransactionRef& tx, const SyncTxState& state, bool update_tx = true, bool rescanning_old_block = false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 379 380 /** WalletFlags set on this wallet. */ 381 std::atomic<uint64_t> m_wallet_flags{0}; 382 383 bool SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& strPurpose); 384 385 //! Unsets a wallet flag and saves it to disk 386 void UnsetWalletFlagWithDB(WalletBatch& batch, uint64_t flag); 387 388 //! Unset the blank wallet flag and saves it to disk 389 void UnsetBlankWalletFlag(WalletBatch& batch) override; 390 391 /** Interface for accessing chain state. */ 392 interfaces::Chain* m_chain; 393 394 /** Wallet name: relative directory name or "" for default wallet. */ 395 std::string m_name; 396 397 /** Internal database handle. */ 398 std::unique_ptr<WalletDatabase> m_database; 399 400 /** 401 * The following is used to keep track of how far behind the wallet is 402 * from the chain sync, and to allow clients to block on us being caught up. 403 * 404 * Processed hash is a pointer on node's tip and doesn't imply that the wallet 405 * has scanned sequentially all blocks up to this one. 406 */ 407 uint256 m_last_block_processed GUARDED_BY(cs_wallet); 408 409 /** Height of last block processed is used by wallet to know depth of transactions 410 * without relying on Chain interface beyond asynchronous updates. For safety, we 411 * initialize it to -1. Height is a pointer on node's tip and doesn't imply 412 * that the wallet has scanned sequentially all blocks up to this one. 413 */ 414 int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1; 415 416 std::map<OutputType, ScriptPubKeyMan*> m_external_spk_managers; 417 std::map<OutputType, ScriptPubKeyMan*> m_internal_spk_managers; 418 419 // Indexed by a unique identifier produced by each ScriptPubKeyMan using 420 // ScriptPubKeyMan::GetID. In many cases it will be the hash of an internal structure 421 std::map<uint256, std::unique_ptr<ScriptPubKeyMan>> m_spk_managers; 422 423 // Appends spk managers into the main 'm_spk_managers'. 424 // Must be the only method adding data to it. 425 void AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man); 426 427 // Same as 'AddActiveScriptPubKeyMan' but designed for use within a batch transaction context 428 void AddActiveScriptPubKeyManWithDb(WalletBatch& batch, uint256 id, OutputType type, bool internal); 429 430 /** Store wallet flags */ 431 void SetWalletFlagWithDB(WalletBatch& batch, uint64_t flags); 432 433 //! Cache of descriptor ScriptPubKeys used for IsMine. Maps ScriptPubKey to set of spkms 434 std::unordered_map<CScript, std::vector<ScriptPubKeyMan*>, SaltedSipHasher> m_cached_spks; 435 436 //! Set of both spent and unspent transaction outputs owned by this wallet 437 std::unordered_map<COutPoint, WalletTXO, SaltedOutpointHasher> m_txos GUARDED_BY(cs_wallet); 438 439 /** 440 * Catch wallet up to current chain, scanning new blocks, updating the best 441 * block locator and m_last_block_processed, and registering for 442 * notifications about new blocks and transactions. 443 */ 444 static bool AttachChain(const std::shared_ptr<CWallet>& wallet, interfaces::Chain& chain, bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings); 445 446 static NodeClock::time_point GetDefaultNextResend(); 447 448 // Update last block processed in memory only 449 void SetLastBlockProcessedInMem(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 450 451 //! Update mempool conflicts for TRUC sibling transactions 452 void UpdateTrucSiblingConflicts(const CWalletTx& parent_wtx, const Txid& child_txid, bool add_conflict) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 453 454 public: 455 /** 456 * Main wallet lock. 457 * This lock protects all the fields added by CWallet. 458 */ 459 mutable RecursiveMutex cs_wallet; 460 461 WalletDatabase& GetDatabase() const override 462 { 463 assert(static_cast<bool>(m_database)); 464 return *m_database; 465 } 466 467 /** Get a name for this wallet for logging/debugging purposes. 468 */ 469 const std::string& GetName() const { return m_name; } 470 471 typedef std::map<unsigned int, CMasterKey> MasterKeyMap; 472 MasterKeyMap mapMasterKeys; 473 unsigned int nMasterKeyMaxID = 0; 474 475 /** Construct wallet with specified name and database implementation. */ 476 CWallet(interfaces::Chain* chain, const std::string& name, std::unique_ptr<WalletDatabase> database) 477 : m_chain(chain), 478 m_name(name), 479 m_database(std::move(database)) 480 { 481 } 482 483 ~CWallet() 484 { 485 // Should not have slots connected at this point. 486 assert(NotifyUnload.empty()); 487 } 488 489 bool IsLocked() const override; 490 bool Lock(); 491 492 /** Interface to assert chain access */ 493 bool HaveChain() const { return m_chain ? true : false; } 494 495 /** Map from txid to CWalletTx for all transactions this wallet is 496 * interested in, including received and sent transactions. */ 497 std::unordered_map<Txid, CWalletTx, SaltedTxidHasher> mapWallet GUARDED_BY(cs_wallet); 498 499 typedef std::multimap<int64_t, CWalletTx*> TxItems; 500 TxItems wtxOrdered; 501 502 int64_t nOrderPosNext GUARDED_BY(cs_wallet) = 0; 503 504 std::map<CTxDestination, CAddressBookData> m_address_book GUARDED_BY(cs_wallet); 505 const CAddressBookData* FindAddressBookEntry(const CTxDestination&, bool allow_change = false) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 506 507 /** Set of Coins owned by this wallet that we won't try to spend from. A 508 * Coin may be locked if it has already been used to fund a transaction 509 * that hasn't confirmed yet. We wouldn't consider the Coin spent already, 510 * but also shouldn't try to use it again. 511 * bool to track whether this locked coin is persisted to disk. 512 */ 513 std::map<COutPoint, bool> m_locked_coins GUARDED_BY(cs_wallet); 514 515 /** Registered interfaces::Chain::Notifications handler. */ 516 std::unique_ptr<interfaces::Handler> m_chain_notifications_handler; 517 518 /** Interface for accessing chain state. */ 519 interfaces::Chain& chain() const { assert(m_chain); return *m_chain; } 520 521 const CWalletTx* GetWalletTx(const Txid& hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 522 523 std::set<Txid> GetTxConflicts(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 524 525 const std::unordered_map<COutPoint, WalletTXO, SaltedOutpointHasher>& GetTXOs() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) { AssertLockHeld(cs_wallet); return m_txos; }; 526 std::optional<WalletTXO> GetTXO(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 527 528 /** Cache outputs that belong to the wallet from a single transaction */ 529 void RefreshTXOsFromTx(const CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 530 /** Cache outputs that belong to the wallet for all transactions in the wallet */ 531 void RefreshAllTXOs() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 532 533 /** 534 * Return depth of transaction in blockchain: 535 * <0 : conflicts with a transaction this deep in the blockchain 536 * 0 : in memory pool, waiting to be included in a block 537 * >=1 : this many blocks deep in the main chain 538 * 539 * Preconditions: it is only valid to call this function when the wallet is 540 * online and the block index is loaded. So this cannot be called by 541 * bitcoin-wallet tool code or by wallet migration code. If this is called 542 * without the wallet being online, it won't be able able to determine the 543 * the height of the last block processed, or the heights of blocks 544 * referenced in transaction, and might cause assert failures. 545 */ 546 int GetTxDepthInMainChain(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 547 548 /** 549 * @return number of blocks to maturity for this transaction: 550 * 0 : is not a coinbase transaction, or is a mature coinbase transaction 551 * >0 : is a coinbase transaction which matures in this many blocks 552 */ 553 int GetTxBlocksToMaturity(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 554 bool IsTxImmatureCoinBase(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 555 556 enum class SpendType { 557 UNSPENT, 558 CONFIRMED, 559 MEMPOOL, 560 NONMEMPOOL, 561 }; 562 SpendType HowSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 563 bool IsSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 564 565 // Whether this or any known scriptPubKey with the same single key has been spent. 566 bool IsSpentKey(const CScript& scriptPubKey) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 567 void SetSpentKeyState(WalletBatch& batch, const Txid& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 568 569 /** Display address on an external signer. */ 570 util::Result<void> DisplayAddress(const CTxDestination& dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 571 572 bool IsLockedCoin(const COutPoint& output) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 573 void LoadLockedCoin(const COutPoint& coin, bool persistent) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 574 bool LockCoin(const COutPoint& output, bool persist) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 575 bool UnlockCoin(const COutPoint& output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 576 bool UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 577 void ListLockedCoins(std::vector<COutPoint>& vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 578 579 /* 580 * Rescan abort properties 581 */ 582 void AbortRescan() { fAbortRescan = true; } 583 bool IsAbortingRescan() const { return fAbortRescan; } 584 bool IsScanning() const { return fScanningWallet; } 585 bool IsScanningWithPassphrase() const { return m_scanning_with_passphrase; } 586 SteadyClock::duration ScanningDuration() const { return fScanningWallet ? SteadyClock::now() - m_scanning_start.load() : SteadyClock::duration{}; } 587 double ScanningProgress() const { return fScanningWallet ? (double) m_scanning_progress : 0; } 588 589 //! Upgrade DescriptorCaches 590 void UpgradeDescriptorCache() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 591 592 //! Marks destination as previously spent. 593 void LoadAddressPreviouslySpent(const CTxDestination& dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 594 //! Appends payment request to destination. 595 void LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 596 597 //! Holds a timestamp at which point the wallet is scheduled (externally) to be relocked. Caller must arrange for actual relocking to occur via Lock(). 598 int64_t nRelockTime GUARDED_BY(cs_wallet){0}; 599 600 // Used to prevent concurrent calls to walletpassphrase RPC. 601 Mutex m_unlock_mutex; 602 // Used to prevent deleting the passphrase from memory when it is still in use. 603 RecursiveMutex m_relock_mutex; 604 605 bool Unlock(const SecureString& strWalletPassphrase); 606 bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase); 607 bool EncryptWallet(const SecureString& strWalletPassphrase); 608 609 unsigned int ComputeTimeSmart(const CWalletTx& wtx, bool rescanning_old_block) const; 610 611 /** 612 * Increment the next transaction order id 613 * @return next transaction order id 614 */ 615 int64_t IncOrderPosNext(WalletBatch *batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 616 DBErrors ReorderTransactions(); 617 618 void MarkDirty(); 619 620 //! Callback for updating transaction metadata in mapWallet. 621 //! 622 //! @param wtx - reference to mapWallet transaction to update 623 //! @param new_tx - true if wtx is newly inserted, false if it previously existed 624 //! 625 //! @return true if wtx is changed and needs to be saved to disk, otherwise false 626 using UpdateWalletTxFn = std::function<bool(CWalletTx& wtx, bool new_tx)>; 627 628 /** 629 * Add the transaction to the wallet, wrapping it up inside a CWalletTx 630 * @return the recently added wtx pointer or nullptr if there was a db write error. 631 */ 632 CWalletTx* AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx=nullptr, bool rescanning_old_block = false); 633 bool LoadToWallet(const Txid& hash, const UpdateWalletTxFn& fill_wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 634 void transactionAddedToMempool(const CTransactionRef& tx) override; 635 void blockConnected(const kernel::ChainstateRole& role, const interfaces::BlockInfo& block) override; 636 void blockDisconnected(const interfaces::BlockInfo& block) override; 637 void updatedBlockTip() override; 638 int64_t RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver, bool update); 639 640 struct ScanResult { 641 enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS; 642 643 //! Hash and height of most recent block that was successfully scanned. 644 //! Unset if no blocks were scanned due to read errors or the chain 645 //! being empty. 646 uint256 last_scanned_block; 647 std::optional<int> last_scanned_height; 648 649 //! Height of the most recent block that could not be scanned due to 650 //! read errors or pruning. Will be set if status is FAILURE, unset if 651 //! status is SUCCESS, and may or may not be set if status is 652 //! USER_ABORT. 653 uint256 last_failed_block; 654 }; 655 ScanResult ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, bool fUpdate, bool save_progress); 656 void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) override; 657 /** Set the next time this wallet should resend transactions to 12-36 hours from now, ~1 day on average. */ 658 void SetNextResend() { m_next_resend = GetDefaultNextResend(); } 659 /** Return true if all conditions for periodically resending transactions are met. */ 660 bool ShouldResend() const; 661 void ResubmitWalletTransactions(node::TxBroadcast broadcast_method, bool force); 662 663 OutputType TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const; 664 665 /** Fetch the inputs and sign with SIGHASH_ALL. */ 666 bool SignTransaction(CMutableTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 667 /** Sign the tx given the input coins and sighash. */ 668 bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const; 669 SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const; 670 671 /** 672 * Fills out a PSBT with information from the wallet. Fills in UTXOs if we have 673 * them. Tries to sign if options.sign=true. 674 * Sets `complete` if the PSBT is now complete (i.e. has all required 675 * signatures or signature-parts, and is ready to finalize.) 676 * 677 * @param[in] psbtx PartiallySignedTransaction to fill in 678 * @param[in] options options for filling or signing 679 * @param[out] complete indicates whether the PSBT is now complete 680 * @param[out] n_signed the number of inputs signed by this wallet 681 * @returns an error if something goes wrong 682 */ 683 std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbtx, 684 const common::PSBTFillOptions& options, 685 bool& complete, 686 size_t* n_signed = nullptr) const; 687 688 /** 689 * Submit the transaction to the node's mempool and then relay to peers. 690 * Should be called after CreateTransaction unless you want to abort 691 * broadcasting the transaction. 692 * 693 * @param[in] tx The transaction to be broadcast. 694 * @param[in] mapValue key-values to be set on the transaction. 695 * @param[in] orderForm BIP 70 / BIP 21 order form details to be set on the transaction. 696 */ 697 void CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm); 698 699 /** Pass this transaction to node for optional mempool insertion and relay to peers. */ 700 bool SubmitTxMemoryPoolAndRelay(CWalletTx& wtx, std::string& err_string, node::TxBroadcast broadcast_method) const 701 EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 702 703 /** Updates wallet birth time if 'time' is below it */ 704 void MaybeUpdateBirthTime(int64_t time); 705 706 unsigned int m_confirm_target{DEFAULT_TX_CONFIRM_TARGET}; 707 /** Allow Coin Selection to pick unconfirmed UTXOs that were sent from our own wallet if it 708 * cannot fund the transaction otherwise. */ 709 bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE}; 710 bool m_signal_rbf{DEFAULT_WALLET_RBF}; 711 bool m_allow_fallback_fee{true}; //!< will be false if -fallbackfee=0 712 CFeeRate m_min_fee{DEFAULT_TRANSACTION_MINFEE}; 713 /** 714 * If fee estimation does not have enough data to provide estimates, use this fee instead. 715 * Has no effect if not using fee estimation 716 * Override with -fallbackfee 717 */ 718 CFeeRate m_fallback_fee{DEFAULT_FALLBACK_FEE}; 719 720 /** If the cost to spend a change output at this feerate is greater than the value of the 721 * output itself, just drop it to fees. */ 722 CFeeRate m_discard_rate{DEFAULT_DISCARD_FEE}; 723 724 /** When the actual feerate is less than the consolidate feerate, we will tend to make transactions which 725 * consolidate inputs. When the actual feerate is greater than the consolidate feerate, we will tend to make 726 * transactions which have the lowest fees. 727 */ 728 CFeeRate m_consolidate_feerate{DEFAULT_CONSOLIDATE_FEERATE}; 729 730 /** The maximum fee amount we're willing to pay to prioritize partial spend avoidance. */ 731 CAmount m_max_aps_fee{DEFAULT_MAX_AVOIDPARTIALSPEND_FEE}; //!< note: this is absolute fee, not fee rate 732 OutputType m_default_address_type{DEFAULT_ADDRESS_TYPE}; 733 /** 734 * Default output type for change outputs. When unset, automatically choose type 735 * based on address type setting and the types other of non-change outputs 736 * (see -changetype option documentation and implementation in 737 * CWallet::TransactionChangeType for details). 738 */ 739 std::optional<OutputType> m_default_change_type{}; 740 /** Absolute maximum transaction fee (in satoshis) used by default for the wallet */ 741 CAmount m_default_max_tx_fee{DEFAULT_TRANSACTION_MAXFEE}; 742 743 /** Number of pre-generated keys/scripts by each spkm (part of the look-ahead process, used to detect payments) */ 744 int64_t m_keypool_size{DEFAULT_KEYPOOL_SIZE}; 745 746 /** Notify external script when a wallet transaction comes in or is updated (handled by -walletnotify) */ 747 std::string m_notify_tx_changed_script; 748 749 size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 750 bool TopUpKeyPool(unsigned int kpSize = 0); 751 752 // Filter struct for 'ListAddrBookAddresses' 753 struct AddrBookFilter { 754 // Fetch addresses with the provided label 755 std::optional<std::string> m_op_label{std::nullopt}; 756 // Don't include change addresses by default 757 bool ignore_change{true}; 758 }; 759 760 /** 761 * Filter and retrieve destinations stored in the addressbook 762 */ 763 std::vector<CTxDestination> ListAddrBookAddresses(const std::optional<AddrBookFilter>& filter) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 764 765 /** 766 * Retrieve all the known labels in the address book 767 */ 768 std::set<std::string> ListAddrBookLabels(std::optional<AddressPurpose> purpose) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 769 770 /** 771 * Walk-through the address book entries. 772 * Stops when the provided 'ListAddrBookFunc' returns false. 773 */ 774 using ListAddrBookFunc = std::function<void(const CTxDestination& dest, const std::string& label, bool is_change, const std::optional<AddressPurpose> purpose)>; 775 void ForEachAddrBookEntry(const ListAddrBookFunc& func) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 776 777 /** 778 * Marks all outputs in each one of the destinations dirty, so their cache is 779 * reset and does not return outdated information. 780 */ 781 void MarkDestinationsDirty(const std::set<CTxDestination>& destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 782 783 util::Result<CTxDestination> GetNewDestination(OutputType type, const std::string& label); 784 util::Result<CTxDestination> GetNewChangeDestination(OutputType type); 785 786 bool IsMine(const CTxDestination& dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 787 bool IsMine(const CScript& script) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 788 /** Returns amount of debit, i.e. the amount leaving this wallet due to this input */ 789 CAmount GetDebit(const CTxIn& txin) const; 790 bool IsMine(const CTxOut& txout) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 791 bool IsMine(const CTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 792 bool IsMine(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 793 /** should probably be renamed to IsRelevantToMe */ 794 bool IsFromMe(const CTransaction& tx) const; 795 CAmount GetDebit(const CTransaction& tx) const; 796 797 DBErrors PopulateWalletFromDB(bilingual_str& error, std::vector<bilingual_str>& warnings); 798 799 /** Erases the provided transactions from the wallet. */ 800 util::Result<void> RemoveTxs(std::vector<Txid>& txs_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 801 util::Result<void> RemoveTxs(WalletBatch& batch, std::vector<Txid>& txs_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 802 803 bool SetAddressBook(const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& purpose); 804 805 bool DelAddressBook(const CTxDestination& address); 806 bool DelAddressBookWithDB(WalletBatch& batch, const CTxDestination& address); 807 808 bool IsAddressPreviouslySpent(const CTxDestination& dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 809 bool SetAddressPreviouslySpent(WalletBatch& batch, const CTxDestination& dest, bool used) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 810 811 std::vector<std::string> GetAddressReceiveRequests() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 812 bool SetAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id, const std::string& value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 813 bool EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestination& dest, const std::string& id) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 814 815 unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 816 817 //! Get wallet transactions that conflict with given transaction (spend same outputs) 818 std::set<Txid> GetConflicts(const Txid& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 819 820 //! Check if a given transaction has any of its outputs spent by another transaction in the wallet 821 bool HasWalletSpend(const CTransactionRef& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 822 823 //! Close wallet database 824 void Close(); 825 826 /** Wallet is about to be unloaded */ 827 btcsignals::signal<void ()> NotifyUnload; 828 829 /** 830 * Address book entry changed. 831 * @note called without lock cs_wallet held. 832 */ 833 btcsignals::signal<void(const CTxDestination& address, 834 const std::string& label, bool isMine, 835 AddressPurpose purpose, ChangeType status)> 836 NotifyAddressBookChanged; 837 838 /** 839 * Wallet transaction added, removed or updated. 840 * @note called with lock cs_wallet held. 841 */ 842 btcsignals::signal<void(const Txid& hashTx, ChangeType status)> NotifyTransactionChanged; 843 844 /** Show progress e.g. for rescan */ 845 btcsignals::signal<void (const std::string &title, int nProgress)> ShowProgress; 846 847 /** Keypool has new keys */ 848 btcsignals::signal<void ()> NotifyCanGetAddressesChanged; 849 850 /** 851 * Wallet status (encrypted, locked) changed. 852 * Note: Called without locks held. 853 */ 854 btcsignals::signal<void (CWallet* wallet)> NotifyStatusChanged; 855 856 /** Inquire whether this wallet broadcasts transactions. */ 857 bool GetBroadcastTransactions() const { return fBroadcastTransactions; } 858 /** Set whether this wallet broadcasts transactions. */ 859 void SetBroadcastTransactions(bool broadcast) { fBroadcastTransactions = broadcast; } 860 861 /** Return whether transaction can be abandoned */ 862 bool TransactionCanBeAbandoned(const Txid& hashTx) const; 863 864 /* Mark a transaction (and it in-wallet descendants) as abandoned so its inputs may be respent. */ 865 bool AbandonTransaction(const Txid& hashTx); 866 bool AbandonTransaction(CWalletTx& tx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 867 868 /** Mark a transaction as replaced by another transaction. */ 869 bool MarkReplaced(const Txid& originalHash, const Txid& newHash); 870 871 static bool LoadWalletArgs(std::shared_ptr<CWallet> wallet, const WalletContext& context, bilingual_str& error, std::vector<bilingual_str>& warnings); 872 873 /* Initializes, creates and returns a new CWallet; returns a null pointer in case of an error */ 874 static std::shared_ptr<CWallet> CreateNew(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bilingual_str& error, std::vector<bilingual_str>& warnings); 875 876 /* Initializes, loads, and returns a CWallet from an existing wallet; returns a null pointer in case of an error */ 877 static std::shared_ptr<CWallet> LoadExisting(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, bilingual_str& error, std::vector<bilingual_str>& warnings); 878 879 /** 880 * Wallet post-init setup 881 * Gives the wallet a chance to register repetitive tasks and complete post-init tasks 882 */ 883 void postInitProcess(); 884 885 bool BackupWallet(const std::string& strDest) const; 886 887 /* Returns true if HD is enabled */ 888 bool IsHDEnabled() const; 889 890 /* Returns true if the wallet can give out new addresses. This means it has keys in the keypool or can generate new keys */ 891 bool CanGetAddresses(bool internal = false) const; 892 893 /* Returns the time of the first created key or, in case of an import, it could be the time of the first received transaction */ 894 int64_t GetBirthTime() const { return m_birth_time; } 895 896 /** 897 * Blocks until the wallet state is up-to-date to /at least/ the current 898 * chain at the time this function is entered 899 * Obviously holding cs_main/cs_wallet when going into this call may cause 900 * deadlock 901 */ 902 void BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(::cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet); 903 904 /** set a single wallet flag */ 905 void SetWalletFlag(uint64_t flags); 906 907 /** Unsets a single wallet flag */ 908 void UnsetWalletFlag(uint64_t flag); 909 910 /** check if a certain wallet flag is set */ 911 bool IsWalletFlagSet(uint64_t flag) const override; 912 913 /** overwrite all flags by the given uint64_t 914 flags must be uninitialised (or 0) 915 only known flags may be present */ 916 void InitWalletFlags(uint64_t flags); 917 /** Loads the flags into the wallet. (used by LoadWallet) */ 918 bool LoadWalletFlags(uint64_t flags); 919 //! Retrieve all of the wallet's flags 920 uint64_t GetWalletFlags() const; 921 922 /** Return wallet name for use in logs, will return "default wallet" if the wallet has no name. */ 923 std::string LogName() const override 924 { 925 std::string name{GetName()}; 926 return name.empty() ? "default wallet" : name; 927 }; 928 929 /** Return wallet name for display, like LogName() but translates "default wallet" string. */ 930 std::string DisplayName() const 931 { 932 std::string name{GetName()}; 933 return name.empty() ? _("default wallet") : name; 934 }; 935 936 /** Prepends the wallet name in logging output to ease debugging in multi-wallet use cases */ 937 template <typename... Params> 938 void WalletLogPrintf(util::ConstevalFormatString<sizeof...(Params)> wallet_fmt, const Params&... params) const 939 { 940 LogInfo("[%s] %s", LogName(), tfm::format(wallet_fmt, params...)); 941 }; 942 943 void LogStats() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) 944 { 945 AssertLockHeld(cs_wallet); 946 WalletLogPrintf("setKeyPool.size() = %u\n", GetKeyPoolSize()); 947 WalletLogPrintf("mapWallet.size() = %u\n", mapWallet.size()); 948 WalletLogPrintf("m_address_book.size() = %u\n", m_address_book.size()); 949 }; 950 951 //! Returns all unique ScriptPubKeyMans in m_internal_spk_managers and m_external_spk_managers 952 std::set<ScriptPubKeyMan*> GetActiveScriptPubKeyMans() const; 953 bool IsActiveScriptPubKeyMan(const ScriptPubKeyMan& spkm) const; 954 955 //! Returns all unique ScriptPubKeyMans 956 std::set<ScriptPubKeyMan*> GetAllScriptPubKeyMans() const; 957 958 //! Get the ScriptPubKeyMan for the given OutputType and internal/external chain. 959 ScriptPubKeyMan* GetScriptPubKeyMan(const OutputType& type, bool internal) const; 960 961 //! Get all the ScriptPubKeyMans for a script 962 std::set<ScriptPubKeyMan*> GetScriptPubKeyMans(const CScript& script) const; 963 //! Get the ScriptPubKeyMan by id 964 ScriptPubKeyMan* GetScriptPubKeyMan(const uint256& id) const; 965 966 //! Get the SigningProvider for a script 967 std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const; 968 std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script, SignatureData& sigdata) const; 969 970 //! Get the wallet descriptors for a script. 971 std::vector<WalletDescriptor> GetWalletDescriptors(const CScript& script) const; 972 973 //! Get the LegacyScriptPubKeyMan which is used for all types, internal, and external. 974 LegacyDataSPKM* GetLegacyDataSPKM() const; 975 LegacyDataSPKM* GetOrCreateLegacyDataSPKM(); 976 977 //! Make a Legacy(Data)SPKM and set it for all types, internal, and external. 978 void SetupLegacyScriptPubKeyMan(); 979 980 bool WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const override; 981 982 bool HasEncryptionKeys() const override; 983 bool HaveCryptedKeys() const; 984 985 /** Get last block processed height */ 986 int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) 987 { 988 AssertLockHeld(cs_wallet); 989 assert(m_last_block_processed_height >= 0); 990 return m_last_block_processed_height; 991 }; 992 uint256 GetLastBlockHash() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) 993 { 994 AssertLockHeld(cs_wallet); 995 assert(m_last_block_processed_height >= 0); 996 return m_last_block_processed; 997 } 998 /** Set last block processed height, and write to database */ 999 void SetLastBlockProcessed(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1000 /** Write the current best block to database */ 1001 void WriteBestBlock() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1002 1003 //! Connect the signals from ScriptPubKeyMans to the signals in CWallet 1004 void ConnectScriptPubKeyManNotifiers(); 1005 1006 //! Instantiate a descriptor ScriptPubKeyMan from the WalletDescriptor and load it 1007 DescriptorScriptPubKeyMan& LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor& desc); 1008 1009 //! Adds the active ScriptPubKeyMan for the specified type and internal. Writes it to the wallet file 1010 //! @param[in] id The unique id for the ScriptPubKeyMan 1011 //! @param[in] type The OutputType this ScriptPubKeyMan provides addresses for 1012 //! @param[in] internal Whether this ScriptPubKeyMan provides change addresses 1013 void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal); 1014 1015 //! Loads an active ScriptPubKeyMan for the specified type and internal. (used by LoadWallet) 1016 //! @param[in] id The unique id for the ScriptPubKeyMan 1017 //! @param[in] type The OutputType this ScriptPubKeyMan provides addresses for 1018 //! @param[in] internal Whether this ScriptPubKeyMan provides change addresses 1019 void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal); 1020 1021 //! Remove specified ScriptPubKeyMan from set of active SPK managers. Writes the change to the wallet file. 1022 //! @param[in] id The unique id for the ScriptPubKeyMan 1023 //! @param[in] type The OutputType this ScriptPubKeyMan provides addresses for 1024 //! @param[in] internal Whether this ScriptPubKeyMan provides change addresses 1025 void DeactivateScriptPubKeyMan(uint256 id, OutputType type, bool internal); 1026 1027 //! Create new DescriptorScriptPubKeyMan and add it to the wallet 1028 DescriptorScriptPubKeyMan& SetupDescriptorScriptPubKeyMan(WalletBatch& batch, const CExtKey& master_key, const OutputType& output_type, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1029 //! Create new DescriptorScriptPubKeyMans and add them to the wallet 1030 void SetupDescriptorScriptPubKeyMans(WalletBatch& batch, const CExtKey& master_key) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1031 void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1032 1033 //! Create new seed and default DescriptorScriptPubKeyMans for this wallet 1034 void SetupOwnDescriptorScriptPubKeyMans(WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1035 1036 //! Return the DescriptorScriptPubKeyMan for a WalletDescriptor if it is already in the wallet 1037 DescriptorScriptPubKeyMan* GetDescriptorScriptPubKeyMan(const WalletDescriptor& desc) const; 1038 1039 //! Returns whether the provided ScriptPubKeyMan is internal 1040 //! @param[in] spk_man The ScriptPubKeyMan to test 1041 //! @return contains value only for active DescriptorScriptPubKeyMan, otherwise undefined 1042 std::optional<bool> IsInternalScriptPubKeyMan(ScriptPubKeyMan* spk_man) const; 1043 1044 //! Add a descriptor to the wallet, return a ScriptPubKeyMan & associated output type 1045 util::Result<std::reference_wrapper<DescriptorScriptPubKeyMan>> AddWalletDescriptor(WalletDescriptor& desc, const FlatSigningProvider& signing_provider, const std::string& label, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1046 1047 /** Move all records from the BDB database to a new SQLite database for storage. 1048 * The original BDB file will be deleted and replaced with a new SQLite file. 1049 * A backup is not created. 1050 * May crash if something unexpected happens in the filesystem. 1051 */ 1052 bool MigrateToSQLite(bilingual_str& error) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1053 1054 //! Get all of the descriptors from a legacy wallet 1055 std::optional<MigrationData> GetDescriptorsForLegacy(bilingual_str& error) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1056 1057 //! Adds the ScriptPubKeyMans given in MigrationData to this wallet, removes LegacyScriptPubKeyMan, 1058 //! and where needed, moves tx and address book entries to watchonly_wallet or solvable_wallet 1059 util::Result<void> ApplyMigrationData(WalletBatch& local_wallet_batch, MigrationData& data) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1060 1061 //! Whether the (external) signer performs R-value signature grinding 1062 bool CanGrindR() const; 1063 1064 //! Add scriptPubKeys for this ScriptPubKeyMan into the scriptPubKey cache 1065 void CacheNewScriptPubKeys(const std::set<CScript>& spks, ScriptPubKeyMan* spkm); 1066 1067 void TopUpCallback(const std::set<CScript>& spks, ScriptPubKeyMan* spkm) override; 1068 1069 //! Retrieve the xpubs in use by the active descriptors 1070 std::set<CExtPubKey> GetActiveHDPubKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); 1071 1072 //! Find the private key for the given key id from the wallet's descriptors, if available 1073 //! Returns nullopt when no descriptor has the key or if the wallet is locked. 1074 std::optional<CKey> GetKey(const CKeyID& keyid) const; 1075 1076 //! Disconnect chain notifications and wait for all notifications to be processed 1077 void DisconnectChainNotifications(); 1078 }; 1079 1080 /** 1081 * Called periodically by the schedule thread. Prompts individual wallets to resend 1082 * their transactions. Actual rebroadcast schedule is managed by the wallets themselves. 1083 */ 1084 void MaybeResendWalletTxs(WalletContext& context); 1085 1086 /** RAII object to check and reserve a wallet rescan */ 1087 class WalletRescanReserver 1088 { 1089 private: 1090 using Clock = std::chrono::steady_clock; 1091 using NowFn = std::function<Clock::time_point()>; 1092 CWallet& m_wallet; 1093 bool m_could_reserve{false}; 1094 NowFn m_now; 1095 public: 1096 explicit WalletRescanReserver(CWallet& w) : m_wallet(w) {} 1097 1098 bool reserve(bool with_passphrase = false) 1099 { 1100 assert(!m_could_reserve); 1101 if (m_wallet.fScanningWallet.exchange(true)) { 1102 return false; 1103 } 1104 m_wallet.m_scanning_with_passphrase.exchange(with_passphrase); 1105 m_wallet.m_scanning_start = SteadyClock::now(); 1106 m_wallet.m_scanning_progress = 0; 1107 m_could_reserve = true; 1108 return true; 1109 } 1110 1111 bool isReserved() const 1112 { 1113 return (m_could_reserve && m_wallet.fScanningWallet); 1114 } 1115 1116 Clock::time_point now() const { return m_now ? m_now() : Clock::now(); }; 1117 1118 void setNow(NowFn now) { m_now = std::move(now); } 1119 1120 ~WalletRescanReserver() 1121 { 1122 if (m_could_reserve) { 1123 m_wallet.fScanningWallet = false; 1124 m_wallet.m_scanning_with_passphrase = false; 1125 } 1126 } 1127 }; 1128 1129 //! Add wallet name to persistent configuration so it will be loaded on startup. 1130 bool AddWalletSetting(interfaces::Chain& chain, const std::string& wallet_name); 1131 1132 //! Remove wallet name from persistent configuration so it will not be loaded on startup. 1133 bool RemoveWalletSetting(interfaces::Chain& chain, const std::string& wallet_name); 1134 1135 struct MigrationResult { 1136 std::string wallet_name; 1137 std::shared_ptr<CWallet> wallet; 1138 std::shared_ptr<CWallet> watchonly_wallet; 1139 std::shared_ptr<CWallet> solvables_wallet; 1140 fs::path backup_path; 1141 }; 1142 1143 //! Do all steps to migrate a legacy wallet to a descriptor wallet 1144 [[nodiscard]] util::Result<MigrationResult> MigrateLegacyToDescriptor(const std::string& wallet_name, const SecureString& passphrase, WalletContext& context); 1145 //! Requirement: The wallet provided to this function must be isolated, with no attachment to the node's context. 1146 [[nodiscard]] util::Result<MigrationResult> MigrateLegacyToDescriptor(std::shared_ptr<CWallet> local_wallet, const SecureString& passphrase, WalletContext& context); 1147 } // namespace wallet 1148 1149 #endif // BITCOIN_WALLET_WALLET_H