AddedNodeParams m_params;

CService resolvedAddress;

bool fConnected;

bool fInbound;

CSerializedNetMsg() = default;

CSerializedNetMsg(CSerializedNetMsg&&) = default;

CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default;

// No implicit copying, only moves.

CSerializedNetMsg(const CSerializedNetMsg& msg) = delete;

CSerializedNetMsg& operator=(const CSerializedNetMsg&) = delete;

CSerializedNetMsg Copy() const

{

CSerializedNetMsg copy;

copy.data = data;

copy.m_type = m_type;

return copy;

}

std::vector<unsigned char> data;

std::string m_type;

/** Compute total memory usage of this object (own memory + any dynamic memory). */

size_t GetMemoryUsage() const noexcept;

{

NodeId nodeid;

NodeClock::time_point m_last_send;

NodeClock::time_point m_last_recv;

std::chrono::seconds m_last_tx_time;

std::chrono::seconds m_last_block_time;

NodeClock::time_point m_connected;

std::string m_addr_name;

int nVersion;

std::string cleanSubVer;

bool fInbound;

// We requested high bandwidth connection to peer

bool m_bip152_highbandwidth_to;

// Peer requested high bandwidth connection

bool m_bip152_highbandwidth_from;

uint64_t nSendBytes;

mapMsgTypeSize mapSendBytesPerMsgType;

uint64_t nRecvBytes;

mapMsgTypeSize mapRecvBytesPerMsgType;

NetPermissionFlags m_permission_flags;

NodeClock::duration m_last_ping_time;

NodeClock::duration m_min_ping_time;

// Our address, as reported by the peer

std::string addrLocal;

// Address of this peer

CAddress addr;

// Bind address of our side of the connection

CService addrBind;

// Network the peer connected through

Network m_network;

uint32_t m_mapped_as;

ConnectionType m_conn_type;

/** Transport protocol type. */

TransportProtocolType m_transport_type;

/** BIP324 session id string in hex, if any. */

std::string m_session_id;

{

DataStream m_recv; //!< received message data

/// time of message receipt

NodeClock::time_point m_time{NodeClock::epoch};

uint32_t m_message_size{0}; //!< size of the payload

uint32_t m_raw_message_size{0}; //!< used wire size of the message (including header/checksum)

std::string m_type;

explicit CNetMessage(DataStream&& recv_in) : m_recv(std::move(recv_in)) {}

// Only one CNetMessage object will exist for the same message on either

// the receive or processing queue. For performance reasons we therefore

// delete the copy constructor and assignment operator to avoid the

// possibility of copying CNetMessage objects.

CNetMessage(CNetMessage&&) = default;

CNetMessage(const CNetMessage&) = delete;

CNetMessage& operator=(CNetMessage&&) = default;

CNetMessage& operator=(const CNetMessage&) = delete;

/** Compute total memory usage of this object (own memory + any dynamic memory). */

size_t GetMemoryUsage() const noexcept;

virtual ~Transport() = default;

struct Info

{

TransportProtocolType transport_type;

std::optional<uint256> session_id;

};

/** Retrieve information about this transport. */

virtual Info GetInfo() const noexcept = 0;

// 1. Receiver side functions, for decoding bytes received on the wire into transport protocol

// agnostic CNetMessage (message type & payload) objects.

/** Returns true if the current message is complete (so GetReceivedMessage can be called). */

virtual bool ReceivedMessageComplete() const = 0;

/** Feed wire bytes to the transport.

virtual bool ReceivedBytes(std::span<const uint8_t>& msg_bytes) = 0;

/** Retrieve a completed message from transport.

virtual CNetMessage GetReceivedMessage(NodeClock::time_point time, bool& reject_message) = 0;

// 2. Sending side functions, for converting messages into bytes to be sent over the wire.

/** Set the next message to send.

virtual bool SetMessageToSend(CSerializedNetMsg& msg) noexcept = 0;

/** Return type for GetBytesToSend, consisting of:

using BytesToSend = std::tuple<

std::span<const uint8_t> /*to_send*/,

bool /*more*/,

const std::string& /*m_type*/

>;

/** Get bytes to send on the wire, if any, along with other information about it.

virtual BytesToSend GetBytesToSend(bool have_next_message) const noexcept = 0;

/** Report how many bytes returned by the last GetBytesToSend() have been sent.

virtual void MarkBytesSent(size_t bytes_sent) noexcept = 0;

/** Return the memory usage of this transport attributable to buffered data to send. */

virtual size_t GetSendMemoryUsage() const noexcept = 0;

// 3. Miscellaneous functions.

/** Whether upon disconnections, a reconnect with V1 is warranted. */

virtual bool ShouldReconnectV1() const noexcept = 0;

{

const MessageStartChars m_magic_bytes;

const NodeId m_node_id; // Only for logging

mutable Mutex m_recv_mutex; //!< Lock for receive state

mutable CHash256 hasher GUARDED_BY(m_recv_mutex);

mutable uint256 data_hash GUARDED_BY(m_recv_mutex);

bool in_data GUARDED_BY(m_recv_mutex); // parsing header (false) or data (true)

DataStream hdrbuf GUARDED_BY(m_recv_mutex){}; // partially received header

CMessageHeader hdr GUARDED_BY(m_recv_mutex); // complete header

DataStream vRecv GUARDED_BY(m_recv_mutex){}; // received message data

unsigned int nHdrPos GUARDED_BY(m_recv_mutex);

unsigned int nDataPos GUARDED_BY(m_recv_mutex);

const uint256& GetMessageHash() const EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

int readHeader(std::span<const uint8_t> msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

int readData(std::span<const uint8_t> msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

void Reset() EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex) {

AssertLockHeld(m_recv_mutex);

vRecv.clear();

hdrbuf.clear();

hdrbuf.resize(24);

in_data = false;

nHdrPos = 0;

nDataPos = 0;

data_hash.SetNull();

hasher.Reset();

}

bool CompleteInternal() const noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)

{

AssertLockHeld(m_recv_mutex);

if (!in_data) return false;

return hdr.nMessageSize == nDataPos;

}

/** Lock for sending state. */

mutable Mutex m_send_mutex;

/** The header of the message currently being sent. */

std::vector<uint8_t> m_header_to_send GUARDED_BY(m_send_mutex);

/** The data of the message currently being sent. */

CSerializedNetMsg m_message_to_send GUARDED_BY(m_send_mutex);

/** Whether we're currently sending header bytes or message bytes. */

bool m_sending_header GUARDED_BY(m_send_mutex) {false};

/** How many bytes have been sent so far (from m_header_to_send, or from m_message_to_send.data). */

size_t m_bytes_sent GUARDED_BY(m_send_mutex) {0};

explicit V1Transport(NodeId node_id) noexcept;

bool ReceivedMessageComplete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)

{

AssertLockNotHeld(m_recv_mutex);

return WITH_LOCK(m_recv_mutex, return CompleteInternal());

}

Info GetInfo() const noexcept override;

bool ReceivedBytes(std::span<const uint8_t>& msg_bytes) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)

{

AssertLockNotHeld(m_recv_mutex);

LOCK(m_recv_mutex);

int ret = in_data ? readData(msg_bytes) : readHeader(msg_bytes);

if (ret < 0) {

Reset();

} else {

msg_bytes = msg_bytes.subspan(ret);

}

return ret >= 0;

}

CNetMessage GetReceivedMessage(NodeClock::time_point time, bool& reject_message) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);

