review: apply suggestions.

protocols/relay/examples/relay.rs

@@ -79,7 +79,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     block_on(async {
         loop {
             match swarm.next().await.expect("Infinite Stream.") {
-                SwarmEvent::Behaviour(Event::Relay(event)) => {
+                SwarmEvent::Behaviour(event) => {
                     println!("{event:?}")
                 }
                 SwarmEvent::NewListenAddr { address, .. } => {
@@ -92,42 +92,13 @@ fn main() -> Result<(), Box<dyn Error>> {
 }
 
 #[derive(NetworkBehaviour)]
-#[behaviour(
-    out_event = "Event",
-    event_process = false,
-    prelude = "libp2p_swarm::derive_prelude"
-)]
+#[behaviour(prelude = "libp2p_swarm::derive_prelude")]
 struct Behaviour {
     relay: relay::Behaviour,
     ping: ping::Behaviour,
     identify: identify::Behaviour,
 }
 
-#[derive(Debug)]
-enum Event {
-    Ping(ping::Event),
-    Identify(identify::Event),
-    Relay(relay::Event),
-}
-
-impl From<ping::Event> for Event {
-    fn from(e: ping::Event) -> Self {
-        Event::Ping(e)
-    }
-}
-
-impl From<identify::Event> for Event {
-    fn from(e: identify::Event) -> Self {
-        Event::Identify(e)
-    }
-}
-
-impl From<relay::Event> for Event {
-    fn from(e: relay::Event) -> Self {
-        Event::Relay(e)
-    }
-}
-
 fn generate_ed25519(secret_key_seed: u8) -> identity::Keypair {
     let mut bytes = [0u8; 32];
     bytes[0] = secret_key_seed;

protocols/relay/src/lib.rs

@@ -72,6 +72,8 @@ static_assertions::const_assert! {
 }
 
 /// The ID of an outgoing / incoming, relay / destination request.
+// TODO remove this type and it's usage on `TransportToBehaviourMsg::DialReq`
+// when removed from `v2`.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct RequestId(u64);
 

protocols/relay/src/priv_client/transport.rs

@@ -72,11 +72,11 @@ use thiserror::Error;
 ///    # use libp2p_core::{Multiaddr, multiaddr::{Protocol}, Transport, PeerId};
 ///    # use libp2p_core::transport::memory::MemoryTransport;
 ///    # use libp2p_core::transport::choice::OrTransport;
-///    # use libp2p_relay::client;
+///    # use libp2p_relay as relay;
 ///    # let relay_id = PeerId::random();
 ///    # let local_peer_id = PeerId::random();
 ///    let actual_transport = MemoryTransport::default();
-///    let (relay_transport, behaviour) = client::Behaviour::new_transport_and_behaviour(
+///    let (relay_transport, behaviour) = relay::client::new(
 ///       local_peer_id,
 ///    );
 ///    let mut transport = OrTransport::new(relay_transport, actual_transport);

protocols/relay/src/v2.rs

@@ -167,5 +167,8 @@ pub mod protocol {
     pub const STOP_PROTOCOL_NAME: &[u8; 32] = crate::STOP_PROTOCOL_NAME;
 }
 
-#[deprecated(since = "0.15.0", note = "Use libp2p_relay::RequestId instead.")]
+#[deprecated(
+    since = "0.15.0",
+    note = "RequestId will be deprecated as it isn't used"
+)]
 pub type RequestId = super::RequestId;

protocols/relay/tests/lib.rs

@@ -342,63 +342,19 @@ where
 }
 
 #[derive(NetworkBehaviour)]
-#[behaviour(
-    out_event = "RelayEvent",
-    event_process = false,
-    prelude = "libp2p_swarm::derive_prelude"
-)]
+#[behaviour(prelude = "libp2p_swarm::derive_prelude")]
 struct Relay {
     relay: relay::Behaviour,
     ping: ping::Behaviour,
 }
 
-#[derive(Debug)]
-enum RelayEvent {
-    Relay(relay::Event),
-    Ping(ping::Event),
-}
-
-impl From<relay::Event> for RelayEvent {
-    fn from(event: relay::Event) -> Self {
-        RelayEvent::Relay(event)
-    }
-}
-
-impl From<ping::Event> for RelayEvent {
-    fn from(event: ping::Event) -> Self {
-        RelayEvent::Ping(event)
-    }
-}
-
 #[derive(NetworkBehaviour)]
-#[behaviour(
-    out_event = "ClientEvent",
-    event_process = false,
-    prelude = "libp2p_swarm::derive_prelude"
-)]
+#[behaviour(prelude = "libp2p_swarm::derive_prelude")]
 struct Client {
     relay: relay::client::Behaviour,
     ping: ping::Behaviour,
 }
 
-#[derive(Debug)]
-enum ClientEvent {
-    Relay(relay::client::Event),
-    Ping(ping::Event),
-}
-
-impl From<relay::client::Event> for ClientEvent {
-    fn from(event: relay::client::Event) -> Self {
-        ClientEvent::Relay(event)
-    }
-}
-
-impl From<ping::Event> for ClientEvent {
-    fn from(event: ping::Event) -> Self {
-        ClientEvent::Ping(event)
-    }
-}
-
 fn spawn_swarm_on_pool<B: NetworkBehaviour + Send>(pool: &LocalPool, swarm: Swarm<B>) {
     pool.spawner()
         .spawn_obj(swarm.collect::<Vec<_>>().map(|_| ()).boxed().into())