Include non-permanently connected peers in list_peers()

Author: tnull

bindings/ldk_node.udl

@@ -37,7 +37,7 @@ interface Node {
 	[Throws=NodeError]
 	u64 total_onchain_balance_sats();
 	[Throws=NodeError]
-	void connect(PublicKey node_id, NetAddress address, boolean permanently);
+	void connect(PublicKey node_id, NetAddress address, boolean persist);
 	[Throws=NodeError]
 	void disconnect(PublicKey node_id);
 	[Throws=NodeError]
@@ -153,6 +153,7 @@ dictionary ChannelDetails {
 dictionary PeerDetails {
 	PublicKey node_id;
 	NetAddress address;
+	boolean is_persisted;
 	boolean is_connected;
 };
 

src/lib.rs

@@ -1063,9 +1063,9 @@ impl Node {
 
 	/// Connect to a node on the peer-to-peer network.
 	///
-	/// If `permanently` is set to `true`, we'll remember the peer and reconnect to it on restart.
+	/// If `persist` is set to `true`, we'll remember the peer and reconnect to it on restart.
 	pub fn connect(
-		&self, node_id: PublicKey, address: NetAddress, permanently: bool,
+		&self, node_id: PublicKey, address: NetAddress, persist: bool,
 	) -> Result<(), Error> {
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
@@ -1096,7 +1096,7 @@ impl Node {
 
 		log_info!(self.logger, "Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
-		if permanently {
+		if persist {
 			self.peer_store.add_peer(peer_info)?;
 		}
 
@@ -1594,17 +1594,43 @@ impl Node {
 
 	/// Retrieves a list of known peers.
 	pub fn list_peers(&self) -> Vec<PeerDetails> {
-		let active_connected_peers: Vec<PublicKey> =
-			self.peer_manager.get_peer_node_ids().iter().map(|p| p.0).collect();
-		self.peer_store
-			.list_peers()
-			.iter()
-			.map(|p| PeerDetails {
+		let mut peers = Vec::new();
+
+		// First add all connected peers, preferring to list the connected address if available.
+		let connected_peers = self.peer_manager.get_peer_node_ids();
+		for (node_id, con_addr_opt) in connected_peers {
+			let stored_peer = self.peer_store.get_peer(&node_id);
+			let stored_addr_opt = stored_peer.as_ref().map(|p| p.address.clone());
+			let address = match (con_addr_opt, stored_addr_opt) {
+				(Some(con_addr), Some(_stored_addr)) => NetAddress(con_addr),
+				(None, Some(stored_addr)) => stored_addr,
+				(Some(con_addr), None) => NetAddress(con_addr),
+				(None, None) => continue,
+			};
+
+			let is_persisted = stored_peer.is_some();
+			let is_connected = true;
+			let details = PeerDetails { node_id, address, is_persisted, is_connected };
+			peers.push(details);
+		}
+
+		// Now add all known-but-offline peers, too.
+		for p in self.peer_store.list_peers() {
+			if peers.iter().find(|d| d.node_id == p.node_id).is_some() {
+				continue;
+			}
+
+			let details = PeerDetails {
 				node_id: p.node_id,
-				address: p.address.clone(),
-				is_connected: active_connected_peers.contains(&p.node_id),
-			})
-			.collect()
+				address: p.address,
+				is_persisted: true,
+				is_connected: false,
+			};
+
+			peers.push(details);
+		}
+
+		peers
 	}
 
 	/// Creates a digital ECDSA signature of a message with the node's secret key.

src/types.rs

@@ -397,11 +397,13 @@ impl From<LdkChannelDetails> for ChannelDetails {
 /// [`Node::list_peers`]: [`crate::Node::list_peers`]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PeerDetails {
-	/// Our peer's node ID.
+	/// The node ID of the peer.
 	pub node_id: PublicKey,
-	/// The IP address and TCP port of the peer.
+	/// The network address of the peer.
 	pub address: NetAddress,
-	/// Indicates whether or not the user is currently has an active connection with the peer.
+	/// Indicates whether we'll try to reconnect to this peer after restarts.
+	pub is_persisted: bool,
+	/// Indicates whether we currently have an active connection with the peer.
 	pub is_connected: bool,
 }