chore(clippy): make clippy happy (#1710)

crates/net/discv4/src/lib.rs

@@ -406,10 +406,10 @@ impl Discv4Service {
         let mut tasks = JoinSet::<()>::new();
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { receive_loop(udp, ingress_tx, local_node_record.id).await });
+        tasks.spawn(receive_loop(udp, ingress_tx, local_node_record.id));
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { send_loop(udp, egress_rx).await });
+        tasks.spawn(send_loop(udp, egress_rx));
 
         let kbuckets = KBucketsTable::new(
             NodeKey::from(&local_node_record).into(),

crates/net/discv4/src/test_utils.rs

@@ -65,10 +65,10 @@ impl MockDiscovery {
         let mut tasks = JoinSet::<()>::new();
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { receive_loop(udp, ingress_tx, local_enr.id).await });
+        tasks.spawn(receive_loop(udp, ingress_tx, local_enr.id));
 
         let udp = Arc::clone(&socket);
-        tasks.spawn(async move { send_loop(udp, egress_rx).await });
+        tasks.spawn(send_loop(udp, egress_rx));
 
         let (tx, command_rx) = mpsc::channel(128);
         let this = Self {

crates/net/dns/src/query.rs

@@ -59,18 +59,15 @@ impl<R: Resolver, K: EnrKeyUnambiguous> QueryPool<R, K> {
     pub(crate) fn resolve_root(&mut self, link: LinkEntry<K>) {
         let resolver = Arc::clone(&self.resolver);
         let timeout = self.lookup_timeout;
-        self.queued_queries.push_back(Query::Root(Box::pin(async move {
-            resolve_root(resolver, link, timeout).await
-        })))
+        self.queued_queries.push_back(Query::Root(Box::pin(resolve_root(resolver, link, timeout))))
     }
 
     /// Resolves the [DnsEntry] for `<hash.domain>`
     pub(crate) fn resolve_entry(&mut self, link: LinkEntry<K>, hash: String, kind: ResolveKind) {
         let resolver = Arc::clone(&self.resolver);
         let timeout = self.lookup_timeout;
-        self.queued_queries.push_back(Query::Entry(Box::pin(async move {
-            resolve_entry(resolver, link, hash, kind, timeout).await
-        })))
+        self.queued_queries
+            .push_back(Query::Entry(Box::pin(resolve_entry(resolver, link, hash, kind, timeout))))
     }
 
     /// Advances the state of the queries

crates/net/downloaders/src/bodies/task.rs

@@ -76,7 +76,7 @@ impl TaskDownloader {
             downloader,
         };
 
-        spawner.spawn(async move { downloader.await }.boxed());
+        spawner.spawn(downloader.boxed());
 
         Self { from_downloader: UnboundedReceiverStream::new(bodies_rx), to_downloader }
     }

crates/net/downloaders/src/headers/task.rs

@@ -68,7 +68,7 @@ impl TaskDownloader {
             updates: UnboundedReceiverStream::new(updates_rx),
             downloader,
         };
-        spawner.spawn(async move { downloader.await }.boxed());
+        spawner.spawn(downloader.boxed());
 
         Self { from_downloader: UnboundedReceiverStream::new(headers_rx), to_downloader }
     }

crates/net/network/src/session/mod.rs

@@ -169,7 +169,7 @@ impl SessionManager {
     where
         F: Future<Output = ()> + Send + 'static,
     {
-        self.executor.spawn(async move { f.await }.boxed());
+        self.executor.spawn(f.boxed());
     }
 
     /// Invoked on a received status update.
@@ -209,20 +209,17 @@ impl SessionManager {
         let hello_message = self.hello_message.clone();
         let status = self.status;
         let fork_filter = self.fork_filter.clone();
-        self.spawn(async move {
-            start_pending_incoming_session(
-                disconnect_rx,
-                session_id,
-                metered_stream,
-                pending_events,
-                remote_addr,
-                secret_key,
-                hello_message,
-                status,
-                fork_filter,
-            )
-            .await
-        });
+        self.spawn(start_pending_incoming_session(
+            disconnect_rx,
+            session_id,
+            metered_stream,
+            pending_events,
+            remote_addr,
+            secret_key,
+            hello_message,
+            status,
+            fork_filter,
+        ));
 
         let handle = PendingSessionHandle {
             disconnect_tx: Some(disconnect_tx),
@@ -243,21 +240,18 @@ impl SessionManager {
         let fork_filter = self.fork_filter.clone();
         let status = self.status;
         let band_with_meter = self.bandwidth_meter.clone();
-        self.spawn(async move {
-            start_pending_outbound_session(
-                disconnect_rx,
-                pending_events,
-                session_id,
-                remote_addr,
-                remote_peer_id,
-                secret_key,
-                hello_message,
-                status,
-                fork_filter,
-                band_with_meter,
-            )
-            .await
-        });
+        self.spawn(start_pending_outbound_session(
+            disconnect_rx,
+            pending_events,
+            session_id,
+            remote_addr,
+            remote_peer_id,
+            secret_key,
+            hello_message,
+            status,
+            fork_filter,
+            band_with_meter,
+        ));
 
         let handle = PendingSessionHandle {
             disconnect_tx: Some(disconnect_tx),

crates/net/network/src/test_utils/testnet.rs

@@ -77,7 +77,7 @@ where
         &mut self,
         configs: impl IntoIterator<Item = PeerConfig<C>>,
     ) -> Result<(), NetworkError> {
-        let peers = configs.into_iter().map(|c| async { c.launch().await }).collect::<Vec<_>>();
+        let peers = configs.into_iter().map(|c| c.launch()).collect::<Vec<_>>();
         let peers = futures::future::join_all(peers).await;
         for peer in peers {
             self.peers.push(peer?);

crates/net/network/src/transactions.rs

@@ -431,6 +431,8 @@ where
                         let pool_transaction = <Pool::Transaction as FromRecoveredTransaction>::from_recovered_transaction(tx);
 
                         let pool = self.pool.clone();
+
+                        #[allow(clippy::redundant_async_block)]
                         let import = Box::pin(async move {
                             pool.add_external_transaction(pool_transaction).await
                         });