Struct PeerCapabilityNegotiator 

pub struct PeerCapabilityNegotiator {
    pub config: NegotiatorConfig,
    pub negotiation_history: VecDeque<NegotiationRecord>,
    pub max_history: usize,
    pub total_negotiations: u64,
    pub total_accepted: u64,
    pub total_rejected: u64,
}

Production-grade peer capability negotiator.

PeerCapabilityNegotiator handles the full lifecycle of capability negotiation:

1. Building NegotiationOffers from local config for outbound connections.
2. Evaluating incoming offers and producing NegotiationResults.
3. Recording negotiation outcomes in a bounded history ring.
4. Exposing aggregate statistics for monitoring dashboards.

Thread Safety

PeerCapabilityNegotiator is Send + Sync (all fields are Send + Sync). For concurrent access, wrap in Arc<Mutex<_>> or Arc<RwLock<_>>.

Fields

config: NegotiatorConfig

Local negotiation configuration (policy, capabilities, limits).

negotiation_history: VecDeque<NegotiationRecord>

Bounded ring of historical negotiation records (newest last).

max_history: usize

Maximum number of historical records retained.

total_negotiations: u64

Total number of negotiate() calls.

total_accepted: u64

Negotiations that returned Accepted.

total_rejected: u64

Negotiations that returned Rejected.

Implementations

impl PeerCapabilityNegotiator

pub fn new(config: NegotiatorConfig, max_history: usize) -> Self

Create a new negotiator with the given config and maximum history size.

Panics

Does not panic; a max_history of 0 is valid (no history retained).

pub fn build_offer(&self, peer_id: String, now: u64) -> NegotiationOffer

Build a NegotiationOffer from this node’s local capabilities.

peer_id is the identifier we place in the offer (usually our own peer ID), and now is the current Unix-millisecond timestamp.

pub fn evaluate_offer(&self, offer: &NegotiationOffer) -> NegotiationResult

Evaluate an incoming peer offer and return the negotiation outcome.

The evaluation proceeds in three phases:

1. Protocol version gate — if offer.protocol_version < min_protocol_version, immediately return Rejected { reason: "protocol version too low", ... }.
2. Required-capability scan — identify which locally required capabilities are absent from (or version-incompatible with) the offer.
3. Policy decision — apply CapabilityPolicy to decide Accepted/Rejected.

pub fn negotiate( &mut self, peer_id: String, offer: NegotiationOffer, start_ms: u64, end_ms: u64, ) -> &NegotiationResult

Evaluate an offer, record it in history, update counters, and return the result.

• peer_id — identifier of the remote peer.
• offer — the remote peer’s capability offer.
• start_ms — Unix-millisecond timestamp when the negotiation began.
• end_ms — Unix-millisecond timestamp when evaluation completed.

Returns a reference to the stored NegotiationResult in the history ring.

History Eviction

When the history ring is full (len() == max_history), the oldest record is evicted before the new one is appended. If max_history is 0, the record is computed and counters are updated but nothing is stored.

pub fn is_capability_supported( &self, name: &str, version: &CapabilityVersion, ) -> bool

Returns true if the local config contains a capability with name whose version is compatible with version.

pub fn common_capabilities(&self, offer: &NegotiationOffer) -> Vec<String>

Returns the names of capabilities present in both the local config and the offer, with a compatible version.

pub fn history_for_peer(&self, peer_id: &str) -> Vec<&NegotiationRecord>

Returns all historical records for the specified peer.

pub fn negotiator_stats(&self) -> NegotiatorStats

Snapshot of aggregate negotiation statistics.

Trait Implementations

impl Debug for PeerCapabilityNegotiator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.