Minor fixes and touch-ups

blockchain/blocks/src/election_proof.rs

@@ -215,8 +215,8 @@ pub mod json {
             win_count,
         } = Deserialize::deserialize(deserializer)?;
         Ok(ElectionProof {
-            vrfproof,
             win_count,
+            vrfproof,
         })
     }
 

blockchain/chain/src/store/chain_store.rs

@@ -895,10 +895,10 @@ pub fn genesis<DB>(db: &DB) -> Result<Option<BlockHeader>, Error>
 where
     DB: BlockStore,
 {
-    Ok(match db.read(GENESIS_KEY)? {
-        Some(bz) => Some(BlockHeader::unmarshal_cbor(&bz)?),
-        None => None,
-    })
+    Ok(db
+        .read(GENESIS_KEY)?
+        .map(|bz| BlockHeader::unmarshal_cbor(&bz))
+        .transpose()?)
 }
 
 /// Attempts to deserialize to unsigend message or signed message and then returns it at as a
@@ -1083,7 +1083,7 @@ mod tests {
         let cs = ChainStore::new(Arc::new(db));
         let gen_block = BlockHeader::builder()
             .epoch(1)
-            .weight((2 as u32).into())
+            .weight(2_u32.into())
             .messages(cid::new_from_cbor(&[], Identity))
             .message_receipts(cid::new_from_cbor(&[], Identity))
             .state_root(cid::new_from_cbor(&[], Identity))

blockchain/chain_sync/src/sync.rs

@@ -673,7 +673,7 @@ mod tests {
         Sender<NetworkEvent>,
         Receiver<NetworkMessage>,
     ) {
-        let chain_store = Arc::new(ChainStore::new(db.clone()));
+        let chain_store = Arc::new(ChainStore::new(db));
         let test_provider = TestApi::default();
         let (tx, _rx) = bounded(10);
         let mpool = task::block_on(MessagePool::new(

blockchain/chain_sync/src/sync/peer_test.rs

@@ -19,7 +19,7 @@ use std::time::Duration;
 fn peer_manager_update() {
     let db = Arc::new(MemoryDB::default());
 
-    let chain_store = Arc::new(ChainStore::new(db.clone()));
+    let chain_store = Arc::new(ChainStore::new(db));
     let (tx, _rx) = bounded(10);
     let mpool = task::block_on(MessagePool::new(
         TestApi::default(),
@@ -61,17 +61,17 @@ fn peer_manager_update() {
     )
     .unwrap();
 
-    let peer_manager = Arc::clone(&cs.network.peer_manager.clone());
+    let peer_manager = Arc::clone(&cs.network.peer_manager);
 
     let (worker_tx, worker_rx) = bounded(10);
     task::spawn(async {
         cs.start(worker_tx, worker_rx).await;
     });
 
     let source = PeerId::random();
-    let source_clone = source.clone();
+    let source_clone = source;
 
-    let gen_cloned = genesis_ts.clone();
+    let gen_cloned = genesis_ts;
     task::block_on(async {
         event_sender
             .send(NetworkEvent::HelloRequest {

blockchain/chain_sync/src/sync_worker.rs

@@ -1079,7 +1079,7 @@ mod tests {
         task::block_on(async move {
             sw.network
                 .peer_manager()
-                .update_peer_head(source.clone(), head.clone())
+                .update_peer_head(source, head.clone())
                 .await;
             assert_eq!(sw.network.peer_manager().len().await, 1);
             // make chain_exchange request

blockchain/chain_sync/src/sync_worker/full_sync_test.rs

@@ -64,9 +64,7 @@ async fn space_race_full_sync() {
     let network = SyncNetworkContext::new(network_send, Arc::new(peer_manager), db);
 
     let provider_db = Arc::new(MemoryDB::default());
-    let cids: Vec<Cid> = load_car(provider_db.as_ref(), EXPORT_SR_40.as_ref())
-        .await
-        .unwrap();
+    let cids: Vec<Cid> = load_car(provider_db.as_ref(), EXPORT_SR_40).await.unwrap();
     let prov_cs = ChainStore::new(provider_db);
     let target = prov_cs
         .tipset_from_keys(&TipsetKeys::new(cids))

blockchain/chain_sync/src/sync_worker/validate_block_test.rs

@@ -21,7 +21,7 @@ async fn validate_specific_block() {
 
     let db = Arc::new(MemoryDB::default());
 
-    let cids = load_car(db.as_ref(), EXPORT_SR_40.as_ref()).await.unwrap();
+    let cids = load_car(db.as_ref(), EXPORT_SR_40).await.unwrap();
 
     let chain_store = Arc::new(ChainStore::new(db.clone()));
     let state_manager = Arc::new(StateManager::new(chain_store.clone()));

blockchain/message_pool/src/msg_chain.rs

@@ -143,10 +143,7 @@ impl MsgChain {
 
     pub(crate) fn trim(&mut self, gas_limit: i64, base_fee: &BigInt) {
         let mut i = self.chain.len() as i64 - 1;
-        let prev = match self.prev() {
-            Some(prev) => Some((prev.eff_perf, prev.gas_limit)),
-            None => None,
-        };
+        let prev = self.prev().map(|prev| (prev.eff_perf, prev.gas_limit));
         let mut mc = self.curr_mut();
         while i >= 0 && (mc.gas_limit > gas_limit || (mc.gas_perf < 0.0)) {
             let gas_reward = get_gas_reward(&mc.msgs[i as usize], base_fee);
@@ -189,10 +186,7 @@ impl MsgChain {
     }
     #[allow(dead_code)]
     pub(crate) fn set_eff_perf(&mut self) {
-        let prev = match self.prev() {
-            Some(prev) => Some((prev.eff_perf, prev.gas_limit)),
-            None => None,
-        };
+        let prev = self.prev().map(|prev| (prev.eff_perf, prev.gas_limit));
 
         let mc = self.curr_mut();
         let mut eff_perf = mc.gas_perf * mc.bp;

blockchain/message_pool/src/msgpool/mod.rs

@@ -458,8 +458,8 @@ pub mod tests {
         gas_price: u64,
     ) -> SignedMessage {
         let umsg: UnsignedMessage = UnsignedMessage::builder()
-            .to(to.clone())
-            .from(from.clone())
+            .to(*to)
+            .from(*from)
             .sequence(sequence)
             .gas_limit(gas_limit)
             .gas_fee_cap((gas_price + 100).into())
@@ -860,7 +860,7 @@ pub mod tests {
             let mut smsg_vec = Vec::new();
             tma.write()
                 .await
-                .set_state_balance_raw(&a1, BigInt::from(1_000_000_000_000_000_000 as u64));
+                .set_state_balance_raw(&a1, BigInt::from(1_000_000_000_000_000_000_u64));
             for i in 0..10 {
                 let msg = if i != 5 {
                     create_smsg(&a2, &a1, wallet.borrow_mut(), i, gas_limit, 1 + i)

blockchain/state_manager/src/utils.rs

@@ -43,31 +43,30 @@ where
             .ok_or_else(|| Error::State("Power actor address could not be resolved".to_string()))?;
         let mas = miner::State::load(self.blockstore(), &actor)?;
 
-        let proving_sectors = if nv < NetworkVersion::V7 {
+        let proving_sectors = {
             let mut proving_sectors = BitField::new();
-            mas.for_each_deadline(store, |_, deadline| {
-                let mut fault_sectors = BitField::new();
-                deadline.for_each(store, |_, partition: miner::Partition| {
-                    proving_sectors |= &partition.all_sectors();
-                    fault_sectors |= &partition.faulty_sectors();
-                    Ok(())
-                })?;
 
-                proving_sectors -= &fault_sectors;
-                Ok(())
-            })?;
+            if nv < NetworkVersion::V7 {
+                mas.for_each_deadline(store, |_, deadline| {
+                    let mut fault_sectors = BitField::new();
+                    deadline.for_each(store, |_, partition: miner::Partition| {
+                        proving_sectors |= &partition.all_sectors();
+                        fault_sectors |= &partition.faulty_sectors();
+                        Ok(())
+                    })?;
 
-            proving_sectors
-        } else {
-            let mut proving_sectors = BitField::new();
-            mas.for_each_deadline(store, |_, deadline| {
-                deadline.for_each(store, |_, partition: miner::Partition| {
-                    proving_sectors |= &partition.active_sectors();
+                    proving_sectors -= &fault_sectors;
                     Ok(())
                 })?;
-                Ok(())
-            })?;
-
+            } else {
+                mas.for_each_deadline(store, |_, deadline| {
+                    deadline.for_each(store, |_, partition: miner::Partition| {
+                        proving_sectors |= &partition.active_sectors();
+                        Ok(())
+                    })?;
+                    Ok(())
+                })?;
+            }
             proving_sectors
         };
 

encoding/src/bytes.rs

@@ -48,7 +48,7 @@ mod tests {
 
     #[test]
     fn array_symmetric_serialization() {
-        let vec: Vec<u8> = (0..32).map(|x| x).collect::<Vec<u8>>();
+        let vec: Vec<u8> = (0..32).collect::<Vec<u8>>();
         let slice_bz = to_vec(&BytesSer(&vec)).unwrap();
         let Byte32De(arr) = from_slice(&slice_bz).unwrap();
         // Check decoded array against slice

ipld/blockstore/src/buffered.rs

@@ -299,17 +299,15 @@ mod tests {
         )
         .unwrap();
         let map = ipld!({
-            "array": Link(arr_cid.clone()),
-            "sealed": Link(sealed_comm_cid.clone()),
-            "unsealed": Link(unsealed_comm_cid.clone()),
-            "identity": Link(identity_cid.clone()),
+            "array": Link(arr_cid),
+            "sealed": Link(sealed_comm_cid),
+            "unsealed": Link(unsealed_comm_cid),
+            "identity": Link(identity_cid),
             "value": str_val,
         });
         let map_cid = buf_store.put(&map, Code::Blake2b256).unwrap();
 
-        let root_cid = buf_store
-            .put(&(map_cid.clone(), 1u8), Code::Blake2b256)
-            .unwrap();
+        let root_cid = buf_store.put(&(map_cid, 1u8), Code::Blake2b256).unwrap();
 
         // Make sure a block not connected to the root does not get written
         let unconnected = buf_store.put(&27u8, Code::Blake2b256).unwrap();

ipld/cid/src/lib.rs

@@ -90,7 +90,7 @@ impl Cid {
     }
 
     /// Returns the encoded bytes of the `Cid`.
-    pub fn to_bytes(&self) -> Vec<u8> {
+    pub fn to_bytes(self) -> Vec<u8> {
         self.0.to_bytes()
     }
 }

ipld/cid/tests/base_cid_tests.rs

@@ -100,7 +100,7 @@ fn test_hash() {
     };
     let mut map = HashMap::new();
     let cid = forest_cid::new_from_prefix(&prefix, &data).unwrap();
-    map.insert(cid.clone(), data.clone());
+    map.insert(cid, data.clone());
     assert_eq!(&data, map.get(&cid).unwrap());
 }
 

ipld/hamt/tests/hamt_tests.rs

@@ -453,7 +453,7 @@ fn clean_child_ordering() {
     let mut h: Hamt<_, _> = Hamt::new_with_bit_width(&store, 5);
 
     for i in 100..195 {
-        h.set(make_key(i), dummy_value.clone()).unwrap();
+        h.set(make_key(i), dummy_value).unwrap();
     }
 
     let root = h.flush().unwrap();

ipld/tests/cbor_test.rs

@@ -21,7 +21,7 @@ fn encode_new_type() {
     let name = "Test".to_string();
     let t_struct = TestStruct {
         name: name.clone(),
-        details: details.clone(),
+        details,
     };
     let struct_encoded = to_vec(&t_struct).unwrap();
 
@@ -43,22 +43,22 @@ fn cid_conversions_ipld() {
     let cid = cid::new_from_cbor(&[1, 2, 3], Blake2b256);
     let m_s = TestStruct {
         name: "s".to_owned(),
-        details: cid.clone(),
+        details: cid,
     };
     assert_eq!(
         to_ipld(&m_s).unwrap(),
-        ipld!({"name": "s", "details": Link(cid.clone()) })
+        ipld!({"name": "s", "details": Link(cid) })
     );
     let serialized = to_vec(&cid).unwrap();
-    let ipld = ipld!(Link(cid.clone()));
+    let ipld = ipld!(Link(cid));
     let ipld2 = to_ipld(&cid).unwrap();
     assert_eq!(ipld, ipld2);
     assert_eq!(to_vec(&ipld).unwrap(), serialized);
     assert_eq!(to_ipld(&cid).unwrap(), Ipld::Link(cid));
 
     // Test with identity hash (different length prefix for cbor)
     let cid = cid::new_from_cbor(&[1, 2], Identity);
-    let ipld = ipld!(Link(cid.clone()));
+    let ipld = ipld!(Link(cid));
     let ipld2 = to_ipld(&cid).unwrap();
     assert_eq!(ipld, ipld2);
 }

key_management/src/wallet.rs

@@ -254,7 +254,7 @@ mod tests {
     fn contains_key() {
         let key_vec = construct_priv_keys();
         let found_key = key_vec[0].clone();
-        let addr = key_vec[0].address.clone();
+        let addr = key_vec[0].address;
 
         let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), key_vec);
 
@@ -281,7 +281,7 @@ mod tests {
     fn sign() {
         let key_vec = construct_priv_keys();
         let priv_key_bytes = key_vec[2].key_info.private_key().clone();
-        let addr = key_vec[2].address.clone();
+        let addr = key_vec[2].address;
         let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), key_vec);
         let msg = [0u8; 64];
 
@@ -306,7 +306,7 @@ mod tests {
 
         let key_info = wallet.export(&key.address).unwrap();
         // test to see if export returns the correct key_info
-        assert_eq!(key_info, key.key_info.clone());
+        assert_eq!(key_info, key.key_info);
 
         let new_priv_key = generate(SignatureType::Secp256k1).unwrap();
         let pub_key =
@@ -391,7 +391,7 @@ mod tests {
         wallet.keystore.put(test_addr_string, key_info).unwrap();
 
         // check to make sure that the set_default function completed without error
-        assert!(wallet.set_default(test_addr.clone()).is_ok());
+        assert!(wallet.set_default(test_addr).is_ok());
 
         // check to make sure that the test_addr is actually the default addr for the wallet
         assert_eq!(wallet.get_default().unwrap(), test_addr);
@@ -402,7 +402,7 @@ mod tests {
         let secp_priv_key = generate(SignatureType::Secp256k1).unwrap();
         let secp_key_info = KeyInfo::new(SignatureType::Secp256k1, secp_priv_key);
         let secp_key = Key::try_from(secp_key_info).unwrap();
-        let addr = secp_key.address.clone();
+        let addr = secp_key.address;
         let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), vec![secp_key]);
 
         let msg = [0u8; 64];
@@ -420,7 +420,7 @@ mod tests {
         let bls_priv_key = generate(SignatureType::BLS).unwrap();
         let bls_key_info = KeyInfo::new(SignatureType::BLS, bls_priv_key);
         let bls_key = Key::try_from(bls_key_info).unwrap();
-        let addr = bls_key.address.clone();
+        let addr = bls_key.address;
         let mut wallet = Wallet::new_from_keys(MemKeyStore::new(), vec![bls_key]);
 
         let msg = [0u8; 64];

node/db/tests/subtests/mod.rs

@@ -18,7 +18,7 @@ where
 {
     let key = [0];
     let value = [1];
-    db.write(key.clone(), value.clone()).unwrap();
+    db.write(key, value).unwrap();
     let res = db.read(key).unwrap().unwrap();
     assert_eq!(value.as_ref(), res.as_slice());
 }
@@ -29,7 +29,7 @@ where
 {
     let key = [0];
     let value = [1];
-    db.write(key.clone(), value.clone()).unwrap();
+    db.write(key, value).unwrap();
     let res = db.exists(key).unwrap();
     assert_eq!(res, true);
 }
@@ -49,11 +49,11 @@ where
 {
     let key = [0];
     let value = [1];
-    db.write(key.clone(), value.clone()).unwrap();
-    let res = db.exists(key.clone()).unwrap();
+    db.write(key, value).unwrap();
+    let res = db.exists(key).unwrap();
     assert_eq!(res, true);
-    db.delete(key.clone()).unwrap();
-    let res = db.exists(key.clone()).unwrap();
+    db.delete(key).unwrap();
+    let res = db.exists(key).unwrap();
     assert_eq!(res, false);
 }
 
@@ -64,7 +64,7 @@ where
     let values = [([0], [0]), ([1], [1]), ([2], [2])];
     db.bulk_write(&values).unwrap();
     for (k, _) in values.iter() {
-        let res = db.exists(k.clone()).unwrap();
+        let res = db.exists(*k).unwrap();
         assert_eq!(res, true);
     }
 }
@@ -96,7 +96,7 @@ where
     db.bulk_write(&kvs).unwrap();
     db.bulk_delete(&keys).unwrap();
     for k in keys.iter() {
-        let res = db.exists(k.clone()).unwrap();
+        let res = db.exists(*k).unwrap();
         assert_eq!(res, false);
     }
 }