lib: Apply linter suggestions.

src/blockchain/contract_store.rs

@@ -51,7 +51,7 @@ impl WasmStore {
     /// Fetches the bincode for a given ContractId
     /// Returns an error if the bincode is not found.
     pub fn get(&self, contract_id: ContractId) -> Result<Vec<u8>> {
-        if let Some(bincode) = self.0.get(&serialize(&contract_id))? {
+        if let Some(bincode) = self.0.get(serialize(&contract_id))? {
             return Ok(bincode.to_vec())
         }
 
@@ -60,7 +60,7 @@ impl WasmStore {
 
     /// Inserts or replaces the bincode for a given ContractId
     pub fn insert(&self, contract_id: ContractId, bincode: &[u8]) -> Result<()> {
-        if let Err(e) = self.0.insert(&serialize(&contract_id), bincode) {
+        if let Err(e) = self.0.insert(serialize(&contract_id), bincode) {
             error!(target: "blockchain::contractstore", "Failed to insert bincode to WasmStore: {}", e);
             return Err(e.into())
         }
@@ -223,7 +223,7 @@ impl ContractStateStore {
 
         let zkas_tree = self.lookup(db, contract_id, SMART_CONTRACT_ZKAS_DB_NAME)?;
 
-        let Some(zkas_bytes) = zkas_tree.get(&serialize(&zkas_ns))? else {
+        let Some(zkas_bytes) = zkas_tree.get(serialize(&zkas_ns))? else {
             return Err(Error::ZkasBincodeNotFound)
         };
 

src/consensus/lead_coin.rs

@@ -240,9 +240,8 @@ impl LeadCoin {
     }
 
     pub fn headstart() -> pallas::Base {
-        let headstart = constants::MIN_F.clone() * Float10::try_from(constants::P.clone()).unwrap();
-        let headstart_base = fbig2base(headstart);
-        headstart_base
+        let headstart = constants::MIN_F.clone() * Float10::try_from(constants::P).unwrap();
+        fbig2base(headstart)
     }
 
     pub fn is_leader(
@@ -270,7 +269,7 @@ impl LeadCoin {
 
         {
             let mut writer = BufWriter::new(f);
-            writer.write(&y_t_str.into_bytes()).unwrap();
+            let _ = writer.write(&y_t_str.into_bytes()).unwrap();
         }
         info!(target: "consensus::leadcoin", "is_leader(): y = {:?}", y);
         info!(target: "consensus::leadcoin", "is_leader(): T = {:?}", target);
@@ -321,7 +320,7 @@ impl LeadCoin {
             coin1_commitment: derived_c1_cm,
             coin1_commitment_root: commitment_root,
             coin1_commitment_pos: u32::try_from(usize::from(leaf_pos)).unwrap(),
-            coin1_commitment_merkle_path: commitment_merkle_path.try_into().unwrap(),
+            coin1_commitment_merkle_path: commitment_merkle_path,
             coin1_sk: self.coin1_sk,
             coin1_sk_root: self.coin1_sk_root,
             coin1_sk_pos: self.coin1_sk_pos,

src/consensus/state.rs

@@ -372,12 +372,12 @@ impl ConsensusState {
         info!(target: "consensus::state", "Previous leaders: {}", self.previous_leaders);
         // Write counter to file
         let mut count_str: String = self.previous_leaders.to_string();
-        count_str.push_str(",");
+        count_str.push(',');
         let f =
             File::options().append(true).create(true).open(constants::LEADER_HISTORY_LOG).unwrap();
         {
             let mut writer = BufWriter::new(f);
-            writer.write(&count_str.into_bytes()).unwrap();
+            let _ = writer.write(&count_str.into_bytes()).unwrap();
         }
         // Calculate feedback
         let feedback = Float10::try_from(self.previous_leaders as i64).unwrap();
@@ -403,10 +403,10 @@ impl ConsensusState {
         info!(target: "consensus::state", "pid::err: {:}", err);
         info!(target: "consensus::state", "pid::err-1: {}", self.err_history[err_len - 1].clone());
         info!(target: "consensus::state", "pid::err-2: {}", self.err_history[err_len - 2].clone());
-        info!(target: "consensus::state", "pid::k1: {}", k1.clone());
-        info!(target: "consensus::state", "pid::k2: {}", k2.clone());
-        info!(target: "consensus::state", "pid::k3: {}", k3.clone());
-        self.err_history.push(err.clone());
+        info!(target: "consensus::state", "pid::k1: {}", k1);
+        info!(target: "consensus::state", "pid::k2: {}", k2);
+        info!(target: "consensus::state", "pid::k3: {}", k3);
+        self.err_history.push(err);
         ret
     }
     /// the probability inverse of winnig lottery having all the stake
@@ -423,9 +423,9 @@ impl ConsensusState {
             File::options().append(true).create(true).open(constants::F_HISTORY_LOG).unwrap();
         {
             let mut f_history = format!("{:}", f);
-            f_history.push_str(",");
+            f_history.push(',');
             let mut writer = BufWriter::new(file);
-            writer.write(&f_history.into_bytes()).unwrap();
+            let _ = writer.write(&f_history.into_bytes()).unwrap();
         }
         self.f_history.push(f.clone());
         f
@@ -618,7 +618,7 @@ impl ConsensusState {
             return false
         }
         let previous_slot = current_slot - 1;
-        !self.get_slot_checkpoint(previous_slot).is_ok()
+        self.get_slot_checkpoint(previous_slot).is_err()
     }
 
     /// Auxillary function to update all fork state checkpoints to nodes coins current canonical states.

src/consensus/task/consensus_sync.rs

@@ -117,7 +117,7 @@ pub async fn consensus_sync_task(p2p: P2pPtr, state: ValidatorStatePtr) -> Resul
     let mut response = response_sub.receive().await?;
     // Verify that peer has finished finalizing forks
     loop {
-        if response.forks.len() != 0 {
+        if !response.forks.is_empty() {
             warn!(target: "consensus::consensus_sync", "Peer has not finished finalization, retrying...");
             sleep(1).await;
             peer.send(ConsensusRequest {}).await?;

src/consensus/utils.rs

@@ -62,9 +62,9 @@ pub fn base2ibig(base: pallas::Base) -> IBig {
         u64::from_le_bytes(byts[24..32].try_into().expect("")),
     ];
     let uparts = UBig::from_words(&words);
-    let ibig = IBig::from_parts(Sign::Positive, uparts);
-    ibig
+    IBig::from_parts(Sign::Positive, uparts)
 }
+
 #[cfg(test)]
 mod tests {
     use dashu::integer::IBig;

src/consensus/validator.rs

@@ -271,7 +271,7 @@ impl ValidatorState {
         let (proof, public_inputs) = coin.create_lead_proof(
             sigma1,
             sigma2,
-            eta.clone(),
+            eta,
             pallas::Base::from(self.consensus.current_slot()),
             self.lead_proving_key.as_ref().unwrap(),
             derived_blind,
@@ -904,7 +904,7 @@ impl ValidatorState {
                     let (_, vk) = self.blockchain.contracts.get_zkas(
                         &self.blockchain.sled_db,
                         &call.contract_id,
-                        &zkas_ns,
+                        zkas_ns,
                     )?;
 
                     inner_vk_map.insert(zkas_ns.to_string(), vk);
@@ -939,7 +939,7 @@ impl ValidatorState {
                 }
                 Err(e) => {
                     error!(target: "consensus::validator", "Signature verification for tx {} failed: {}", tx_hash, e);
-                    return Err(e.into())
+                    return Err(e)
                 }
             };
 
@@ -950,7 +950,7 @@ impl ValidatorState {
                 }
                 Err(e) => {
                     error!(target: "consensus::validator", "ZK proof verification for tx {} failed: {}", tx_hash, e);
-                    return Err(e.into())
+                    return Err(e)
                 }
             };
 

src/net/acceptor.rs

@@ -118,9 +118,7 @@ impl Acceptor {
                 }
 
                 let auth_cookie = auth_cookie.unwrap();
-
-                let auth_cookie = hex::encode(&fs::read(auth_cookie).unwrap());
-
+                let auth_cookie = hex::encode(fs::read(auth_cookie).unwrap());
                 let transport = TorTransport::new(socks5_url, Some((torc_url, auth_cookie)))?;
 
                 // generate EHS pointing to local address

src/net/hosts.rs

@@ -63,7 +63,7 @@ impl Hosts {
         let addrs = if !self.localnet {
             let filtered = filter_localnet(input_addrs);
             let filtered = filter_invalid(&self.ipv4_range, &self.ipv6_range, filtered);
-            filtered.into_iter().map(|(k, _)| k).collect()
+            filtered.into_keys().collect()
         } else {
             debug!(target: "net::hosts::store()", "hosts::store() [Localnet mode, skipping filterring.]");
             input_addrs

src/raft/consensus_leader.rs

@@ -105,7 +105,7 @@ impl<T: Decodable + Encodable + Clone> Raft<T> {
 
     async fn commit_log(&mut self) -> Result<()> {
         let nodes_ptr = self.nodes.lock().await;
-        let min_acks = ((nodes_ptr.len() + 1) / 2) as usize;
+        let min_acks = (nodes_ptr.len() + 1) / 2;
         let nodes = nodes_ptr.clone();
         drop(nodes_ptr);
 

src/rpc/server.rs

@@ -178,9 +178,10 @@ pub async fn listen_and_serve(
             let listener = transport.listen_on(accept_url.clone());
             accept!(listener, transport, upgrade);
         }
+
         TransportName::Tor(upgrade) => {
             let (socks5_url, torc_url, auth_cookie) = TorTransport::get_listener_env()?;
-            let auth_cookie = hex::encode(&std::fs::read(auth_cookie).unwrap());
+            let auth_cookie = hex::encode(std::fs::read(auth_cookie).unwrap());
             let transport = TorTransport::new(socks5_url, Some((torc_url, auth_cookie)))?;
 
             // Generate EHS pointing to local address
@@ -190,6 +191,7 @@ pub async fn listen_and_serve(
             let listener = transport.clone().listen_on(accept_url.clone());
             accept!(listener, transport, upgrade);
         }
+
         TransportName::Unix => {
             let transport = UnixTransport::new();
             let listener = transport.listen_on(accept_url.clone());

src/sdk/src/crypto/merkle_node.rs

@@ -42,7 +42,6 @@ lazy_static! {
         iter::empty()
             .chain(Some(MerkleNode::empty_leaf()))
             .chain((0..MERKLE_DEPTH).scan(MerkleNode::empty_leaf(), |state, l| {
-                let l = l as u8;
                 *state = MerkleNode::combine(l.into(), state, state);
                 Some(*state)
             }))

src/sdk/src/crypto/note.rs

@@ -71,13 +71,26 @@ impl AeadEncryptedNote {
             &[],
             &mut plaintext,
         ) {
-            Ok(()) => {
-                let d = D::decode(&plaintext[..ct_len - AEAD_TAG_SIZE])?;
-                return Ok(d)
-            }
-            Err(e) => {
-                Err(ContractError::IoError(format!("Note decrypt failed: {}", e.to_string())))
-            }
+            Ok(()) => Ok(D::decode(&plaintext[..ct_len - AEAD_TAG_SIZE])?),
+            Err(e) => Err(ContractError::IoError(format!("Note decrypt failed: {}", e))),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_aead_note() {
+        let plaintext = "gm world";
+        let keypair = Keypair::new(&mut OsRng);
+
+        let encrypted_note =
+            AeadEncryptedNote::encrypt(&plaintext, &keypair.public, &mut OsRng).unwrap();
+
+        let plaintext2 = encrypted_note.decrypt(&keypair.secret).unwrap();
+
+        assert_eq!(plaintext, plaintext2);
+    }
+}

src/sdk/src/db.rs

@@ -212,11 +212,11 @@ pub fn put_object_bytes(data: &[u8]) -> i64 {
 }
 
 pub fn get_object_bytes(data: &mut [u8], object_index: u32) -> i64 {
-    unsafe { get_object_bytes_(data.as_mut_ptr(), object_index as u32) }
+    unsafe { get_object_bytes_(data.as_mut_ptr(), object_index) }
 }
 
 pub fn get_object_size(object_index: u32) -> i64 {
-    unsafe { get_object_size_(object_index as u32) }
+    unsafe { get_object_size_(object_index) }
 }
 
 extern "C" {

src/serial/src/lib.rs

@@ -304,7 +304,7 @@ impl Encodable for VarInt {
 
             _ => {
                 s.write_u8(0xFF)?;
-                (self.0 as u64).encode(s)?;
+                self.0.encode(s)?;
                 Ok(9)
             }
         }

src/tx/mod.rs

@@ -79,7 +79,7 @@ impl Transaction {
                 if let Some(vk) = contract_map.get(zk_ns) {
                     // We have a verifying key for this
                     debug!("public inputs: {:#?}", public_vals);
-                    if let Err(e) = proof.verify(&vk, public_vals) {
+                    if let Err(e) = proof.verify(vk, public_vals) {
                         error!(
                             target: "",
                             "Failed verifying {}::{} ZK proof: {:#?}",

src/zk/proof.rs

@@ -48,10 +48,10 @@ impl VerifyingKey {
         let mut vk = vec![];
         self.vk.write(&mut vk)?;
 
-        writer.write(&(params.len() as u32).to_le_bytes())?;
-        writer.write(&params)?;
-        writer.write(&(vk.len() as u32).to_le_bytes())?;
-        writer.write(&vk)?;
+        let _ = writer.write(&(params.len() as u32).to_le_bytes())?;
+        let _ = writer.write(&params)?;
+        let _ = writer.write(&(vk.len() as u32).to_le_bytes())?;
+        let _ = writer.write(&vk)?;
 
         Ok(())
     }