refactor!: Move ConnectionId and PendingPoint to libp2p-swarm (#3346)

Both of these are only needed as part of `libp2p-swarm`. Them residing in `libp2p-core` is a left-over from when `libp2p-core` still contained `Pool`.

core/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 0.39.0 [unreleased]
+
+- Move `ConnectionId` to `libp2p-swarm`. See [PR 3221].
+- Move `PendingPoint` to `libp2p-swarm` and make it crate-private. See [PR 3221].
+
+[PR 3221]: https://github.com/libp2p/rust-libp2p/pull/3221
+
 # 0.38.0
 
 - Remove deprecated functions `StreamMuxerExt::next_{inbound,outbound}`. See [PR 3031].

core/src/connection.rs

@@ -20,29 +20,6 @@
 
 use crate::multiaddr::{Multiaddr, Protocol};
 
-/// Connection identifier.
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct ConnectionId(usize);
-
-impl ConnectionId {
-    /// Creates a `ConnectionId` from a non-negative integer.
-    ///
-    /// This is primarily useful for creating connection IDs
-    /// in test environments. There is in general no guarantee
-    /// that all connection IDs are based on non-negative integers.
-    pub fn new(id: usize) -> Self {
-        Self(id)
-    }
-}
-
-impl std::ops::Add<usize> for ConnectionId {
-    type Output = Self;
-
-    fn add(self, other: usize) -> Self {
-        Self(self.0 + other)
-    }
-}
-
 /// The endpoint roles associated with a peer-to-peer communication channel.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Endpoint {
@@ -75,42 +52,6 @@ impl Endpoint {
     }
 }
 
