chore: minor reversals and changes

Author: dariusc93

Cargo.toml

@@ -83,12 +83,12 @@ getrandom_03 = { version = "0.3.3", package = "getrandom" }
 hickory-resolver = "0.25.2"
 idb = "0.6.5"
 indexmap = "2.10.0"
-libp2p = { version = "0.57.0" }
-libp2p-allow-block-list = "0.7.0"
-libp2p-connection-limits = "0.7.0"
-libp2p-stream = { version = "0.5.0-alpha" }
-libp2p-webrtc = { version = "=0.10.0-alpha", features = ["pem"] }
-libp2p-webrtc-websys = "0.5.0"
+libp2p = { version = "0.56.0" }
+libp2p-allow-block-list = "0.6.0"
+libp2p-connection-limits = "0.6.0"
+libp2p-stream = { version = "=0.4.0-alpha" }
+libp2p-webrtc = { version = "=0.9.0-alpha.1", features = ["pem"] }
+libp2p-webrtc-websys = "0.4.0"
 other-error = "0.1.1"
 pollable-map = "0.1.7"
 parking_lot = "0.12"
@@ -180,12 +180,4 @@ tokio = { default-features = false, features = ["sync", "macros"], workspace = t
 url = { workspace = true, optional = true }
 wasm-bindgen.workspace = true
 wasm-bindgen-futures.workspace = true
-web-sys = { workspace = true, optional = true }
-
-[patch.crates-io]
-libp2p = { git = "https://github.com/libp2p/rust-libp2p.git", branch = "master" }
-libp2p-allow-block-list = { git = "https://github.com/libp2p/rust-libp2p.git", branch = "master" }
-libp2p-connection-limits = { git = "https://github.com/libp2p/rust-libp2p.git", branch = "master" }
-libp2p-stream = { git = "https://github.com/libp2p/rust-libp2p.git", branch = "master" }
-libp2p-webrtc = { git = "https://github.com/libp2p/rust-libp2p.git", branch = "master" }
-libp2p-webrtc-websys = { git = "https://github.com/libp2p/rust-libp2p.git", branch = "master" }
+web-sys = { workspace = true, optional = true }

examples/upnp/src/main.rs

@@ -13,16 +13,15 @@ async fn main() -> std::io::Result<()> {
                 println!("New listen address: {addr}")
             }
             SwarmEvent::Behaviour(BehaviourEvent::Upnp(event)) => match event {
-                UpnpEvent::NewExternalAddr { external_addr, .. } => {
-                    println!("New external address: {external_addr}")
-                }
-                UpnpEvent::ExpiredExternalAddr { external_addr, .. } => {
-                    println!("Expired external address: {external_addr}")
+                UpnpEvent::NewExternalAddr(addr) => println!("New external address: {addr}"),
+                UpnpEvent::ExpiredExternalAddr(addr) => {
+                    println!("Expired external address: {addr}")
                 }
                 UpnpEvent::GatewayNotFound => println!("Gateway not found"),
                 UpnpEvent::NonRoutableGateway => println!("Gateway is not routable"),
             },
             _ => {}
+            _ => {}
         })
         .build()
         .await?;

src/behaviour/autorelay.rs

@@ -1,11 +1,4 @@
 // TODO: Replace with builtin autorelay behaviour from libp2p. See https://github.com/libp2p/rust-libp2p/pull/6156
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    num::NonZeroU8,
-    task::{Context, Poll, Waker},
-    time::Duration,
-};
-
 use crate::behaviour::autorelay::handler::Out;
 use crate::multiaddr_ext::MultiaddrExt;
 use crate::prelude::swarm::derive_prelude::{ListenerId, PortUse};