bool SetMessageToSend(CSerializedNetMsg& msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

size_t GetSendMemoryUsage() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

bool ShouldReconnectV1() const noexcept override { return false; }

{

/** Contents of the version packet to send. BIP324 stipulates that senders should leave this

static constexpr std::array<std::byte, 0> VERSION_CONTENTS = {};

/** The length of the V1 prefix to match bytes initially received by responders with to

static constexpr size_t V1_PREFIX_LEN = 16;

// The sender side and receiver side of V2Transport are state machines that are transitioned

// through, based on what has been received. The receive state corresponds to the contents of,

// and bytes received to, the receive buffer. The send state controls what can be appended to

// the send buffer and what can be sent from it.

/** State type that defines the current contents of the receive buffer and/or how the next

enum class RecvState : uint8_t {

/** (Responder only) either v2 public key or v1 header.

KEY_MAYBE_V1,

/** Public key.

KEY,

/** Garbage and garbage terminator.

GARB_GARBTERM,

/** Version packet.

VERSION,

/** Application packet.

APP,

/** Nothing (an application packet is available for GetMessage()).

APP_READY,

/** Nothing (this transport is using v1 fallback).

V1,

};

/** State type that controls the sender side.

enum class SendState : uint8_t {

/** (Responder only) Not sending until v1 or v2 is detected.

MAYBE_V1,

/** Waiting for the other side's public key.

AWAITING_KEY,

/** Normal sending state.

READY,

/** This transport is using v1 fallback.

V1,

};

/** Cipher state. */

BIP324Cipher m_cipher;

/** Whether we are the initiator side. */

const bool m_initiating;

/** NodeId (for debug logging). */

const NodeId m_nodeid;

/** Encapsulate a V1Transport to fall back to. */

V1Transport m_v1_fallback;

/** Lock for receiver-side fields. */

mutable Mutex m_recv_mutex ACQUIRED_BEFORE(m_send_mutex);

/** In {VERSION, APP}, the decrypted packet length, if m_recv_buffer.size() >=

uint32_t m_recv_len GUARDED_BY(m_recv_mutex) {0};

/** Receive buffer; meaning is determined by m_recv_state. */

std::vector<uint8_t> m_recv_buffer GUARDED_BY(m_recv_mutex);

/** AAD expected in next received packet (currently used only for garbage). */

std::vector<uint8_t> m_recv_aad GUARDED_BY(m_recv_mutex);

/** Buffer to put decrypted contents in, for converting to CNetMessage. */

std::vector<uint8_t> m_recv_decode_buffer GUARDED_BY(m_recv_mutex);

/** Current receiver state. */

RecvState m_recv_state GUARDED_BY(m_recv_mutex);

/** Lock for sending-side fields. If both sending and receiving fields are accessed,

mutable Mutex m_send_mutex ACQUIRED_AFTER(m_recv_mutex);

/** The send buffer; meaning is determined by m_send_state. */

std::vector<uint8_t> m_send_buffer GUARDED_BY(m_send_mutex);

/** How many bytes from the send buffer have been sent so far. */

uint32_t m_send_pos GUARDED_BY(m_send_mutex) {0};

/** The garbage sent, or to be sent (MAYBE_V1 and AWAITING_KEY state only). */

std::vector<uint8_t> m_send_garbage GUARDED_BY(m_send_mutex);

/** Type of the message being sent. */

std::string m_send_type GUARDED_BY(m_send_mutex);

/** Current sender state. */

SendState m_send_state GUARDED_BY(m_send_mutex);

/** Whether we've sent at least 24 bytes (which would trigger disconnect for V1 peers). */

bool m_sent_v1_header_worth GUARDED_BY(m_send_mutex) {false};

/** Change the receive state. */

void SetReceiveState(RecvState recv_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

/** Change the send state. */

void SetSendState(SendState send_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex);

/** Given a packet's contents, find the message type (if valid), and strip it from contents. */

static std::optional<std::string> GetMessageType(std::span<const uint8_t>& contents) noexcept;

/** Determine how many received bytes can be processed in one go (not allowed in V1 state). */

size_t GetMaxBytesToProcess() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

/** Put our public key + garbage in the send buffer. */

void StartSendingHandshake() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex);

/** Process bytes in m_recv_buffer, while in KEY_MAYBE_V1 state. */

void ProcessReceivedMaybeV1Bytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex);

/** Process bytes in m_recv_buffer, while in KEY state. */

bool ProcessReceivedKeyBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex, !m_send_mutex);

