Struct ChannelGraph 

pub struct ChannelGraph {
    pub(crate) me: OffchainPublicKey,
    pub(crate) edge_penalty: f64,
    pub(crate) min_ack_rate: f64,
    pub(crate) inner: Arc<RwLock<InnerGraph>>,
}

A directed graph representing logical channels between nodes.

The graph is directed, with nodes representing the physical nodes in the network using their [OffchainPublicKey] as identifier and edges representing the logical channels between them. Each logical channel aggregates different weighted properties, like channel capacity (calculated from the on-chain channel balance, ticket price and ticket probability) and evaluated transport network properties between the nodes.

Interior mutability is provided via an internal [RwLock] so that all trait methods (which take &self) can safely read and write the graph. In production code, the graph is expected to be shared behind an Arc<ChannelGraph>.

Fields

me: OffchainPublicKey

edge_penalty: f64

min_ack_rate: f64

inner: Arc<RwLock<InnerGraph>>

Implementations

impl ChannelGraph

pub fn new(me: OffchainPublicKey) -> Self

Creates a new channel graph with the given self identity and default edge scoring parameters (edge_penalty = 0.5, min_ack_rate = 0.1).

The me key represents the local node which is automatically added to the graph as the first node.

Production code should prefer with_edge_params to receive values from PathPlannerConfig.

pub fn with_edge_params( me: OffchainPublicKey, edge_penalty: f64, min_ack_rate: f64, ) -> Self

Creates a new channel graph with custom edge scoring parameters.

• me – offchain public key of the local node (added as the first graph node).
• edge_penalty – penalty multiplier for edges lacking probe-based quality observations.
• min_ack_rate – minimum acceptable message acknowledgment rate for path selection.

pub fn me(&self) -> &OffchainPublicKey

Returns the self-identity key of this graph.

Trait Implementations

impl Clone for ChannelGraph

fn clone(&self) -> ChannelGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChannelGraph

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

Formats the value using the given formatter.

impl NetworkGraphConnectivity for ChannelGraph

type NodeId = OffchainPublicKey

The identifier type used to reference nodes in the graph.

type Observed = Observations

The concrete edge observation type.

fn connected_edges( &self, ) -> Vec<(OffchainPublicKey, OffchainPublicKey, Observations)>

Returns all edges in the graph as (source, destination, observations) triples.

fn reachable_edges( &self, ) -> Vec<(OffchainPublicKey, OffchainPublicKey, Observations)>

Returns edges reachable from the graph’s identity node via directed traversal.

impl NetworkGraphTraverse for ChannelGraph

type NodeId = OffchainPublicKey

The identifier type used to reference nodes in the graph.

type Observed = Observations

The concrete edge observation type used by value functions during traversal.

fn simple_paths<C: ValueFn<Weight = Self::Observed>>( &self, source: &Self::NodeId, destination: &Self::NodeId, length: usize, take_count: Option<usize>, value_fn: C, ) -> Vec<(Vec<Self::NodeId>, PathId, C::Value)>

Returns a list of routes from the source to the destination with the specified length at the time of calling.

fn simple_paths_from<C: ValueFn<Weight = Self::Observed>>( &self, source: &Self::NodeId, length: usize, take_count: Option<usize>, value_fn: C, ) -> Vec<(Vec<Self::NodeId>, PathId, C::Value)>

Returns a list of routes from the source to any reachable node with the specified edge length.

fn simple_loopback_to_self( &self, length: usize, take_count: Option<usize>, ) -> Vec<(Vec<Self::NodeId>, PathId)>

Return a list of nodes with a full loopback from myself to myself.

impl NetworkGraphUpdate for ChannelGraph

fn record_edge<N, P>(&self, update: MeasurableEdge<N, P>)

where N: MeasurablePeer + Send + Clone, P: MeasurablePath + Send + Clone,

Records an edge measurement derived from network telemetry.

fn record_node<N>(&self, update: N)

where N: MeasurableNode + Clone + Send + Sync + 'static,

Records a node observation derived from network telemetry.

impl NetworkGraphView for ChannelGraph

type NodeId = OffchainPublicKey

The identifier type used to reference nodes in the graph.

type Observed = Observations

The concrete type of observations for peers.

fn node_count(&self) -> usize

Returns the number of nodes in the graph.

fn contains_node(&self, key: &OffchainPublicKey) -> bool

Checks whether the graph contains the given node.

fn nodes(&self) -> BoxStream<'static, Self::NodeId>

Returns a stream of all known nodes in the network graph.

fn has_edge(&self, src: &OffchainPublicKey, dest: &OffchainPublicKey) -> bool

Checks whether a directed edge exists between two nodes.

fn edge( &self, src: &Self::NodeId, dest: &Self::NodeId, ) -> Option<Self::Observed>

Returns the weight represented by the observations for the edge between the given source and destination, if available.

fn identity(&self) -> &OffchainPublicKey

Returns the self-identity node of this graph.

impl NetworkGraphWrite for ChannelGraph

fn upsert_edge<F>( &self, src: &OffchainPublicKey, dest: &OffchainPublicKey, f: F, )

where F: FnOnce(&mut Observations),

Mutably updates the edge observations between two nodes.

If the edge does not exist, it gets created first.

If the nodes do not exist, they are added as well.

type Error = ChannelGraphError

The error type returned by fallible write operations.

type NodeId = OffchainPublicKey

The identifier type used to reference nodes in the graph.

type Observed = Observations

The concrete type of observations for peers.

fn add_node(&self, key: OffchainPublicKey)

Adds a node to the graph if it does not already exist.

fn remove_node(&self, key: &OffchainPublicKey)

Removes a node and all its associated edges from the graph.

fn add_edge( &self, src: &OffchainPublicKey, dest: &OffchainPublicKey, ) -> Result<(), ChannelGraphError>

Adds a directed edge between two existing nodes with default observations.

fn remove_edge(&self, src: &OffchainPublicKey, dest: &OffchainPublicKey)

Removes a directed edge between two nodes.