Struct PeerStats 

pub struct PeerStats {

    pub peer_id: String,
    pub connected_at: Instant,
    pub requests_sent: u64,
    pub successes: u64,
    pub timeouts: u64,
    pub failures: u64,
    pub srtt_ms: f64,
    pub rttvar_ms: f64,
    pub rto_ms: u64,
    pub consecutive_rto_backoffs: u32,
    pub backoff_level: u32,
    pub backed_off_until: Option<Instant>,
    pub last_success: Option<Instant>,
    pub last_failure: Option<Instant>,
    pub bytes_received: u64,
    pub bytes_sent: u64,
    pub cashu_paid_sat: u64,
    pub cashu_received_sat: u64,
    pub cashu_payment_receipts: u64,
    pub cashu_payment_defaults: u64,
}

Per-peer performance statistics

Fields

peer_id: String

Peer identifier

connected_at: Instant

When this peer was connected

requests_sent: u64

Total requests sent to this peer

successes: u64

Total successful responses received

timeouts: u64

Total timeouts

failures: u64

Total failures (bad data, disconnects, etc.)

srtt_ms: f64

Smoothed round-trip time (RFC 2988 SRTT)

rttvar_ms: f64

RTT variance (RFC 2988 RTTVAR)

rto_ms: u64

Retransmission timeout (computed from SRTT and RTTVAR)

consecutive_rto_backoffs: u32

Consecutive RTO backoffs (for capping)

backoff_level: u32

Current backoff level (how many times we’ve backed off)

backed_off_until: Option<Instant>

When backoff expires (None if not backed off)

last_success: Option<Instant>

Last successful response timestamp

last_failure: Option<Instant>

Last failure timestamp

bytes_received: u64

Total bytes received from this peer

bytes_sent: u64

Total bytes sent to this peer

cashu_paid_sat: u64

Total sats paid to this peer through an external payment channel.

cashu_received_sat: u64

Total sats this peer paid us after successful delivery.

cashu_payment_receipts: u64

Number of successful post-delivery payments received from this peer.

cashu_payment_defaults: u64

Number of times this peer failed to pay after successful delivery.

Implementations

impl PeerStats

pub fn new(peer_id: impl Into<String>) -> Self

Create new peer stats

pub fn success_rate(&self) -> f64

Get success rate (0.0 to 1.0)

pub fn selection_rate(&self) -> f64

Get selection rate (selections per second since connected)

pub fn is_backed_off(&self) -> bool

Check if peer is currently backed off

pub fn backoff_remaining(&self) -> Duration

Get remaining backoff time

pub fn record_request(&mut self, bytes: u64)

Record a request being sent

pub fn record_success(&mut self, rtt_ms: u64, bytes: u64)

Record a successful response with RTT Uses RFC 2988 algorithm for smoothed RTT calculation

pub fn record_timeout(&mut self)

Record a timeout

pub fn record_failure(&mut self)

Record a failure (bad data, disconnect, etc.)

pub fn record_cashu_payment(&mut self, amount_sat: u64)

Record an out-of-band payment to this peer (e.g. Cashu channel transfer).

pub fn record_cashu_receipt(&mut self, amount_sat: u64)

Record a settled payment received from this peer after we served data.

pub fn record_cashu_payment_default(&mut self)

Record that this peer failed to pay after successful delivery.

pub fn score(&self) -> f64

Calculate peer score for selection (higher is better) Combines success rate, RTT, and recent performance

pub fn utility_score(&self, total_requests: u64) -> f64

Utility-centric score with exploration bonus (UCB-style).

Balances:

• good/bad outcome ratio (successes vs failures+timeouts),
• latency efficiency,
• bytes efficiency (received vs sent),
• uncertainty bonus for less-tested peers.

pub fn tit_for_tat_score(&self, total_requests: u64) -> f64

Tit-for-tat style score:

• reward peers that answer our requests with useful bytes (reciprocity)
• reward reliable responders
• penalize timeout/failure-heavy peers (retaliation)
• keep a small exploration term for under-sampled peers

pub fn cashu_priority_boost(&self) -> f64

Normalize paid amount to a bounded priority score in [0, 1).

pub fn payment_reliability_multiplier(&self) -> f64

Cooperative peers that actually pay us should not be penalized; repeated defaults quickly reduce their desirability.

pub fn exceeds_payment_default_threshold(&self, threshold: u64) -> bool

Trait Implementations

impl Clone for PeerStats

fn clone(&self) -> PeerStats

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PeerStats

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

Formats the value using the given formatter.