Struct ChannelGraph 

pub struct ChannelGraph {
    pub(crate) me: OffchainPublicKey,
    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

inner: Arc<RwLock<InnerGraph>>

Implementations

impl ChannelGraph

pub fn new(me: OffchainPublicKey) -> Self

Creates a new channel graph with the given self identity.

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

pub fn me(&self) -> &OffchainPublicKey

Returns the self-identity key of this graph.

impl ChannelGraph

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

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

Only nodes that participate in at least one edge appear in the result. Isolated nodes (no incoming or outgoing edges) are omitted.

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

Returns edges reachable from self.me via directed BFS.

Only edges where both the source and destination are reachable from our node are included. This filters out disconnected subgraphs that we cannot actually route through.

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 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 cost functions during traversal.

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

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: CostFn<Weight = Self::Observed>>( &self, source: &Self::NodeId, length: usize, take_count: Option<usize>, cost_fn: C, ) -> Vec<(Vec<Self::NodeId>, PathId, C::Cost)>

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.

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.