Struct PathPlannerConfig 

pub struct PathPlannerConfig {
    pub max_cache_capacity: u64,
    pub cache_ttl: Duration,
    pub refresh_period: Duration,
    pub max_cached_paths: usize,
    pub edge_penalty: f64,
    pub min_ack_rate: f64,
    pub min_paths_anonymity_floor: usize,
    pub latency_halflife: Duration,
    pub capacity_reference: u128,
    pub return_path_weight_temper: f64,
    pub return_path_exploration: f64,
    pub max_plausible_loopback_rtt: Duration,
}

Configuration for PathPlanner’s internal path cache.

Fields

max_cache_capacity: u64

Maximum number of (source, destination, options) entries in the path cache.

cache_ttl: Duration

Time-to-live for a cached path list. When an entry expires the next PathPlanner::resolve_routing call transparently recomputes it (lazy refresh).

Candidate weights are computed once, when the entry is filled, and frozen in the [hopr_utils::statistics::WeightedCollection] – so this bounds how stale the weights a live session draws from can be, not merely how stale the candidate set is. At the previous 60 s a relay that stopped delivering kept its full share of return-path draws for a minute after the graph had already scored it down.

refresh_period: Duration

Period between proactive background cache-refresh sweeps.

Held at half the TTL so a steady-state session is normally served from an entry that was re-weighted rather than one that expired under it.

max_cached_paths: usize

Maximum number of candidate paths the selector may return per query. All returned candidates are validated and cached.

edge_penalty: f64

Penalty multiplier for edges lacking probe-based quality observations. Applied during path cost evaluation to down-weight unprobed edges. Must be finite and in 0.0..=1.0.

min_ack_rate: f64

Minimum acceptable message acknowledgment rate for path selection. Edges with an ack rate below this threshold are excluded from candidate paths. Must be finite and in 0.0..=1.0.

min_paths_anonymity_floor: usize

Candidate count below which no latency-based pruning occurs.

When fewer paths than this value are found, the selector returns all of them unchanged (min(found_count, floor) semantics — the floor is never a minimum to fabricate). Set to 0 to disable pruning entirely.

latency_halflife: Duration

Total path latency at which the latency factor in the composite weight equals 0.5. Higher values make the weight less sensitive to latency differences.

capacity_reference: u128

Reference channel balance used to scale the capacity factor in the composite weight. capacity_factor saturates at 1.0 near this value. Defaults to 10_000_000 (~10 MiB in wxHOPR tokens).

return_path_weight_temper: f64

Exponent applied to return-path weights before sampling, flattening the distribution.

Return paths are drawn weighted-random by path value, which concentrates a session’s SURBs on the few highest-valued relays — losing one then costs far more than the reliable-mode loss tolerance. Raising each weight to γ ∈ (0, 1] compresses the spread between good and bad candidates without changing their order: w' = w^γ.

1.0 samples by raw path value (most traffic on the best relays, largest blast radius when one dies). Values approaching 0.0 tend to a uniform draw (smallest blast radius, most traffic on poor relays). With weights (0.4, 0.3, 0.2, 0.1), γ = 0.5 moves the busiest relay’s share from 40% to 33% and the ratio between busiest and least-busy from 4.0 to 2.0.

Defaults to 0.5.

return_path_exploration: f64

Fraction of return-path draws made uniformly at random instead of by weight.

Weights come from observations, and observations only exist for paths that get selected — a closed loop in which a path that falls out of favour stops being measured, so its score can never recover and it is never chosen again. Spending a small share of draws uniformly keeps every candidate under observation, which is what lets a recovered one climb back.

Costs throughput in proportion: this share of return paths deliberately ignores which candidate looks best. Candidates have already passed the selector’s gates (open channels, min_ack_rate, and so on) before reaching here, so an exploratory draw is random only with respect to quality, never a route the cost function rejected. 0.0 disables it. Defaults to 0.1.

max_plausible_loopback_rtt: Duration

Upper bound on a loopback probe’s round-trip time considered plausible. Measurements above this cap (clock skew, stale telemetry) are discarded instead of poisoning the latency EMA with an absurd value.

Trait Implementations

impl Clone for PathPlannerConfig

fn clone(&self) -> PathPlannerConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PathPlannerConfig

impl Debug for PathPlannerConfig

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

Formats the value using the given formatter.

impl Default for PathPlannerConfig

fn default() -> Self

Return PathPlannerConfig { max_cache_capacity: 10_000, cache_ttl: Duration::from_secs(10), refresh_period: Duration::from_secs(5), max_cached_paths: 50, edge_penalty: 0.5, min_ack_rate: 0.1, min_paths_anonymity_floor: 8, latency_halflife: Duration::from_millis(100), capacity_reference: 10_000_000, return_path_weight_temper: 0.5, return_path_exploration: 0.1, max_plausible_loopback_rtt: Duration::from_secs(30) }

impl PartialEq for PathPlannerConfig

fn eq(&self, other: &PathPlannerConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for PathPlannerConfig

impl Validate for PathPlannerConfig

fn validate(&self) -> Result<(), ValidationErrors>

impl<'v_a> ValidateArgs<'v_a> for PathPlannerConfig

type Args = ()

fn validate_with_args(&self, args: Self::Args) -> Result<(), ValidationErrors>