Inside Bitcoin

501    std::unordered_map<Txid, CWalletTx, SaltedTxidHasher> mapWallet GUARDED_BY(cs_wallet);
502
503    typedef std::multimap<int64_t, CWalletTx*> TxItems;
504    TxItems wtxOrdered;
505
506    int64_t nOrderPosNext GUARDED_BY(cs_wallet) = 0;
507
508    std::map<CTxDestination, CAddressBookData> m_address_book GUARDED_BY(cs_wallet);
509    const CAddressBookData* FindAddressBookEntry(const CTxDestination&, bool allow_change = false) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
510
511    /** Set of Coins owned by this wallet that we won't try to spend from. A
512     * Coin may be locked if it has already been used to fund a transaction
513     * that hasn't confirmed yet. We wouldn't consider the Coin spent already,
514     * but also shouldn't try to use it again.
515     * bool to track whether this locked coin is persisted to disk.
516     */
517    std::map<COutPoint, bool> m_locked_coins GUARDED_BY(cs_wallet);
518
519    /** Registered interfaces::Chain::Notifications handler. */
520    std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
521
522    /** Interface for accessing chain state. */
523    interfaces::Chain& chain() const { assert(m_chain); return *m_chain; }
524
525    const CWalletTx* GetWalletTx(const Txid& hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
526
527    std::set<Txid> GetTxConflicts(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
528
529    const std::unordered_map<COutPoint, WalletTXO, SaltedOutpointHasher>& GetTXOs() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) { AssertLockHeld(cs_wallet); return m_txos; };
530    std::optional<WalletTXO> GetTXO(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
531
532    /** Cache outputs that belong to the wallet from a single transaction */
533    void RefreshTXOsFromTx(const CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
534    /** Cache outputs that belong to the wallet for all transactions in the wallet */
535    void RefreshAllTXOs() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
536
537    /**
538     * Return depth of transaction in blockchain:
539     * <0  : conflicts with a transaction this deep in the blockchain
540     *  0  : in memory pool, waiting to be included in a block
541     * >=1 : this many blocks deep in the main chain
542     *
543     * Preconditions: it is only valid to call this function when the wallet is
544     * online and the block index is loaded. So this cannot be called by
545     * bitcoin-wallet tool code or by wallet migration code. If this is called
546     * without the wallet being online, it won't be able able to determine the
547     * the height of the last block processed, or the heights of blocks
548     * referenced in transaction, and might cause assert failures.
549     */
550    int GetTxDepthInMainChain(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
551
552    /**
553     * @return number of blocks to maturity for this transaction:
554     *  0 : is not a coinbase transaction, or is a mature coinbase transaction
555     * >0 : is a coinbase transaction which matures in this many blocks
556     */
557    int GetTxBlocksToMaturity(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
558    bool IsTxImmatureCoinBase(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
559
560    enum class SpendType {
561        UNSPENT,
562        CONFIRMED,
563        MEMPOOL,
564        NONMEMPOOL,
565    };
566    SpendType HowSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
567    bool IsSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
568
569    // Whether this or any known scriptPubKey with the same single key has been spent.
570    bool IsSpentKey(const CScript& scriptPubKey) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
571    void SetSpentKeyState(WalletBatch& batch, const Txid& hash, unsigned int n, bool used, std::set<CTxDestination>& tx_destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
572
573    /** Display address on an external signer. */
574    util::Result<void> DisplayAddress(const CTxDestination& dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
575
576    bool IsLockedCoin(const COutPoint& output) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
577    void LoadLockedCoin(const COutPoint& coin, bool persistent) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
578    bool LockCoin(const COutPoint& output, bool persist) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
579    bool UnlockCoin(const COutPoint& output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
580    bool UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
581    void ListLockedCoins(std::vector<COutPoint>& vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
582
583    /*
584     * Rescan abort properties
585     */
586    void AbortRescan() { fAbortRescan = true; }
587    bool IsAbortingRescan() const { return fAbortRescan; }
588    bool IsScanning() const { return fScanningWallet; }
589    bool IsScanningWithPassphrase() const { return m_scanning_with_passphrase; }
590    SteadyClock::duration ScanningDuration() const { return fScanningWallet ? SteadyClock::now() - m_scanning_start.load() : SteadyClock::duration{}; }
591    double ScanningProgress() const { return fScanningWallet ? (double) m_scanning_progress : 0; }
592
593    //! Upgrade DescriptorCaches
594    void UpgradeDescriptorCache() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
595
596    //! Marks destination as previously spent.
597    void LoadAddressPreviouslySpent(const CTxDestination& dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
598    //! Appends payment request to destination.
599    void LoadAddressReceiveRequest(const CTxDestination& dest, const std::string& id, const std::string& request) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
600
601    //! Holds a timestamp at which point the wallet is scheduled (externally) to be relocked. Caller must arrange for actual relocking to occur via Lock().
602    int64_t nRelockTime GUARDED_BY(cs_wallet){0};
603
604    // Used to prevent concurrent calls to walletpassphrase RPC.
605    Mutex m_unlock_mutex;
606    // Used to prevent deleting the passphrase from memory when it is still in use.
607    RecursiveMutex m_relock_mutex;
608
609    bool Unlock(const SecureString& strWalletPassphrase);
610    bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase);
611    bool EncryptWallet(const SecureString& strWalletPassphrase);
612
613    unsigned int ComputeTimeSmart(const CWalletTx& wtx, bool rescanning_old_block) const;
614
615    /**
616     * Increment the next transaction order id
617     * @return next transaction order id
618     */
619    int64_t IncOrderPosNext(WalletBatch *batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
620    DBErrors ReorderTransactions();
621
622    void MarkDirty();
623
624    //! Callback for updating transaction metadata in mapWallet.
625    //!
626    //! @param wtx - reference to mapWallet transaction to update
627    //! @param new_tx - true if wtx is newly inserted, false if it previously existed
628    //!
629    //! @return true if wtx is changed and needs to be saved to disk, otherwise false
630    using UpdateWalletTxFn = std::function<bool(CWalletTx& wtx, bool new_tx)>;
631
632    /**
633     * Add the transaction to the wallet, wrapping it up inside a CWalletTx
634     * @return the recently added wtx pointer or nullptr if there was a db write error.
635     */
636    CWalletTx* AddToWallet(CTransactionRef tx, const TxState& state, const UpdateWalletTxFn& update_wtx=nullptr, bool rescanning_old_block = false);
637    bool LoadToWallet(CWalletTx&& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
638    void transactionAddedToMempool(const CTransactionRef& tx) override;
639    void blockConnected(const kernel::ChainstateRole& role, const interfaces::BlockInfo& block) override;
640    void blockDisconnected(const interfaces::BlockInfo& block) override;
641    void updatedBlockTip() override;
642    int64_t RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver);
643
644    struct ScanResult {
645        enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS;
646
647        //! Hash and height of most recent block that was successfully scanned.
648        //! Unset if no blocks were scanned due to read errors or the chain
649        //! being empty.
650        uint256 last_scanned_block;
651        std::optional<int> last_scanned_height;
652
653        //! Height of the most recent block that could not be scanned due to
654        //! read errors or pruning. Will be set if status is FAILURE, unset if
655        //! status is SUCCESS, and may or may not be set if status is
656        //! USER_ABORT.
657        uint256 last_failed_block;
658    };
659    ScanResult ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, bool save_progress);
660    void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) override;
661    /** Set the next time this wallet should resend transactions to 12-36 hours from now, ~1 day on average. */
662    void SetNextResend() { m_next_resend = GetDefaultNextResend(); }
663    /** Return true if all conditions for periodically resending transactions are met. */
664    bool ShouldResend() const;
665    void ResubmitWalletTransactions(node::TxBroadcast broadcast_method, bool force);
666
667    OutputType TransactionChangeType(const std::optional<OutputType>& change_type, const std::vector<CRecipient>& vecSend) const;
668
669    /** Fetch the inputs and sign with SIGHASH_ALL. */
670    bool SignTransaction(CMutableTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
671    /** Sign the tx given the input coins and sighash. */
672    bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const;
673    SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const;
674
675    /**
676     * Fills out a PSBT with information from the wallet. Fills in UTXOs if we have
677     * them. Tries to sign if options.sign=true.
678     * Sets `complete` if the PSBT is now complete (i.e. has all required
679     * signatures or signature-parts, and is ready to finalize.)
680     *
681     * @param[in]  psbtx PartiallySignedTransaction to fill in
682     * @param[in]  options options for filling or signing
683     * @param[out] complete indicates whether the PSBT is now complete
684     * @param[out] n_signed the number of inputs signed by this wallet
685     * @returns an error if something goes wrong
686     */
687    std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbtx,
688                  const common::PSBTFillOptions& options,
689                  bool& complete,
690                  size_t* n_signed = nullptr) const;
691
692    /**
693     * Submit the transaction to the node's mempool and then relay to peers.
694     * Should be called after CreateTransaction unless you want to abort
695     * broadcasting the transaction.
696     *
697     * @param[in] tx The transaction to be broadcast.
698     * @param[in] replaces_txid The txid of the transaction that this transaction replaces
699     * @param[in] comment The user's comment for this transaction
700     * @param[in] comment_to The comment for this transaction indicating where coins are sent to
701     * @param[in] messages The BIP 21 URI messages to attach to this transaction
702     */
703    void CommitTransaction(
704        CTransactionRef tx,
705        std::optional<Txid> replaces_txid = std::nullopt,
706        std::optional<std::string> comment = std::nullopt,
707        std::optional<std::string> comment_to = std::nullopt,
708        const std::vector<std::string>& messages = {},
709        const std::vector<std::string>& payment_requests = {}
710    );
711
712    /** Pass this transaction to node for optional mempool insertion and relay to peers. */
713    bool SubmitTxMemoryPoolAndRelay(CWalletTx& wtx, std::string& err_string, node::TxBroadcast broadcast_method) const
714        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
715
716    /** Updates wallet birth time if 'time' is below it */
717    void MaybeUpdateBirthTime(int64_t time);
718
719    unsigned int m_confirm_target{DEFAULT_TX_CONFIRM_TARGET};
720    /** Allow Coin Selection to pick unconfirmed UTXOs that were sent from our own wallet if it
721     * cannot fund the transaction otherwise. */
722    bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE};
723    bool m_signal_rbf{DEFAULT_WALLET_RBF};
724    bool m_allow_fallback_fee{true}; //!< will be false if -fallbackfee=0
725    CFeeRate m_min_fee{DEFAULT_TRANSACTION_MINFEE};
726    /**
727     * If fee estimation does not have enough data to provide estimates, use this fee instead.
728     * Has no effect if not using fee estimation
729     * Override with -fallbackfee
730     */
731    CFeeRate m_fallback_fee{DEFAULT_FALLBACK_FEE};
732
733     /** If the cost to spend a change output at this feerate is greater than the value of the
734      * output itself, just drop it to fees. */
735    CFeeRate m_discard_rate{DEFAULT_DISCARD_FEE};
736
737    /** When the actual feerate is less than the consolidate feerate, we will tend to make transactions which
738     * consolidate inputs. When the actual feerate is greater than the consolidate feerate, we will tend to make
739     * transactions which have the lowest fees.
740     */
741    CFeeRate m_consolidate_feerate{DEFAULT_CONSOLIDATE_FEERATE};
742
743    /** The maximum fee amount we're willing to pay to prioritize partial spend avoidance. */
744    CAmount m_max_aps_fee{DEFAULT_MAX_AVOIDPARTIALSPEND_FEE}; //!< note: this is absolute fee, not fee rate
745    OutputType m_default_address_type{DEFAULT_ADDRESS_TYPE};
746    /**
747     * Default output type for change outputs. When unset, automatically choose type
748     * based on address type setting and the types other of non-change outputs
749     * (see -changetype option documentation and implementation in
750     * CWallet::TransactionChangeType for details).