@@ -22,6 +15,13 @@ use crate::prelude::swarm::{
 use crate::prelude::transport::Endpoint;
 use crate::prelude::{PeerId, Protocol};
 use either::Either;
+use std::collections::BTreeMap;
+use std::{
+    collections::{HashMap, HashSet, VecDeque},
+    num::NonZeroU8,
+    task::{Context, Poll, Waker},
+    time::Duration,
+};
 use web_time::{Instant, SystemTime};
 
 mod handler;
@@ -220,10 +220,10 @@ impl Behaviour {
     /// This will dial and establish a connection to the peer if it doesn't already have a direct
     /// connection.
     /// Note that peers that are through a relay cannot be used as a static peer
-    pub fn add_static_relay(&mut self, peer_id: PeerId, address: Multiaddr) {
+    pub fn add_static_relay(&mut self, peer_id: PeerId, address: Multiaddr) -> bool {
         if address.is_relayed() {
             tracing::warn!(%peer_id, %address, "static relay address is relayed. ignoring.");
-            return;
+            return false;
         }
 
         let entry = self.static_relays.entry(peer_id).or_default();
@@ -245,6 +245,8 @@ impl Behaviour {
         if let Some(waker) = self.waker.take() {
             waker.wake();
         }
+
+        true
     }
 
     /// Remove peer as a static relay.
@@ -410,7 +412,7 @@ impl Behaviour {
     }
 
     /// Removes all existing reservations.
-    fn remove_all_reservations(&mut self) {
+    pub fn remove_all_reservations(&mut self) {
         let relay_listeners = self
             .reservations
             .iter()

src/behaviour/request_response/codec.rs

@@ -1,3 +1,4 @@
+use async_trait::async_trait;
 use bytes::Bytes;
 use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use libp2p::StreamProtocol;
@@ -17,6 +18,7 @@ impl Codec {
     }
 }
 
+#[async_trait]
 impl libp2p::request_response::Codec for Codec {
     type Protocol = StreamProtocol;
     type Request = Bytes;

src/handle.rs

@@ -10,9 +10,6 @@ pub(crate) mod gossipsub;
 mod peer_store;
 #[cfg(feature = "relay")]
 mod relay;
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(feature = "relay")]
-mod relay_server;
 #[cfg(feature = "rendezvous")]
 pub(crate) mod rendezvous;
 #[cfg(feature = "request-response")]
@@ -35,8 +32,6 @@ use crate::handle::gossipsub::ConnexaGossipsub;
 use crate::handle::peer_store::ConnexaPeerstore;
 #[cfg(feature = "relay")]
 use crate::handle::relay::ConnexaRelay;
-#[cfg(feature = "relay")]
-use crate::handle::relay_server::ConnexaRelayServer;
 #[cfg(feature = "rendezvous")]
 use crate::handle::rendezvous::ConnexaRendezvous;
 #[cfg(feature = "request-response")]
@@ -152,12 +147,6 @@ where
         ConnexaRelay::new(self)
     }
 
-    /// Returns a handle for relay server functions
-    #[cfg(feature = "relay")]
-    pub fn relay_server(&self) -> ConnexaRelayServer<'_, T> {
-        ConnexaRelayServer::new(self)
-    }
-
     /// Returns a handle to manage peer whitelist functionality
     pub fn whitelist(&self) -> ConnexaWhitelist<'_, T, K> {
         ConnexaWhitelist::new(self)

src/handle/relay_server.rs

@@ -587,10 +587,6 @@ where
             Command::Rendezvous(rendezvous_command) => {
                 self.process_rendezvous_command(rendezvous_command)
             }
-            #[cfg(feature = "relay")]
-            Command::RelayServer(relay_server_command) => {
-                self.process_relay_server_command(relay_server_command)
-            }
             Command::Custom(custom_command) => {
                 (self.custom_task_callback)(
                     swarm,

src/task.rs

@@ -2,7 +2,6 @@ use crate::behaviour::autorelay;
 use crate::behaviour::peer_store::store::Store;
 use crate::task::ConnexaTask;
 use crate::types::AutoRelayCommand;
-use crate::types::RelayServerCommand;
 use libp2p::relay::{Event as RelayServerEvent, client::Event as RelayClientEvent};
 use libp2p::swarm::NetworkBehaviour;
 use std::fmt::Debug;
@@ -158,36 +157,7 @@ where
             } => {
                 tracing::warn!(%src_peer_id, %dst_peer_id, ?error, "relay server circuit closed");
             }
-            RelayServerEvent::StatusChanged { status } => {
-                tracing::info!(?status, "relay server status changed");
-            }
             _ => {}
         }
     }
 }
-
-impl<X, C: NetworkBehaviour, S, T> ConnexaTask<X, C, S, T>
-where
-    X: Default + Send + 'static,
-    C: Send,
-    C::ToSwarm: Debug,
-    S: Store,
-{
-    pub fn process_relay_server_command(&mut self, command: RelayServerCommand) {
-        let swarm = self.swarm.as_mut().expect("swarm is active");
-        match command {
-            RelayServerCommand::StatusChanged { status, resp } => {
-                let Some(relay) = swarm.behaviour_mut().relay.as_mut() else {
-                    let _ = resp.send(Err(std::io::Error::other(
-                        "relay server protocol is not enabled",
-                    )));
-                    return;
-                };
-
-                relay.set_status(status);
-
-                let _ = resp.send(Ok(()));
-            }
-        }
-    }
-}

src/task/relay.rs

@@ -13,21 +13,11 @@ where
 {
     pub fn process_upnp_event(&mut self, event: UpnpEvent) {
         match event {
-            UpnpEvent::NewExternalAddr {
-                external_addr,
-                local_addr,
-            } => {
-                tracing::info!(
-                    ?external_addr,
-                    ?local_addr,
-                    "upnp external address discovered"
-                );
+            UpnpEvent::NewExternalAddr(addr) => {
+                tracing::info!(?addr, "upnp external address discovered");
             }
-            UpnpEvent::ExpiredExternalAddr {
-                external_addr,
-                local_addr,
-            } => {
-                tracing::info!(?external_addr, ?local_addr, "upnp external address expired");
+            UpnpEvent::ExpiredExternalAddr(addr) => {
+                tracing::info!(?addr, "upnp external address expired");
             }
             UpnpEvent::GatewayNotFound => {
                 tracing::warn!("upnp gateway not found");

src/task/upnp.rs

@@ -48,9 +48,6 @@ pub enum Command<T = ()> {
     Autonat(AutonatCommand),
     #[cfg(feature = "relay")]
     AutoRelay(AutoRelayCommand),
-    #[cfg(not(target_arch = "wasm32"))]
-    #[cfg(feature = "relay")]
-    RelayServer(RelayServerCommand),
     Whitelist(WhitelistCommand),
     Blacklist(BlacklistCommand),
     ConnectionLimits(ConnectionLimitsCommand),
@@ -120,14 +117,6 @@ impl<T> From<AutoRelayCommand> for Command<T> {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(feature = "relay")]
-impl<T> From<RelayServerCommand> for Command<T> {
-    fn from(cmd: RelayServerCommand) -> Self {
-        Command::RelayServer(cmd)
-    }
-}
-
 impl<T> From<WhitelistCommand> for Command<T> {
     fn from(cmd: WhitelistCommand) -> Self {
         Command::Whitelist(cmd)
@@ -555,15 +544,6 @@ pub enum RendezvousCommand {
     },
 }
 
-#[cfg(feature = "relay")]
-#[derive(Debug)]
-pub enum RelayServerCommand {
-    StatusChanged {
-        status: Option<libp2p::relay::Status>,
-        resp: oneshot::Sender<Result<()>>,
-    },
-}
-
 #[cfg(feature = "kad")]
 #[derive(Clone, Debug)]
 pub enum DHTEvent {