#include <net_processing.h>

#include <addrman.h>

#include <arith_uint256.h>

#include <banman.h>

#include <blockencodings.h>

#include <blockfilter.h>

#include <chain.h>

#include <chainparams.h>

#include <common/bloom.h>

#include <consensus/amount.h>

#include <consensus/params.h>

#include <consensus/validation.h>

#include <core_memusage.h>

#include <crypto/siphash.h>

#include <deploymentstatus.h>

#include <flatfile.h>

#include <headerssync.h>

#include <index/blockfilterindex.h>

#include <kernel/types.h>

#include <logging.h>

#include <merkleblock.h>

#include <net.h>

#include <net_permissions.h>

#include <netaddress.h>

#include <netbase.h>

#include <netmessagemaker.h>

#include <node/blockstorage.h>

#include <node/connection_types.h>

#include <node/protocol_version.h>

#include <node/timeoffsets.h>

#include <node/txdownloadman.h>

#include <node/txorphanage.h>

#include <node/txreconciliation.h>

#include <node/warnings.h>

#include <policy/feerate.h>

#include <policy/fees/block_policy_estimator.h>

#include <policy/packages.h>

#include <policy/policy.h>

#include <primitives/block.h>

#include <primitives/transaction.h>

#include <private_broadcast.h>

#include <protocol.h>

#include <random.h>

#include <scheduler.h>

#include <script/script.h>

#include <serialize.h>

#include <span.h>

#include <streams.h>

#include <sync.h>

#include <tinyformat.h>

#include <txmempool.h>

#include <uint256.h>

#include <util/check.h>

#include <util/strencodings.h>

#include <util/time.h>

#include <util/trace.h>

#include <validation.h>

#include <algorithm>

#include <array>

#include <atomic>

#include <compare>

#include <cstddef>

#include <deque>

#include <exception>

#include <functional>

#include <future>

#include <initializer_list>

#include <iterator>

#include <limits>

#include <list>

#include <map>

#include <memory>

#include <optional>

#include <queue>

#include <ranges>

#include <ratio>

#include <set>

#include <span>

#include <typeinfo>

#include <utility>

using kernel::ChainstateRole;

using namespace util::hex_literals;

TRACEPOINT_SEMAPHORE(net, inbound_message);

TRACEPOINT_SEMAPHORE(net, misbehaving_connection);

static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_BASE = 15min;

static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER = 1ms;

static constexpr auto HEADERS_RESPONSE_TIME{2min};

static constexpr int32_t MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT = 4;

static constexpr auto CHAIN_SYNC_TIMEOUT{20min};

static constexpr auto STALE_CHECK_INTERVAL{10min};

static constexpr auto EXTRA_PEER_CHECK_INTERVAL{45s};

static constexpr auto MINIMUM_CONNECT_TIME{30s};

static constexpr uint64_t RANDOMIZER_ID_ADDRESS_RELAY = 0x3cac0035b5866b90ULL;

static constexpr int STALE_RELAY_AGE_LIMIT = 30 * 24 * 60 * 60;

static constexpr int HISTORICAL_BLOCK_AGE = 7 * 24 * 60 * 60;

static constexpr auto PING_INTERVAL{2min};

static const unsigned int MAX_LOCATOR_SZ = 101;

static const unsigned int MAX_INV_SZ = 50000;

static const unsigned int MAX_GETDATA_SZ = 1000;

static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;

static constexpr auto BLOCK_STALLING_TIMEOUT_DEFAULT{2s};

static constexpr auto BLOCK_STALLING_TIMEOUT_MAX{64s};

static const int MAX_CMPCTBLOCK_DEPTH = 5;

static const int MAX_BLOCKTXN_DEPTH = 10;

static_assert(MAX_BLOCKTXN_DEPTH <= MIN_BLOCKS_TO_KEEP, "MAX_BLOCKTXN_DEPTH too high");

static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;

static constexpr double BLOCK_DOWNLOAD_TIMEOUT_BASE = 1;

static constexpr double BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 0.5;

static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;

static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288;

static const unsigned int NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS = 144;

static constexpr auto AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL{24h};

static constexpr auto AVG_ADDRESS_BROADCAST_INTERVAL{30s};

