Make clippy happy (#156)

Author: mattsse

examples/custom_executor.rs

@@ -52,7 +52,7 @@ fn main() {
                     enr.tcp4()
                 );
                 if let Err(e) = discv5.add_enr(enr) {
-                    println!("ENR was not added: {}", e);
+                    println!("ENR was not added: {e}");
                 }
             }
             Err(e) => panic!("Decoding ENR failed: {}", e),
@@ -70,7 +70,7 @@ fn main() {
         loop {
             match event_stream.recv().await {
                 Some(Discv5Event::SocketUpdated(addr)) => {
-                    println!("Nodes ENR socket address has been updated to: {:?}", addr);
+                    println!("Nodes ENR socket address has been updated to: {addr:?}");
                 }
                 Some(Discv5Event::Discovered(enr)) => {
                     println!("A peer has been discovered: {}", enr.node_id());

examples/request_enr.rs

@@ -56,10 +56,10 @@ async fn main() {
         Ok(enr) => {
             println!("ENR Found:");
             println!("Base64:{}", enr.to_base64());
-            println!("{}", enr);
+            println!("{enr}");
         }
         Err(e) => {
-            println!("Error:{:?}", e);
+            println!("Error:{e:?}");
         }
     }
 }

examples/simple_server.rs

@@ -85,7 +85,7 @@ async fn main() {
                     enr.tcp4()
                 );
                 if let Err(e) = discv5.add_enr(enr) {
-                    println!("ENR was not added: {}", e);
+                    println!("ENR was not added: {e}");
                 }
             }
             Err(e) => panic!("Decoding ENR failed: {}", e),
@@ -102,7 +102,7 @@ async fn main() {
     loop {
         match event_stream.recv().await {
             Some(Discv5Event::SocketUpdated(addr)) => {
-                println!("Nodes ENR socket address has been updated to: {:?}", addr);
+                println!("Nodes ENR socket address has been updated to: {addr:?}");
             }
             Some(Discv5Event::Discovered(enr)) => {
                 println!("A peer has been discovered: {}", enr.node_id());

src/config.rs

@@ -317,7 +317,7 @@ impl Discv5ConfigBuilder {
     pub fn build(&mut self) -> Discv5Config {
         // If an executor is not provided, assume a current tokio runtime is running.
         if self.config.executor.is_none() {
-            self.config.executor = Some(Box::new(crate::executor::TokioExecutor::default()));
+            self.config.executor = Some(Box::<crate::executor::TokioExecutor>::default());
         };
 
         assert!(self.config.incoming_bucket_limit <= MAX_NODES_PER_BUCKET);

src/discv5.rs

@@ -98,7 +98,7 @@ impl Discv5 {
 
         // If an executor is not provided, assume a current tokio runtime is running. If not panic.
         if config.executor.is_none() {
-            config.executor = Some(Box::new(crate::executor::TokioExecutor::default()));
+            config.executor = Some(Box::<crate::executor::TokioExecutor>::default());
         };
 
         // NOTE: Currently we don't expose custom filter support in the configuration. Users can

src/discv5/test.rs

@@ -95,7 +95,7 @@ fn find_seed_same_bucket() {
     let mut seed = 1;
     'main: loop {
         if seed % 1000 == 0 {
-            println!("Seed: {}", seed);
+            println!("Seed: {seed}");
         }
 
         let keys = generate_deterministic_keypair(11, seed);
@@ -116,7 +116,7 @@ fn find_seed_same_bucket() {
         }
         break;
     }
-    println!("Found Seed: {}", seed);
+    println!("Found Seed: {seed}");
 }
 
 #[allow(dead_code)]
@@ -147,12 +147,12 @@ fn find_seed_spread_bucket() {
             break;
         }
         if seed % 1000 == 0 {
-            println!("Seed: {}", seed);
+            println!("Seed: {seed}");
         }
     }
-    println!("Found Seed: {}", seed);
+    println!("Found Seed: {seed}");
     for (k, v) in buckets.iter() {
-        println!("{}, {}", k, v);
+        println!("{k}, {v}");
     }
 }
 
@@ -172,7 +172,7 @@ fn find_seed_linear_topology() {
     'main: loop {
         seed += 1;
         if seed % 1000 == 0 {
-            println!("Trying seed: {}", seed);
+            println!("Trying seed: {seed}");
         }
 
         let keys = generate_deterministic_keypair(11, seed);
@@ -233,22 +233,21 @@ fn find_seed_linear_topology() {
         break;
     }
     // We've found a solution. Check it.
-    println!("Found Seed: {}", seed);
-    println!("Ordering: {:?}", ordering);
+    println!("Found Seed: {seed}");
+    println!("Ordering: {ordering:?}");
     let target = main_result.remove(0);
     // remove the target
-    println!("Target: {}", target);
+    println!("Target: {target}");
     for (x, id) in main_result.iter().enumerate() {
-        println!("Node{}: {}", x, id);
+        println!("Node{x}: {id}");
     }
 
     for (node, previous_node) in main_result.iter().skip(1).zip(main_result.clone()) {
         let key: Key<NodeId> = (*node).into();
         let distance = key.log2_distance(&previous_node.into()).unwrap();
         let target_distance = key.log2_distance(&target.into()).unwrap();
         println!(
-            "Distance of node {} relative to next node: {} is: {},  relative to target {}",
-            previous_node, node, distance, target_distance
+            "Distance of node {previous_node} relative to next node: {node} is: {distance},  relative to target {target_distance}"
         );
     }
 }
@@ -391,7 +390,7 @@ async fn test_findnode_query() {
         let distance = key
             .log2_distance(&previous_node_enr.node_id().into())
             .unwrap();
-        println!("Distance of node relative to next: {}", distance);
+        println!("Distance of node relative to next: {distance}");
         node.add_enr(previous_node_enr).unwrap();
     }
 
@@ -533,7 +532,7 @@ async fn test_predicate_search() {
         found_nodes.len(),
         total_nodes,
     );
-    println!("Nodes expected to pass predicate search {}", num_nodes);
+    println!("Nodes expected to pass predicate search {num_nodes}");
     assert_eq!(found_nodes.len(), num_nodes);
 }
 

src/error.rs

@@ -129,19 +129,19 @@ pub enum QueryError {
 
 impl fmt::Display for Discv5Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for RequestError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for QueryError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 

src/handler/crypto/mod.rs

@@ -136,7 +136,7 @@ pub(crate) fn sign_nonce(
             let message = Sha256::new().chain(signing_message);
             let signature: Signature = key
                 .try_sign_digest(message)
-                .map_err(|e| Discv5Error::Error(format!("Failed to sign message: {}", e)))?;
+                .map_err(|e| Discv5Error::Error(format!("Failed to sign message: {e}")))?;
             Ok(signature.as_bytes().to_vec())
         }
         CombinedKey::Ed25519(_) => Err(Discv5Error::KeyTypeNotSupported("Ed25519")),
@@ -305,7 +305,7 @@ mod tests {
                 .unwrap();
         let dst_id: NodeId = node_key_2().public().into();
 
-        println!("{}", dst_id);
+        println!("{dst_id}");
 
         let expected_sig = hex::decode("94852a1e2318c4e5e9d422c98eaf19d1d90d876b29cd06ca7cb7546d0fff7b484fe86c09a064fe72bdbef73ba8e9c34df0cd2b53e9d65528c2c7f336d5dfc6e6").unwrap();
 
@@ -409,6 +409,6 @@ mod tests {
         dbg!(hex::encode(&message));
         let rpc = crate::rpc::Message::decode(&message).unwrap();
 
-        println!("{}", rpc);
+        println!("{rpc}");
     }
 }

src/handler/mod.rs

@@ -463,7 +463,7 @@ impl Handler {
                 };
                 let packet = session
                     .encrypt_message(self.node_id, &request.encode())
-                    .map_err(|e| RequestError::EncryptionFailed(format!("{:?}", e)))?;
+                    .map_err(|e| RequestError::EncryptionFailed(format!("{e:?}")))?;
                 (packet, false)
             } else {
                 // No session exists, start a new handshake

src/kbucket.rs

@@ -1050,7 +1050,7 @@ mod tests {
 
         // Expire the timeout for the pending entry on the full bucket.`
         let full_bucket = &mut table.buckets[full_bucket_index.unwrap().get()];
-        let elapsed = Instant::now() - Duration::from_secs(1);
+        let elapsed = Instant::now().checked_sub(Duration::from_secs(1)).unwrap();
         full_bucket.pending_mut().unwrap().set_ready_at(elapsed);
 
         match table.entry(&expected_applied.inserted) {