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

bin/reth/src/node/mod.rs

@@ -342,11 +342,11 @@ impl Command {
             NetworkManager::builder(config).await?.request_handler(client).split_with_handle();
 
         let known_peers_file = self.network.persistent_peers_file();
-        task_executor.spawn_critical_with_signal("p2p network task", |shutdown| async move {
-            run_network_until_shutdown(shutdown, network, known_peers_file).await
+        task_executor.spawn_critical_with_signal("p2p network task", |shutdown| {
+            run_network_until_shutdown(shutdown, network, known_peers_file)
         });
 
-        task_executor.spawn_critical("p2p eth request handler", async move { eth.await });
+        task_executor.spawn_critical("p2p eth request handler", eth);
 
         // TODO spawn pool
 

bin/reth/src/p2p/mod.rs

@@ -137,7 +137,7 @@ impl Command {
                 };
                 let (_, result) = (move || {
                     let client = fetch_client.clone();
-                    async move { client.get_block_bodies(vec![hash]).await }
+                    client.get_block_bodies(vec![hash])
                 })
                 .retry(&backoff)
                 .notify(|err, _| println!("Error requesting block: {err}. Retrying..."))

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
                         });

crates/stages/src/pipeline/mod.rs

@@ -490,7 +490,9 @@ mod tests {
         let events = pipeline.events();
 
         // Run pipeline
-        tokio::spawn(async move { pipeline.run(db).await });
+        tokio::spawn(async move {
+            pipeline.run(db).await.unwrap();
+        });
 
         // Check that the stages were run in order
         assert_eq!(