replace duplicate code with common function

src/codec/identity.rs

@@ -102,7 +102,7 @@ mod tests {
         let bytes = [3u8; 64];
         let mut bytes = BytesMut::from(&bytes[..]);
 
-        let decoded = codec.decode(&mut bytes);
+        let _decoded = codec.decode(&mut bytes);
     }
 
     #[test]

src/protocol/libp2p/kademlia/bucket.rs

@@ -128,7 +128,7 @@ mod tests {
             .collect::<Vec<_>>();
 
         let target = Key::from(PeerId::random());
-        let mut iter = bucket.closest_iter(&target);
+        let iter = bucket.closest_iter(&target);
         let mut prev = None;
 
         for node in iter {
@@ -173,7 +173,7 @@ mod tests {
             .collect::<Vec<_>>();
 
         let target = Key::from(PeerId::random());
-        let mut iter = bucket.closest_iter(&target);
+        let iter = bucket.closest_iter(&target);
         let mut prev = None;
         let mut num_peers = 0usize;
 

src/protocol/libp2p/kademlia/routing_table.rs

@@ -22,9 +22,12 @@
 //! Kademlia routing table implementation.
 
 use crate::{
-    protocol::libp2p::kademlia::{
-        bucket::{KBucket, KBucketEntry},
-        types::{ConnectionType, Distance, KademliaPeer, Key, U256},
+    protocol::{
+        libp2p::kademlia::{
+            bucket::{KBucket, KBucketEntry},
+            types::{ConnectionType, Distance, KademliaPeer, Key, U256},
+        },
+        sort_address,
     },
     transport::{
         manager::address::{scores, AddressRecord},
@@ -33,8 +36,7 @@ use crate::{
     PeerId,
 };
 
-use multiaddr::{Multiaddr, Protocol};
-use multihash::Multihash;
+use multiaddr::Multiaddr;
 
 /// Number of k-buckets.
 const NUM_BUCKETS: usize = 256;
@@ -188,17 +190,7 @@ impl RoutingTable {
         );
 
         // TODO: https://github.com/paritytech/litep2p/issues/337 this has to be moved elsewhere at some point
-        let addresses: Vec<Multiaddr> = addresses
-            .into_iter()
-            .filter_map(|address| {
-                let last = address.iter().last();
-                if std::matches!(last, Some(Protocol::P2p(_))) {
-                    Some(address)
-                } else {
-                    Some(address.with(Protocol::P2p(Multihash::from_bytes(&peer.to_bytes()).ok()?)))
-                }
-            })
-            .collect();
+        let addresses: Vec<Multiaddr> = sort_address(addresses.into_iter(), peer);
 
         if addresses.is_empty() {
             tracing::debug!(
@@ -304,23 +296,25 @@ impl Iterator for ClosestBucketsIter {
                 self.state = ClosestBucketsIterState::ZoomIn(i);
                 Some(i)
             }
-            ClosestBucketsIterState::ZoomIn(i) =>
+            ClosestBucketsIterState::ZoomIn(i) => {
                 if let Some(i) = self.next_in(i) {
                     self.state = ClosestBucketsIterState::ZoomIn(i);
                     Some(i)
                 } else {
                     let i = BucketIndex(0);
                     self.state = ClosestBucketsIterState::ZoomOut(i);
                     Some(i)
-                },
-            ClosestBucketsIterState::ZoomOut(i) =>
+                }
+            }
+            ClosestBucketsIterState::ZoomOut(i) => {
                 if let Some(i) = self.next_out(i) {
                     self.state = ClosestBucketsIterState::ZoomOut(i);
                     Some(i)
                 } else {
                     self.state = ClosestBucketsIterState::Done;
                     None
-                },
+                }
+            }
             ClosestBucketsIterState::Done => None,
         }
     }

src/protocol/mod.rs

@@ -29,7 +29,8 @@ use crate::{
     PeerId,
 };
 
-use multiaddr::Multiaddr;
+use multiaddr::{Multiaddr, Protocol};
+use multihash::Multihash;
 
 use std::fmt::Debug;
 
@@ -141,3 +142,18 @@ pub trait UserProtocol: Send {
     /// Start the the user protocol event loop.
     async fn run(self: Box<Self>, service: TransportService) -> crate::Result<()>;
 }
+
+pub fn sort_address(addresses: impl Iterator<Item = Multiaddr>, peer_id: PeerId) -> Vec<Multiaddr> {
+    addresses
+        .filter_map(|address| {
+            let last = address.iter().last();
+            if std::matches!(last, Some(Protocol::P2p(_))) {
+                Some(address)
+            } else {
+                Some(address.with(Protocol::P2p(
+                    Multihash::from_bytes(&peer_id.to_bytes()).ok()?,
+                )))
+            }
+        })
+        .collect()
+}

src/protocol/transport_service.rs

@@ -28,8 +28,7 @@ use crate::{
 };
 
 use futures::{future::BoxFuture, stream::FuturesUnordered, Stream, StreamExt};
-use multiaddr::{Multiaddr, Protocol};
-use multihash::Multihash;
+use multiaddr::Multiaddr;
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 
 use std::{
@@ -44,6 +43,8 @@ use std::{
     time::{Duration, Instant},
 };
 
+use super::sort_address;
+
 /// Logging target for the file.
 const LOG_TARGET: &str = "litep2p::transport-service";
 
@@ -467,15 +468,7 @@ impl TransportService {
     ///
     /// The list is filtered for duplicates and unsupported transports.
     pub fn add_known_address(&mut self, peer: &PeerId, addresses: impl Iterator<Item = Multiaddr>) {
-        let addresses: HashSet<Multiaddr> = addresses
-            .filter_map(|address| {
-                if !std::matches!(address.iter().last(), Some(Protocol::P2p(_))) {
-                    Some(address.with(Protocol::P2p(Multihash::from_bytes(&peer.to_bytes()).ok()?)))
-                } else {
-                    Some(address)
-                }
-            })
-            .collect();
+        let addresses = sort_address(addresses.into_iter(), *peer);
 
         self.transport_handle.add_known_address(peer, addresses.into_iter());
     }

src/transport/manager/mod.rs

@@ -552,10 +552,11 @@ impl TransportManager {
                 #[cfg(feature = "websocket")]
                 Some(Protocol::Ws(_)) | Some(Protocol::Wss(_)) => SupportedTransport::WebSocket,
                 Some(Protocol::P2p(_)) => SupportedTransport::Tcp,
-                _ =>
+                _ => {
                     return Err(Error::TransportNotSupported(
                         address_record.address().clone(),
-                    )),
+                    ))
+                }
             },
             #[cfg(feature = "quic")]
             Protocol::Udp(_) => match protocol_stack
@@ -1358,6 +1359,7 @@ mod tests {
         rx: tokio::sync::mpsc::Receiver<TransportEvent>,
     }
 
+    #[allow(dead_code)]
     impl MockTransport {
         fn new(rx: tokio::sync::mpsc::Receiver<TransportEvent>) -> Self {
             Self { rx }

tests/conformance/rust/kademlia.rs

@@ -24,7 +24,7 @@ use libp2p::{
     identify, identity,
     kad::{
         self, store::RecordStore, AddProviderOk, GetProvidersOk, InboundRequest,
-        KademliaEvent as Libp2pKademliaEvent, QueryResult, RecordKey as Libp2pRecordKey,
+        KademliaEvent as Libp2pKademliaEvent, QueryResult,
     },
     swarm::{keep_alive, AddressScore, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     PeerId, Swarm,