net_processing.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 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 <avalanche/avalanche.h>
#include <net.h>
#include <sync.h>
#include <validationinterface.h>
 
namespace avalanche {
struct ProofId;
class Processor;
} // namespace avalanche
 
class AddrMan;
class CTxMemPool;
class ChainstateManager;
class Config;
 
static const uint32_t DEFAULT_MAX_ORPHAN_TRANSACTIONS{100};
static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN{100};
static const bool DEFAULT_PEERBLOCKFILTERS = false;
static const int DISCOURAGEMENT_THRESHOLD{100};
static constexpr size_t MAX_ADDR_TO_SEND{1000};
 
static const unsigned int MAX_HEADERS_RESULTS = 2000;
 
struct CNodeStateStats {
    int nSyncHeight = -1;
    int nCommonHeight = -1;
    int m_starting_height = -1;
    std::chrono::microseconds m_ping_wait;
    std::vector<int> vHeightInFlight;
    bool m_relay_txs;
    Amount 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};
};
 
class PeerManager : public CValidationInterface, public NetEventsInterface {
public:
    struct Options {
        bool ignore_incoming_txs{DEFAULT_BLOCKSONLY};
        uint32_t max_orphan_txs{DEFAULT_MAX_ORPHAN_TRANSACTIONS};
        uint32_t max_extra_txs{DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN};
        bool capture_messages{false};
        size_t max_addr_to_send{MAX_ADDR_TO_SEND};
 
        int64_t avalanche_cooldown{AVALANCHE_DEFAULT_COOLDOWN};
        int64_t avalanche_peer_replacement_cooldown{
            AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN};
        bool avalanche_preconsensus{DEFAULT_AVALANCHE_PRECONSENSUS};
 
        bool deterministic_rng{false};
    };
 
    static std::unique_ptr<PeerManager>
    make(CConnman &connman, AddrMan &addrman, BanMan *banman,
         ChainstateManager &chainman, CTxMemPool &pool,
         avalanche::Processor *const avalanche, Options opts);
    virtual ~PeerManager() {}
 
    virtual std::optional<std::string>
    FetchBlock(const Config &config, NodeId peer_id,
               const CBlockIndex &block_index) = 0;
 
    virtual void StartScheduledTasks(CScheduler &scheduler) = 0;
 
    virtual bool GetNodeStateStats(NodeId nodeid,
                                   CNodeStateStats &stats) const = 0;
 
    virtual bool IgnoresIncomingTxs() = 0;
 
    virtual void RelayTransaction(const TxId &txid) = 0;
 
    virtual void RelayProof(const avalanche::ProofId &proofid) = 0;
 
    virtual void SendPings() = 0;
 
    virtual void SetBestHeight(int height) = 0;
 
    virtual void UnitTestMisbehaving(const NodeId peer_id,
                                     const int howmuch) = 0;
 
    virtual void CheckForStaleTipAndEvictPeers() = 0;
 
    virtual void ProcessMessage(const Config &config, CNode &pfrom,
                                const std::string &msg_type, CDataStream &vRecv,
                                const std::chrono::microseconds time_received,
                                const std::atomic<bool> &interruptMsgProc)
        EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex) = 0;
 
    virtual void UpdateLastBlockAnnounceTime(NodeId node,
                                             int64_t time_in_seconds) = 0;
};
 
#endif // BITCOIN_NET_PROCESSING_H