static constexpr auto ROTATE_ADDR_RELAY_DEST_INTERVAL{24h};

static constexpr auto INBOUND_INVENTORY_BROADCAST_INTERVAL{5s};

static constexpr auto OUTBOUND_INVENTORY_BROADCAST_INTERVAL{2s};

static constexpr unsigned int INVENTORY_BROADCAST_PER_SECOND{14};

static constexpr unsigned int INVENTORY_BROADCAST_TARGET = INVENTORY_BROADCAST_PER_SECOND * count_seconds(INBOUND_INVENTORY_BROADCAST_INTERVAL);

static constexpr unsigned int INVENTORY_BROADCAST_MAX = 1000;

static_assert(INVENTORY_BROADCAST_MAX >= INVENTORY_BROADCAST_TARGET, "INVENTORY_BROADCAST_MAX too low");

static_assert(INVENTORY_BROADCAST_MAX <= node::MAX_PEER_TX_ANNOUNCEMENTS, "INVENTORY_BROADCAST_MAX too high");

static constexpr auto AVG_FEEFILTER_BROADCAST_INTERVAL{10min};

static constexpr auto MAX_FEEFILTER_CHANGE_DELAY{5min};

static constexpr uint32_t MAX_GETCFILTERS_SIZE = 1000;

static constexpr uint32_t MAX_GETCFHEADERS_SIZE = 2000;

static constexpr size_t MAX_PCT_ADDR_TO_SEND = 23;

static constexpr size_t MAX_ADDR_TO_SEND{1000};

static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};

static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};

static constexpr uint64_t CMPCTBLOCKS_VERSION{2};

static constexpr size_t NUM_PRIVATE_BROADCAST_PER_TX{3};

static constexpr auto PRIVATE_BROADCAST_MAX_CONNECTION_LIFETIME{3min};

namespace {

struct QueuedBlock {

/** BlockIndex. We must have this since we only request blocks when we've already validated the header. */

const CBlockIndex* pindex;

/** Optional, used for CMPCTBLOCK downloads */

std::unique_ptr<PartiallyDownloadedBlock> partialBlock;

};

struct Peer {

/** Same id as the CNode object for this peer */

const NodeId m_id{0};

/** Services we offered to this peer.

const ServiceFlags m_our_services;

/** Services this peer offered to us. */

std::atomic<ServiceFlags> m_their_services{NODE_NONE};

//! Whether this peer is an inbound connection

const bool m_is_inbound;

/** Protects misbehavior data members */

Mutex m_misbehavior_mutex;

/** Whether this peer should be disconnected and marked as discouraged (unless it has NetPermissionFlags::NoBan permission). */

bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};

/** Protects block inventory data members */

Mutex m_block_inv_mutex;

/** List of blocks that we'll announce via an `inv` message.

std::vector<uint256> m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex);

/** Unfiltered list of blocks that we'd like to announce via a `headers`

std::vector<uint256> m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex);

/** The final block hash that we sent in an `inv` message to this peer.

uint256 m_continuation_block GUARDED_BY(m_block_inv_mutex) {};

/** Set to true once initial VERSION message was sent (only relevant for outbound peers). */

bool m_outbound_version_message_sent GUARDED_BY(NetEventsInterface::g_msgproc_mutex){false};

/** The pong reply we're expecting, or 0 if no pong expected. */

std::atomic<uint64_t> m_ping_nonce_sent{0};

/** When the last ping was sent, or 0 if no ping was ever sent */

std::atomic<std::chrono::microseconds> m_ping_start{0us};

/** Whether a ping has been requested by the user */

std::atomic<bool> m_ping_queued{false};

/** Whether this peer relays txs via wtxid */

std::atomic<bool> m_wtxid_relay{false};

/** The feerate in the most recent BIP133 `feefilter` message sent to the peer.

CAmount m_fee_filter_sent GUARDED_BY(NetEventsInterface::g_msgproc_mutex){0};

/** Timestamp after which we will send the next BIP133 `feefilter` message

std::chrono::microseconds m_next_send_feefilter GUARDED_BY(NetEventsInterface::g_msgproc_mutex){0};

struct TxRelay {

mutable RecursiveMutex m_bloom_filter_mutex;

/** Whether we relay transactions to this peer. */

bool m_relay_txs GUARDED_BY(m_bloom_filter_mutex){false};

/** A bloom filter for which transactions to announce to the peer. See BIP37. */

std::unique_ptr<CBloomFilter> m_bloom_filter PT_GUARDED_BY(m_bloom_filter_mutex) GUARDED_BY(m_bloom_filter_mutex){nullptr};

mutable RecursiveMutex m_tx_inventory_mutex;

/** A filter of all the (w)txids that the peer has announced to

CRollingBloomFilter m_tx_inventory_known_filter GUARDED_BY(m_tx_inventory_mutex){50000, 0.000001};

/** Set of wtxids we still have to announce. For non-wtxid-relay peers,

std::set<Wtxid> m_tx_inventory_to_send GUARDED_BY(m_tx_inventory_mutex);

/** Whether the peer has requested us to send our complete mempool. Only

bool m_send_mempool GUARDED_BY(m_tx_inventory_mutex){false};

/** The next time after which we will send an `inv` message containing

std::chrono::microseconds m_next_inv_send_time GUARDED_BY(m_tx_inventory_mutex){0};

/** The mempool sequence num at which we sent the last `inv` message to this peer.

uint64_t m_last_inv_sequence GUARDED_BY(m_tx_inventory_mutex){1};

/** Minimum fee rate with which to filter transaction announcements to this node. See BIP133. */

std::atomic<CAmount> m_fee_filter_received{0};

};

