Fix clippy lints

beacon_node/eth2-libp2p/src/behaviour.rs

@@ -65,17 +65,11 @@ impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<GossipsubE
                 self.events.push(BehaviourEvent::GossipMessage {
                     source: gs_msg.source,
                     topics: gs_msg.topics,
-                    message: pubsub_message,
+                    message: Box::new(pubsub_message),
                 });
             }
-            GossipsubEvent::Subscribed {
-                peer_id: _,
-                topic: _,
-            }
-            | GossipsubEvent::Unsubscribed {
-                peer_id: _,
-                topic: _,
-            } => {}
+            GossipsubEvent::Subscribed { .. } => {}
+            GossipsubEvent::Unsubscribed { .. } => {}
         }
     }
 }
@@ -110,7 +104,8 @@ impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<IdentifyEv
                     );
                     info.listen_addrs.truncate(20);
                 }
-                self.events.push(BehaviourEvent::Identified(peer_id, info));
+                self.events
+                    .push(BehaviourEvent::Identified(peer_id, Box::new(info)));
             }
             IdentifyEvent::Error { .. } => {}
             IdentifyEvent::SendBack { .. } => {}
@@ -183,12 +178,12 @@ impl<TSubstream: AsyncRead + AsyncWrite> Behaviour<TSubstream> {
 pub enum BehaviourEvent {
     RPC(PeerId, RPCEvent),
     PeerDialed(PeerId),
-    Identified(PeerId, IdentifyInfo),
+    Identified(PeerId, Box<IdentifyInfo>),
     // TODO: This is a stub at the moment
     GossipMessage {
         source: PeerId,
         topics: Vec<TopicHash>,
-        message: PubsubMessage,
+        message: Box<PubsubMessage>,
     },
 }
 

beacon_node/eth2-libp2p/src/rpc/mod.rs

@@ -26,7 +26,7 @@ pub struct Rpc<TSubstream> {
     /// Pins the generic substream.
     marker: PhantomData<TSubstream>,
     /// Slog logger for RPC behaviour.
-    log: slog::Logger,
+    _log: slog::Logger,
 }
 
 impl<TSubstream> Rpc<TSubstream> {
@@ -35,7 +35,7 @@ impl<TSubstream> Rpc<TSubstream> {
         Rpc {
             events: Vec::new(),
             marker: PhantomData,
-            log,
+            _log: log,
         }
     }
 
@@ -65,7 +65,7 @@ where
 
     fn inject_connected(&mut self, peer_id: PeerId, connected_point: ConnectedPoint) {
         // if initialised the connection, report this upwards to send the HELLO request
-        if let ConnectedPoint::Dialer { address: _ } = connected_point {
+        if let ConnectedPoint::Dialer { .. } = connected_point {
             self.events.push(NetworkBehaviourAction::GenerateEvent(
                 RPCMessage::PeerDialed(peer_id),
             ));

beacon_node/eth2-libp2p/src/rpc/protocol.rs

@@ -31,7 +31,7 @@ impl Default for RPCProtocol {
 }
 
 /// A monotonic counter for ordering `RPCRequest`s.
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, Default)]
 pub struct RequestId(u64);
 
 impl RequestId {
@@ -48,6 +48,12 @@ impl RequestId {
 
 impl Eq for RequestId {}
 
+impl PartialEq for RequestId {
+    fn eq(&self, other: &RequestId) -> bool {
+        self.0 == other.0
+    }
+}
+
 impl Hash for RequestId {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.0.hash(state);
@@ -104,17 +110,15 @@ impl UpgradeInfo for RPCEvent {
     }
 }
 
+type FnDecodeRPCEvent = fn(Vec<u8>, ()) -> Result<RPCEvent, DecodeError>;
+
 impl<TSocket> InboundUpgrade<TSocket> for RPCProtocol
 where
     TSocket: AsyncRead + AsyncWrite,
 {
     type Output = RPCEvent;
     type Error = DecodeError;
-    type Future = upgrade::ReadOneThen<
-        upgrade::Negotiated<TSocket>,
-        (),
-        fn(Vec<u8>, ()) -> Result<RPCEvent, DecodeError>,
-    >;
+    type Future = upgrade::ReadOneThen<upgrade::Negotiated<TSocket>, (), FnDecodeRPCEvent>;
 
     fn upgrade_inbound(self, socket: upgrade::Negotiated<TSocket>, _: Self::Info) -> Self::Future {
         upgrade::read_one_then(socket, MAX_READ_SIZE, (), |packet, ()| Ok(decode(packet)?))

beacon_node/eth2-libp2p/src/service.rs

@@ -19,13 +19,16 @@ use std::io::{Error, ErrorKind};
 use std::time::Duration;
 use types::{TopicBuilder, TopicHash};
 
+type Libp2pStream = Boxed<(PeerId, StreamMuxerBox), Error>;
+type Libp2pBehaviour = Behaviour<Substream<StreamMuxerBox>>;
+
 /// The configuration and state of the libp2p components for the beacon node.
 pub struct Service {
     /// The libp2p Swarm handler.
     //TODO: Make this private
-    pub swarm: Swarm<Boxed<(PeerId, StreamMuxerBox), Error>, Behaviour<Substream<StreamMuxerBox>>>,
+    pub swarm: Swarm<Libp2pStream, Libp2pBehaviour>,
     /// This node's PeerId.
-    local_peer_id: PeerId,
+    _local_peer_id: PeerId,
     /// The libp2p logger handle.
     pub log: slog::Logger,
 }
@@ -89,7 +92,7 @@ impl Service {
         info!(log, "Subscribed to topics: {:?}", subscribed_topics);
 
         Ok(Service {
-            local_peer_id,
+            _local_peer_id: local_peer_id,
             swarm,
             log,
         })
@@ -179,11 +182,11 @@ pub enum Libp2pEvent {
     /// Initiated the connection to a new peer.
     PeerDialed(PeerId),
     /// Received information about a peer on the network.
-    Identified(PeerId, IdentifyInfo),
+    Identified(PeerId, Box<IdentifyInfo>),
     /// Received pubsub message.
     PubsubMessage {
         source: PeerId,
         topics: Vec<TopicHash>,
-        message: PubsubMessage,
+        message: Box<PubsubMessage>,
     },
 }