Expose API for PublicAddresses

examples/custom_executor.rs

@@ -122,7 +122,7 @@ async fn main() {
 
     // dial `litep2p1`
     litep2p2
-        .dial_address(litep2p1.listen_addresses().next().unwrap().clone())
+        .dial_address(litep2p1.public_addresses().get_addresses().get(0).unwrap().clone())
         .await
         .unwrap();
 

examples/custom_protocol.rs

@@ -277,7 +277,7 @@ async fn main() {
     let (mut litep2p2, mut handle2) = make_litep2p();
 
     let peer2 = *litep2p2.local_peer_id();
-    let listen_address = litep2p2.listen_addresses().next().unwrap().clone();
+    let listen_address = litep2p2.public_addresses().get_addresses().get(0).unwrap().clone();
     litep2p1.add_known_address(peer2, std::iter::once(listen_address));
 
     tokio::spawn(async move {

examples/echo_notification.rs

@@ -125,7 +125,7 @@ async fn main() {
 
     // get the first (and only) listen address for the second peer
     // and add it as a known address for `litep2p1`
-    let listen_address = litep2p2.listen_addresses().next().unwrap().clone();
+    let listen_address = litep2p2.public_addresses().get_addresses().get(0).unwrap().clone();
     let peer = *litep2p2.local_peer_id();
 
     litep2p1.add_known_address(peer, vec![listen_address].into_iter());

examples/gossiping.rs

@@ -237,7 +237,7 @@ async fn main() {
 
     // establish connection to litep2p for all other litep2ps
     let peer2 = *litep2p2.local_peer_id();
-    let listen_address = litep2p2.listen_addresses().next().unwrap().clone();
+    let listen_address = litep2p2.public_addresses().get_addresses().get(0).unwrap().clone();
 
     litep2p1.add_known_address(peer2, vec![listen_address.clone()].into_iter());
     litep2p3.add_known_address(peer2, vec![listen_address.clone()].into_iter());

src/lib.rs

@@ -30,12 +30,14 @@
 
 use crate::{
     config::Litep2pConfig,
+    error::DialError,
     protocol::{
         libp2p::{bitswap::Bitswap, identify::Identify, kademlia::Kademlia, ping::Ping},
         mdns::Mdns,
         notification::NotificationProtocol,
         request_response::RequestResponseProtocol,
     },
+    public_addresses::PublicAddresses,
     transport::{
         manager::{SupportedTransport, TransportManager},
         tcp::TcpTransport,
@@ -50,9 +52,7 @@ use crate::transport::webrtc::WebRtcTransport;
 #[cfg(feature = "websocket")]
 use crate::transport::websocket::WebSocketTransport;
 
-use error::DialError;
-use multiaddr::{Multiaddr, Protocol};
-use multihash::Multihash;
+use multiaddr::Multiaddr;
 use transport::Endpoint;
 use types::ConnectionId;
 
@@ -71,6 +71,7 @@ pub mod crypto;
 pub mod error;
 pub mod executor;
 pub mod protocol;
+pub mod public_addresses;
 pub mod substream;
 pub mod transport;
 pub mod types;
@@ -138,7 +139,7 @@ pub struct Litep2p {
     local_peer_id: PeerId,
 
     /// Listen addresses.
-    listen_addresses: Vec<Multiaddr>,
+    listen_addresses: PublicAddresses,
 
     /// Transport manager.
     transport_manager: TransportManager,
@@ -152,7 +153,6 @@ impl Litep2p {
     pub fn new(mut litep2p_config: Litep2pConfig) -> crate::Result<Litep2p> {
         let local_peer_id = PeerId::from_public_key(&litep2p_config.keypair.public().into());
         let bandwidth_sink = BandwidthSink::new();
-        let mut listen_addresses = vec![];
 
         let supported_transports = Self::supported_transports(&litep2p_config);
         let (mut transport_manager, transport_handle) = TransportManager::new(
@@ -315,9 +315,6 @@ impl Litep2p {
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
-                listen_addresses.push(address.with(Protocol::P2p(
-                    Multihash::from_bytes(&local_peer_id.to_bytes()).unwrap(),
-                )));
             }
 
             transport_manager.register_transport(SupportedTransport::Tcp, Box::new(transport));
@@ -332,9 +329,6 @@ impl Litep2p {
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
-                listen_addresses.push(address.with(Protocol::P2p(
-                    Multihash::from_bytes(&local_peer_id.to_bytes()).unwrap(),
-                )));
             }
 
             transport_manager.register_transport(SupportedTransport::Quic, Box::new(transport));
@@ -349,9 +343,6 @@ impl Litep2p {
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
-                listen_addresses.push(address.with(Protocol::P2p(
-                    Multihash::from_bytes(&local_peer_id.to_bytes()).unwrap(),
-                )));
             }
 
             transport_manager.register_transport(SupportedTransport::WebRtc, Box::new(transport));
@@ -366,18 +357,17 @@ impl Litep2p {
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
-                listen_addresses.push(address.with(Protocol::P2p(
-                    Multihash::from_bytes(&local_peer_id.to_bytes()).unwrap(),
-                )));
             }
 
             transport_manager
                 .register_transport(SupportedTransport::WebSocket, Box::new(transport));
         }
 
+        let listen_addresses = transport_manager.public_addresses();
+
         // enable mdns if the config exists
         if let Some(config) = litep2p_config.mdns.take() {
-            let mdns = Mdns::new(transport_handle, config, listen_addresses.clone())?;
+            let mdns = Mdns::new(transport_handle, config, listen_addresses.get_addresses())?;
 
             litep2p_config.executor.run(Box::pin(async move {
                 let _ = mdns.start().await;
@@ -387,7 +377,7 @@ impl Litep2p {
         // if identify was enabled, give it the enabled protocols and listen addresses and start it
         if let Some((service, mut identify_config)) = identify_info.take() {
             identify_config.protocols = transport_manager.protocols().cloned().collect();
-            let identify = Identify::new(service, identify_config, listen_addresses.clone());
+            let identify = Identify::new(service, identify_config);
 
             litep2p_config.executor.run(Box::pin(async move {
                 let _ = identify.run().await;
@@ -399,7 +389,7 @@ impl Litep2p {
         }
 
         // verify that at least one transport is specified
-        if listen_addresses.is_empty() {
+        if listen_addresses.inner.read().is_empty() {
             tracing::warn!(
                 target: LOG_TARGET,
                 "litep2p started with no listen addresses, cannot accept inbound connections",
@@ -450,9 +440,9 @@ impl Litep2p {
         &self.local_peer_id
     }
 
-    /// Get listen address of litep2p.
-    pub fn listen_addresses(&self) -> impl Iterator<Item = &Multiaddr> {
-        self.listen_addresses.iter()
+    /// Get the list of public addresses of the node.
+    pub fn public_addresses(&self) -> PublicAddresses {
+        self.listen_addresses.clone()
     }
 
     /// Get handle to bandwidth sink.
@@ -473,7 +463,7 @@ impl Litep2p {
     /// Add one ore more known addresses for peer.
     ///
     /// Return value denotes how many addresses were added for the peer.
-    // Addresses belonging to disabled/unsupported transports will be ignored.
+    /// Addresses belonging to disabled/unsupported transports will be ignored.
     pub fn add_known_address(
         &mut self,
         peer: PeerId,

src/protocol/libp2p/identify.rs

@@ -25,14 +25,15 @@ use crate::{
     crypto::PublicKey,
     error::{Error, SubstreamError},
     protocol::{Direction, TransportEvent, TransportService},
+    public_addresses::PublicAddresses,
     substream::Substream,
     transport::Endpoint,
     types::{protocol::ProtocolName, SubstreamId},
     PeerId, DEFAULT_CHANNEL_SIZE,
 };
 
 use futures::{future::BoxFuture, stream::FuturesUnordered, Stream, StreamExt};
-use multiaddr::Multiaddr;
+use multiaddr::{Multiaddr, Protocol};
 use prost::Message;
 use tokio::sync::mpsc::{channel, Sender};
 use tokio_stream::wrappers::ReceiverStream;
@@ -183,7 +184,7 @@ pub(crate) struct Identify {
     user_agent: String,
 
     /// Public addresses.
-    listen_addresses: HashSet<Multiaddr>,
+    listen_addresses: PublicAddresses,
 
     /// Protocols supported by the local node, filled by `Litep2p`.
     protocols: Vec<String>,
@@ -200,16 +201,31 @@ pub(crate) struct Identify {
 
 impl Identify {
     /// Create new [`Identify`] protocol.
-    pub(crate) fn new(
-        service: TransportService,
-        config: Config,
-        listen_addresses: Vec<Multiaddr>,
-    ) -> Self {
+    pub(crate) fn new(service: TransportService, config: Config) -> Self {
+        let listen_addresses = service.public_addresses();
+
+        let local_peer_id = service.local_peer_id();
+        let filtered_public_addr = config.public_addresses.into_iter().filter_map(|address| {
+            if address.is_empty() {
+                return None;
+            }
+            if let Some(peer_id) = PeerId::try_from_multiaddr(&address) {
+                if peer_id != local_peer_id {
+                    return None;
+                }
+
+                return Some(address);
+            }
+
+            Some(address.with(Protocol::P2p(local_peer_id.into())))
+        });
+        listen_addresses.inner.write().extend(filtered_public_addr);
+
         Self {
             service,
             tx: config.tx_event,
             peers: HashMap::new(),
-            listen_addresses: config.public_addresses.into_iter().chain(listen_addresses).collect(),
+            listen_addresses,
             public: config.public.expect("public key to be supplied"),
             protocol_version: config.protocol_version,
             user_agent: config.user_agent.unwrap_or(DEFAULT_AGENT.to_string()),
@@ -265,15 +281,13 @@ impl Identify {
             }
         };
 
+        let listen_addrs =
+            self.listen_addresses.inner.read().iter().map(|addr| addr.to_vec()).collect();
         let identify = identify_schema::Identify {
             protocol_version: Some(self.protocol_version.clone()),
             agent_version: Some(self.user_agent.clone()),
             public_key: Some(self.public.to_protobuf_encoding()),
-            listen_addrs: self
-                .listen_addresses
-                .iter()
-                .map(|address| address.to_vec())
-                .collect::<Vec<_>>(),
+            listen_addrs,
             observed_addr,
             protocols: self.protocols.clone(),
         };
@@ -413,3 +427,79 @@ impl Identify {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{config::ConfigBuilder, transport::tcp::config::Config as TcpConfig, Litep2p};
+    use multiaddr::{Multiaddr, Protocol};
+
+    fn create_litep2p() -> (
+        Litep2p,
+        Box<dyn Stream<Item = IdentifyEvent> + Send + Unpin>,
+        PeerId,
+    ) {
+        let (identify_config, identify) = Config::new(
+            "1.0.0".to_string(),
+            Some("litep2p/1.0.0".to_string()),
+            vec![Multiaddr::empty()],
+        );
+
+        let keypair = crate::crypto::ed25519::Keypair::generate();
+        let peer = PeerId::from_public_key(&crate::crypto::PublicKey::Ed25519(keypair.public()));
+        let config = ConfigBuilder::new()
+            .with_keypair(keypair)
+            .with_tcp(TcpConfig {
+                listen_addresses: vec!["/ip6/::1/tcp/0".parse().unwrap()],
+                ..Default::default()
+            })
+            .with_libp2p_identify(identify_config)
+            .build();
+
+        (Litep2p::new(config).unwrap(), identify, peer)
+    }
+
+    #[tokio::test]
+    async fn update_identify_addresses() {
+        // Create two instances of litep2p
+        let (mut litep2p1, mut event_stream1, peer1) = create_litep2p();
+        let (mut litep2p2, mut event_stream2, _peer2) = create_litep2p();
+        let litep2p1_address =
+            litep2p1.public_addresses().get_addresses().into_iter().next().unwrap();
+
+        let multiaddr: Multiaddr = "/ip6/::9/tcp/111".parse().unwrap();
+        // Litep2p1 is now reporting the new address.
+        assert!(litep2p1.public_addresses().add_public_address(multiaddr.clone()).unwrap());
+
+        // Dial `litep2p1`
+        litep2p2.dial_address(litep2p1_address).await.unwrap();
+
+        let expected_multiaddr = multiaddr.with(Protocol::P2p(peer1.into()));
+
+        tokio::spawn(async move {
+            loop {
+                tokio::select! {
+                    _ = litep2p1.next_event() => {}
+                    _event = event_stream1.next() => {}
+                }
+            }
+        });
+
+        loop {
+            tokio::select! {
+                _ = litep2p2.next_event() => {}
+                event = event_stream2.next() => match event {
+                    Some(IdentifyEvent::PeerIdentified {
+                        listen_addresses,
+                        ..
+                    }) => {
+                        println!(" listen_addresses: {:?}", listen_addresses);
+                        assert!(listen_addresses.iter().any(|address| address == &expected_multiaddr));
+                        break;
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}

src/protocol/transport_service.rs

@@ -21,6 +21,7 @@
 use crate::{
     error::Error,
     protocol::{connection::ConnectionHandle, InnerTransportEvent, TransportEvent},
+    public_addresses::PublicAddresses,
     transport::{manager::TransportManagerHandle, Endpoint},
     types::{protocol::ProtocolName, ConnectionId, SubstreamId},
     PeerId, DEFAULT_CHANNEL_SIZE,
@@ -150,13 +151,18 @@ impl TransportService {
                 transport_handle,
                 next_substream_id,
                 connections: HashMap::new(),
-                keep_alive_timeout: keep_alive_timeout,
+                keep_alive_timeout,
                 pending_keep_alive_timeouts: FuturesUnordered::new(),
             },
             tx,
         )
     }
 
+    /// Get the list of public addresses of the node.
+    pub fn public_addresses(&self) -> PublicAddresses {
+        self.transport_handle.public_addresses()
+    }
+
     /// Handle connection established event.
     fn on_connection_established(
         &mut self,
@@ -444,7 +450,7 @@ mod tests {
             Arc::new(RwLock::new(HashMap::new())),
             cmd_tx,
             HashSet::new(),
-            Default::default(),
+            PublicAddresses::new(peer),
         );
 
         let (service, sender) = TransportService::new(