/* Initializes a TxRelay struct for this peer. Can be called at most once for a peer. */

TxRelay* SetTxRelay() EXCLUSIVE_LOCKS_REQUIRED(!m_tx_relay_mutex)

{

LOCK(m_tx_relay_mutex);

Assume(!m_tx_relay);

m_tx_relay = std::make_unique<Peer::TxRelay>();

return m_tx_relay.get();

};

TxRelay* GetTxRelay() EXCLUSIVE_LOCKS_REQUIRED(!m_tx_relay_mutex)

{

return WITH_LOCK(m_tx_relay_mutex, return m_tx_relay.get());

};

/** A vector of addresses to send to the peer, limited to MAX_ADDR_TO_SEND. */

std::vector<CAddress> m_addrs_to_send GUARDED_BY(NetEventsInterface::g_msgproc_mutex);

/** Probabilistic filter to track recent addr messages relayed with this

std::unique_ptr<CRollingBloomFilter> m_addr_known GUARDED_BY(NetEventsInterface::g_msgproc_mutex);

/** Whether we are participating in address relay with this connection.

std::atomic_bool m_addr_relay_enabled{false};

/** Whether a getaddr request to this peer is outstanding. */

bool m_getaddr_sent GUARDED_BY(NetEventsInterface::g_msgproc_mutex){false};

/** Guards address sending timers. */

mutable Mutex m_addr_send_times_mutex;

/** Time point to send the next ADDR message to this peer. */

std::chrono::microseconds m_next_addr_send GUARDED_BY(m_addr_send_times_mutex){0};

/** Time point to possibly re-announce our local address to this peer. */

std::chrono::microseconds m_next_local_addr_send GUARDED_BY(m_addr_send_times_mutex){0};

/** Whether the peer has signaled support for receiving ADDRv2 (BIP155)

std::atomic_bool m_wants_addrv2{false};

/** Whether this peer has already sent us a getaddr message. */

bool m_getaddr_recvd GUARDED_BY(NetEventsInterface::g_msgproc_mutex){false};

/** Number of addresses that can be processed from this peer. Start at 1 to

double m_addr_token_bucket GUARDED_BY(NetEventsInterface::g_msgproc_mutex){1.0};

/** When m_addr_token_bucket was last updated */

NodeClock::time_point m_addr_token_timestamp GUARDED_BY(NetEventsInterface::g_msgproc_mutex){NodeClock::now()};

/** Total number of addresses that were dropped due to rate limiting. */

std::atomic<uint64_t> m_addr_rate_limited{0};

/** Total number of addresses that were processed (excludes rate-limited ones). */

std::atomic<uint64_t> m_addr_processed{0};

/** Whether we've sent this peer a getheaders in response to an inv prior to initial-headers-sync completing */

