clippy cleanups.

src/blockchain/slabstore.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use log::{debug, trace};
+use log::trace;
 
 use super::{
     rocks::{columns, IteratorMode, RocksColumn},

src/circuit/mint_contract.rs

@@ -119,12 +119,8 @@ impl Circuit<pallas::Base> for MintContract {
 
         // Configuration for curve point operations.
         // This uses 10 advice columns and spans the whole circuit.
-        let ecc_config = EccChip::<OrchardFixedBases>::configure(
-            meta,
-            advices,
-            lagrange_coeffs,
-            range_check.clone(),
-        );
+        let ecc_config =
+            EccChip::<OrchardFixedBases>::configure(meta, advices, lagrange_coeffs, range_check);
 
         // Configuration for the Poseidon hash
         let poseidon_config = PoseidonChip::configure(

src/crypto/constants/util.rs

@@ -16,10 +16,10 @@ pub fn gen_const_array<Output: Copy + Default, const LEN: usize>(
 
 pub(crate) fn gen_const_array_with_default<Output: Copy, const LEN: usize>(
     default_value: Output,
-    mut closure: impl FnMut(usize) -> Output,
+    closure: impl FnMut(usize) -> Output,
 ) -> [Output; LEN] {
     let mut ret: [Output; LEN] = [default_value; LEN];
-    for (bit, val) in ret.iter_mut().zip((0..LEN).map(|idx| closure(idx))) {
+    for (bit, val) in ret.iter_mut().zip((0..LEN).map(closure)) {
         *bit = val;
     }
     ret

src/darkpulse/net/protocol_slab.rs

@@ -99,7 +99,7 @@ impl ProtocolSlab {
             let slabs_hash = self.slabman.lock().await.get_slabs_hash();
             for slab in inv_msg.slabs_hash.iter() {
                 if !slabs_hash.contains(slab) {
-                    list_of_hash.push(slab.clone());
+                    list_of_hash.push(*slab);
                 }
             }
             let getslabs_msg = messages::GetSlabsMessage { slabs_hash: list_of_hash };
@@ -114,7 +114,7 @@ impl ProtocolSlab {
             let get_slabs_msg = self.get_slabs_sub.receive().await?;
             for slab_hash in get_slabs_msg.slabs_hash.iter() {
                 let slabman = self.slabman.lock().await;
-                let slab = slabman.get_slab(&slab_hash);
+                let slab = slabman.get_slab(slab_hash);
                 if let Some(slab) = slab {
                     self.channel.send(slab.clone()).await?;
                 }
@@ -129,7 +129,7 @@ impl ProtocolSlab {
             let slab_msg = self.slab_sub.receive().await?;
             info!("receive slab message!");
 
-            let channels = self.slabman.lock().await.get_channels().unwrap_or(vec![]);
+            let channels = self.slabman.lock().await.get_channels().unwrap_or_default();
 
             let slab = messages::SlabMessage {
                 nonce: slab_msg.nonce,

src/darkpulse/slabs_manager.rs

@@ -40,7 +40,7 @@ impl SlabsManager {
         let mut slabs: HashMap<CiphertextHash, SlabMessage> = HashMap::new();
 
         if let Some(channel_id) = main_channel.get_channel_id() {
-            slabs = db.get_channel_slabs(channel_id.clone()).unwrap_or(slabs);
+            slabs = db.get_channel_slabs(*channel_id).unwrap_or(slabs);
         }
 
         Arc::new(async_std::sync::Mutex::new(SlabsManager {
@@ -82,7 +82,7 @@ impl SlabsManager {
         let default_slabs: HashMap<CiphertextHash, SlabMessage> = HashMap::new();
 
         if let Some(channel_id) = self.main_channel.get_channel_id() {
-            self.slabs = self.db.get_channel_slabs(channel_id.clone()).unwrap_or(default_slabs);
+            self.slabs = self.db.get_channel_slabs(*channel_id).unwrap_or(default_slabs);
         }
     }
 

src/darkpulse/utility.rs

@@ -30,9 +30,8 @@ pub fn get_current_time() -> u64 {
     let start = SystemTime::now();
     let since_the_epoch =
         start.duration_since(UNIX_EPOCH).expect("Incorrect system clock: time went backwards");
-    let in_ms =
-        since_the_epoch.as_secs() * 1000 + since_the_epoch.subsec_nanos() as u64 / 1_000_000;
-    return in_ms
+
+    since_the_epoch.as_secs() * 1000 + since_the_epoch.subsec_nanos() as u64 / 1_000_000
 }
 
 pub fn save_to_addrs_store(stored_addrs: &Vec<SocketAddr>) -> Result<()> {
@@ -88,7 +87,7 @@ pub async fn pack_slab(
     let timestamp = chrono::offset::Utc::now();
     let timestamp: i64 = timestamp.timestamp_millis() / 1000;
 
-    let msg_payload = MessagePayload { nickname: username.clone(), text: message, timestamp };
+    let msg_payload = MessagePayload { nickname: username, text: message, timestamp };
 
     let control_message = ControlMessage { control: control_command, payload: msg_payload };
 
@@ -128,14 +127,13 @@ pub async fn read_line<R: AsyncBufRead + Unpin>(reader: &mut R) -> Result<String
 pub fn choose_channel(db: &Dbsql, channel_name: Option<String>) -> Result<Channel> {
     let channels = db.get_channels()?;
     let mut main_channel = Channel::gen_new(String::from("test_channel"));
-    if channels.len() > 0 {
+    if !channels.is_empty() {
         match channel_name {
             Some(name) => {
                 main_channel = channels
                     .iter()
-                    .filter(|ch| ch.get_channel_name() == &name)
-                    .next()
-                    .expect(format!("there is no channel with the name {}: ", name).as_str())
+                    .find(|ch| ch.get_channel_name() == &name)
+                    .unwrap_or_else(|| panic!("there is no channel with the name {}: ", name))
                     .clone();
             }
             None => {