feat: add getaddednodeinfo rpc

crates/floresta-wire/src/p2p_wire/node/peer_man.rs

@@ -35,6 +35,8 @@ use crate::node_context::NodeContext;
 use crate::node_context::PeerId;
 use crate::node_handle::NodeResponse;
 use crate::node_handle::UserRequest;
+use crate::node_interface::AddedNodeAddress;
+use crate::node_interface::AddedNodeInfo;
 use crate::node_interface::PeerInfo;
 use crate::p2p_wire::error::WireError;
 use crate::p2p_wire::peer::PeerMessages;
@@ -849,6 +851,45 @@ where
         })
     }
 
+    pub(crate) fn handle_get_added_node_info(
+        &self,
+        node: Option<BitcoinSocketAddr>,
+    ) -> Vec<AddedNodeInfo> {
+        self.added_peers
+            .iter()
+            .filter_map(|added| {
+                // If a node filter is specified, skip entries that don't match
+                if let Some(filter) = &node {
+                    if &added.address != filter {
+                        return None;
+                    }
+                }
+
+                let connected = self.peers.values().any(|peer| {
+                    peer.address.as_bitcoin_socket_addr() == &added.address
+                        && peer.state == PeerStatus::Ready
+                });
+
+                let addr_str = added.address.to_string();
+
+                let addresses = if connected {
+                    vec![AddedNodeAddress {
+                        address: addr_str.clone(),
+                        connected: "outbound".to_string(),
+                    }]
+                } else {
+                    vec![]
+                };
+
+                Some(AddedNodeInfo {
+                    addednode: addr_str,
+                    connected,
+                    addresses,
+                })
+            })
+            .collect()
+    }
+
     // === ADDNODE ===
 
     /// Handles addnode-RPC `Add` requests, adding a new peer to the `added_peers` list. This means

crates/floresta-wire/src/p2p_wire/node/user_req.rs

@@ -167,6 +167,12 @@ where
                 return;
             }
 
+            UserRequest::GetAddedNodeInfo(node) => {
+                let info = self.handle_get_added_node_info(node);
+                try_and_log!(responder.send(NodeResponse::GetAddedNodeInfo(info)));
+                return;
+            }
+
             UserRequest::SendTransaction(transaction) => {
                 let txid = transaction.compute_txid();
                 let mut mempool = self.mempool.lock().await;

crates/floresta-wire/src/p2p_wire/node_handle.rs

@@ -30,6 +30,7 @@ use super::UtreexoNodeConfig;
 use super::node::NodeNotification;
 use crate::address_man::ConnectionStats;
 use crate::bitcoin_socket_addr::BitcoinSocketAddr;
+use crate::node_interface::AddedNodeInfo;
 use crate::node_interface::ChainMethods;
 use crate::node_interface::MempoolMethods;
 use crate::node_interface::NetworkMethods;
@@ -93,6 +94,9 @@ pub enum UserRequest {
 
     /// Return address manager statistics.
     GetAddrManInfo,
+
+    /// Request for data regarding added nodes possibly filter by a provided one
+    GetAddedNodeInfo(Option<BitcoinSocketAddr>),
 }
 
 #[derive(Debug)]
@@ -139,6 +143,9 @@ pub enum NodeResponse {
 
     /// Address manager statistics.
     GetAddrManInfo(ConnectionStats),
+
+    /// Request for data regarding added nodes possibly filter by a provided one
+    GetAddedNodeInfo(Vec<AddedNodeInfo>),
 }
 
 #[derive(Debug)]
@@ -271,6 +278,17 @@ impl NetworkMethods for NodeHandle {
         extract_variant!(Ping, val)
     }
 
+    async fn get_added_node_info(
+        &self,
+        node: Option<BitcoinSocketAddr>,
+    ) -> Result<Vec<AddedNodeInfo>, Self::Error> {
+        let val = self
+            .send_request(UserRequest::GetAddedNodeInfo(node))
+            .await?;
+
+        extract_variant!(GetAddedNodeInfo, val)
+    }
+
     async fn get_addrman_info(&self) -> Result<ConnectionStats, Self::Error> {
         let val = self.send_request(UserRequest::GetAddrManInfo).await?;
 

crates/floresta-wire/src/p2p_wire/node_interface.rs

@@ -108,6 +108,33 @@ pub enum UserRequest {
 
     /// Return address manager statistics.
     GetAddrManInfo,
+
+    /// Return information about manually added nodes, optionally filtered by address.
+    GetAddedNodeInfo(Option<BitcoinSocketAddr>),
+}
+
+#[derive(Debug, Clone, Serialize)]
+/// Information about a manually added node (via `addnode`).
+pub struct AddedNodeInfo {
+    /// The address of the added node in "ip:port" format.
+    pub addednode: String,
+
+    /// Whether we are currently connected to this node.
+    pub connected: bool,
+
+    /// Connection details. Only populated when `connected` is true.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub addresses: Vec<AddedNodeAddress>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+/// Address information for a connected added node.
+pub struct AddedNodeAddress {
+    /// The peer address in "ip:port" format.
+    pub address: String,
+
+    /// The connection direction: "outbound" (Floresta does not accept inbound).
+    pub connected: String,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -213,6 +240,12 @@ pub trait NetworkMethods {
     /// about a single peer.
     fn get_peer_info(&self) -> impl Future<Output = Result<Vec<PeerInfo>, Self::Error>>;
 
+    /// Information about all manually added nodes possibly filtering by a given one.
+    fn get_added_node_info(
+        &self,
+        node: Option<BitcoinSocketAddr>,
+    ) -> impl Future<Output = Result<Vec<AddedNodeInfo>, Self::Error>>;
+
     /// Returns the number of peers currently connected to the node
     fn get_connection_count(&self) -> impl Future<Output = Result<usize, Self::Error>>;