bool m_inv_triggered_getheaders_before_sync GUARDED_BY(NetEventsInterface::g_msgproc_mutex){false};

/** Protects m_getdata_requests **/

Mutex m_getdata_requests_mutex;

/** Work queue of items requested by this peer **/

std::deque<CInv> m_getdata_requests GUARDED_BY(m_getdata_requests_mutex);

/** Time of the last getheaders message to this peer */

NodeClock::time_point m_last_getheaders_timestamp GUARDED_BY(NetEventsInterface::g_msgproc_mutex){};

/** Protects m_headers_sync **/

Mutex m_headers_sync_mutex;

/** Headers-sync state for this peer (eg for initial sync, or syncing large

std::unique_ptr<HeadersSyncState> m_headers_sync PT_GUARDED_BY(m_headers_sync_mutex) GUARDED_BY(m_headers_sync_mutex) {};

/** Whether we've sent our peer a sendheaders message. **/

std::atomic<bool> m_sent_sendheaders{false};

/** When to potentially disconnect peer for stalling headers download */

std::chrono::microseconds m_headers_sync_timeout GUARDED_BY(NetEventsInterface::g_msgproc_mutex){0us};

/** Whether this peer wants invs or headers (when possible) for block announcements */

bool m_prefers_headers GUARDED_BY(NetEventsInterface::g_msgproc_mutex){false};

/** Time offset computed during the version handshake based on the

std::atomic<std::chrono::seconds> m_time_offset{0s};

explicit Peer(NodeId id, ServiceFlags our_services, bool is_inbound)

: m_id{id}

, m_our_services{our_services}

, m_is_inbound{is_inbound}

{}

mutable Mutex m_tx_relay_mutex;

/** Transaction relay data. May be a nullptr. */

std::unique_ptr<TxRelay> m_tx_relay GUARDED_BY(m_tx_relay_mutex);

};

using PeerRef = std::shared_ptr<Peer>;

struct CNodeState {

//! The best known block we know this peer has announced.

const CBlockIndex* pindexBestKnownBlock{nullptr};

//! The hash of the last unknown block this peer has announced.

uint256 hashLastUnknownBlock{};

//! The last full block we both have.

const CBlockIndex* pindexLastCommonBlock{nullptr};

//! The best header we have sent our peer.

const CBlockIndex* pindexBestHeaderSent{nullptr};

//! Whether we've started headers synchronization with this peer.

bool fSyncStarted{false};

//! Since when we're stalling block download progress (in microseconds), or 0.

std::chrono::microseconds m_stalling_since{0us};

std::list<QueuedBlock> vBlocksInFlight;

//! When the first entry in vBlocksInFlight started downloading. Don't care when vBlocksInFlight is empty.

std::chrono::microseconds m_downloading_since{0us};

//! Whether we consider this a preferred download peer.

bool fPreferredDownload{false};

/** Whether this peer wants invs or cmpctblocks (when possible) for block announcements. */

bool m_requested_hb_cmpctblocks{false};

/** Whether this peer will send us cmpctblocks if we request them. */

bool m_provides_cmpctblocks{false};

/** State used to enforce CHAIN_SYNC_TIMEOUT and EXTRA_PEER_CHECK_INTERVAL logic.

struct ChainSyncTimeoutState {

//! A timeout used for checking whether our peer has sufficiently synced

std::chrono::seconds m_timeout{0s};

//! A header with the work we require on our peer's chain

const CBlockIndex* m_work_header{nullptr};

//! After timeout is reached, set to true after sending getheaders

bool m_sent_getheaders{false};

//! Whether this peer is protected from disconnection due to a bad/slow chain

bool m_protect{false};

};

ChainSyncTimeoutState m_chain_sync;

//! Time of last new block announcement

int64_t m_last_block_announcement{0};

};

class PeerManagerImpl final : public PeerManager

{

PeerManagerImpl(CConnman& connman, AddrMan& addrman,

BanMan* banman, ChainstateManager& chainman,

CTxMemPool& pool, node::Warnings& warnings, Options opts);

/** Overridden from CValidationInterface. */

void ActiveTipChange(const CBlockIndex& new_tip, bool) override

EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);

