fix: linter warnings

Author: varex83

crates/charon-p2p/examples/p2p.rs

@@ -7,8 +7,10 @@
 use anyhow::Result;
 use charon_eth2::enr::Record;
 use charon_p2p::{
-    behaviours::pluto::{PlutoBehaviourEvent},
-    behaviours::pluto_mdns::{PlutoMdnsBehaviour, PlutoMdnsBehaviourEvent},
+    behaviours::{
+        pluto::PlutoBehaviourEvent,
+        pluto_mdns::{PlutoMdnsBehaviour, PlutoMdnsBehaviourEvent},
+    },
     config::P2PConfig,
     gater::ConnGater,
     p2p::{Node, NodeType},

crates/charon-p2p/src/behaviours/pluto_mdns.rs

@@ -18,7 +18,7 @@ impl PlutoMdnsBehaviour {
         Self {
             pluto: PlutoBehaviour::new(key, relay_client),
             mdns: mdns::tokio::Behaviour::new(mdns::Config::default(), key.public().to_peer_id())
-                .unwrap(),
+                .expect("Failed to create mDNS behaviour"),
         }
     }
 }

crates/charon-p2p/src/p2p.rs

@@ -1,54 +1,54 @@
-#![allow(missing_docs)]
-#![allow(dead_code)]
-#![allow(unused)]
-
 //! P2P core concepts
 
-use std::{sync::Once, time::Duration};
+use std::time::Duration;
 
 use libp2p::{
-    Swarm, SwarmBuilder, identify,
-    identity::Keypair,
-    noise, ping, relay,
-    swarm::{NetworkBehaviour, SwarmEvent},
-    tcp, yamux,
+    Swarm, SwarmBuilder, identity::Keypair, noise, relay, swarm::NetworkBehaviour, tcp, yamux,
 };
 
-use libp2p::mdns;
-
 use crate::{config::P2PConfig, gater::ConnGater};
 
+/// P2P error.
 #[derive(Debug, thiserror::Error)]
 pub enum P2PError {
     /// Failed to build the swarm.
     #[error("Failed to build the swarm: {0}")]
     FailedToBuildSwarm(Box<dyn std::error::Error + Send + Sync>),
 
+    /// Failed to convert the secret key to a libp2p keypair.
     #[error("Failed to convert the secret key to a libp2p keypair: {0}")]
     FailedToConvertSecretKeyToLibp2pKeypair(#[from] k256::pkcs8::der::Error),
 
+    /// Failed to decode the libp2p keypair.
     #[error("Failed to decode the libp2p keypair: {0}")]
     FailedToDecodeLibp2pKeypair(#[from] libp2p::identity::DecodingError),
 }
 
 impl P2PError {
+    /// Failed to build the swarm.
     pub fn failed_to_build_swarm(error: impl std::error::Error + Send + Sync + 'static) -> Self {
         Self::FailedToBuildSwarm(Box::new(error))
     }
 }
 
 type Result<T> = std::result::Result<T, P2PError>;
 
+/// Node type.
 pub enum NodeType {
+    /// TCP node.
     TCP,
+    /// QUIC node.
     QUIC,
 }
 
+/// Node.
 pub struct Node<B: NetworkBehaviour> {
+    /// Swarm.
     pub swarm: Swarm<B>,
 }
 
 impl<B: NetworkBehaviour> Node<B> {
+    /// Creates a new node.
     pub fn new<F>(
         cfg: P2PConfig,
         key: k256::SecretKey,
@@ -78,11 +78,12 @@ impl<B: NetworkBehaviour> Node<B> {
         tcp::Config::default()
     }
 
-    pub fn new_with_quic<F>(
-        cfg: P2PConfig,
+    /// Creates a new node with QUIC.
+    fn new_with_quic<F>(
+        _cfg: P2PConfig,
         key: k256::SecretKey,
-        conn_gater: ConnGater,
-        filter_private_addrs: bool,
+        _conn_gater: ConnGater,
+        _filter_private_addrs: bool,
         behaviour_fn: F,
     ) -> Result<Self>
     where
@@ -91,7 +92,7 @@ impl<B: NetworkBehaviour> Node<B> {
         let mut der = key.to_sec1_der()?;
         let keypair = Keypair::secp256k1_from_der(&mut der)?;
 
-        let mut swarm = SwarmBuilder::with_existing_identity(keypair.clone())
+        let swarm = SwarmBuilder::with_existing_identity(keypair.clone())
             .with_tokio()
             .with_tcp(
                 Self::default_tcp_config(),
@@ -112,20 +113,21 @@ impl<B: NetworkBehaviour> Node<B> {
         Ok(Node { swarm })
     }
 
-    pub fn new_with_tcp<F>(
-        cfg: P2PConfig,
+    /// Creates a new node with TCP.
+    fn new_with_tcp<F>(
+        _cfg: P2PConfig,
         key: k256::SecretKey,
-        conn_gater: ConnGater,
-        filter_private_addrs: bool,
+        _conn_gater: ConnGater,
+        _filter_private_addrs: bool,
         behaviour_fn: F,
     ) -> Result<Self>
     where
         F: Fn(&Keypair, relay::client::Behaviour) -> B,
     {
-        let mut der = key.to_sec1_der().unwrap();
-        let keypair = Keypair::secp256k1_from_der(&mut der).unwrap();
+        let mut der = key.to_sec1_der()?;
+        let keypair = Keypair::secp256k1_from_der(&mut der)?;
 
-        let mut swarm = SwarmBuilder::with_existing_identity(keypair.clone())
+        let swarm = SwarmBuilder::with_existing_identity(keypair.clone())
             .with_tokio()
             .with_tcp(
                 Self::default_tcp_config(),