/** Process bytes in m_recv_buffer, while in GARB_GARBTERM state. */

bool ProcessReceivedGarbageBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

/** Process bytes in m_recv_buffer, while in VERSION/APP state. */

bool ProcessReceivedPacketBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex);

static constexpr uint32_t MAX_GARBAGE_LEN = 4095;

/** Construct a V2 transport with securely generated random keys.

V2Transport(NodeId nodeid, bool initiating) noexcept;

/** Construct a V2 transport with specified keys and garbage (test use only). */

V2Transport(NodeId nodeid, bool initiating, const CKey& key, std::span<const std::byte> ent32, std::vector<uint8_t> garbage) noexcept;

// Receive side functions.

bool ReceivedMessageComplete() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);

bool ReceivedBytes(std::span<const uint8_t>& msg_bytes) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex);

CNetMessage GetReceivedMessage(NodeClock::time_point time, bool& reject_message) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);

// Send side functions.

bool SetMessageToSend(CSerializedNetMsg& msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

size_t GetSendMemoryUsage() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex);

// Miscellaneous functions.

bool ShouldReconnectV1() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex);

Info GetInfo() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);

{

NetPermissionFlags permission_flags = NetPermissionFlags::None;

std::unique_ptr<i2p::sam::Session> i2p_sam_session = nullptr;

bool prefer_evict = false;

size_t recv_flood_size{DEFAULT_MAXRECEIVEBUFFER * 1000};

bool use_v2transport = false;

{

/** Transport serializer/deserializer. The receive side functions are only called under cs_vRecv, while

const std::unique_ptr<Transport> m_transport;

const NetPermissionFlags m_permission_flags;

/**

std::shared_ptr<Sock> m_sock GUARDED_BY(m_sock_mutex);

/** Sum of GetMemoryUsage of all vSendMsg entries. */

size_t m_send_memusage GUARDED_BY(cs_vSend){0};

/** Total number of bytes sent on the wire to this peer. */

uint64_t nSendBytes GUARDED_BY(cs_vSend){0};

/** Messages still to be fed to m_transport->SetMessageToSend. */

std::deque<CSerializedNetMsg> vSendMsg GUARDED_BY(cs_vSend);

Mutex cs_vSend;

Mutex m_sock_mutex;

Mutex cs_vRecv;

uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};

std::atomic<NodeClock::time_point> m_last_send{NodeClock::epoch};

std::atomic<NodeClock::time_point> m_last_recv{NodeClock::epoch};

//! Unix epoch time at peer connection

const NodeClock::time_point m_connected;

// Address of this peer

const CAddress addr;

// Bind address of our side of the connection

const CService addrBind;

const std::string m_addr_name;

/** The pszDest argument provided to ConnectNode(). Only used for reconnections. */

const std::string m_dest;

//! Whether this peer is an inbound onion, i.e. connected via our Tor onion service.

const bool m_inbound_onion;

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

Mutex m_subver_mutex;

/**

std::string cleanSubVer GUARDED_BY(m_subver_mutex){};

const bool m_prefer_evict{false}; // This peer is preferred for eviction.

bool HasPermission(NetPermissionFlags permission) const {

return NetPermissions::HasFlag(m_permission_flags, permission);

}

/** fSuccessfullyConnected is set to true on receiving VERACK from the peer. */

std::atomic_bool fSuccessfullyConnected{false};

// Setting fDisconnect to true will cause the node to be disconnected the

// next time DisconnectNodes() runs

std::atomic_bool fDisconnect{false};

CountingSemaphoreGrant<> grantOutbound;

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

const uint64_t nKeyedNetGroup;

std::atomic_bool fPauseRecv{false};

std::atomic_bool fPauseSend{false};

/** Network key used to prevent fingerprinting our node across networks.

const uint64_t m_network_key;

const ConnectionType m_conn_type;

/** Move all messages from the received queue to the processing queue. */

void MarkReceivedMsgsForProcessing()

EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex);

