fix(peer-store/memory-store): don't store remote address as listener

On connection establishment, only the dialer should store the remote's address in the peer store.
From the listener perspective, there is no information if the observed remote address is actually a listening address of the peer.

Pull-Request: #6010.

Author: elenaf9

misc/peer-store/src/memory_store.rs

@@ -15,7 +15,7 @@ use std::{
 };
 
 use libp2p_core::{Multiaddr, PeerId};
-use libp2p_swarm::{DialError, FromSwarm};
+use libp2p_swarm::{behaviour::ConnectionEstablished, DialError, FromSwarm};
 use lru::LruCache;
 
 use super::Store;
@@ -191,21 +191,23 @@ impl<T> Store for MemoryStore<T> {
                     self.push_event_and_wake(crate::store::Event::RecordUpdated(info.peer_id));
                 }
             }
-            FromSwarm::ConnectionEstablished(info) => {
+            FromSwarm::ConnectionEstablished(ConnectionEstablished {
+                peer_id,
+                failed_addresses,
+                endpoint,
+                ..
+            }) if endpoint.is_dialer() => {
                 let mut is_record_updated = false;
                 if self.config.remove_addr_on_dial_error {
-                    for failed_addr in info.failed_addresses {
+                    for failed_addr in *failed_addresses {
                         is_record_updated |=
-                            self.remove_address_silent(&info.peer_id, failed_addr, false);
+                            self.remove_address_silent(peer_id, failed_addr, false);
                     }
                 }
-                is_record_updated |= self.update_address_silent(
-                    &info.peer_id,
-                    info.endpoint.get_remote_address(),
-                    false,
-                );
+                is_record_updated |=
+                    self.update_address_silent(peer_id, endpoint.get_remote_address(), false);
                 if is_record_updated {
-                    self.push_event_and_wake(crate::store::Event::RecordUpdated(info.peer_id));
+                    self.push_event_and_wake(crate::store::Event::RecordUpdated(*peer_id));
                 }
             }
             FromSwarm::DialFailure(info) => {
@@ -302,9 +304,7 @@ impl Config {
     }
     /// If set to `true`, the store will remove addresses if the swarm indicates a dial failure.
     /// More specifically:
-    /// - Failed dials indicated in
-    ///   [`ConnectionEstablished`](libp2p_swarm::behaviour::ConnectionEstablished)'s
-    ///   `failed_addresses` will be removed.
+    /// - Failed dials indicated in [`ConnectionEstablished`]'s `failed_addresses` will be removed.
     /// - [`DialError::LocalPeerId`] causes the full peer entry to be removed.
     /// - On [`DialError::WrongPeerId`], the address will be removed from the incorrect peer's
     ///   record and re-added to the correct peer's record.
@@ -499,6 +499,7 @@ mod test {
         rt.block_on(async {
             let (listen_addr, _) = swarm1.listen().with_memory_addr_external().await;
             let swarm1_peer_id = *swarm1.local_peer_id();
+            let swarm2_peer_id = *swarm2.local_peer_id();
             swarm2.dial(listen_addr.clone()).expect("dial to succeed");
             let handle = spawn_wait_conn_established(swarm1);
             swarm2
@@ -508,12 +509,17 @@ mod test {
                 })
                 .await;
             let mut swarm1 = handle.await.expect("future to complete");
+            expect_record_update(&mut swarm2, swarm1_peer_id).await;
             assert!(swarm2
                 .behaviour()
                 .address_of_peer(&swarm1_peer_id)
                 .expect("swarm should be connected and record about it should be created")
                 .any(|addr| *addr == listen_addr));
-            expect_record_update(&mut swarm1, *swarm2.local_peer_id()).await;
+            // Address from connection is not stored on the listener side.
+            assert!(swarm1
+                .behaviour()
+                .address_of_peer(&swarm2_peer_id)
+                .is_none());
             let (new_listen_addr, _) = swarm1.listen().with_memory_addr_external().await;
             let handle = spawn_wait_conn_established(swarm1);
             swarm2
@@ -590,15 +596,18 @@ mod test {
                 .await
                 .expect("future to complete");
             let mut swarm1 = handle.await.expect("future to complete");
-            // expexting update from direct connection.
             expect_record_update(&mut swarm2, swarm1_peer_id).await;
             assert!(swarm2
                 .behaviour()
                 .peer_store
                 .address_of_peer(&swarm1_peer_id)
                 .expect("swarm should be connected and record about it should be created")
                 .any(|addr| *addr == listen_addr));
-            expect_record_update(&mut swarm1, *swarm2.local_peer_id()).await;
+            assert!(swarm1
+                .behaviour()
+                .peer_store
+                .address_of_peer(&swarm2_peer_id)
+                .is_none());
             swarm1.next_swarm_event().await; // skip `identify::Event::Sent`
             swarm1.next_swarm_event().await; // skip `identify::Event::Received`
             let (new_listen_addr, _) = swarm1.listen().with_memory_addr_external().await;