Struct EdgeValueFn 

pub struct EdgeValueFn<C, W> {
    initial: C,
    min: Option<C>,
    value_fn: Arc<dyn Fn(C, &W, usize) -> C + Sync + Send>,
}

A graph edge value function implementing a fold over path edges.

The penalty is a penalizing multiplier applied to edges that lack probe-based quality observations (e.g. only on-chain capacity or only immediate connectivity data). It scales the accumulated value downward, making unprobed edges less attractive than measured ones while still allowing path discovery. A value of 1.0 means no penalty; lower values (e.g. 0.5) increasingly penalize unprobed edges.

Use one of the named constructors to create the appropriate variant:

• EdgeValueFn::forward — full graph traversal in the forward direction
• EdgeValueFn::returning — full graph traversal in the return direction
• EdgeValueFn::forward_without_self_loopback — simple forward paths without final loopback

Fields

initial: C

min: Option<C>

value_fn: Arc<dyn Fn(C, &W, usize) -> C + Sync + Send>

Implementations

impl<W> EdgeValueFn<f64, W>

where W: EdgeObservableRead + Send + 'static,

pub fn forward( length: NonZero<usize>, penalty: f64, min_ack_rate: f64, ) -> EdgeValueFn<f64, W>

Build a forward HOPR value function for full graph traversals.

penalty is clamped to [0.0, 1.0] — the penalizing multiplier applied to edges lacking probe-based quality observations.

min_ack_rate is clamped to [0.0, 1.0] — the minimum acceptable message acknowledgment rate for the immediate peer. Edges with an ack rate below this threshold are rejected.

• First edge: requires connectivity and intermediate capacity; scores by the better of immediate/intermediate observations, then applies the ack rate modifier.
• Last edge: accepts intermediate capacity or immediate connectivity; penalizes when neither is available (last hop is not monetized). When length == 1 the single edge is both first and last; the ack rate modifier is applied when immediate QoS data is available.
• Intermediate edges: require capacity; penalize when unprobed.

pub fn returning( length: NonZero<usize>, penalty: f64, min_ack_rate: f64, ) -> EdgeValueFn<f64, W>

Build a HOPR value function for full graph traversals in the return direction.

penalty is clamped to [0.0, 1.0] — the penalizing multiplier applied to edges lacking probe-based quality observations.

min_ack_rate is clamped to [0.0, 1.0] — the minimum acceptable message acknowledgment rate for the immediate peer. Edges with an ack rate below this threshold are rejected.

Used when the planner (me) constructs the return path dest -> relay -> me. The first edge (dest -> relay) has relaxed requirements compared to EdgeValueFn::forward because the planner lacks intermediate QoS data.

• Last edge (relay -> me): requires immediate connectivity; applies the ack rate modifier.
• All other edges: require intermediate capacity; the penalty penalizing multiplier is applied when probe scores are absent.

pub fn forward_without_self_loopback( penalty: f64, min_ack_rate: f64, ) -> EdgeValueFn<f64, W>

Build a value function for simple forward paths without the final loopback.

penalty is clamped to [0.0, 1.0] — the penalizing multiplier applied to edges lacking probe-based quality observations.

min_ack_rate is clamped to [0.0, 1.0] — the minimum acceptable message acknowledgment rate for the immediate peer. Edges with an ack rate below this threshold are rejected.

• First edge: same as EdgeValueFn::forward.
• All other edges: require capacity; the penalty penalizing multiplier is applied when probe scores are absent.

Trait Implementations

impl<C, W> Clone for EdgeValueFn<C, W>

where C: Clone,

fn clone(&self) -> EdgeValueFn<C, W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, W> ValueFn for EdgeValueFn<C, W>

where C: Clone + PartialOrd + Send + Sync + 'static, W: EdgeObservableRead + Send + 'static,

type Value = C

type Weight = W

fn initial_value(&self) -> <EdgeValueFn<C, W> as ValueFn>::Value

The initial value that will be modified by the value function.

fn min_value(&self) -> Option<<EdgeValueFn<C, W> as ValueFn>::Value>

The minimum value, below which the value function will force discard upon traversal.

fn into_value_fn( self, ) -> Arc<dyn Fn(<EdgeValueFn<C, W> as ValueFn>::Value, &<EdgeValueFn<C, W> as ValueFn>::Weight, usize) -> <EdgeValueFn<C, W> as ValueFn>::Value + Sync + Send>

The value function accepting graph properties to establish the final value.