void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override

EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);

void BlockDisconnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex* pindex) override

EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);

void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& state) override

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) override

EXCLUSIVE_LOCKS_REQUIRED(!m_most_recent_block_mutex);

/** Implement NetEventsInterface */

void InitializeNode(const CNode& node, ServiceFlags our_services) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_tx_download_mutex);

void FinalizeNode(const CNode& node) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_headers_presync_mutex, !m_tx_download_mutex);

bool HasAllDesirableServiceFlags(ServiceFlags services) const override;

bool ProcessMessages(CNode& node, std::atomic<bool>& interrupt) override

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_most_recent_block_mutex, !m_headers_presync_mutex, g_msgproc_mutex, !m_tx_download_mutex);

bool SendMessages(CNode& node) override

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_most_recent_block_mutex, g_msgproc_mutex, !m_tx_download_mutex);

/** Implement PeerManager */

void StartScheduledTasks(CScheduler& scheduler) override;

void CheckForStaleTipAndEvictPeers() override;

util::Expected<void, std::string> FetchBlock(NodeId peer_id, const CBlockIndex& block_index) override

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

std::vector<node::TxOrphanage::OrphanInfo> GetOrphanTransactions() override EXCLUSIVE_LOCKS_REQUIRED(!m_tx_download_mutex);

PeerManagerInfo GetInfo() const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

std::vector<PrivateBroadcast::TxBroadcastInfo> GetPrivateBroadcastInfo() const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

std::vector<CTransactionRef> AbortPrivateBroadcast(const uint256& id) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

void SendPings() override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

void InitiateTxBroadcastToAll(const Txid& txid, const Wtxid& wtxid) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

void InitiateTxBroadcastPrivate(const CTransactionRef& tx) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

void SetBestBlock(int height, std::chrono::seconds time) override

{

m_best_height = height;

m_best_block_time = time;

};

void UnitTestMisbehaving(NodeId peer_id) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex) { Misbehaving(*Assert(GetPeerRef(peer_id)), ""); };

void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds) override;

ServiceFlags GetDesirableServiceFlags(ServiceFlags services) const override;

void ProcessMessage(Peer& peer, CNode& pfrom, const std::string& msg_type, DataStream& vRecv, std::chrono::microseconds time_received,

const std::atomic<bool>& interruptMsgProc)

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_most_recent_block_mutex, !m_headers_presync_mutex, g_msgproc_mutex, !m_tx_download_mutex);

/** Consider evicting an outbound peer based on the amount of time they've been behind our tip */

void ConsiderEviction(CNode& pto, Peer& peer, std::chrono::seconds time_in_seconds) EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_msgproc_mutex);

/** If we have extra outbound peers, try to disconnect the one with the oldest block announcement */

void EvictExtraOutboundPeers(std::chrono::seconds now) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/** Retrieve unbroadcast transactions from the mempool and reattempt sending to peers */

void ReattemptInitialBroadcast(CScheduler& scheduler) EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

/** Rebroadcast stale private transactions (already broadcast but not received back from the network). */

void ReattemptPrivateBroadcast(CScheduler& scheduler);

/** Get a shared pointer to the Peer object.

PeerRef GetPeerRef(NodeId id) const EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

/** Get a shared pointer to the Peer object and remove it from m_peer_map.

PeerRef RemovePeer(NodeId id) EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

/** Mark a peer as misbehaving, which will cause it to be disconnected and its

void Misbehaving(Peer& peer, const std::string& message);

/**

void MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,

bool via_compact_block, const std::string& message = "")

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);

/** Maybe disconnect a peer and discourage future connections from its address.

bool MaybeDiscourageAndDisconnect(CNode& pnode, Peer& peer);

/** Handle a transaction whose result was not MempoolAcceptResult::ResultType::VALID.

std::optional<node::PackageToValidate> ProcessInvalidTx(NodeId nodeid, const CTransactionRef& tx, const TxValidationState& result,

bool first_time_failure)

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, m_tx_download_mutex);

/** Handle a transaction whose result was MempoolAcceptResult::ResultType::VALID.

void ProcessValidTx(NodeId nodeid, const CTransactionRef& tx, const std::list<CTransactionRef>& replaced_transactions)

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, m_tx_download_mutex);

/** Handle the results of package validation: calls ProcessValidTx and ProcessInvalidTx for

void ProcessPackageResult(const node::PackageToValidate& package_to_validate, const PackageMempoolAcceptResult& package_result)

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, m_tx_download_mutex);

/**

bool ProcessOrphanTx(Peer& peer)

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex, !m_tx_download_mutex);

/** Process a single headers message from a peer.

void ProcessHeadersMessage(CNode& pfrom, Peer& peer,

std::vector<CBlockHeader>&& headers,

bool via_compact_block)

EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_headers_presync_mutex, g_msgproc_mutex);

/** Various helpers for headers processing, invoked by ProcessHeadersMessage() */