/** Poll the next message from the processing queue of this connection.

std::optional<std::pair<CNetMessage, bool>> PollMessage()

EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex);

/** Account for the total size of a sent message in the per msg type connection stats. */

void AccountForSentBytes(const std::string& msg_type, size_t sent_bytes)

EXCLUSIVE_LOCKS_REQUIRED(cs_vSend)

{

mapSendBytesPerMsgType[msg_type] += sent_bytes;

}

bool IsOutboundOrBlockRelayConn() const {

switch (m_conn_type) {

case ConnectionType::OUTBOUND_FULL_RELAY:

case ConnectionType::BLOCK_RELAY:

return true;

case ConnectionType::INBOUND:

case ConnectionType::MANUAL:

case ConnectionType::ADDR_FETCH:

case ConnectionType::FEELER:

case ConnectionType::PRIVATE_BROADCAST:

return false;

} // no default case, so the compiler can warn about missing cases

assert(false);

}

bool IsFullOutboundConn() const {

return m_conn_type == ConnectionType::OUTBOUND_FULL_RELAY;

}

bool IsManualConn() const {

return m_conn_type == ConnectionType::MANUAL;

}

bool IsManualOrFullOutboundConn() const

{

switch (m_conn_type) {

case ConnectionType::INBOUND:

case ConnectionType::FEELER:

case ConnectionType::BLOCK_RELAY:

case ConnectionType::ADDR_FETCH:

case ConnectionType::PRIVATE_BROADCAST:

return false;

case ConnectionType::OUTBOUND_FULL_RELAY:

case ConnectionType::MANUAL:

return true;

} // no default case, so the compiler can warn about missing cases

assert(false);

}

bool IsBlockOnlyConn() const {

return m_conn_type == ConnectionType::BLOCK_RELAY;

}

bool IsFeelerConn() const {

return m_conn_type == ConnectionType::FEELER;

}

bool IsAddrFetchConn() const {

return m_conn_type == ConnectionType::ADDR_FETCH;

}

bool IsPrivateBroadcastConn() const

{

return m_conn_type == ConnectionType::PRIVATE_BROADCAST;

}

bool IsInboundConn() const {

return m_conn_type == ConnectionType::INBOUND;

}

