feat: bump msrv to 1.85.0 and use 2024 edition

.github/workflows/ci.yml

@@ -225,7 +225,7 @@ jobs:
       fail-fast: false
       matrix:
         rust-version: [
-          1.83.0, # current stable
+          1.85.0, # current stable
           beta,
         ]
     steps:

Cargo.toml

@@ -70,8 +70,8 @@ members = [
 resolver = "2"
 
 [workspace.package]
-rust-version = "1.83.0"
-edition = "2021"
+rust-version = "1.85.0"
+edition = "2024"
 
 [workspace.dependencies]
 libp2p = { version = "0.55.1", path = "libp2p" }

core/src/either.rs

@@ -28,9 +28,9 @@ use futures::prelude::*;
 use pin_project::pin_project;
 
 use crate::{
+    Multiaddr,
     muxing::{StreamMuxer, StreamMuxerEvent},
     transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent},
-    Multiaddr,
 };
 
 impl<A, B> StreamMuxer for future::Either<A, B>

core/src/lib.rs

@@ -36,7 +36,7 @@ mod proto {
     include!("generated/mod.rs");
     pub use self::{
         envelope_proto::*,
-        peer_record_proto::{mod_PeerRecord::*, PeerRecord},
+        peer_record_proto::{PeerRecord, mod_PeerRecord::*},
     };
 }
 

core/src/muxing.rs

@@ -53,8 +53,8 @@
 use std::{future::Future, pin::Pin};
 
 use futures::{
-    task::{Context, Poll},
     AsyncRead, AsyncWrite,
+    task::{Context, Poll},
 };
 use multiaddr::Multiaddr;
 

core/src/peer_record.rs

@@ -2,7 +2,7 @@ use libp2p_identity::{Keypair, PeerId, SigningError};
 use quick_protobuf::{BytesReader, Writer};
 use web_time::SystemTime;
 
-use crate::{proto, signed_envelope, signed_envelope::SignedEnvelope, DecodeError, Multiaddr};
+use crate::{DecodeError, Multiaddr, proto, signed_envelope, signed_envelope::SignedEnvelope};
 
 const PAYLOAD_TYPE: &str = "/libp2p/routing-state-record";
 const DOMAIN_SEP: &str = "libp2p-routing-state";

core/src/signed_envelope.rs

@@ -4,7 +4,7 @@ use libp2p_identity::{Keypair, PublicKey, SigningError};
 use quick_protobuf::{BytesReader, Writer};
 use unsigned_varint::encode::usize_buffer;
 
-use crate::{proto, DecodeError};
+use crate::{DecodeError, proto};
 
 /// A signed envelope contains an arbitrary byte string payload, a signature of the payload, and the
 /// public key that can be used to verify the signature.

core/src/transport/and_then.rs

@@ -175,7 +175,7 @@ where
                         Poll::Ready(Ok(v)) => Poll::Ready(Ok(v)),
                         Poll::Ready(Err(err)) => return Poll::Ready(Err(Either::Right(err))),
                         Poll::Pending => Poll::Pending,
-                    }
+                    };
                 }
             };
 

core/src/transport/choice.rs

@@ -120,7 +120,7 @@ where
                 addr
             }
             Err(TransportError::Other(err)) => {
-                return Err(TransportError::Other(Either::Left(err)))
+                return Err(TransportError::Other(Either::Left(err)));
             }
         };
 
@@ -140,7 +140,7 @@ where
                 addr
             }
             Err(TransportError::Other(err)) => {
-                return Err(TransportError::Other(Either::Right(err)))
+                return Err(TransportError::Other(Either::Right(err)));
             }
         };
 
@@ -154,13 +154,13 @@ where
         let this = self.project();
         match this.0.poll(cx) {
             Poll::Ready(ev) => {
-                return Poll::Ready(ev.map_upgrade(EitherFuture::First).map_err(Either::Left))
+                return Poll::Ready(ev.map_upgrade(EitherFuture::First).map_err(Either::Left));
             }
             Poll::Pending => {}
         }
         match this.1.poll(cx) {
             Poll::Ready(ev) => {
-                return Poll::Ready(ev.map_upgrade(EitherFuture::Second).map_err(Either::Right))
+                return Poll::Ready(ev.map_upgrade(EitherFuture::Second).map_err(Either::Right));
             }
             Poll::Pending => {}
         }

core/src/transport/dummy.rs

@@ -26,8 +26,8 @@ use futures::{
 };
 
 use crate::{
-    transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent},
     Multiaddr,
