chore(*): Run rustfmt 1.7.0 and clippy 0.1.76

core/src/peer_record.rs

@@ -168,40 +168,41 @@
     #[test]
     fn mismatched_signature() {
         use quick_protobuf::MessageWrite;
 
         let addr: Multiaddr = HOME.parse().unwrap();
 
-        let envelope = {
-            let identity_a = Keypair::generate_ed25519();
-            let identity_b = Keypair::generate_ed25519();
-
-            let payload = {
-                let record = proto::PeerRecord {
-                    peer_id: identity_a.public().to_peer_id().to_bytes(),
-                    seq: 0,
-                    addresses: vec![proto::AddressInfo {
-                        multiaddr: addr.to_vec(),
-                    }],
+        let envelope =
+            {
+                let identity_a = Keypair::generate_ed25519();
+                let identity_b = Keypair::generate_ed25519();
+
+                let payload = {
+                    let record = proto::PeerRecord {
+                        peer_id: identity_a.public().to_peer_id().to_bytes(),
+                        seq: 0,
+                        addresses: vec![proto::AddressInfo {
+                            multiaddr: addr.to_vec(),
+                        }],
+                    };
+
+                    let mut buf = Vec::with_capacity(record.get_size());
+                    let mut writer = Writer::new(&mut buf);
+                    record
+                        .write_message(&mut writer)
+                        .expect("Encoding to succeed");
+
+                    buf
                 };
 
-                let mut buf = Vec::with_capacity(record.get_size());
-                let mut writer = Writer::new(&mut buf);
-                record
-                    .write_message(&mut writer)
-                    .expect("Encoding to succeed");
-
-                buf
+                SignedEnvelope::new(
+                    &identity_b,
+                    String::from(DOMAIN_SEP),
+                    PAYLOAD_TYPE.as_bytes().to_vec(),
+                    payload,
+                )
+                .unwrap()
             };
 
-            SignedEnvelope::new(
-                &identity_b,
-                String::from(DOMAIN_SEP),
-                PAYLOAD_TYPE.as_bytes().to_vec(),
-                payload,
-            )
-            .unwrap()
-        };
-
         assert!(matches!(
             PeerRecord::from_signed_envelope(envelope),
             Err(FromEnvelopeError::MismatchedSignature)

core/src/signed_envelope.rs

@@ -117,17 +117,18 @@
     let payload_type_length =
         unsigned_varint::encode::usize(payload_type.len(), &mut payload_type_length_buffer);
 
     let mut payload_length_buffer = usize_buffer();
     let payload_length = unsigned_varint::encode::usize(payload.len(), &mut payload_length_buffer);
 
-    let mut buffer = Vec::with_capacity(
-        domain_sep_length.len()
-            + domain_separation.len()
-            + payload_type_length.len()
-            + payload_type.len()
-            + payload_length.len()
-            + payload.len(),
-    );
+    let mut buffer =
+        Vec::with_capacity(
+            domain_sep_length.len()
+                + domain_separation.len()
+                + payload_type_length.len()
+                + payload_type.len()
+                + payload_length.len()
+                + payload.len(),
+        );
 
     buffer.extend_from_slice(domain_sep_length);
     buffer.extend_from_slice(domain_separation.as_bytes());

core/src/transport/memory.rs

@@ -547,25 +547,26 @@
         let rand_port = rand::random::<u64>().saturating_add(1);
         let t1_addr: Multiaddr = format!("/memory/{rand_port}").parse().unwrap();
         let cloned_t1_addr = t1_addr.clone();
 
         let mut t1 = MemoryTransport::default().boxed();
 
-        let listener = async move {
-            t1.listen_on(ListenerId::next(), t1_addr.clone()).unwrap();
-            let upgrade = loop {
-                let event = t1.select_next_some().await;
-                if let Some(upgrade) = event.into_incoming() {
-                    break upgrade;
-                }
-            };
+        let listener =
+            async move {
+                t1.listen_on(ListenerId::next(), t1_addr.clone()).unwrap();
+                let upgrade = loop {
+                    let event = t1.select_next_some().await;
+                    if let Some(upgrade) = event.into_incoming() {
+                        break upgrade;
+                    }
+                };
 
-            let mut socket = upgrade.0.await.unwrap();
+                let mut socket = upgrade.0.await.unwrap();
 
-            let mut buf = [0; 3];
-            socket.read_exact(&mut buf).await.unwrap();
+                let mut buf = [0; 3];
+                socket.read_exact(&mut buf).await.unwrap();
 
-            assert_eq!(buf, msg);
-        };
+                assert_eq!(buf, msg);
+            };
 
         // Setup dialer.
 
@@ -602,16 +603,17 @@
                     );
                     return;
                 }
             }
         };
 
-        let dialer = async move {
-            MemoryTransport::default()
-                .dial(listener_addr_cloned)
-                .unwrap()
-                .await
-                .unwrap();
-        };
+        let dialer =
+            async move {
+                MemoryTransport::default()
+                    .dial(listener_addr_cloned)
+                    .unwrap()
+                    .await
+                    .unwrap();
+            };
 
         futures::executor::block_on(futures::future::join(listener, dialer));
     }