/** Return true if headers are continuous and have valid proof-of-work (DoS points assigned on failure) */

bool CheckHeadersPoW(const std::vector<CBlockHeader>& headers, Peer& peer);

/** Calculate an anti-DoS work threshold for headers chains */

arith_uint256 GetAntiDoSWorkThreshold();

/** Deal with state tracking and headers sync for peers that send

void HandleUnconnectingHeaders(CNode& pfrom, Peer& peer, const std::vector<CBlockHeader>& headers) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

/** Return true if the headers connect to each other, false otherwise */

bool CheckHeadersAreContinuous(const std::vector<CBlockHeader>& headers) const;

/** Try to continue a low-work headers sync that has already begun.

bool IsContinuationOfLowWorkHeadersSync(Peer& peer, CNode& pfrom,

std::vector<CBlockHeader>& headers)

EXCLUSIVE_LOCKS_REQUIRED(peer.m_headers_sync_mutex, !m_headers_presync_mutex, g_msgproc_mutex);

/** Check work on a headers chain to be processed, and if insufficient,

bool TryLowWorkHeadersSync(Peer& peer, CNode& pfrom,

const CBlockIndex& chain_start_header,

std::vector<CBlockHeader>& headers)

EXCLUSIVE_LOCKS_REQUIRED(!peer.m_headers_sync_mutex, !m_peer_mutex, !m_headers_presync_mutex, g_msgproc_mutex);

/** Return true if the given header is an ancestor of

bool IsAncestorOfBestHeaderOrTip(const CBlockIndex* header) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/** Request further headers from this peer with a given locator.

bool MaybeSendGetHeaders(CNode& pfrom, const CBlockLocator& locator, Peer& peer) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

/** Potentially fetch blocks from this peer upon receipt of a new headers tip */

void HeadersDirectFetchBlocks(CNode& pfrom, const Peer& peer, const CBlockIndex& last_header);

/** Update peer state based on received headers message */

void UpdatePeerStateForReceivedHeaders(CNode& pfrom, Peer& peer, const CBlockIndex& last_header, bool received_new_header, bool may_have_more_headers)

EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

void SendBlockTransactions(CNode& pfrom, Peer& peer, const CBlock& block, const BlockTransactionsRequest& req);

/** Send a message to a peer */

void PushMessage(CNode& node, CSerializedNetMsg&& msg) const { m_connman.PushMessage(&node, std::move(msg)); }

template <typename... Args>

void MakeAndPushMessage(CNode& node, std::string msg_type, Args&&... args) const

{

m_connman.PushMessage(&node, NetMsg::Make(std::move(msg_type), std::forward<Args>(args)...));

}

/** Send a version message to a peer */

void PushNodeVersion(CNode& pnode, const Peer& peer);

/** Send a ping message every PING_INTERVAL or if requested via RPC (peer.m_ping_queued is true).

void MaybeSendPing(CNode& node_to, Peer& peer, std::chrono::microseconds now);

/** Send `addr` messages on a regular schedule. */

void MaybeSendAddr(CNode& node, Peer& peer, std::chrono::microseconds current_time) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

/** Send a single `sendheaders` message, after we have completed headers sync with a peer. */

void MaybeSendSendHeaders(CNode& node, Peer& peer) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

/** Relay (gossip) an address to a few randomly chosen nodes.

void RelayAddress(NodeId originator, const CAddress& addr, bool fReachable) EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex);

/** Send `feefilter` message. */

