net_processing.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-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_NET_PROCESSING_H
#define BITCOIN_NET_PROCESSING_H
 
#include <consensus/amount.h>
#include <net.h>
#include <node/txorphanage.h>
#include <node/types.h>
#include <private_broadcast.h>
#include <protocol.h>
#include <uint256.h>
#include <util/expected.h>
#include <validationinterface.h>
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
class AddrMan;
class CTxMemPool;
class ChainstateManager;
class BanMan;
class CBlockIndex;
class CScheduler;
class DataStream;
class uint256;
 
namespace node {
class Warnings;
} // namespace node
 
static constexpr bool DEFAULT_TXRECONCILIATION_ENABLE{false};
static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN{100};
static constexpr unsigned int DEFAULT_TX_SEND_RATE{14};
static const bool DEFAULT_PEERBLOOMFILTERS = false;
static const bool DEFAULT_PEERBLOCKFILTERS = false;
static const unsigned int MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK = 3;
static const unsigned int MAX_HEADERS_RESULTS = 2000;
static constexpr uint64_t CMPCTBLOCKS_VERSION{2};
 
struct CNodeStateStats {
    int nSyncHeight = -1;
    int nCommonHeight = -1;
    NodeClock::duration m_ping_wait;
    std::vector<int> vHeightInFlight;
    bool m_relay_txs;
    int m_inv_to_send = 0;
    uint64_t m_last_inv_seq{0};
    CAmount m_fee_filter_received;
    uint64_t m_addr_processed = 0;
    uint64_t m_addr_rate_limited = 0;
    bool m_addr_relay_enabled{false};
    ServiceFlags their_services;
    int64_t presync_height{-1};
    std::chrono::seconds time_offset{0};
};
 
struct PeerManagerInfo {
    struct InvBucketInfo {
        size_t backlog_count{0};
        double count_bucket{0};
        double size_bucket{0};
    };
 
    std::chrono::seconds median_outbound_time_offset{0s};
    bool ignores_incoming_txs{false};
    bool private_broadcast{DEFAULT_PRIVATE_BROADCAST};
    unsigned int tx_send_rate{0};
    InvBucketInfo inbound_bucket;
    InvBucketInfo outbound_bucket;
};
 
class PeerManager : public CValidationInterface, public NetEventsInterface
{
public:
    struct Options {
        bool ignore_incoming_txs{DEFAULT_BLOCKSONLY};
        bool reconcile_txs{DEFAULT_TXRECONCILIATION_ENABLE};
        uint32_t max_extra_txs{DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN};
        bool capture_messages{false};
        bool deterministic_rng{false};
        uint32_t max_headers_result{MAX_HEADERS_RESULTS};
        bool private_broadcast{DEFAULT_PRIVATE_BROADCAST};
        unsigned int tx_send_rate{DEFAULT_TX_SEND_RATE};
    };
 
    static std::unique_ptr<PeerManager> make(CConnman& connman, AddrMan& addrman,
                                             BanMan* banman, ChainstateManager& chainman,
                                             CTxMemPool& pool, node::Warnings& warnings, Options opts);
    virtual ~PeerManager() = default;
 
    virtual util::Expected<void, std::string> FetchBlock(NodeId peer_id, const CBlockIndex& block_index) = 0;
 
    virtual void StartScheduledTasks(CScheduler& scheduler) = 0;
 
    virtual bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const = 0;
 
    virtual std::vector<node::TxOrphanage::OrphanInfo> GetOrphanTransactions() = 0;
 
    virtual PeerManagerInfo GetInfo() const = 0;
 
    virtual std::vector<PrivateBroadcast::TxBroadcastInfo> GetPrivateBroadcastInfo() const = 0;
 
    virtual std::vector<CTransactionRef> AbortPrivateBroadcast(const uint256& id) = 0;
 
    virtual void InitiateTxBroadcastToAll(const Wtxid& wtxid) = 0;
 
    [[nodiscard]] virtual node::TransactionError InitiateTxBroadcastPrivate(const CTransactionRef& tx) = 0;
 
    virtual void SendPings() = 0;
 
    virtual void SetBestBlock(int height, std::chrono::seconds time) = 0;
 
    /* Public for unit testing. */
    virtual void UnitTestMisbehaving(NodeId peer_id) = 0;
 
    virtual void CheckForStaleTipAndEvictPeers() = 0;
 
    virtual void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds) = 0;
 
    virtual ServiceFlags GetDesirableServiceFlags(ServiceFlags services) const = 0;
};
 
#endif // BITCOIN_NET_PROCESSING_H