Inside Bitcoin

251     * support but now serves as a cached IsMine value. Wallet code should
252     * not rely on this field being set.
253     */
254    std::optional<AddressPurpose> purpose;
255
256    /**
257     * Whether coins with this address have previously been spent. Set when the
258     * the wallet avoid_reuse option is enabled and this is an IsMine address
259     * that has already received funds and spent them. This is used during coin
260     * selection to increase privacy by not creating different transactions
261     * that spend from the same addresses.
262     */
263    bool previously_spent{false};
264
265    /**
266     * Map containing data about previously generated receive requests
267     * requesting funds to be sent to this address. Only present for IsMine
268     * addresses. Map keys are decimal numbers uniquely identifying each
269     * request, and map values are serialized RecentRequestEntry objects
270     * containing BIP21 URI information including message and amount.
271     */
272    std::map<std::string, std::string> receive_requests{};
273
274    /** Accessor methods. */
275    bool IsChange() const { return !label.has_value(); }
276    std::string GetLabel() const { return label ? *label : std::string{}; }
277    void SetLabel(std::string name) { label = std::move(name); }
278};
279
280inline std::string PurposeToString(AddressPurpose p)
281{
282    switch(p) {
283    case AddressPurpose::RECEIVE: return "receive";
284    case AddressPurpose::SEND: return "send";
285    case AddressPurpose::REFUND: return "refund";
286    } // no default case, so the compiler can warn about missing cases
287    assert(false);
288}
289
290inline std::optional<AddressPurpose> PurposeFromString(std::string_view s)
291{
292    if (s == "receive") return AddressPurpose::RECEIVE;
293    else if (s == "send") return AddressPurpose::SEND;
294    else if (s == "refund") return AddressPurpose::REFUND;
295    return {};
296}
297
298struct CRecipient
299{
300    CTxDestination dest;
301    CAmount nAmount;
302    bool fSubtractFeeFromAmount;
303};
304
305class WalletRescanReserver; //forward declarations for ScanForWalletTransactions/RescanFromTime
306/**
307 * A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions.
308 */
309class CWallet final : public WalletStorage, public interfaces::Chain::Notifications
310{
311private:
312    CKeyingMaterial vMasterKey GUARDED_BY(cs_wallet);
313
314    bool Unlock(const CKeyingMaterial& vMasterKeyIn);
315
316    std::atomic<bool> fAbortRescan{false};
317    std::atomic<bool> fScanningWallet{false}; // controlled by WalletRescanReserver
318    std::atomic<bool> m_scanning_with_passphrase{false};
319    std::atomic<SteadyClock::time_point> m_scanning_start{SteadyClock::time_point{}};
320    std::atomic<double> m_scanning_progress{0};
321    friend class WalletRescanReserver;
322
323    /** The next scheduled rebroadcast of wallet transactions. */
324    NodeClock::time_point m_next_resend{GetDefaultNextResend()};
325    /** Whether this wallet will submit newly created transactions to the node's mempool and
326     * prompt rebroadcasts (see ResendWalletTransactions()). */
327    bool fBroadcastTransactions = false;
328    // Local time that the tip block was received. Used to schedule wallet rebroadcasts.
329    std::atomic<int64_t> m_best_block_time {0};
330
331    // First created key time. Used to skip blocks prior to this time.
332    // 'std::numeric_limits<int64_t>::max()' if wallet is blank.
333    std::atomic<int64_t> m_birth_time{std::numeric_limits<int64_t>::max()};
334
335    /**
336     * Used to keep track of spent outpoints, and
337     * detect and report conflicts (double-spends or
338     * mutated transactions where the mutant gets mined).
339     */
340    typedef std::unordered_multimap<COutPoint, Txid, SaltedOutpointHasher> TxSpends;
341    TxSpends mapTxSpends GUARDED_BY(cs_wallet);
342    void AddToSpends(const COutPoint& outpoint, const Txid& txid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
343    void AddToSpends(const CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
344
345    /**
346     * Add a transaction to the wallet, or update it.  confirm.block_* should
347     * be set when the transaction was known to be included in a block.  When
348     * block_hash.IsNull(), then wallet state is not updated in AddToWallet, but
349     * notifications happen and cached balances are marked dirty.
350     *
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 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    /** Collects all wallet txs that differ from wtx only in their scriptSigs (i.e. different tx id malleated variants)
377     *  plus wtx itself. Sorted by the order in which they were inserted in the wallet (CWalletTx::nOrderPos) */
378    std::set<CWalletTx*, WalletTxOrderComparator> GetMalleatedVariants(const CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
379
380    void SyncMalleatedTxMetadata(WalletBatch& batch, const CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
381
382    bool SyncTransaction(const CTransactionRef& tx, const SyncTxState& state, bool rescanning_old_block = false) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
383
384    /** WalletFlags set on this wallet. */
385    std::atomic<uint64_t> m_wallet_flags{0};
386
387    bool SetAddressBookWithDB(WalletBatch& batch, const CTxDestination& address, const std::string& strName, const std::optional<AddressPurpose>& strPurpose);
388
389    //! Unsets a wallet flag and saves it to disk
390    void UnsetWalletFlagWithDB(WalletBatch& batch, uint64_t flag);
391
392    //! Unset the blank wallet flag and saves it to disk
393    void UnsetBlankWalletFlag(WalletBatch& batch) override;
394
395    /** Interface for accessing chain state. */
396    interfaces::Chain* m_chain;
397
398    /** Wallet name: relative directory name or "" for default wallet. */
399    std::string m_name;
400
401    /** Internal database handle. */
402    std::unique_ptr<WalletDatabase> m_database;
403
404    /**
405     * The following is used to keep track of how far behind the wallet is
406     * from the chain sync, and to allow clients to block on us being caught up.
407     *
408     * Processed hash is a pointer on node's tip and doesn't imply that the wallet
409     * has scanned sequentially all blocks up to this one.
410     */
411    uint256 m_last_block_processed GUARDED_BY(cs_wallet);
412
413    /** Height of last block processed is used by wallet to know depth of transactions
414     * without relying on Chain interface beyond asynchronous updates. For safety, we
415     * initialize it to -1. Height is a pointer on node's tip and doesn't imply
416     * that the wallet has scanned sequentially all blocks up to this one.
417     */
418    int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1;
419
420    std::map<OutputType, ScriptPubKeyMan*> m_external_spk_managers;
421    std::map<OutputType, ScriptPubKeyMan*> m_internal_spk_managers;
422
423    // Indexed by a unique identifier produced by each ScriptPubKeyMan using
424    // ScriptPubKeyMan::GetID. In many cases it will be the hash of an internal structure
425    std::map<uint256, std::unique_ptr<ScriptPubKeyMan>> m_spk_managers;
426
427    // Appends spk managers into the main 'm_spk_managers'.
428    // Must be the only method adding data to it.
429    void AddScriptPubKeyMan(const uint256& id, std::unique_ptr<ScriptPubKeyMan> spkm_man);
430
431    // Same as 'AddActiveScriptPubKeyMan' but designed for use within a batch transaction context
432    void AddActiveScriptPubKeyManWithDb(WalletBatch& batch, uint256 id, OutputType type, bool internal);
433
434    /** Store wallet flags */
435    void SetWalletFlagWithDB(WalletBatch& batch, uint64_t flags);
436
437    //! Cache of descriptor ScriptPubKeys used for IsMine. Maps ScriptPubKey to set of spkms
438    std::unordered_map<CScript, std::vector<ScriptPubKeyMan*>, SaltedSipHasher> m_cached_spks;
439
440    //! Set of both spent and unspent transaction outputs owned by this wallet
441    std::unordered_map<COutPoint, WalletTXO, SaltedOutpointHasher> m_txos GUARDED_BY(cs_wallet);
442
443    /**
444     * Catch wallet up to current chain, scanning new blocks, updating the best
445     * block locator and m_last_block_processed, and registering for
446     * notifications about new blocks and transactions.
447     */
448    static bool AttachChain(const std::shared_ptr<CWallet>& wallet, interfaces::Chain& chain, bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings);
449
450    static NodeClock::time_point GetDefaultNextResend();
451
452    // Update last block processed in memory only
453    void SetLastBlockProcessedInMem(int block_height, uint256 block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
454
455    //! Update mempool conflicts for TRUC sibling transactions
456    void UpdateTrucSiblingConflicts(const CWalletTx& parent_wtx, const Txid& child_txid, bool add_conflict) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
457
458public:
459    /**
460     * Main wallet lock.
461     * This lock protects all the fields added by CWallet.
462     */
463    mutable RecursiveMutex cs_wallet;
464
465    WalletDatabase& GetDatabase() const override
466    {
467        assert(static_cast<bool>(m_database));
468        return *m_database;
469    }
470
471    /** Get a name for this wallet for logging/debugging purposes.
472     */
473    const std::string& GetName() const { return m_name; }
474
475    typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
476    MasterKeyMap mapMasterKeys;
477    unsigned int nMasterKeyMaxID = 0;
478
479    /** Construct wallet with specified name and database implementation. */
480    CWallet(interfaces::Chain* chain, const std::string& name, std::unique_ptr<WalletDatabase> database)
481        : m_chain(chain),
482          m_name(name),
483          m_database(std::move(database))
484    {
485    }
486
487    ~CWallet()
488    {
489        // Should not have slots connected at this point.
490        assert(NotifyUnload.empty());
491    }
492
493    bool IsLocked() const override;
494    bool Lock();
495
496    /** Interface to assert chain access */
497    bool HaveChain() const { return m_chain ? true : false; }
498
499    /** Map from txid to CWalletTx for all transactions this wallet is
500     * interested in, including received and sent transactions. */