void MaybeSendFeefilter(CNode& node, Peer& peer, std::chrono::microseconds current_time) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

FastRandomContext m_rng GUARDED_BY(NetEventsInterface::g_msgproc_mutex);

FeeFilterRounder m_fee_filter_rounder GUARDED_BY(NetEventsInterface::g_msgproc_mutex);

const CChainParams& m_chainparams;

CConnman& m_connman;

AddrMan& m_addrman;

/** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */

BanMan* const m_banman;

ChainstateManager& m_chainman;

CTxMemPool& m_mempool;

/** Synchronizes tx download including TxRequestTracker, rejection filters, and TxOrphanage.

Mutex m_tx_download_mutex ACQUIRED_BEFORE(m_mempool.cs);

node::TxDownloadManager m_txdownloadman GUARDED_BY(m_tx_download_mutex);

std::unique_ptr<TxReconciliationTracker> m_txreconciliation;

/** The height of the best chain */

std::atomic<int> m_best_height{-1};

/** The time of the best chain tip block */

std::atomic<std::chrono::seconds> m_best_block_time{0s};

/** Next time to check for stale tip */

std::chrono::seconds m_stale_tip_check_time GUARDED_BY(cs_main){0s};

node::Warnings& m_warnings;

TimeOffsets m_outbound_time_offsets{m_warnings};

const Options m_opts;

bool RejectIncomingTxs(const CNode& peer) const;

/** Whether we've completed initial sync yet, for determining when to turn

bool m_initial_sync_finished GUARDED_BY(cs_main){false};

/** Protects m_peer_map. This mutex must not be locked while holding a lock

mutable Mutex m_peer_mutex;

/**

std::map<NodeId, PeerRef> m_peer_map GUARDED_BY(m_peer_mutex);

/** Map maintaining per-node state. */

std::map<NodeId, CNodeState> m_node_states GUARDED_BY(cs_main);

/** Get a pointer to a const CNodeState, used when not mutating the CNodeState object. */

const CNodeState* State(NodeId pnode) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/** Get a pointer to a mutable CNodeState. */

CNodeState* State(NodeId pnode) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

uint32_t GetFetchFlags(const Peer& peer) const;

std::map<uint64_t, std::chrono::microseconds> m_next_inv_to_inbounds_per_network_key GUARDED_BY(g_msgproc_mutex);

/** Number of nodes with fSyncStarted. */

int nSyncStarted GUARDED_BY(cs_main) = 0;

/** Hash of the last block we received via INV */

uint256 m_last_block_inv_triggering_headers_sync GUARDED_BY(g_msgproc_mutex){};

/**

std::map<uint256, std::pair<NodeId, bool>> mapBlockSource GUARDED_BY(cs_main);

/** Number of peers with wtxid relay. */

std::atomic<int> m_wtxid_relay_peers{0};

/** Number of outbound peers with m_chain_sync.m_protect. */

int m_outbound_peers_with_protect_from_disconnect GUARDED_BY(cs_main) = 0;

/** Number of preferable block download peers. */

int m_num_preferred_download_peers GUARDED_BY(cs_main){0};

/** Stalling timeout for blocks in IBD */

std::atomic<std::chrono::seconds> m_block_stalling_timeout{BLOCK_STALLING_TIMEOUT_DEFAULT};

/**

std::chrono::microseconds NextInvToInbounds(std::chrono::microseconds now,

std::chrono::seconds average_interval,

uint64_t network_key) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

// All of the following cache a recent block, and are protected by m_most_recent_block_mutex

Mutex m_most_recent_block_mutex;

std::shared_ptr<const CBlock> m_most_recent_block GUARDED_BY(m_most_recent_block_mutex);

std::shared_ptr<const CBlockHeaderAndShortTxIDs> m_most_recent_compact_block GUARDED_BY(m_most_recent_block_mutex);

uint256 m_most_recent_block_hash GUARDED_BY(m_most_recent_block_mutex);

std::unique_ptr<const std::map<GenTxid, CTransactionRef>> m_most_recent_block_txs GUARDED_BY(m_most_recent_block_mutex);

// Data about the low-work headers synchronization, aggregated from all peers' HeadersSyncStates.

/** Mutex guarding the other m_headers_presync_* variables. */

