Merge branch 'master' into master

dariusc93 · web-flow · commit 162f21242d93 · 2025-08-19T12:57:21.000-05:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/core/src/transport.rs b/core/src/transport.rs
@@ -62,7 +62,7 @@ static NEXT_LISTENER_ID: AtomicUsize = AtomicUsize::new(1);
 pub enum PortUse {
     /// Always allocate a new port for the dial.
     New,
-    /// Best effor reusing of an existing port.
+    /// Best effort reusing of an existing port.
     ///
     /// If there is no listener present that can be used to dial, a new port is allocated.
     #[default]
diff --git a/misc/multistream-select/src/lib.rs b/misc/multistream-select/src/lib.rs
@@ -118,7 +118,7 @@ pub enum Version {
     ///
     /// This strategy is only applicable for the node with the role of "dialer"
     /// in the negotiation and only if the dialer supports just a single
-    /// application protocol. In that case the dialer immedidately "settles"
+    /// application protocol. In that case the dialer immediately "settles"
     /// on that protocol, buffering the negotiation messages to be sent
     /// with the first round of application protocol data (or an attempt
     /// is made to read from the `Negotiated` I/O stream).
diff --git a/misc/peer-store/Cargo.toml b/misc/peer-store/Cargo.toml
@@ -9,9 +9,9 @@ publish = false
 rust-version.workspace = true
 
 [dependencies]
+hashlink = { workspace = true }
 libp2p-core = { workspace = true }
 libp2p-swarm = { workspace = true }
-lru = "0.12.3"
 libp2p-identity = { workspace = true, optional = true }
 
 [dev-dependencies]
diff --git a/misc/peer-store/src/memory_store.rs b/misc/peer-store/src/memory_store.rs
@@ -14,9 +14,9 @@ use std::{
     task::{Poll, Waker},
 };
 
+use hashlink::LruCache;
 use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::{behaviour::ConnectionEstablished, DialError, FromSwarm};
-use lru::LruCache;
 
 use super::Store;
 
@@ -317,15 +317,15 @@ pub struct PeerRecord<T> {
 impl<T> PeerRecord<T> {
     pub(crate) fn new(cap: NonZeroUsize) -> Self {
         Self {
-            addresses: LruCache::new(cap),
+            addresses: LruCache::new(cap.get()),
             custom_data: None,
         }
     }
 
     /// Iterate over all addresses. More recently-used address comes first.
     /// Does not change the order.
     pub fn addresses(&self) -> impl Iterator<Item = &Multiaddr> {
-        self.addresses.iter().map(|(addr, _)| addr)
+        self.addresses.iter().rev().map(|(addr, _)| addr)
     }
 
     /// Update the address in the LRU cache, promote it to the front if it exists,
@@ -335,14 +335,13 @@ impl<T> PeerRecord<T> {
     pub fn add_address(&mut self, address: &Multiaddr, is_permanent: bool) -> bool {
         if let Some(was_permanent) = self.addresses.get(address) {
             if !*was_permanent && is_permanent {
-                self.addresses
-                    .get_or_insert(address.clone(), || is_permanent);
+                self.addresses.insert(address.clone(), is_permanent);
             }
-            return false;
+            false
+        } else {
+            self.addresses.insert(address.clone(), is_permanent);
+            true
         }
-        self.addresses
-            .get_or_insert(address.clone(), || is_permanent);
-        true
     }
 
     /// Remove the address in the LRU cache regardless of its position.
@@ -353,7 +352,7 @@ impl<T> PeerRecord<T> {
         if !force && self.addresses.peek(address) == Some(&true) {
             return false;
         }
-        self.addresses.pop(address).is_some()
+        self.addresses.remove(address).is_some()
     }
 
     pub fn get_custom_data(&self) -> Option<&T> {
@@ -399,14 +398,14 @@ mod test {
         store.add_address(&peer, &addr1);
         store.add_address(&peer, &addr2);
         store.add_address(&peer, &addr3);
-        assert!(
+        assert_eq!(
             store
                 .records
                 .get(&peer)
                 .expect("peer to be in the store")
                 .addresses()
-                .collect::<Vec<_>>()
-                == vec![&addr3, &addr2, &addr1]
+                .collect::<Vec<_>>(),
+            vec![&addr3, &addr2, &addr1]
         );
         store.add_address(&peer, &addr1);
         assert!(
diff --git a/protocols/dcutr/Cargo.toml b/protocols/dcutr/Cargo.toml
@@ -23,7 +23,7 @@ quick-protobuf = "0.8"
 quick-protobuf-codec = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-lru = "0.12.3"
+hashlink = { workspace = true }
 futures-bounded = { workspace = true }
 
 [dev-dependencies]
diff --git a/protocols/dcutr/src/behaviour.rs b/protocols/dcutr/src/behaviour.rs
@@ -23,11 +23,11 @@
 use std::{
     collections::{HashMap, HashSet, VecDeque},
     convert::Infallible,
-    num::NonZeroUsize,
     task::{Context, Poll},
 };
 
 use either::Either;
+use hashlink::LruCache;
 use libp2p_core::{
     connection::ConnectedPoint, multiaddr::Protocol, transport::PortUse, Endpoint, Multiaddr,
 };
@@ -38,7 +38,6 @@ use libp2p_swarm::{
     dummy, ConnectionDenied, ConnectionHandler, ConnectionId, NetworkBehaviour,
     NewExternalAddrCandidate, NotifyHandler, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
-use lru::LruCache;
 use thiserror::Error;
 
 use crate::{handler, protocol};
@@ -361,7 +360,7 @@ struct Candidates {
 impl Candidates {
     fn new(me: PeerId) -> Self {
         Self {
-            inner: LruCache::new(NonZeroUsize::new(20).expect("20 > 0")),
+            inner: LruCache::new(20),
             me,
         }
     }
@@ -375,7 +374,7 @@ impl Candidates {
             address.push(Protocol::P2p(self.me));
         }
 
-        self.inner.push(address, ());
+        self.inner.insert(address, ());
     }
 
     fn iter(&self) -> impl Iterator<Item = &Multiaddr> {
diff --git a/protocols/kad/src/behaviour.rs b/protocols/kad/src/behaviour.rs
@@ -2768,7 +2768,7 @@ pub enum Event {
         result: QueryResult,
         /// Execution statistics from the query.
         stats: QueryStats,
-        /// Indicates which event this is, if therer are multiple responses for a single query.
+        /// Indicates which event this is, if there are multiple responses for a single query.
         step: ProgressStep,
     },
 
diff --git a/protocols/kad/src/query/peers/closest.rs b/protocols/kad/src/query/peers/closest.rs
@@ -713,7 +713,7 @@ mod tests {
                 _ => panic!("No peer."),
             };
             iter.on_success(&peer1, closer.clone());
-            // Duplicate result from te same peer.
+            // Duplicate result from the same peer.
             iter.on_success(&peer1, closer.clone());
 
             // If there is a second peer, let it also report the same "closer" peer.
diff --git a/swarm/Cargo.toml b/swarm/Cargo.toml
@@ -17,10 +17,10 @@ futures = { workspace = true }
 futures-timer = "3.0.3"
 getrandom = { workspace = true, features = ["js"], optional = true } # Explicit dependency to be used in `wasm-bindgen` feature
 web-time = { workspace = true }
+hashlink = { workspace = true }
 libp2p-core = { workspace = true }
 libp2p-identity = { workspace = true }
 libp2p-swarm-derive = { workspace = true, optional = true }
-lru = "0.12.3"
 multistream-select = { workspace = true }
 rand = "0.8"
 smallvec = "1.13.2"
diff --git a/swarm/src/behaviour/peer_addresses.rs b/swarm/src/behaviour/peer_addresses.rs
@@ -1,8 +1,8 @@
 use std::num::NonZeroUsize;
 
+use hashlink::LruCache;
 use libp2p_core::Multiaddr;
 use libp2p_identity::PeerId;
-use lru::LruCache;
 
 use crate::{behaviour::FromSwarm, DialError, DialFailure, NewExternalAddrOfPeer};
 
@@ -15,7 +15,7 @@ impl PeerAddresses {
     ///
     /// For each peer, we will at most store 10 addresses.
     pub fn new(number_of_peers: NonZeroUsize) -> Self {
-        Self(LruCache::new(number_of_peers))
+        Self(LruCache::new(number_of_peers.get()))
     }
 
     /// Feed a [`FromSwarm`] event to this struct.
@@ -48,11 +48,11 @@ impl PeerAddresses {
         match prepare_addr(&peer, &address) {
             Ok(address) => {
                 if let Some(cached) = self.0.get_mut(&peer) {
-                    cached.put(address, ()).is_none()
+                    cached.insert(address, ()).is_none()
                 } else {
-                    let mut set = LruCache::new(NonZeroUsize::new(10).expect("10 > 0"));
-                    set.put(address, ());
-                    self.0.put(peer, set);
+                    let mut set = LruCache::new(10);
+                    set.insert(address, ());
+                    self.0.insert(peer, set);
 
                     true
                 }
@@ -75,7 +75,7 @@ impl PeerAddresses {
     pub fn remove(&mut self, peer: &PeerId, address: &Multiaddr) -> bool {
         match self.0.get_mut(peer) {
             Some(addrs) => match prepare_addr(peer, address) {
-                Ok(address) => addrs.pop(&address).is_some(),
+                Ok(address) => addrs.remove(&address).is_some(),
                 Err(_) => false,
             },
             None => false,
@@ -89,7 +89,7 @@ fn prepare_addr(peer: &PeerId, addr: &Multiaddr) -> Result<Multiaddr, Multiaddr>
 
 impl Default for PeerAddresses {
     fn default() -> Self {
-        Self(LruCache::new(NonZeroUsize::new(100).unwrap()))
+        Self(LruCache::new(100))
     }
 }
 
diff --git a/swarm/src/connection.rs b/swarm/src/connection.rs
@@ -760,7 +760,7 @@ enum Shutdown {
     Later(Delay),
 }
 
-// Structure used to avoid allocations when storing the protocols in the `HashMap.
+// Structure used to avoid allocations when storing the protocols in the `HashMap`.
 // Instead of allocating a new `String` for the key,
 // we use `T::as_ref()` in `Hash`, `Eq` and `PartialEq` requirements.
 pub(crate) struct AsStrHashEq<T>(pub(crate) T);
diff --git a/transports/tcp/src/lib.rs b/transports/tcp/src/lib.rs
@@ -165,8 +165,8 @@ impl Config {
     ///
     /// # Deprecation Notice
     ///
-    /// The new implementation works on a per-connaction basis, defined by the behaviour. This
-    /// removes the necessaity to configure the transport for port reuse, instead the behaviour
+    /// The new implementation works on a per-connection basis, defined by the behaviour. This
+    /// removes the necessity to configure the transport for port reuse, instead the behaviour
     /// requiring this behaviour can decide whether to use port reuse or not.
     ///
     /// The API to configure port reuse is part of [`Transport`] and the option can be found in
@@ -175,7 +175,7 @@ impl Config {
     /// If [`PortUse::Reuse`] is enabled, the transport will try to reuse the local port of the
     /// listener. If that's not possible, i.e. there is no listener or the transport doesn't allow
     /// a direct control over ports, a new port (or the default behaviour) is used. If port reuse
-    /// is enabled for a connection, this option will be treated on a best-effor basis.
+    /// is enabled for a connection, this option will be treated on a best-effort basis.
     #[deprecated(
         since = "0.42.0",
         note = "This option does nothing now, since the port reuse policy is now decided on a per-connection basis by the behaviour. The function will be removed in a future release."
diff --git a/transports/tls/src/certificate.rs b/transports/tls/src/certificate.rs
@@ -185,7 +185,7 @@ fn parse_unverified(der_input: &[u8]) -> Result<P2pCertificate<'_>, webpki::Erro
         }
 
         if oid == &p2p_ext_oid {
-            // The public host key and the signature are ANS.1-encoded
+            // The public host key and the signature are ASN.1-encoded
             // into the SignedKey data structure, which is carried
             // in the libp2p Public Key Extension.
             // SignedKey ::= SEQUENCE {
@@ -254,7 +254,7 @@ fn make_libp2p_extension(
             .map_err(|_| rcgen::Error::RingUnspecified)?
     };
 
-    // The public host key and the signature are ANS.1-encoded
+    // The public host key and the signature are ASN.1-encoded
     // into the SignedKey data structure, which is carried
     // in the libp2p Public Key Extension.
     // SignedKey ::= SEQUENCE {
diff --git a/transports/webrtc/src/tokio/upgrade.rs b/transports/webrtc/src/tokio/upgrade.rs
@@ -181,7 +181,7 @@ fn setting_engine(
 
     // Select only the first address of the local candidates.
     // See https://github.com/libp2p/rust-libp2p/pull/5448#discussion_r2017418520.
-    // TODO: remove when https://github.com/webrtc-rs/webrtc/issues/662 get's addressed.
+    // TODO: remove when https://github.com/webrtc-rs/webrtc/issues/662 gets addressed.
     se.set_ip_filter(Box::new({
         let once = AtomicBool::new(true);
         move |_ip| {