core/src/transport/upgrade.rs

@@ -209,13 +209,10 @@
         C: AsyncRead + AsyncWrite + Unpin,
         D: AsyncRead + AsyncWrite + Unpin,
         U: InboundConnectionUpgrade<Negotiated<C>, Output = D, Error = E>,
         U: OutboundConnectionUpgrade<Negotiated<C>, Output = D, Error = E> + Clone,
         E: Error + 'static,
     {
-        Authenticated(Builder::new(
-            Upgrade::new(self.0.inner, upgrade),
-            self.0.version,
-        ))
+        Authenticated(Builder::new(Upgrade::new(self.0.inner, upgrade), self.0.version))
     }
 
     /// Upgrades the transport with a (sub)stream multiplexer.
@@ -521,32 +518,33 @@
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // We use a `this` variable because the compiler can't mutably borrow multiple times
         // accross a `Deref`.
         let this = &mut *self;
 
         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))
-                    {
-                        Ok(v) => v,
-                        Err(err) => return Poll::Ready(Err(err)),
-                    };
-                    let u = up
-                        .take()
-                        .expect("DialUpgradeFuture is constructed with Either::Left(Some).");
-                    future::Either::Right((i, apply_outbound(c, u, upgrade::Version::V1)))
+            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))
+                        {
+                            Ok(v) => v,
+                            Err(err) => return Poll::Ready(Err(err)),
+                        };
+                        let u = up
+                            .take()
+                            .expect("DialUpgradeFuture is constructed with Either::Left(Some).");
+                        future::Either::Right((i, apply_outbound(c, u, upgrade::Version::V1)))
+                    }
+                    future::Either::Right((i, ref mut up)) => {
+                        let d = match ready!(Future::poll(Pin::new(up), cx)
+                            .map_err(TransportUpgradeError::Upgrade))
+                        {
+                            Ok(d) => d,
+                            Err(err) => return Poll::Ready(Err(err)),
+                        };
+                        return Poll::Ready(Ok((i, d)));
+                    }
                 }
-                future::Either::Right((i, ref mut up)) => {
-                    let d = match ready!(
-                        Future::poll(Pin::new(up), cx).map_err(TransportUpgradeError::Upgrade)
-                    ) {
-                        Ok(d) => d,
-                        Err(err) => return Poll::Ready(Err(err)),
-                    };
-                    return Poll::Ready(Ok((i, d)));
-                }
-            }
         }
     }
 }

examples/autonat/src/bin/autonat_client.rs