+    transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent},
 };
 
 /// Implementation of `Transport` that doesn't support any multiaddr.

core/src/transport/memory.rs

@@ -19,7 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use std::{
-    collections::{hash_map::Entry, VecDeque},
+    collections::{VecDeque, hash_map::Entry},
     error, fmt, io,
     num::NonZeroU64,
     pin::Pin,
@@ -406,7 +406,7 @@ impl<T> Drop for Chan<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{transport::PortUse, Endpoint};
+    use crate::{Endpoint, transport::PortUse};
 
     #[test]
     fn parse_memory_addr_works() {
@@ -463,21 +463,27 @@ mod tests {
         let listener_id_3 = ListenerId::next();
         transport.listen_on(listener_id_3, addr_2.clone()).unwrap();
 
-        assert!(transport
-            .listen_on(ListenerId::next(), addr_1.clone())
-            .is_err());
-        assert!(transport
-            .listen_on(ListenerId::next(), addr_2.clone())
-            .is_err());
+        assert!(
+            transport
+                .listen_on(ListenerId::next(), addr_1.clone())
+                .is_err()
+        );
+        assert!(
+            transport
+                .listen_on(ListenerId::next(), addr_2.clone())
+                .is_err()
+        );
 
         assert!(
             transport.remove_listener(listener_id_2),
             "Listener doesn't exist."
         );
         assert!(transport.listen_on(ListenerId::next(), addr_1).is_ok());
-        assert!(transport
-            .listen_on(ListenerId::next(), addr_2.clone())
-            .is_err());
+        assert!(
+            transport
+                .listen_on(ListenerId::next(), addr_2.clone())
+                .is_err()
+        );
 
         assert!(
             transport.remove_listener(listener_id_3),
@@ -489,30 +495,34 @@ mod tests {
     #[test]
     fn port_not_in_use() {
         let mut transport = MemoryTransport::default();
-        assert!(transport
-            .dial(
-                "/memory/810172461024613".parse().unwrap(),
-                DialOpts {
-                    role: Endpoint::Dialer,
-                    port_use: PortUse::New
-                }
-            )
-            .is_err());
+        assert!(
+            transport
+                .dial(
+                    "/memory/810172461024613".parse().unwrap(),
+                    DialOpts {
+                        role: Endpoint::Dialer,
+                        port_use: PortUse::New
+                    }
+                )
+                .is_err()
+        );
         transport
             .listen_on(
                 ListenerId::next(),
                 "/memory/810172461024613".parse().unwrap(),
             )
             .unwrap();
-        assert!(transport
-            .dial(
-                "/memory/810172461024613".parse().unwrap(),
-                DialOpts {
-                    role: Endpoint::Dialer,
-                    port_use: PortUse::New
-                }
-            )
-            .is_ok());
+        assert!(
+            transport
+                .dial(
+                    "/memory/810172461024613".parse().unwrap(),
+                    DialOpts {
+                        role: Endpoint::Dialer,
+                        port_use: PortUse::New
+                    }
+                )
+                .is_ok()
+        );
     }
 
     #[test]

core/src/transport/timeout.rs

@@ -35,8 +35,8 @@ use futures::prelude::*;
 use futures_timer::Delay;
 
 use crate::{
-    transport::{DialOpts, ListenerId, TransportError, TransportEvent},
     Multiaddr, Transport,
+    transport::{DialOpts, ListenerId, TransportError, TransportEvent},
 };
 
 /// A `TransportTimeout` is a `Transport` that wraps another `Transport` and adds

core/src/transport/upgrade.rs

@@ -34,17 +34,17 @@ use multiaddr::Multiaddr;
 
 pub use crate::upgrade::Version;
 use crate::{
+    Negotiated,
     connection::ConnectedPoint,
     muxing::{StreamMuxer, StreamMuxerBox},
     transport::{
-        and_then::AndThen, boxed::boxed, timeout::TransportTimeout, DialOpts, ListenerId,
-        Transport, TransportError, TransportEvent,
+        DialOpts, ListenerId, Transport, TransportError, TransportEvent, and_then::AndThen,
+        boxed::boxed, timeout::TransportTimeout,
     },
     upgrade::{
-        self, apply_inbound, apply_outbound, InboundConnectionUpgrade, InboundUpgradeApply,
-        OutboundConnectionUpgrade, OutboundUpgradeApply, UpgradeError,
+        self, InboundConnectionUpgrade, InboundUpgradeApply, OutboundConnectionUpgrade,
+        OutboundUpgradeApply, UpgradeError, apply_inbound, apply_outbound,
     },
-    Negotiated,
 };
 
 /// A `Builder` facilitates upgrading of a [`Transport`] for use with
@@ -506,9 +506,10 @@ where
         loop {
             this.upgrade = match this.upgrade {
                 future::Either::Left(ref mut up) => {
-                    let (i, c) = match ready!(TryFuture::try_poll(this.future.as_mut(), cx)
-                        .map_err(TransportUpgradeError::Transport))
-                    {
+                    let (i, c) = match ready!(
+                        TryFuture::try_poll(this.future.as_mut(), cx)
+                            .map_err(TransportUpgradeError::Transport)
+                    ) {
                         Ok(v) => v,
                         Err(err) => return Poll::Ready(Err(err)),
                     };
@@ -565,9 +566,10 @@ where
         loop {
             this.upgrade = match this.upgrade {
                 future::Either::Left(ref mut up) => {
-                    let (i, c) = match ready!(TryFuture::try_poll(this.future.as_mut(), cx)
-                        .map_err(TransportUpgradeError::Transport))
-                    {
+                    let (i, c) = match ready!(
+                        TryFuture::try_poll(this.future.as_mut(), cx)
+                            .map_err(TransportUpgradeError::Transport)
+                    ) {
                         Ok(v) => v,
                         Err(err) => return Poll::Ready(Err(err)),
                     };
@@ -577,9 +579,10 @@ where
                     future::Either::Right((i, apply_inbound(c, u)))
                 }
                 future::Either::Right((i, ref mut up)) => {
-                    let d = match ready!(TryFuture::try_poll(Pin::new(up), cx)
-                        .map_err(TransportUpgradeError::Upgrade))
-                    {
+                    let d = match ready!(
+                        TryFuture::try_poll(Pin::new(up), cx)
+                            .map_err(TransportUpgradeError::Upgrade)
+                    ) {
                         Ok(v) => v,
                         Err(err) => return Poll::Ready(Err(err)),
                     };

core/src/upgrade.rs

@@ -65,7 +65,7 @@ mod ready;
 mod select;
 
 pub(crate) use apply::{
-    apply, apply_inbound, apply_outbound, InboundUpgradeApply, OutboundUpgradeApply,
+    InboundUpgradeApply, OutboundUpgradeApply, apply, apply_inbound, apply_outbound,
 };
 pub(crate) use error::UpgradeError;
 use futures::future::Future;

core/src/upgrade/apply.rs

@@ -29,9 +29,9 @@ pub(crate) use multistream_select::Version;
 use multistream_select::{DialerSelectFuture, ListenerSelectFuture};
 
 use crate::{
+    Negotiated,
     connection::ConnectedPoint,
     upgrade::{InboundConnectionUpgrade, OutboundConnectionUpgrade, UpgradeError},
-    Negotiated,
 };
 
 // TODO: Still needed?

core/tests/transport_upgrade.rs

@@ -22,9 +22,9 @@ use std::{io, pin::Pin};
 
 use futures::prelude::*;
 use libp2p_core::{
+    Endpoint,
     transport::{DialOpts, ListenerId, MemoryTransport, PortUse, Transport},
     upgrade::{self, InboundConnectionUpgrade, OutboundConnectionUpgrade, UpgradeInfo},
-    Endpoint,
 };
 use libp2p_identity as identity;
 use libp2p_mplex::Config;

examples/autonat/src/bin/autonat_client.rs

@@ -25,11 +25,11 @@ use std::{error::Error, net::Ipv4Addr, time::Duration};
 use clap::Parser;
 use futures::StreamExt;
 use libp2p::{
-    autonat,
-    core::{multiaddr::Protocol, Multiaddr},
+    PeerId, autonat,
+    core::{Multiaddr, multiaddr::Protocol},
     identify, identity, noise,
     swarm::{NetworkBehaviour, SwarmEvent},
-    tcp, yamux, PeerId,
+    tcp, yamux,
 };
 use tracing_subscriber::EnvFilter;
 

examples/autonat/src/bin/autonat_server.rs

@@ -26,7 +26,7 @@ use clap::Parser;
 use futures::StreamExt;
 use libp2p::{
     autonat,
-    core::{multiaddr::Protocol, Multiaddr},
+    core::{Multiaddr, multiaddr::Protocol},
     identify, identity, noise,
     swarm::{NetworkBehaviour, SwarmEvent},
     tcp, yamux,