-/// The endpoint roles associated with a pending peer-to-peer connection.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum PendingPoint {
-    /// The socket comes from a dialer.
-    ///
-    /// There is no single address associated with the Dialer of a pending
-    /// connection. Addresses are dialed in parallel. Only once the first dial
-    /// is successful is the address of the connection known.
-    Dialer {
-        /// Same as [`ConnectedPoint::Dialer`] `role_override`.
-        role_override: Endpoint,
-    },
-    /// The socket comes from a listener.
-    Listener {
-        /// Local connection address.
-        local_addr: Multiaddr,
-        /// Address used to send back data to the remote.
-        send_back_addr: Multiaddr,
-    },
-}
-
-impl From<ConnectedPoint> for PendingPoint {
-    fn from(endpoint: ConnectedPoint) -> Self {
-        match endpoint {
-            ConnectedPoint::Dialer { role_override, .. } => PendingPoint::Dialer { role_override },
-            ConnectedPoint::Listener {
-                local_addr,
-                send_back_addr,
-            } => PendingPoint::Listener {
-                local_addr,
-                send_back_addr,
-            },
-        }
-    }
-}
-
 /// The endpoint roles associated with an established peer-to-peer connection.
 #[derive(PartialEq, Eq, Debug, Clone, Hash)]
 pub enum ConnectedPoint {

protocols/autonat/src/behaviour.rs

@@ -28,9 +28,7 @@ use as_server::AsServer;
 pub use as_server::{InboundProbeError, InboundProbeEvent};
 use futures_timer::Delay;
 use instant::Instant;
-use libp2p_core::{
+use libp2p_core::{multiaddr::Protocol, ConnectedPoint, Endpoint, Multiaddr, PeerId};
-    connection::ConnectionId, multiaddr::Protocol, ConnectedPoint, Endpoint, Multiaddr, PeerId,
-};
 use libp2p_request_response::{
     self as request_response, ProtocolSupport, RequestId, ResponseChannel,
 };
@@ -39,8 +37,8 @@ use libp2p_swarm::{
         AddressChange, ConnectionClosed, ConnectionEstablished, DialFailure, ExpiredExternalAddr,
         ExpiredListenAddr, FromSwarm,
     },
-    ConnectionHandler, ExternalAddresses, IntoConnectionHandler, ListenAddresses, NetworkBehaviour,
+    ConnectionHandler, ConnectionId, ExternalAddresses, IntoConnectionHandler, ListenAddresses,
-    NetworkBehaviourAction, PollParameters,
+    NetworkBehaviour, NetworkBehaviourAction, PollParameters,
 };
 use std::{
     collections::{HashMap, VecDeque},

protocols/autonat/src/behaviour/as_client.rs

@@ -27,10 +27,11 @@ use super::{
 use futures::FutureExt;
 use futures_timer::Delay;
 use instant::Instant;
-use libp2p_core::{connection::ConnectionId, Multiaddr, PeerId};
+use libp2p_core::{Multiaddr, PeerId};
 use libp2p_request_response::{self as request_response, OutboundFailure, RequestId};
 use libp2p_swarm::{
-    AddressScore, ExternalAddresses, ListenAddresses, NetworkBehaviourAction, PollParameters,
+    AddressScore, ConnectionId, ExternalAddresses, ListenAddresses, NetworkBehaviourAction,
+    PollParameters,
 };
 use rand::{seq::SliceRandom, thread_rng};
 use std::{

protocols/autonat/src/behaviour/as_server.rs

@@ -23,13 +23,13 @@ use super::{
     ResponseError,
 };
 use instant::Instant;
-use libp2p_core::{connection::ConnectionId, multiaddr::Protocol, Multiaddr, PeerId};
+use libp2p_core::{multiaddr::Protocol, Multiaddr, PeerId};
 use libp2p_request_response::{
     self as request_response, InboundFailure, RequestId, ResponseChannel,
 };
 use libp2p_swarm::{
     dial_opts::{DialOpts, PeerCondition},
-    DialError, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
+    ConnectionId, DialError, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
 };
 use std::{
     collections::{HashMap, HashSet, VecDeque},

protocols/dcutr/src/behaviour_impl.rs

@@ -22,11 +22,12 @@
 
 use crate::handler;
 use either::Either;
-use libp2p_core::connection::{ConnectedPoint, ConnectionId};
+use libp2p_core::connection::ConnectedPoint;
 use libp2p_core::multiaddr::Protocol;
 use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm};
 use libp2p_swarm::dial_opts::{self, DialOpts};
+use libp2p_swarm::ConnectionId;
 use libp2p_swarm::{
     ConnectionHandler, ConnectionHandlerUpgrErr, ExternalAddresses, IntoConnectionHandler,
     NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,

protocols/dcutr/src/handler.rs

@@ -20,12 +20,11 @@
 
 use crate::protocol;
 use either::Either;
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::DeniedUpgrade;
 use libp2p_core::{ConnectedPoint, PeerId};
 use libp2p_swarm::dummy;
 use libp2p_swarm::handler::SendWrapper;
-use libp2p_swarm::{ConnectionHandler, IntoConnectionHandler};
+use libp2p_swarm::{ConnectionHandler, ConnectionId, IntoConnectionHandler};
 
 pub mod direct;
 pub mod relayed;

protocols/dcutr/src/handler/direct.rs

@@ -20,11 +20,10 @@
 
 //! [`ConnectionHandler`] handling direct connection upgraded through a relayed connection.
 
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::DeniedUpgrade;
 use libp2p_swarm::handler::ConnectionEvent;
 use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr, KeepAlive,
+    ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr, ConnectionId, KeepAlive,
     SubstreamProtocol,
 };
 use std::task::{Context, Poll};

protocols/floodsub/src/layer.rs

@@ -26,11 +26,11 @@ use crate::topic::Topic;
 use crate::FloodsubConfig;
 use cuckoofilter::{CuckooError, CuckooFilter};
 use fnv::FnvHashSet;
-use libp2p_core::{connection::ConnectionId, PeerId};
+use libp2p_core::PeerId;
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, FromSwarm};
 use libp2p_swarm::{
-    dial_opts::DialOpts, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, OneShotHandler,
+    dial_opts::DialOpts, ConnectionId, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
-    PollParameters,
+    OneShotHandler, PollParameters,
 };
 use libp2p_swarm::{ConnectionHandler, IntoConnectionHandler};
 use log::warn;

protocols/gossipsub/src/behaviour.rs

@@ -36,14 +36,13 @@ use prost::Message;
 use rand::{seq::SliceRandom, thread_rng};
 
 use libp2p_core::{
-    connection::ConnectionId, identity::Keypair, multiaddr::Protocol::Ip4,
+    identity::Keypair, multiaddr::Protocol::Ip4, multiaddr::Protocol::Ip6, Multiaddr, PeerId,
-    multiaddr::Protocol::Ip6, Multiaddr, PeerId,
 };
 use libp2p_swarm::{
     behaviour::{AddressChange, ConnectionClosed, ConnectionEstablished, FromSwarm},
     dial_opts::DialOpts,
-    ConnectionHandler, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction,
+    ConnectionHandler, ConnectionId, IntoConnectionHandler, NetworkBehaviour,
-    NotifyHandler, PollParameters,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use wasm_timer::Instant;
 

protocols/gossipsub/src/types.rs

@@ -21,7 +21,8 @@
 //! A collection of types using the Gossipsub system.
 use crate::rpc_proto;
 use crate::TopicHash;
-use libp2p_core::{connection::ConnectionId, PeerId};
+use libp2p_core::PeerId;
+use libp2p_swarm::ConnectionId;
 use prometheus_client::encoding::EncodeLabelValue;
 use prost::Message;
 use std::fmt;

protocols/identify/src/behaviour.rs

@@ -20,10 +20,9 @@
 
 use crate::handler::{self, InEvent, Proto};
 use crate::protocol::{Info, Protocol, UpgradeError};
-use libp2p_core::{
+use libp2p_core::{multiaddr, ConnectedPoint, Multiaddr, PeerId, PublicKey};
-    connection::ConnectionId, multiaddr, ConnectedPoint, Multiaddr, PeerId, PublicKey,
-};
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm};
+use libp2p_swarm::ConnectionId;
 use libp2p_swarm::{
     dial_opts::DialOpts, AddressScore, ConnectionHandler, ConnectionHandlerUpgrErr, DialError,
     ExternalAddresses, IntoConnectionHandler, ListenAddresses, NetworkBehaviour,

protocols/identify/src/protocol.rs

@@ -22,11 +22,11 @@ use crate::structs_proto;
 use asynchronous_codec::{FramedRead, FramedWrite};
 use futures::{future::BoxFuture, prelude::*};
 use libp2p_core::{
-    connection::ConnectionId,
     identity, multiaddr,
     upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo},
     Multiaddr, PublicKey,
 };
+use libp2p_swarm::ConnectionId;
 use log::{debug, trace};
 use std::convert::TryFrom;
 use std::{io, iter, pin::Pin};

protocols/kad/src/behaviour.rs

@@ -39,14 +39,14 @@ use crate::record::{
 use crate::K_VALUE;
 use fnv::{FnvHashMap, FnvHashSet};
 use instant::Instant;
-use libp2p_core::{connection::ConnectionId, ConnectedPoint, Multiaddr, PeerId};
+use libp2p_core::{ConnectedPoint, Multiaddr, PeerId};
 use libp2p_swarm::behaviour::{
     AddressChange, ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm,
 };
 use libp2p_swarm::{
     dial_opts::{self, DialOpts},
-    DialError, ExternalAddresses, ListenAddresses, NetworkBehaviour, NetworkBehaviourAction,
+    ConnectionId, DialError, ExternalAddresses, ListenAddresses, NetworkBehaviour,
-    NotifyHandler, PollParameters,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use log::{debug, info, warn};
 use smallvec::SmallVec;

protocols/kad/src/behaviour/test.rs

@@ -28,7 +28,7 @@ use crate::K_VALUE;
 use futures::{executor::block_on, future::poll_fn, prelude::*};
 use futures_timer::Delay;
 use libp2p_core::{
-    connection::{ConnectedPoint, ConnectionId},
+    connection::ConnectedPoint,
     identity,
     multiaddr::{multiaddr, Multiaddr, Protocol},
     multihash::{Code, Multihash, MultihashDigest},
@@ -36,7 +36,7 @@ use libp2p_core::{
     upgrade, Endpoint, PeerId, Transport,
 };
 use libp2p_noise as noise;
-use libp2p_swarm::{Swarm, SwarmEvent};
+use libp2p_swarm::{ConnectionId, Swarm, SwarmEvent};
 use libp2p_yamux as yamux;
 use quickcheck::*;
 use rand::{random, rngs::StdRng, thread_rng, Rng, SeedableRng};

protocols/mdns/src/behaviour.rs

@@ -189,7 +189,7 @@ where
     fn on_connection_handler_event(
         &mut self,
         _: PeerId,
-        _: libp2p_core::connection::ConnectionId,
+        _: libp2p_swarm::ConnectionId,
         ev: <Self::ConnectionHandler as ConnectionHandler>::OutEvent,
     ) {
         void::unreachable(ev)

protocols/ping/src/lib.rs

@@ -47,9 +47,9 @@ mod protocol;
 
 use handler::Handler;
 pub use handler::{Config, Failure, Success};
-use libp2p_core::{connection::ConnectionId, PeerId};
+use libp2p_core::PeerId;
 use libp2p_swarm::{
-    behaviour::FromSwarm, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
+    behaviour::FromSwarm, ConnectionId, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
 };
 use std::{
     collections::VecDeque,

protocols/relay/src/behaviour.rs

@@ -27,13 +27,12 @@ use crate::message_proto;
 use crate::protocol::{inbound_hop, outbound_stop};
 use either::Either;
 use instant::Instant;
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::multiaddr::Protocol;
 use libp2p_core::PeerId;
 use libp2p_swarm::behaviour::{ConnectionClosed, FromSwarm};
 use libp2p_swarm::{
-    ConnectionHandlerUpgrErr, ExternalAddresses, NetworkBehaviour, NetworkBehaviourAction,
+    ConnectionHandlerUpgrErr, ConnectionId, ExternalAddresses, NetworkBehaviour,
-    NotifyHandler, PollParameters,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use std::collections::{hash_map, HashMap, HashSet, VecDeque};
 use std::num::NonZeroU32;

protocols/relay/src/behaviour/handler.rs

@@ -30,14 +30,13 @@ use futures::io::AsyncWriteExt;
 use futures::stream::{FuturesUnordered, StreamExt};
 use futures_timer::Delay;
 use instant::Instant;
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::{upgrade, ConnectedPoint, Multiaddr, PeerId};
 use libp2p_swarm::handler::{
     ConnectionEvent, DialUpgradeError, FullyNegotiatedInbound, FullyNegotiatedOutbound,
     ListenUpgradeError, SendWrapper,
 };
 use libp2p_swarm::{
-    dummy, ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr,
+    dummy, ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr, ConnectionId,
     IntoConnectionHandler, KeepAlive, NegotiatedSubstream, SubstreamProtocol,
 };
 use std::collections::VecDeque;

protocols/relay/src/priv_client.rs

@@ -32,13 +32,12 @@ use futures::future::{BoxFuture, FutureExt};
 use futures::io::{AsyncRead, AsyncWrite};
 use futures::ready;
 use futures::stream::StreamExt;
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::PeerId;
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, FromSwarm};
 use libp2p_swarm::dial_opts::DialOpts;
 use libp2p_swarm::{
-    ConnectionHandlerUpgrErr, NegotiatedSubstream, NetworkBehaviour, NetworkBehaviourAction,
+    ConnectionHandlerUpgrErr, ConnectionId, NegotiatedSubstream, NetworkBehaviour,
-    NotifyHandler, PollParameters,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use std::collections::{hash_map, HashMap, VecDeque};
 use std::io::{Error, ErrorKind, IoSlice};

protocols/rendezvous/src/client.rs

@@ -28,14 +28,13 @@ use futures::future::FutureExt;
 use futures::stream::FuturesUnordered;
 use futures::stream::StreamExt;
 use instant::Duration;
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::identity::error::SigningError;
 use libp2p_core::identity::Keypair;
 use libp2p_core::{Multiaddr, PeerId, PeerRecord};
 use libp2p_swarm::behaviour::FromSwarm;
 use libp2p_swarm::{
-    CloseConnection, ExternalAddresses, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
+    CloseConnection, ConnectionId, ExternalAddresses, NetworkBehaviour, NetworkBehaviourAction,
-    PollParameters,
+    NotifyHandler, PollParameters,
 };
 use std::collections::{HashMap, VecDeque};
 use std::iter::FromIterator;

protocols/rendezvous/src/server.rs

@@ -27,11 +27,11 @@ use futures::future::BoxFuture;
 use futures::ready;
 use futures::stream::FuturesUnordered;
 use futures::{FutureExt, StreamExt};
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::PeerId;
 use libp2p_swarm::behaviour::FromSwarm;
 use libp2p_swarm::{
-    CloseConnection, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
+    CloseConnection, ConnectionId, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
+    PollParameters,
 };
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::iter::FromIterator;

protocols/request-response/src/lib.rs

@@ -70,11 +70,12 @@ pub use handler::ProtocolSupport;
 
 use futures::channel::oneshot;
 use handler::{Handler, RequestProtocol};
-use libp2p_core::{connection::ConnectionId, ConnectedPoint, Multiaddr, PeerId};
+use libp2p_core::{ConnectedPoint, Multiaddr, PeerId};
 use libp2p_swarm::{
     behaviour::{AddressChange, ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm},
     dial_opts::DialOpts,
-    IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
+    ConnectionId, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
+    PollParameters,
 };
 use smallvec::SmallVec;
 use std::{

swarm/src/behaviour.rs

@@ -26,12 +26,11 @@ pub mod toggle;
 pub use external_addresses::ExternalAddresses;
 pub use listen_addresses::ListenAddresses;
 
+use crate::connection::ConnectionId;
 use crate::dial_opts::DialOpts;
 use crate::handler::{ConnectionHandler, IntoConnectionHandler};
 use crate::{AddressRecord, AddressScore, DialError};
-use libp2p_core::{
+use libp2p_core::{transport::ListenerId, ConnectedPoint, Multiaddr, PeerId};
-    connection::ConnectionId, transport::ListenerId, ConnectedPoint, Multiaddr, PeerId,
-};
 use std::{task::Context, task::Poll};
 
 /// Custom event that can be received by the [`ConnectionHandler`].
@@ -259,14 +258,14 @@ pub enum NetworkBehaviourAction<
     /// ```rust
     /// # use futures::executor::block_on;
     /// # use futures::stream::StreamExt;
-    /// # use libp2p_core::connection::ConnectionId;
     /// # use libp2p_core::identity;
     /// # use libp2p_core::transport::{MemoryTransport, Transport};
     /// # use libp2p_core::upgrade::{self, DeniedUpgrade, InboundUpgrade, OutboundUpgrade};
     /// # use libp2p_core::PeerId;
     /// # use libp2p_plaintext::PlainText2Config;
     /// # use libp2p_swarm::{
-    /// #     FromSwarm, DialFailure, DialError, IntoConnectionHandler, KeepAlive, NegotiatedSubstream,
+    /// #     ConnectionId, DialError, IntoConnectionHandler, KeepAlive, NegotiatedSubstream,
+    /// #     FromSwarm, DialFailure,
     /// #     NetworkBehaviour, NetworkBehaviourAction, PollParameters, ConnectionHandler,
     /// #     ConnectionHandlerEvent, ConnectionHandlerUpgrErr, SubstreamProtocol, Swarm, SwarmEvent,
     /// # };

swarm/src/behaviour/either.rs

@@ -19,6 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::behaviour::{self, NetworkBehaviour, NetworkBehaviourAction, PollParameters};
+use crate::connection::ConnectionId;
 use crate::handler::either::IntoEitherHandler;
 use either::Either;
 use libp2p_core::{Multiaddr, PeerId};
@@ -69,7 +70,7 @@ where
     fn on_connection_handler_event(
         &mut self,
         peer_id: PeerId,
-        connection_id: libp2p_core::connection::ConnectionId,
+        connection_id: ConnectionId,
         event: crate::THandlerOutEvent<Self>,
     ) {
         match (self, event) {

swarm/src/behaviour/toggle.rs

@@ -19,6 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::behaviour::FromSwarm;
+use crate::connection::ConnectionId;
 use crate::handler::{
     AddressChange, ConnectionEvent, ConnectionHandler, ConnectionHandlerEvent,
     ConnectionHandlerUpgrErr, DialUpgradeError, FullyNegotiatedInbound, FullyNegotiatedOutbound,
@@ -93,7 +94,7 @@ where
     fn on_connection_handler_event(
         &mut self,
         peer_id: PeerId,
-        connection_id: libp2p_core::connection::ConnectionId,
+        connection_id: ConnectionId,
         event: crate::THandlerOutEvent<Self>,
     ) {
         if let Some(behaviour) = &mut self.inner {

swarm/src/connection.rs

@@ -42,13 +42,36 @@ use libp2p_core::connection::ConnectedPoint;
 use libp2p_core::multiaddr::Multiaddr;
 use libp2p_core::muxing::{StreamMuxerBox, StreamMuxerEvent, StreamMuxerExt, SubstreamBox};
 use libp2p_core::upgrade::{InboundUpgradeApply, OutboundUpgradeApply};
-use libp2p_core::PeerId;
 use libp2p_core::{upgrade, UpgradeError};
+use libp2p_core::{Endpoint, PeerId};
 use std::future::Future;
 use std::task::Waker;
 use std::time::Duration;
 use std::{fmt, io, mem, pin::Pin, task::Context, task::Poll};
 
+/// Connection identifier.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ConnectionId(usize);
+
+impl ConnectionId {
+    /// Creates a `ConnectionId` from a non-negative integer.
+    ///
+    /// This is primarily useful for creating connection IDs
+    /// in test environments. There is in general no guarantee
+    /// that all connection IDs are based on non-negative integers.
+    pub fn new(id: usize) -> Self {
+        Self(id)
+    }
+}
+
+impl std::ops::Add<usize> for ConnectionId {
+    type Output = Self;
+
+    fn add(self, other: usize) -> Self {
+        Self(self.0 + other)
+    }
+}
+
 /// Information about a successfully established connection.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Connected {
@@ -824,3 +847,39 @@ mod tests {
         }
     }
 }
+
+/// The endpoint roles associated with a pending peer-to-peer connection.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum PendingPoint {
+    /// The socket comes from a dialer.
+    ///
+    /// There is no single address associated with the Dialer of a pending
+    /// connection. Addresses are dialed in parallel. Only once the first dial
+    /// is successful is the address of the connection known.
+    Dialer {
+        /// Same as [`ConnectedPoint::Dialer`] `role_override`.
+        role_override: Endpoint,
+    },
+    /// The socket comes from a listener.
+    Listener {
+        /// Local connection address.
+        local_addr: Multiaddr,
+        /// Address used to send back data to the remote.
+        send_back_addr: Multiaddr,
+    },
+}
+
+impl From<ConnectedPoint> for PendingPoint {
+    fn from(endpoint: ConnectedPoint) -> Self {
+        match endpoint {
+            ConnectedPoint::Dialer { role_override, .. } => PendingPoint::Dialer { role_override },
+            ConnectedPoint::Listener {
+                local_addr,
+                send_back_addr,
+            } => PendingPoint::Listener {
+                local_addr,
+                send_back_addr,
+            },
+        }
+    }
+}

swarm/src/connection/pool.rs

@@ -19,7 +19,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::connection::Connection;
+use crate::connection::{Connection, ConnectionId, PendingPoint};
 use crate::{
     behaviour::{THandlerInEvent, THandlerOutEvent},
     connection::{
@@ -39,7 +39,7 @@ use futures::{
     stream::FuturesUnordered,
 };
 use instant::Instant;
-use libp2p_core::connection::{ConnectionId, Endpoint, PendingPoint};
+use libp2p_core::connection::Endpoint;
 use libp2p_core::muxing::{StreamMuxerBox, StreamMuxerExt};
 use std::{
     collections::{hash_map, HashMap},

swarm/src/connection/pool/task.rs

@@ -24,7 +24,8 @@
 use super::concurrent_dial::ConcurrentDial;
 use crate::{
     connection::{
-        self, ConnectionError, PendingInboundConnectionError, PendingOutboundConnectionError,
+        self, ConnectionError, ConnectionId, PendingInboundConnectionError,
+        PendingOutboundConnectionError,
     },
     transport::TransportError,
     ConnectionHandler, Multiaddr, PeerId,
@@ -34,7 +35,6 @@ use futures::{
     future::{poll_fn, Either, Future},
     SinkExt, StreamExt,
 };
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::muxing::StreamMuxerBox;
 use std::pin::Pin;
 use void::Void;

swarm/src/dummy.rs

@@ -1,9 +1,9 @@
 use crate::behaviour::{FromSwarm, NetworkBehaviour, NetworkBehaviourAction, PollParameters};
+use crate::connection::ConnectionId;
 use crate::handler::{
     ConnectionEvent, DialUpgradeError, FullyNegotiatedInbound, FullyNegotiatedOutbound,
 };
 use crate::{ConnectionHandlerEvent, ConnectionHandlerUpgrErr, KeepAlive, SubstreamProtocol};
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::DeniedUpgrade;
 use libp2p_core::PeerId;
 use libp2p_core::UpgradeError;

swarm/src/keep_alive.rs

@@ -1,9 +1,9 @@
 use crate::behaviour::{FromSwarm, NetworkBehaviour, NetworkBehaviourAction, PollParameters};
+use crate::connection::ConnectionId;
 use crate::handler::{
     ConnectionEvent, ConnectionHandlerEvent, FullyNegotiatedInbound, FullyNegotiatedOutbound,
     KeepAlive, SubstreamProtocol,
 };
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::DeniedUpgrade;
 use libp2p_core::PeerId;
 use std::task::{Context, Poll};

swarm/src/lib.rs

@@ -84,6 +84,7 @@ pub mod derive_prelude {
     pub use crate::behaviour::NewExternalAddr;
     pub use crate::behaviour::NewListenAddr;
     pub use crate::behaviour::NewListener;
+    pub use crate::connection::ConnectionId;
     pub use crate::ConnectionHandler;
     pub use crate::DialError;
     pub use crate::IntoConnectionHandler;
@@ -92,7 +93,6 @@ pub mod derive_prelude {
     pub use crate::NetworkBehaviourAction;
     pub use crate::PollParameters;
     pub use futures::prelude as futures;
-    pub use libp2p_core::connection::ConnectionId;
     pub use libp2p_core::either::EitherOutput;
     pub use libp2p_core::transport::ListenerId;
     pub use libp2p_core::ConnectedPoint;
@@ -108,8 +108,8 @@ pub use behaviour::{
 };
 pub use connection::pool::{ConnectionCounters, ConnectionLimits};
 pub use connection::{
-    ConnectionError, ConnectionLimit, PendingConnectionError, PendingInboundConnectionError,
+    ConnectionError, ConnectionId, ConnectionLimit, PendingConnectionError,
-    PendingOutboundConnectionError,
+    PendingInboundConnectionError, PendingOutboundConnectionError,
 };
 pub use executor::Executor;
 pub use handler::{
@@ -125,7 +125,6 @@ use connection::pool::{EstablishedConnection, Pool, PoolConfig, PoolEvent};
 use connection::IncomingInfo;
 use dial_opts::{DialOpts, PeerCondition};
 use futures::{executor::ThreadPoolBuilder, prelude::*, stream::FusedStream};
-use libp2p_core::connection::ConnectionId;
 use libp2p_core::muxing::SubstreamBox;
 use libp2p_core::{
     connection::ConnectedPoint,

swarm/src/test.rs

@@ -23,12 +23,10 @@ use crate::behaviour::{
     FromSwarm, ListenerClosed, ListenerError, NewExternalAddr, NewListenAddr, NewListener,
 };
 use crate::{
-    ConnectionHandler, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction,
+    ConnectionHandler, ConnectionId, IntoConnectionHandler, NetworkBehaviour,
-    PollParameters,
+    NetworkBehaviourAction, PollParameters,
-};
-use libp2p_core::{
-    connection::ConnectionId, multiaddr::Multiaddr, transport::ListenerId, ConnectedPoint, PeerId,
 };
+use libp2p_core::{multiaddr::Multiaddr, transport::ListenerId, ConnectedPoint, PeerId};
 use std::collections::HashMap;
 use std::task::{Context, Poll};
 

swarm/tests/swarm_derive.rs

@@ -368,10 +368,10 @@ fn generated_out_event_derive_debug() {
 
 #[test]
 fn custom_out_event_no_type_parameters() {
-    use libp2p_core::connection::ConnectionId;
     use libp2p_core::PeerId;
     use libp2p_swarm::{
-        ConnectionHandler, IntoConnectionHandler, NetworkBehaviourAction, PollParameters,
+        ConnectionHandler, ConnectionId, IntoConnectionHandler, NetworkBehaviourAction,
+        PollParameters,
     };
     use std::task::Context;
     use std::task::Poll;