txdownloadman_impl.h

Go to the documentation of this file.

// Copyright (c) 2024-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_NODE_TXDOWNLOADMAN_IMPL_H
#define BITCOIN_NODE_TXDOWNLOADMAN_IMPL_H
 
#include <node/txdownloadman.h>
 
#include <common/bloom.h>
#include <consensus/validation.h>
#include <kernel/chain.h>
#include <net.h>
#include <node/txorphanage.h>
#include <primitives/transaction.h>
#include <policy/packages.h>
#include <random.h>
#include <txrequest.h>
 
class CTxMemPool;
namespace node {
class TxDownloadManagerImpl {
public:
    const CTxMemPool& m_mempool;
    FastRandomContext m_rng;
 
    std::unique_ptr<TxOrphanage> m_orphanage;
    TxRequestTracker m_txrequest;
 
    std::unique_ptr<CRollingBloomFilter> m_lazy_recent_rejects{nullptr};
 
    CRollingBloomFilter& RecentRejectsFilter()
    {
        if (!m_lazy_recent_rejects) {
            m_lazy_recent_rejects = std::make_unique<CRollingBloomFilter>(120'000, 0.000'001);
        }
 
        return *m_lazy_recent_rejects;
    }
 
    std::unique_ptr<CRollingBloomFilter> m_lazy_recent_rejects_reconsiderable{nullptr};
 
    CRollingBloomFilter& RecentRejectsReconsiderableFilter()
    {
        if (!m_lazy_recent_rejects_reconsiderable) {
            m_lazy_recent_rejects_reconsiderable = std::make_unique<CRollingBloomFilter>(120'000, 0.000'001);
        }
 
        return *m_lazy_recent_rejects_reconsiderable;
    }
 
    /*
     * Filter for transactions that have been recently confirmed.
     * We use this to avoid requesting transactions that have already been
     * confirmed.
     *
     * Blocks don't typically have more than 4000 transactions, so this should
     * be at least six blocks (~1 hr) worth of transactions that we can store,
     * inserting both a txid and wtxid for every observed transaction.
     * If the number of transactions appearing in a block goes up, or if we are
     * seeing getdata requests more than an hour after initial announcement, we
     * can increase this number.
     * The false positive rate of 1/1M should come out to less than 1
     * transaction per day that would be inadvertently ignored (which is the
     * same probability that we have in the reject filter).
     */
    std::unique_ptr<CRollingBloomFilter> m_lazy_recent_confirmed_transactions{nullptr};
 
    CRollingBloomFilter& RecentConfirmedTransactionsFilter()
    {
        if (!m_lazy_recent_confirmed_transactions) {
            m_lazy_recent_confirmed_transactions = std::make_unique<CRollingBloomFilter>(48'000, 0.000'001);
        }
 
        return *m_lazy_recent_confirmed_transactions;
    }
 
    TxDownloadManagerImpl(const TxDownloadOptions& options)
        : m_mempool{options.m_mempool},
          m_rng{options.m_deterministic_txrequest},
          m_orphanage{MakeTxOrphanage()},
          m_txrequest{options.m_deterministic_txrequest}
    {}
 
    struct PeerInfo {
        const TxDownloadConnectionInfo m_connection_info;
 
        PeerInfo(const TxDownloadConnectionInfo& info) : m_connection_info{info} {}
    };
 
    std::map<NodeId, PeerInfo> m_peer_info;
 
    uint32_t m_num_wtxid_peers{0};
 
    void ActiveTipChange();
    void BlockConnected(const std::shared_ptr<const CBlock>& pblock);
    void BlockDisconnected();
 
    bool AlreadyHaveTx(const GenTxid& gtxid, bool include_reconsiderable);
 
    void ConnectedPeer(NodeId nodeid, const TxDownloadConnectionInfo& info);
    void DisconnectedPeer(NodeId nodeid);
 
    bool AddTxAnnouncement(NodeId peer, const GenTxid& gtxid, std::chrono::microseconds now);
 
    std::vector<GenTxid> GetRequestsToSend(NodeId nodeid, std::chrono::microseconds current_time);
 
    void ReceivedNotFound(NodeId nodeid, const std::vector<GenTxid>& gtxids);
 
    std::optional<PackageToValidate> Find1P1CPackage(const CTransactionRef& ptx, NodeId nodeid);
 
    void MempoolAcceptedTx(const CTransactionRef& tx);
    RejectedTxTodo MempoolRejectedTx(const CTransactionRef& ptx, const TxValidationState& state, NodeId nodeid, bool first_time_failure);
    void MempoolRejectedPackage(const Package& package);
 
    std::pair<bool, std::optional<PackageToValidate>> ReceivedTx(NodeId nodeid, const CTransactionRef& ptx);
 
    bool HaveMoreWork(NodeId nodeid);
    CTransactionRef GetTxToReconsider(NodeId nodeid);
 
    void CheckIsEmpty();
    void CheckIsEmpty(NodeId nodeid);
 
    std::vector<TxOrphanage::OrphanInfo> GetOrphanTransactions() const;
 
protected:
    std::vector<Txid> GetUniqueParents(const CTransaction& tx);
 
    bool MaybeAddOrphanResolutionCandidate(const std::vector<Txid>& unique_parents, const Wtxid& wtxid, NodeId nodeid, std::chrono::microseconds now);
};
} // namespace node
#endif // BITCOIN_NODE_TXDOWNLOADMAN_IMPL_H