feat(rpc): Include more peer info

node/src/rpc/mod.rs

@@ -153,6 +153,7 @@ pub enum ActionStatsResponse {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum PeerConnectionStatus {
+    Disconnecting,
     Disconnected,
     Connecting,
     Connected,
@@ -166,8 +167,10 @@ pub struct RpcPeerInfo {
     pub best_tip_global_slot: Option<u32>,
     pub best_tip_timestamp: Option<u64>,
     pub connection_status: PeerConnectionStatus,
+    pub connecting_details: Option<String>,
     pub address: Option<String>,
     pub incoming: bool,
+    pub is_libp2p: bool,
     pub time: u64,
 }
 

node/src/rpc/rpc_reducer.rs

@@ -637,31 +637,46 @@ pub fn collect_rpc_peers_info(state: &crate::State) -> Vec<RpcPeerInfo> {
             .iter()
             .map(|(peer_id, state)| {
                 let best_tip = state.status.as_ready().and_then(|r| r.best_tip.as_ref());
-                let (connection_status, time, incoming) = match &state.status {
+                let (connection_status, time, incoming, connecting_details) = match &state.status {
                     p2p::P2pPeerStatus::Connecting(c) => match c {
-                        p2p::connection::P2pConnectionState::Outgoing(o) => {
-                            (PeerConnectionStatus::Connecting, o.time().into(), false)
-                        }
-                        p2p::connection::P2pConnectionState::Incoming(i) => {
-                            (PeerConnectionStatus::Connecting, i.time().into(), true)
-                        }
+                        p2p::connection::P2pConnectionState::Outgoing(o) => (
+                            PeerConnectionStatus::Connecting,
+                            o.time().into(),
+                            false,
+                            Some(format!("{o:?}")),
+                        ),
+                        p2p::connection::P2pConnectionState::Incoming(i) => (
+                            PeerConnectionStatus::Connecting,
+                            i.time().into(),
+                            true,
+                            Some(format!("{i:?}")),
+                        ),
                     },
-                    p2p::P2pPeerStatus::Disconnecting { time } => {
-                        (PeerConnectionStatus::Disconnected, (*time).into(), false)
-                    }
-                    p2p::P2pPeerStatus::Disconnected { time } => {
-                        (PeerConnectionStatus::Disconnected, (*time).into(), false)
-                    }
+                    p2p::P2pPeerStatus::Disconnecting { time } => (
+                        PeerConnectionStatus::Disconnecting,
+                        (*time).into(),
+                        false,
+                        None,
+                    ),
+                    p2p::P2pPeerStatus::Disconnected { time } => (
+                        PeerConnectionStatus::Disconnected,
+                        (*time).into(),
+                        false,
+                        None,
+                    ),
                     p2p::P2pPeerStatus::Ready(r) => (
                         PeerConnectionStatus::Connected,
                         r.connected_since.into(),
                         r.is_incoming,
+                        None,
                     ),
                 };
                 RpcPeerInfo {
                     peer_id: *peer_id,
                     connection_status,
+                    connecting_details,
                     address: state.dial_opts.as_ref().map(|opts| opts.to_string()),
+                    is_libp2p: state.is_libp2p,
                     incoming,
                     best_tip: best_tip.map(|bt| bt.hash.clone()),
                     best_tip_height: best_tip.map(|bt| bt.height()),