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