impl ConnectedPeerManager

Author: EthanYuan

mutiny-core/src/lib.rs

@@ -28,7 +28,7 @@ mod networking;
 mod node;
 pub mod nodemanager;
 mod onchain;
-mod peermanager;
+pub mod peermanager;
 pub mod scorer;
 pub mod storage;
 mod subscription;

mutiny-core/src/messagehandler.rs

@@ -10,6 +10,7 @@ use lightning::util::ser::{Writeable, Writer};
 use serde::{Deserialize, Serialize};
 
 use crate::node::LiquidityManager;
+use crate::peermanager::CONNECTED_PEER_MANAGER;
 use crate::storage::MutinyStorage;
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Hash)]
@@ -175,6 +176,14 @@ impl<S: MutinyStorage> CustomMessageHandler for MutinyMessageHandler<S> {
         msg: &lightning::ln::msgs::Init,
         inbound: bool,
     ) -> Result<(), ()> {
+        CONNECTED_PEER_MANAGER.add_peer(
+            *their_node_id,
+            inbound,
+            msg.remote_network_address
+                .as_ref()
+                .map(|addr| format!("{}", addr)),
+        );
+
         if let Some(cb) = self.ln_event_callback.clone() {
             let event = CommonLnEvent::OnConnect {
                 their_node_id: their_node_id.to_string(),
@@ -190,6 +199,8 @@ impl<S: MutinyStorage> CustomMessageHandler for MutinyMessageHandler<S> {
     }
 
     fn peer_disconnected(&self, their_node_id: &PublicKey) {
+        CONNECTED_PEER_MANAGER.remove_peer(their_node_id);
+
         if let Some(cb) = self.ln_event_callback.clone() {
             let event = CommonLnEvent::OnDisconnect {
                 their_node_id: their_node_id.to_string(),

mutiny-core/src/peermanager.rs

@@ -24,8 +24,10 @@ use lightning::routing::gossip::NodeId;
 use lightning::util::logger::Logger;
 use lightning::{ln::msgs::SocketAddress, log_warn};
 use lightning::{log_debug, log_error};
+use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use utils::Mutex;
 
 #[cfg(target_arch = "wasm32")]
 use crate::networking::ws_socket::WsTcpSocketDescriptor;
@@ -36,6 +38,9 @@ use lightning::ln::peer_handler::SocketDescriptor as LdkSocketDescriptor;
 #[cfg(target_arch = "wasm32")]
 use crate::networking::proxy::WsProxy;
 
+pub static CONNECTED_PEER_MANAGER: once_cell::sync::Lazy<ConnectedPeerManager> =
+    once_cell::sync::Lazy::new(ConnectedPeerManager::default);
+
 #[allow(dead_code)]
 pub trait PeerManager: Send + Sync + 'static {
     fn get_peer_node_ids(&self) -> Vec<PublicKey>;
@@ -581,3 +586,88 @@ fn try_parse_addr_string(addr: &str) -> (Option<std::net::SocketAddr>, Option<So
     });
     (socket_addr, net_addr)
 }
+
+#[derive(Debug, Clone)]
+pub struct ConnectedPeerInfo {
+    pub inbound: bool,
+    pub remote_address: Option<String>,
+    pub connected_at_timestamp: u64,
+}
+
+pub struct ConnectedPeerManager {
+    peers: Arc<Mutex<HashMap<PublicKey, ConnectedPeerInfo>>>,
+    logger: Mutex<Option<Arc<MutinyLogger>>>,
+}
+
+impl Default for ConnectedPeerManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ConnectedPeerManager {
+    pub fn new() -> Self {
+        Self {
+            peers: Arc::new(Mutex::new(HashMap::new())),
+            logger: Mutex::new(None),
+        }
+    }
+
+    pub fn set_logger(&self, logger: Arc<MutinyLogger>) {
+        let mut lock = self.logger.lock().unwrap();
+        *lock = Some(logger);
+    }
+
+    pub fn add_peer(
+        &self,
+        their_node_id: PublicKey,
+        inbound: bool,
+        remote_address: Option<String>,
+    ) {
+        let timestamp = utils::now().as_secs();
+
+        let info = ConnectedPeerInfo {
+            inbound,
+            remote_address,
+            connected_at_timestamp: timestamp,
+        };
+
+        let mut peers = self.peers.lock().unwrap();
+        let inserted = peers.insert(their_node_id, info).is_none();
+        let logger = {
+            let guard = self.logger.lock().expect(
+                "
+                Failed to lock logger",
+            );
+            guard.clone()
+        };
+        if inserted {
+            if let Some(logger) = logger {
+                log_debug!(logger, "Connected to peer: {}", their_node_id);
+            }
+        }
+    }
+
+    pub fn remove_peer(&self, their_node_id: &PublicKey) {
+        let mut peers = self.peers.lock().unwrap();
+        let removed = peers.remove(their_node_id).is_some();
+
+        let logger = {
+            let guard = self.logger.lock().expect(
+                "
+                Failed to lock logger",
+            );
+            guard.clone()
+        };
+        if removed {
+            if let Some(logger) = logger {
+                log_debug!(logger, "Disconnected from peer: {}", their_node_id);
+            }
+        }
+    }
+
+    pub fn is_any_connected(&self) -> bool {
+        let lock = self.peers.lock().unwrap();
+        !lock.is_empty()
+    }
+}

mutiny-wasm/src/lib.rs

@@ -32,6 +32,7 @@ use mutiny_core::authmanager::AuthManager;
 use mutiny_core::encrypt::decrypt_with_password;
 use mutiny_core::error::MutinyError;
 use mutiny_core::messagehandler::{CommonLnEvent, CommonLnEventCallback};
+use mutiny_core::peermanager::CONNECTED_PEER_MANAGER;
 use mutiny_core::storage::{DeviceLock, MutinyStorage, DEVICE_LOCK_KEY};
 use mutiny_core::utils::sleep;
 use mutiny_core::vss::{MutinyVssClient, VSS_MANAGER};
@@ -225,6 +226,7 @@ impl MutinyWallet {
         log_info!(logger, "Node version {version}");
 
         VSS_MANAGER.set_logger(logger.clone());
+        CONNECTED_PEER_MANAGER.set_logger(logger.clone());
 
         let cipher = password
             .as_ref()