Mutex m_headers_presync_mutex;

/** A type to represent statistics about a peer's low-work headers sync.

using HeadersPresyncStats = std::pair<arith_uint256, std::optional<std::pair<int64_t, uint32_t>>>;

/** Statistics for all peers in low-work headers sync. */

std::map<NodeId, HeadersPresyncStats> m_headers_presync_stats GUARDED_BY(m_headers_presync_mutex) {};

/** The peer with the most-work entry in m_headers_presync_stats. */

NodeId m_headers_presync_bestpeer GUARDED_BY(m_headers_presync_mutex) {-1};

/** The m_headers_presync_stats improved, and needs signalling. */

std::atomic_bool m_headers_presync_should_signal{false};

/** Height of the highest block announced using BIP 152 high-bandwidth mode. */

int m_highest_fast_announce GUARDED_BY(::cs_main){0};

/** Have we requested this block from a peer */

bool IsBlockRequested(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/** Have we requested this block from an outbound peer */

bool IsBlockRequestedFromOutbound(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main, !m_peer_mutex);

/** Remove this block from our tracked requested blocks. Called if:

void RemoveBlockRequest(const uint256& hash, std::optional<NodeId> from_peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/* Mark a block as in flight

bool BlockRequested(NodeId nodeid, const CBlockIndex& block, std::list<QueuedBlock>::iterator** pit = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

bool TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/** Update pindexLastCommonBlock and add not-in-flight missing successors to vBlocks, until it has

void FindNextBlocksToDownload(const Peer& peer, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, NodeId& nodeStaller) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/** Request blocks for the background chainstate, if one is in use. */

void TryDownloadingHistoricalBlocks(const Peer& peer, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, const CBlockIndex* from_tip, const CBlockIndex* target_block) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/**

void FindNextBlocks(std::vector<const CBlockIndex*>& vBlocks, const Peer& peer, CNodeState *state, const CBlockIndex *pindexWalk, unsigned int count, int nWindowEnd, const CChain* activeChain=nullptr, NodeId* nodeStaller=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/* Multimap used to preserve insertion order */

typedef std::multimap<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator>> BlockDownloadMap;

BlockDownloadMap mapBlocksInFlight GUARDED_BY(cs_main);

/** When our tip was last updated. */

std::atomic<std::chrono::seconds> m_last_tip_update{0s};

/** Determine whether or not a peer can request a transaction, and return it (or nullptr if not found or not allowed). */

CTransactionRef FindTxForGetData(const Peer::TxRelay& tx_relay, const GenTxid& gtxid)

EXCLUSIVE_LOCKS_REQUIRED(!m_most_recent_block_mutex, !tx_relay.m_tx_inventory_mutex);

void ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic<bool>& interruptMsgProc)

EXCLUSIVE_LOCKS_REQUIRED(!m_most_recent_block_mutex, peer.m_getdata_requests_mutex, NetEventsInterface::g_msgproc_mutex)

LOCKS_EXCLUDED(::cs_main);

/** Process a new block. Perform any post-processing housekeeping */

void ProcessBlock(CNode& node, const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked);

/** Process compact block txns */

void ProcessCompactBlockTxns(CNode& pfrom, Peer& peer, const BlockTransactions& block_transactions)

EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex, !m_most_recent_block_mutex);

/**

void PushPrivateBroadcastTx(CNode& node) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex, !m_most_recent_block_mutex);

/**

void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid) EXCLUSIVE_LOCKS_REQUIRED(cs_main, !m_peer_mutex);

/** Stack of nodes which we have set to announce using compact blocks */

std::list<NodeId> lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main);

/** Number of peers from which we're downloading blocks. */

int m_peers_downloading_from GUARDED_BY(cs_main) = 0;

void AddToCompactExtraTransactions(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);

/** Orphan/conflicted/etc transactions that are kept for compact block reconstruction.

std::vector<std::pair<Wtxid, CTransactionRef>> vExtraTxnForCompact GUARDED_BY(g_msgproc_mutex);

/** Offset into vExtraTxnForCompact to insert the next tx */

size_t vExtraTxnForCompactIt GUARDED_BY(g_msgproc_mutex) = 0;