txdownloadman.h

Go to the documentation of this file.

// Copyright (c) 2024 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_H
#define BITCOIN_NODE_TXDOWNLOADMAN_H
 
#include <net.h>
#include <policy/packages.h>
#include <txorphanage.h>
 
#include <cstdint>
#include <memory>
 
class CBlock;
class CRollingBloomFilter;
class CTxMemPool;
class GenTxid;
class TxRequestTracker;
namespace node {
class TxDownloadManagerImpl;
 
static constexpr int32_t MAX_PEER_TX_REQUEST_IN_FLIGHT = 100;
static constexpr int32_t MAX_PEER_TX_ANNOUNCEMENTS = 5000;
static constexpr auto TXID_RELAY_DELAY{2s};
static constexpr auto NONPREF_PEER_TX_DELAY{2s};
static constexpr auto OVERLOADED_PEER_TX_DELAY{2s};
static constexpr auto GETDATA_TX_INTERVAL{60s};
struct TxDownloadOptions {
    const CTxMemPool& m_mempool;
    FastRandomContext& m_rng;
    const uint32_t m_max_orphan_txs;
    bool m_deterministic_txrequest{false};
};
struct TxDownloadConnectionInfo {
    const bool m_preferred;
    const bool m_relay_permissions;
    const bool m_wtxid_relay;
};
struct PackageToValidate {
    Package m_txns;
    std::vector<NodeId> m_senders;
    explicit PackageToValidate(const CTransactionRef& parent,
                               const CTransactionRef& child,
                               NodeId parent_sender,
                               NodeId child_sender) :
        m_txns{parent, child},
        m_senders{parent_sender, child_sender}
    {}
 
    // Move ctor
    PackageToValidate(PackageToValidate&& other) : m_txns{std::move(other.m_txns)}, m_senders{std::move(other.m_senders)} {}
    // Copy ctor
    PackageToValidate(const PackageToValidate& other) = default;
 
    // Move assignment
    PackageToValidate& operator=(PackageToValidate&& other) {
        this->m_txns = std::move(other.m_txns);
        this->m_senders = std::move(other.m_senders);
        return *this;
    }
 
    std::string ToString() const {
        Assume(m_txns.size() == 2);
        return strprintf("parent %s (wtxid=%s, sender=%d) + child %s (wtxid=%s, sender=%d)",
                         m_txns.front()->GetHash().ToString(),
                         m_txns.front()->GetWitnessHash().ToString(),
                         m_senders.front(),
                         m_txns.back()->GetHash().ToString(),
                         m_txns.back()->GetWitnessHash().ToString(),
                         m_senders.back());
    }
};
struct RejectedTxTodo
{
    bool m_should_add_extra_compact_tx;
    std::vector<uint256> m_unique_parents;
    std::optional<PackageToValidate> m_package_to_validate;
};
 
 
class TxDownloadManager {
    const std::unique_ptr<TxDownloadManagerImpl> m_impl;
 
public:
    explicit TxDownloadManager(const TxDownloadOptions& options);
    ~TxDownloadManager();
 
    // Responses to chain events. TxDownloadManager is not an actual client of ValidationInterface, these are called through PeerManager.
    void ActiveTipChange();
    void BlockConnected(const std::shared_ptr<const CBlock>& pblock);
    void BlockDisconnected();
 
    void ConnectedPeer(NodeId nodeid, const TxDownloadConnectionInfo& info);
 
    void DisconnectedPeer(NodeId nodeid);
 
    bool AddTxAnnouncement(NodeId peer, const GenTxid& gtxid, std::chrono::microseconds now, bool p2p_inv);
 
    std::vector<GenTxid> GetRequestsToSend(NodeId nodeid, std::chrono::microseconds current_time);
 
    void ReceivedNotFound(NodeId nodeid, const std::vector<uint256>& txhashes);
 
    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) const;
 
    CTransactionRef GetTxToReconsider(NodeId nodeid);
 
    void CheckIsEmpty() const;
 
    void CheckIsEmpty(NodeId nodeid) const;
 
    std::vector<TxOrphanage::OrphanTxBase> GetOrphanTransactions() const;
};
} // namespace node
#endif // BITCOIN_NODE_TXDOWNLOADMAN_H