@@ -88,13 +88,12 @@
     auto_nat: autonat::Behaviour,
 }
 
 impl Behaviour {
     fn new(local_public_key: identity::PublicKey) -> Self {
         Self {
-            identify: identify::Behaviour::new(identify::Config::new(
-                "/ipfs/0.1.0".into(),
-                local_public_key.clone(),
-            )),
+            identify: identify::Behaviour::new(
+                identify::Config::new("/ipfs/0.1.0".into(), local_public_key.clone())
+            ),
             auto_nat: autonat::Behaviour::new(
                 local_public_key.to_peer_id(),
                 autonat::Config {

examples/autonat/src/bin/autonat_server.rs

@@ -75,13 +75,12 @@
     auto_nat: autonat::Behaviour,
 }
 
 impl Behaviour {
     fn new(local_public_key: identity::PublicKey) -> Self {
         Self {
-            identify: identify::Behaviour::new(identify::Config::new(
-                "/ipfs/0.1.0".into(),
-                local_public_key.clone(),
-            )),
+            identify: identify::Behaviour::new(
+                identify::Config::new("/ipfs/0.1.0".into(), local_public_key.clone())
+            ),
             auto_nat: autonat::Behaviour::new(
                 local_public_key.to_peer_id(),
                 autonat::Config {

examples/browser-webrtc/src/lib.rs

@@ -15,17 +15,18 @@
 pub async fn run(libp2p_endpoint: String) -> Result<(), JsError> {
     wasm_logger::init(wasm_logger::Config::default());
 
     let body = Body::from_current_window()?;
     body.append_p("Let's ping the WebRTC Server!")?;
 
-    let mut swarm = libp2p::SwarmBuilder::with_new_identity()
-        .with_wasm_bindgen()
-        .with_other_transport(|key| {
-            webrtc_websys::Transport::new(webrtc_websys::Config::new(&key))
-        })?
-        .with_behaviour(|_| ping::Behaviour::new(ping::Config::new()))?
-        .with_swarm_config(|c| c.with_idle_connection_timeout(Duration::from_secs(5)))
-        .build();
+    let mut swarm =
+        libp2p::SwarmBuilder::with_new_identity()
+            .with_wasm_bindgen()
+            .with_other_transport(
+                |key| webrtc_websys::Transport::new(webrtc_websys::Config::new(&key))
+            )?
+            .with_behaviour(|_| ping::Behaviour::new(ping::Config::new()))?
+            .with_swarm_config(|c| c.with_idle_connection_timeout(Duration::from_secs(5)))
+            .build();
 
     let addr = libp2p_endpoint.parse::<Multiaddr>()?;
     tracing::info!("Dialing {addr}");

examples/browser-webrtc/src/main.rs

@@ -46,26 +46,27 @@
     let address_webrtc = Multiaddr::from(Ipv4Addr::UNSPECIFIED)
         .with(Protocol::Udp(0))
         .with(Protocol::WebRTCDirect);
 
     swarm.listen_on(address_webrtc.clone())?;
 
-    let address = loop {
-        if let SwarmEvent::NewListenAddr { address, .. } = swarm.select_next_some().await {
-            if address
-                .iter()
-                .any(|e| e == Protocol::Ip4(Ipv4Addr::LOCALHOST))
-            {
-                tracing::debug!(
-                    "Ignoring localhost address to make sure the example works in Firefox"
-                );
-                continue;
+    let address =
+        loop {
+            if let SwarmEvent::NewListenAddr { address, .. } = swarm.select_next_some().await {
+                if address
+                    .iter()
+                    .any(|e| e == Protocol::Ip4(Ipv4Addr::LOCALHOST))
+                {
+                    tracing::debug!(
+                        "Ignoring localhost address to make sure the example works in Firefox"
+                    );
+                    continue;
+                }
+
+                tracing::info!(%address, "Listening");
+
+                break address;
             }
-
-            tracing::info!(%address, "Listening");
-
-            break address;
-        }
-    };
+        };
 
     let addr = address.with(Protocol::P2p(*swarm.local_peer_id()));
 

examples/dcutr/src/main.rs

@@ -148,9 +148,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 SwarmEvent::Dialing { .. } => {}
                 SwarmEvent::ConnectionEstablished { .. } => {}
                 SwarmEvent::Behaviour(BehaviourEvent::Ping(_)) => {}
-                SwarmEvent::Behaviour(BehaviourEvent::Identify(identify::Event::Sent {
-                    ..
-                })) => {
+                SwarmEvent::Behaviour(BehaviourEvent::Identify(identify::Event::Sent { .. })) => {
                     tracing::info!("Told relay its public address");
                     told_relay_observed_addr = true;
                 }
@@ -193,9 +191,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 SwarmEvent::NewListenAddr { address, .. } => {
                     tracing::info!(%address, "Listening on address");
                 }
-                SwarmEvent::Behaviour(BehaviourEvent::RelayClient(
-                    relay::client::Event::ReservationReqAccepted { .. },
-                )) => {
+                SwarmEvent::Behaviour(
+                    BehaviourEvent::RelayClient(relay::client::Event::ReservationReqAccepted { .. })
+                ) => {
                     assert!(opts.mode == Mode::Listen);
                     tracing::info!("Relay accepted our reservation request");
                 }

examples/file-sharing/src/network.rs

@@ -247,16 +247,16 @@ impl EventLoop {
             SwarmEvent::Behaviour(BehaviourEvent::Kademlia(
                 kad::Event::OutboundQueryProgressed {
                     result:
-                        kad::QueryResult::GetProviders(Ok(
-                            kad::GetProvidersOk::FinishedWithNoAdditionalRecord { .. },
-                        )),
+                        kad::QueryResult::GetProviders(
+                            Ok(kad::GetProvidersOk::FinishedWithNoAdditionalRecord { .. })
+                        ),
                     ..
                 },
             )) => {}
             SwarmEvent::Behaviour(BehaviourEvent::Kademlia(_)) => {}
-            SwarmEvent::Behaviour(BehaviourEvent::RequestResponse(
-                request_response::Event::Message { message, .. },
-            )) => match message {
+            SwarmEvent::Behaviour(
+                BehaviourEvent::RequestResponse(request_response::Event::Message { message, .. })
+            ) => match message {
                 request_response::Message::Request {
                     request, channel, ..
                 } => {
@@ -290,9 +290,9 @@ impl EventLoop {
                     .expect("Request to still be pending.")
                     .send(Err(Box::new(error)));
             }
-            SwarmEvent::Behaviour(BehaviourEvent::RequestResponse(
-                request_response::Event::ResponseSent { .. },
-            )) => {}
+            SwarmEvent::Behaviour(
+                BehaviourEvent::RequestResponse(request_response::Event::ResponseSent { .. })
+            ) => {}
             SwarmEvent::NewListenAddr { address, .. } => {
                 let local_peer_id = *self.swarm.local_peer_id();
                 eprintln!(