bool ExpectServicesFromConn() const {

switch (m_conn_type) {

case ConnectionType::INBOUND:

case ConnectionType::MANUAL:

case ConnectionType::FEELER:

return false;

case ConnectionType::OUTBOUND_FULL_RELAY:

case ConnectionType::BLOCK_RELAY:

case ConnectionType::ADDR_FETCH:

case ConnectionType::PRIVATE_BROADCAST:

return true;

} // no default case, so the compiler can warn about missing cases

assert(false);

}

/**

Network ConnectedThroughNetwork() const;

/** Whether this peer connected through a privacy network. */

[[nodiscard]] bool IsConnectedThroughPrivacyNet() const;

// We selected peer as (compact blocks) high-bandwidth peer (BIP152)

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

// Peer selected us as (compact blocks) high-bandwidth peer (BIP152)

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

/** Whether this peer provides all services that we want. Used for eviction decisions */

std::atomic_bool m_has_all_wanted_services{false};

/** Whether we should relay transactions to this peer. This only changes

std::atomic_bool m_relays_txs{false};

/** Whether this peer has loaded a bloom filter. Used only in inbound

std::atomic_bool m_bloom_filter_loaded{false};

/// UNIX epoch time of the last block received from this peer that we had

/// not yet seen (e.g. not already received from another peer), that passed

/// preliminary validity checks and was saved to disk, even if we don't

/// connect the block or it eventually fails to connect. Used as an inbound

/// peer eviction criterion in CConnman::AttemptToEvictConnection.

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

/// UNIX epoch time of the last transaction received from this peer that we

/// had not yet seen (e.g. not already received from another peer) and that

/// was accepted into our mempool. Used as an inbound peer eviction criterion

/// in CConnman::AttemptToEvictConnection.

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

/// Last measured round-trip duration. Used only for stats.

std::atomic<NodeClock::duration> m_last_ping_time{0us};

/// Lowest measured round-trip duration. Used as an inbound peer eviction

/// criterion in CConnman::AttemptToEvictConnection.

std::atomic<NodeClock::duration> m_min_ping_time{NodeClock::duration::max()};

CNode(NodeId id,

std::shared_ptr<Sock> sock,

const CAddress& addrIn,

uint64_t nKeyedNetGroupIn,

uint64_t nLocalHostNonceIn,

const CService& addrBindIn,

const std::string& addrNameIn,

ConnectionType conn_type_in,

bool inbound_onion,

uint64_t network_key,

CNodeOptions&& node_opts = {});

CNode(const CNode&) = delete;

CNode& operator=(const CNode&) = delete;

NodeId GetId() const {

return id;

}

uint64_t GetLocalNonce() const {

return nLocalHostNonce;

}

int GetRefCount() const

{

assert(nRefCount >= 0);

return nRefCount;

}

/**

bool ReceiveMsgBytes(std::span<const uint8_t> msg_bytes, bool& complete) EXCLUSIVE_LOCKS_REQUIRED(!cs_vRecv);

void SetCommonVersion(int greatest_common_version)

{

Assume(m_greatest_common_version == INIT_PROTO_VERSION);

m_greatest_common_version = greatest_common_version;

}

int GetCommonVersion() const

{

return m_greatest_common_version;

}

CService GetAddrLocal() const EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex);

//! May not be called more than once

void SetAddrLocal(const CService& addrLocalIn) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex);

CNode* AddRef()

{

nRefCount++;

return this;

}

void Release()

{

nRefCount--;

}

void CloseSocketDisconnect() EXCLUSIVE_LOCKS_REQUIRED(!m_sock_mutex);

void CopyStats(CNodeStats& stats) EXCLUSIVE_LOCKS_REQUIRED(!m_subver_mutex, !m_addr_local_mutex, !cs_vSend, !cs_vRecv);

std::string ConnectionTypeAsString() const { return ::ConnectionTypeAsString(m_conn_type); }

/**

std::string LogPeer() const;

/**

std::string DisconnectMsg() const;

/// A ping-pong round trip has completed successfully. Update latest and minimum ping durations.

void PongReceived(NodeClock::duration ping_time)

{

m_last_ping_time = ping_time;

m_min_ping_time = std::min(m_min_ping_time.load(), ping_time);

}

const NodeId id;

const uint64_t nLocalHostNonce;

std::atomic<int> m_greatest_common_version{INIT_PROTO_VERSION};

const size_t m_recv_flood_size;

std::list<CNetMessage> vRecvMsg; // Used only by SocketHandler thread

Mutex m_msg_process_queue_mutex;

std::list<CNetMessage> m_msg_process_queue GUARDED_BY(m_msg_process_queue_mutex);