make fix and minor manual cleanups.

bin/dao-cli/src/main.rs

@@ -33,7 +33,7 @@ impl Rpc {
     // <-- {"jsonrpc": "2.0", "result": "hello world", "id": 42}
     async fn say_hello(&self) -> Result<Value> {
         let req = jsonrpc::request(json!("say_hello"), json!([]));
-        Ok(self.client.request(req).await?)
+        self.client.request(req).await
     }
 }
 

bin/darkfid/src/main.rs

@@ -201,7 +201,7 @@ impl Darkfid {
 async_daemonize!(realmain);
 async fn realmain(args: Args, ex: Arc<Executor<'_>>) -> Result<()> {
     // We verify that the system clock is valid before initializing
-    if let Err(_) = check_clock().await {
+    if (check_clock().await).is_err() {
         error!("System clock is invalid, terminating...");
         return Err(Error::InvalidClock)
     };

bin/dnetview/src/main.rs

@@ -51,7 +51,7 @@ impl DnetView {
     // <-- {"jsonrpc": "2.0", "result": "pong", "id": 42}
     async fn _ping(&self) -> Result<Value> {
         let req = jsonrpc::request(json!("ping"), json!([]));
-        Ok(self.rpc_client.request(req).await?)
+        self.rpc_client.request(req).await
     }
 
     //--> {"jsonrpc": "2.0", "method": "poll", "params": [], "id": 42}
@@ -59,8 +59,8 @@ impl DnetView {
     async fn get_info(&self) -> DnetViewResult<Value> {
         let req = jsonrpc::request(json!("get_info"), json!([]));
         match self.rpc_client.request(req).await {
-            Ok(req) => return Ok(req),
-            Err(e) => return Err(DnetViewError::Darkfi(e)),
+            Ok(req) => Ok(req),
+            Err(e) => Err(DnetViewError::Darkfi(e)),
         }
     }
 }
@@ -277,8 +277,8 @@ async fn update_selectable_and_ids(
 async fn parse_external_addr(addr: &Option<&Value>) -> DnetViewResult<Option<String>> {
     match addr {
         Some(addr) => match addr.as_str() {
-            Some(addr) => return Ok(Some(addr.to_string())),
-            None => return Ok(None),
+            Some(addr) => Ok(Some(addr.to_string())),
+            None => Ok(None),
         },
         None => Err(DnetViewError::NoExternalAddr),
     }
@@ -300,7 +300,7 @@ async fn parse_inbound(inbound: &Value, node_id: &String) -> DnetViewResult<Sess
                 true => {
                     connect_count += 1;
                     // channel is empty. initialize with empty values
-                    let id = make_empty_id(&node_id, &session_type, connect_count)?;
+                    let id = make_empty_id(node_id, &session_type, connect_count)?;
                     let addr = "Null".to_string();
                     let state = "Null".to_string();
                     let parent = parent.clone();
@@ -318,7 +318,7 @@ async fn parse_inbound(inbound: &Value, node_id: &String) -> DnetViewResult<Sess
                         last_msg,
                         last_status,
                     );
-                    connects.push(connect_info.clone());
+                    connects.push(connect_info);
                 }
                 false => {
                     // channel is not empty. initialize with whole values
@@ -400,7 +400,7 @@ async fn parse_manual(_manual: &Value, node_id: &String) -> DnetViewResult<Sessi
 
     let session_id = make_session_id(&parent, &session_type)?;
     //let id: u64 = 0;
-    let connect_id = make_empty_id(&node_id, &session_type, 0)?;
+    let connect_id = make_empty_id(node_id, &session_type, 0)?;
     //let connect_id = make_connect_id(&id)?;
     let addr = "Null".to_string();
     let state = "Null".to_string();
@@ -410,8 +410,8 @@ async fn parse_manual(_manual: &Value, node_id: &String) -> DnetViewResult<Sessi
     let status = "Null".to_string();
     let connect_info =
         ConnectInfo::new(connect_id.clone(), addr, state, parent, msg_log, is_empty, msg, status);
-    connects.push(connect_info.clone());
-    let parent = connect_id.clone();
+    connects.push(connect_info);
+    let parent = connect_id;
     let is_empty = is_empty_session(&connects);
     let accept_addr = None;
     let session_info =
@@ -436,7 +436,7 @@ async fn parse_outbound(outbound: &Value, node_id: &String) -> DnetViewResult<Se
                 match slot["channel"].is_null() {
                     true => {
                         // channel is empty. initialize with empty values
-                        let id = make_empty_id(&node_id, &session_type, slot_count)?;
+                        let id = make_empty_id(node_id, &session_type, slot_count)?;
                         let addr = "Null".to_string();
                         let state = &slot["state"];
                         let state = state.as_str().unwrap().to_string();

bin/dnetview/src/model.rs

@@ -95,6 +95,7 @@ pub struct ConnectInfo {
 }
 
 impl ConnectInfo {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         id: String,
         addr: String,

bin/dnetview/src/util.rs

@@ -1,6 +1,5 @@
 use crate::model::{ConnectInfo, Session};
 use darkfi::{util::serial, Result};
-use log::debug;
 
 pub fn make_node_id(node_name: &String) -> Result<String> {
     //match serial::serialize_hex(node_name).as_str() {
@@ -11,7 +10,7 @@ pub fn make_node_id(node_name: &String) -> Result<String> {
     Ok(serial::serialize_hex(node_name))
 }
 
-pub fn make_session_id(node_id: &String, session: &Session) -> Result<String> {
+pub fn make_session_id(node_id: &str, session: &Session) -> Result<String> {
     let mut num = 0_u64;
 
     match session {
@@ -58,7 +57,7 @@ pub fn make_connect_id(id: &u64) -> Result<String> {
     Ok(serial::serialize_hex(id))
 }
 
-pub fn make_empty_id(node_id: &String, session: &Session, count: u64) -> Result<String> {
+pub fn make_empty_id(node_id: &str, session: &Session, count: u64) -> Result<String> {
     let count = count * 2;
 
     let mut num = 0_u64;
@@ -100,6 +99,6 @@ pub fn make_empty_id(node_id: &String, session: &Session, count: u64) -> Result<
     Ok(serial::serialize_hex(&num))
 }
 
-pub fn is_empty_session(connects: &Vec<ConnectInfo>) -> bool {
+pub fn is_empty_session(connects: &[ConnectInfo]) -> bool {
     return connects.iter().all(|conn| conn.is_empty)
 }

bin/dnetview/src/view.rs

@@ -65,7 +65,7 @@ impl View {
         for info in self.nodes.infos.values() {
             self.active_ids.ids.insert(info.id.to_string());
             for session in &info.children {
-                if !session.is_empty == true {
+                if !session.is_empty {
                     self.active_ids.ids.insert(session.id.to_string());
                     for connect in &session.children {
                         self.active_ids.ids.insert(connect.id.to_string());
@@ -103,10 +103,10 @@ impl View {
             match self.active_ids.state.selected() {
                 Some(i) => match id_list.get(i) {
                     Some(i) => {
-                        self.render_info(f, slice.clone(), i.to_string())?;
+                        self.render_info(f, slice, i.to_string())?;
                         Ok(())
                     }
-                    None => return Err(DnetViewError::NoIdAtIndex),
+                    None => Err(DnetViewError::NoIdAtIndex),
                 },
                 // nothing is selected right now
                 None => Ok(()),
@@ -148,7 +148,7 @@ impl View {
                     ids.push(info.id.clone());
                     node_ids.push(info.id.clone());
                     for session in &info.children {
-                        if !session.is_empty == true {
+                        if !session.is_empty {
                             let name = Span::styled(format!("    {}", session.name), style);
                             let lines = vec![Spans::from(name)];
                             let names = ListItem::new(lines);

bin/drk/src/main.rs

@@ -1,7 +1,7 @@
 use std::{process::exit, str::FromStr, time::Instant};
 
 use clap::{Parser, Subcommand};
-use log::error;
+
 use serde_json::json;
 use simplelog::{ColorChoice, TermLogger, TerminalMode};
 use url::Url;
@@ -99,13 +99,8 @@ impl Drk {
 
     async fn ping(&self) -> Result<()> {
         let start = Instant::now();
-
         let req = jsonrpc::request(json!("ping"), json!([]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Got an error: {}", e);
-            return Err(e)
-        })?;
-
+        let rep = self.rpc_client.request(req).await?;
         let latency = Instant::now() - start;
         println!("Got reply: {}", rep);
         println!("Latency: {:?}", latency);
@@ -117,21 +112,14 @@ impl Drk {
             address.unwrap()
         } else {
             let req = jsonrpc::request(json!("wallet.get_key"), json!([0_i64]));
-            let rep = self.rpc_client.request(req).await.or_else(|e| {
-                error!("Error while fetching default key from wallet: {}", e);
-                return Err(e)
-            })?;
-
+            let rep = self.rpc_client.request(req).await?;
             Address::from_str(rep.as_array().unwrap()[0].as_str().unwrap())?
         };
 
         println!("Requesting airdrop for {}", addr);
         let req = jsonrpc::request(json!("airdrop"), json!([json!(addr.to_string()), amount]));
         let rpc_client = RpcClient::new(endpoint).await?;
-        let rep = rpc_client.request(req).await.or_else(|e| {
-            error!("Failed requesting airdrop: {}", e);
-            return Err(e)
-        })?;
+        let rep = rpc_client.request(req).await?;
         rpc_client.close().await?;
 
         println!("Success! Transaction ID: {}", rep);
@@ -140,22 +128,14 @@ impl Drk {
 
     async fn wallet_keygen(&self) -> Result<()> {
         let req = jsonrpc::request(json!("wallet.keygen"), json!([]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Error while generating new key in wallet: {}", e);
-            return Err(e)
-        })?;
-
+        let rep = self.rpc_client.request(req).await?;
         println!("New address: {}", rep);
         Ok(())
     }
 
     async fn wallet_balance(&self) -> Result<()> {
         let req = jsonrpc::request(json!("wallet.get_balances"), json!([]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Error fetching balances from wallet: {}", e);
-            return Err(e)
-        })?;
-
+        let rep = self.rpc_client.request(req).await?;
         // TODO: Better representation
         println!("Balances:\n{:#?}", rep);
         Ok(())
@@ -163,22 +143,14 @@ impl Drk {
 
     async fn wallet_address(&self) -> Result<()> {
         let req = jsonrpc::request(json!("wallet.get_key"), json!([0_i64]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Error fetching default keypair from wallet: {}", e);
-            return Err(e)
-        })?;
-
+        let rep = self.rpc_client.request(req).await?;
         println!("Default wallet address: {}", rep);
         Ok(())
     }
 
     async fn wallet_all_addresses(&self) -> Result<()> {
         let req = jsonrpc::request(json!("wallet.get_key"), json!([-1]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Error fetching keypairs from wallet: {}", e);
-            return Err(e)
-        })?;
-
+        let rep = self.rpc_client.request(req).await?;
         println!("Wallet addresses:\n{:#?}", rep);
         Ok(())
     }
@@ -197,10 +169,7 @@ impl Drk {
             json!([network.to_string(), token_id, recipient.to_string(), amount]),
         );
 
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Error building and sending transaction: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         println!("Success! Transaction ID: {}", rep);
         Ok(())

bin/ircd/src/server.rs

@@ -1,4 +1,4 @@
-use std::str::FromStr;
+
 
 use async_std::net::TcpStream;
 use futures::{io::WriteHalf, AsyncWriteExt};
@@ -175,22 +175,6 @@ impl IrcServerConnection {
                 // Close the connection
                 return Err(Error::ServiceStopped)
             }
-            // Below, we implement custom server commands that do not conform
-            // to the IRC specification. These are specific to our implementation.
-            "MSGHIST" => {
-                // Fetch the message history for a certain channel with optional
-                // max limit.
-                // MSGHIST #channel num_msgs
-                let channel = tokens.next().ok_or(Error::MalformedPacket)?;
-                let num_msgs = if let Some(n) = tokens.next() { i64::from_str(n)? } else { -1 };
-                info!("Fetching last {} messages for {}", num_msgs, channel);
-
-                if num_msgs < 0 {
-                    // Fetch all messages for the channel
-                } else {
-                    // Fetch newest num_msgs for the channel
-                }
-            }
             _ => {
                 warn!("Unimplemented `{}` command", command);
             }

bin/tau/tau-cli/src/primitives.rs

@@ -91,7 +91,7 @@ pub fn task_from_cli(values: Vec<String>) -> Result<BaseTask> {
         }
 
         if field[0] == "due" {
-            due = due_as_timestamp(&field[1])
+            due = due_as_timestamp(field[1])
         }
 
         if field[0] == "rank" {

bin/tau/tau-cli/src/rpc.rs

@@ -1,4 +1,4 @@
-use log::error;
+
 use serde_json::json;
 
 use darkfi::{rpc::jsonrpc, Result};
@@ -16,10 +16,7 @@ impl Tau {
     /// Add a new task.
     pub async fn add(&self, task: BaseTask) -> Result<()> {
         let req = jsonrpc::request(json!("add"), json!([task]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Failed sending `add` request to taud: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         println!("Got reply: {:?}", rep);
         Ok(())
@@ -28,10 +25,7 @@ impl Tau {
     /// Get all task ids.
     pub async fn get_ids(&self) -> Result<Vec<u64>> {
         let req = jsonrpc::request(json!("get_ids"), json!([]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Failed sending `get_ids` request to taud: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         let mut ret = vec![];
         for i in rep.as_array().unwrap() {
@@ -44,10 +38,7 @@ impl Tau {
     /// Update existing task given it's ID and some params.
     pub async fn update(&self, id: u64, task: BaseTask) -> Result<()> {
         let req = jsonrpc::request(json!("update"), json!([id, task]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Failed sending `update` request to taud: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         println!("Got reply: {:?}", rep);
         Ok(())
@@ -56,10 +47,7 @@ impl Tau {
     /// Set the state for a task.
     pub async fn set_state(&self, id: u64, state: &str) -> Result<()> {
         let req = jsonrpc::request(json!("set_state"), json!([id, state]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Failed sending `set_state` request to taud: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         println!("Got reply: {:?}", rep);
         Ok(())
@@ -68,10 +56,7 @@ impl Tau {
     /// Set a comment for a task.
     pub async fn set_comment(&self, id: u64, content: &str) -> Result<()> {
         let req = jsonrpc::request(json!("set_comment"), json!([id, content]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Failed sending `set_comment` request to taud: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         println!("Got reply: {:?}", rep);
         Ok(())
@@ -80,10 +65,7 @@ impl Tau {
     /// Get task data by its ID.
     pub async fn get_task_by_id(&self, id: u64) -> Result<TaskInfo> {
         let req = jsonrpc::request(json!("get_task_by_id"), json!([id]));
-        let rep = self.rpc_client.request(req).await.or_else(|e| {
-            error!("Error sending `get_task_by_id` request: {}", e);
-            return Err(e)
-        })?;
+        let rep = self.rpc_client.request(req).await?;
 
         Ok(serde_json::from_value(rep)?)
     }

bin/tau/tau-cli/src/util.rs

@@ -52,7 +52,7 @@ pub fn desc_in_editor() -> Result<Option<String>> {
     let mut lines = vec![];
     for i in content.lines() {
         if !i.starts_with('#') {
-            lines.push(format!("{}", i))
+            lines.push(i.to_string())
         }
     }
     Ok(Some(lines.join("\n")))

bin/tau/taud/src/jsonrpc.rs

@@ -249,8 +249,8 @@ impl JsonRpcInterface {
                 let rank_opt = field.get("rank");
                 if let Some(rank) = rank_opt {
                     let rank: Option<f32> = serde_json::from_value(rank.clone())?;
-                    if rank.is_some() {
-                        task.set_rank(rank.unwrap());
+                    if let Some(r) = rank {
+                        task.set_rank(r);
                     }
                 }
             }

bin/tau/taud/src/month_tasks.rs

@@ -53,7 +53,7 @@ impl MonthTasks {
 
     pub fn set_date(&mut self, date: &Timestamp) {
         debug!(target: "tau", "MonthTasks::set_date()");
-        self.created_at = date.clone();
+        self.created_at = *date;
     }
 
     fn get_path(date: &Timestamp, dataset_path: &Path) -> PathBuf {

example/gt.rs

@@ -10,7 +10,7 @@ use halo2_proofs::{
     plonk,
     plonk::{Advice, Circuit, Column, ConstraintSystem, Instance as InstanceColumn},
 };
-use pasta_curves::{pallas, vesta, Fp, Fq};
+use pasta_curves::{pallas, Fp};
 
 const WORD_BITS: u32 = 24;
 
@@ -117,7 +117,7 @@ fn main() {
     let c = pallas::Base::from(0);
     let circuit = ZkCircuit { y: Some(y), v: Some(v), f: Some(f) };
 
-    let mut public_inputs: Vec<pallas::Base> = vec![c];
+    let public_inputs: Vec<pallas::Base> = vec![c];
 
     let prover = MockProver::run(k, &circuit, vec![public_inputs]).unwrap();
     assert_eq!(prover.verify(), Ok(()));

example/lead.rs

@@ -1,28 +1,19 @@
 use halo2_proofs::{arithmetic::Field, dev::MockProver};
-use incrementalmerkletree::{bridgetree::BridgeTree, Hashable, Tree};
+use incrementalmerkletree::{bridgetree::BridgeTree, Tree};
 use pasta_curves::{
     arithmetic::CurveAffine,
-    group::{ff::PrimeField, Curve, GroupEncoding},
-    pallas, Fp,
+    group::{ff::PrimeField, Curve},
+    pallas,
 };
 
 use rand::{thread_rng, Rng};
-use serde::{Deserialize, Serialize};
 
 use darkfi::{
     crypto::{
-        constants::{
-            NullifierK, OrchardFixedBases, OrchardFixedBasesFull, ValueCommitV,
-            MERKLE_DEPTH_ORCHARD,
-        },
-        keypair::{Keypair, PublicKey, SecretKey},
-        lead_proof::{create_lead_proof, verify_lead_proof},
+        constants::MERKLE_DEPTH_ORCHARD,
         leadcoin::LeadCoin,
         merkle_node::MerkleNode,
-        nullifier::Nullifier,
-        proof::{Proof, ProvingKey, VerifyingKey},
-        types::{DrkCoinBlind, DrkSerial, DrkTokenId, DrkValue, DrkValueBlind, DrkValueCommit, *},
-        util::{mod_r_p, pedersen_commitment_scalar, pedersen_commitment_u64},
+        util::{mod_r_p, pedersen_commitment_scalar},
     },
     zk::circuit::lead_contract::LeadContract,
 };
@@ -40,11 +31,11 @@ fn create_coins_sks(len: usize) -> (Vec<MerkleNode>, Vec<[MerkleNode; MERKLE_DEP
     let mut tree = BridgeTree::<MerkleNode, MERKLE_DEPTH>::new(len);
     let mut root_sks: Vec<MerkleNode> = vec![];
     let mut path_sks: Vec<[MerkleNode; MERKLE_DEPTH_ORCHARD]> = vec![];
-    for i in 0..len {
+    for _i in 0..len {
         //TODO (research) why the conversion between point and base is panicing?
         // is the endianess different?
         let base = pedersen_commitment_scalar(pallas::Scalar::one(), pallas::Scalar::from(sk));
-        let coord = base.to_affine().coordinates().unwrap();
+        let _coord = base.to_affine().coordinates().unwrap();
         //let sk =  coord.x() * coord.y();
         //let sk =  *coord.y();
         let sk: [u8; 32] = pallas::Base::random(rng.clone()).to_repr();
@@ -74,9 +65,9 @@ fn create_coins(
 ) -> Vec<LeadCoin> {
     let mut rng = thread_rng();
     let mut seeds: Vec<u64> = vec![];
-    for i in 0..len {
+    for _i in 0..len {
         let rho: u64 = rng.gen();
-        seeds.push(rho.clone());
+        seeds.push(rho);
     }
 
     let mut tree_cm = BridgeTree::<MerkleNode, MERKLE_DEPTH>::new(len);
@@ -102,7 +93,7 @@ fn create_coins(
         let c_pk_pt_x: pallas::Base = *c_pk_pt.x();
         let c_pk_pt_y: pallas::Base = *c_pk_pt.y();
 
-        let c_cm_v = c_v.clone() * c_seed.clone() * c_pk_pt_x * c_pk_pt_y;
+        let c_cm_v = c_v * c_seed * c_pk_pt_x * c_pk_pt_y;
         let c_cm1_blind = cm1_blind; //TODO (fix) should be read from DrkValueBlind
         let c_cm2_blind = cm2_blind; //TODO (fix) should be read from DrkValueBlind
         let c_cm: pallas::Point = pedersen_commitment_scalar(mod_r_p(c_cm_v), mod_r_p(c_cm1_blind));
@@ -127,17 +118,14 @@ fn create_coins(
             let lead_coin_msg_hash =
             poseidon::Hash::<_, P128Pow5T3, ConstantLength<5>, 3, 2>::init().hash(lead_coin_msg);
              */
-        let lead_coin_msg =
-            c_pk_pt_y.clone() * c_pk_pt_x.clone() * c_v * *c_seed2_pt.x() * *c_seed2_pt.y();
+        let lead_coin_msg = c_pk_pt_y * c_pk_pt_x * c_v * *c_seed2_pt.x() * *c_seed2_pt.y();
         let c_cm2 = pedersen_commitment_scalar(mod_r_p(lead_coin_msg), mod_r_p(c_cm2_blind));
         let c_root_sk = root_sks[i];
 
         let c_root_sk_bytes: [u8; 32] = c_root_sk.inner().to_repr();
         let mut c_root_sk_base_bytes: [u8; 32] = [0; 32];
-        for i in 0..23 {
-            c_root_sk_base_bytes[i] = c_root_sk_bytes[i];
-        }
-        let c_root_sk_base = pallas::Base::from_repr(c_root_sk_base_bytes);
+        c_root_sk_base_bytes[..23].copy_from_slice(&c_root_sk_bytes[..23]);
+        let _c_root_sk_base = pallas::Base::from_repr(c_root_sk_base_bytes);
 
         let c_path_sk = path_sks[i];
 
@@ -173,8 +161,8 @@ fn main() {
     //
     const LEN: usize = 10;
     let mut rng = thread_rng();
-    let mut root_sks: Vec<MerkleNode> = vec![];
-    let mut path_sks: Vec<[MerkleNode; MERKLE_DEPTH_ORCHARD]> = vec![];
+    let mut _root_sks: Vec<MerkleNode> = vec![];
+    let mut _path_sks: Vec<[MerkleNode; MERKLE_DEPTH_ORCHARD]> = vec![];
     let mut values: Vec<u64> = vec![];
     for i in 0..LEN {
         values.push(u64::try_from(i * 2).unwrap());
@@ -183,10 +171,9 @@ fn main() {
     let cm1_blind: pallas::Base = pallas::Base::from(cm1_val);
     let cm2_val: u64 = rng.gen();
     let cm2_blind: pallas::Base = pallas::Base::from(cm2_val);
-    (root_sks, path_sks) = create_coins_sks(LEN);
-    let mut coins: Vec<LeadCoin> =
-        create_coins(root_sks.clone(), path_sks.clone(), values, cm1_blind, cm2_blind, LEN);
-    //
+    (_root_sks, _path_sks) = create_coins_sks(LEN);
+    let coins: Vec<LeadCoin> =
+        create_coins(_root_sks, _path_sks, values, cm1_blind, cm2_blind, LEN);
     let coin_idx = 0;
     let coin = coins[coin_idx];
 
@@ -210,8 +197,8 @@ fn main() {
         cm_pos: Some(coin.idx),
         //sn_c1: Some(coin.sn.unwrap()),
         slot: Some(coin.sl.unwrap()),
-        mau_rho: Some(mod_r_p(mau_rho.clone())),
-        mau_y: Some(mod_r_p(mau_y.clone())),
+        mau_rho: Some(mod_r_p(mau_rho)),
+        mau_y: Some(mod_r_p(mau_y)),
         root_cm: Some(coin.root_cm.unwrap()),
     };
 

example/zk.rs

@@ -3,7 +3,7 @@
 use darkfi::{
     crypto::{
         proof::{ProvingKey, VerifyingKey},
-        util::{pedersen_commitment_scalar, pedersen_commitment_u64},
+        util::{pedersen_commitment_u64},
         Proof,
     },
     zk::{

src/blockchain/mod.rs

@@ -96,7 +96,7 @@ impl Blockchain {
         // TODO: Check if we have all transactions
 
         // Check provided info produces the same hash
-        return Ok(blockhash == block.blockhash())
+        Ok(blockhash == block.blockhash())
     }
 
     /// Retrieve [`BlockInfo`]s by given hashes. Fails if any of them are not found.

src/consensus/proto/protocol_sync.rs

@@ -96,7 +96,7 @@ impl ProtocolSync {
         }
 
         debug!("handle_receive_block() [START]");
-        let exclude_list = vec![self.channel.address().clone()];
+        let exclude_list = vec![self.channel.address()];
         loop {
             let info = match self.block_sub.receive().await {
                 Ok(v) => v,

src/crypto/lead_proof.rs

@@ -1,19 +1,15 @@
 use std::time::Instant;
 
-use halo2_gadgets::poseidon::primitives as poseidon;
 use log::debug;
-use pasta_curves::{arithmetic::CurveAffine, group::Curve, pallas};
+use pasta_curves::pallas;
 use rand::rngs::OsRng;
 
 use crate::{
     crypto::{
-        keypair::PublicKey,
         leadcoin::LeadCoin,
         proof::{Proof, ProvingKey, VerifyingKey},
-        types::{DrkCoinBlind, DrkSerial, DrkTokenId, DrkValue, DrkValueBlind, DrkValueCommit},
-        util::{mod_r_p, pedersen_commitment_scalar, pedersen_commitment_u64},
+        util::mod_r_p,
     },
-    util::serial::{SerialDecodable, SerialEncodable},
     zk::circuit::lead_contract::LeadContract,
     Result,
 };
@@ -43,8 +39,8 @@ pub fn create_lead_proof(pk: ProvingKey, coin: LeadCoin) -> Result<Proof> {
         cm_pos: Some(coin.idx),
         //sn_c1: Some(coin.sn.unwrap()),
         slot: Some(coin.sl.unwrap()),
-        mau_rho: Some(mod_r_p(mau_rho.clone())),
-        mau_y: Some(mod_r_p(mau_y.clone())),
+        mau_rho: Some(mod_r_p(mau_rho)),
+        mau_y: Some(mod_r_p(mau_y)),
         root_cm: Some(coin.root_cm.unwrap()),
     };
 

src/crypto/leadcoin.rs

@@ -1,34 +1,14 @@
-use incrementalmerkletree::{bridgetree::BridgeTree, Frontier, Tree};
+use pasta_curves::pallas;
 
-use halo2_gadgets::poseidon::primitives as poseidon;
-use halo2_proofs::dev::MockProver;
-
-use rand::{thread_rng, Rng};
-
-use pasta_curves::{pallas, Fp};
-
-use crate::{
-    crypto::{
-        constants::{
-            NullifierK, OrchardFixedBases, OrchardFixedBasesFull, ValueCommitV,
-            MERKLE_DEPTH_ORCHARD,
-        },
-        keypair::{Keypair, PublicKey, SecretKey},
-        merkle_node::MerkleNode,
-        nullifier::Nullifier,
-        proof::{Proof, ProvingKey, VerifyingKey},
-        types::{DrkCoinBlind, DrkSerial, DrkTokenId, DrkValue, DrkValueBlind, DrkValueCommit, *},
-        util::{mod_r_p, pedersen_commitment_scalar, pedersen_commitment_u64},
-    },
-    zk::circuit::lead_contract::LeadContract,
+use crate::crypto::{
+    constants::MERKLE_DEPTH_ORCHARD,
+    merkle_node::MerkleNode,
+    util::{mod_r_p, pedersen_commitment_scalar},
 };
 
 use incrementalmerkletree::Hashable;
 
-use pasta_curves::{
-    arithmetic::CurveAffine,
-    group::{ff::PrimeField, Curve, GroupEncoding},
-};
+use pasta_curves::{arithmetic::CurveAffine, group::Curve};
 
 //use halo2_proofs::arithmetic::CurveAffine;
 #[derive(Debug, Default, Clone, Copy)]
@@ -58,7 +38,7 @@ impl LeadCoin {
     pub fn public_inputs(&self) -> Vec<pallas::Base> {
         let po_nonce = self.nonce_cm.unwrap().to_affine().coordinates().unwrap();
 
-        let po_tau = pedersen_commitment_scalar(mod_r_p(self.tau.unwrap()), self.root_cm.unwrap())
+        let _po_tau = pedersen_commitment_scalar(mod_r_p(self.tau.unwrap()), self.root_cm.unwrap())
             .to_affine()
             .coordinates()
             .unwrap();
@@ -70,7 +50,7 @@ impl LeadCoin {
         let po_sn = self.sn.unwrap().to_affine().coordinates().unwrap();
 
         let po_cmp = pallas::Base::from(0);
-        let zero = pallas::Base::from(0);
+        let _zero = pallas::Base::from(0);
         // ===============
 
         let cm_pos = self.idx;
@@ -89,7 +69,7 @@ impl LeadCoin {
             }
             current
         };
-        let mut public_inputs: Vec<pallas::Base> = vec![
+        let public_inputs: Vec<pallas::Base> = vec![
             *po_nonce.x(),
             *po_nonce.y(),
             *po_pk.x(),

src/net/transport/unix.rs

@@ -30,7 +30,7 @@ impl TransportListener for UnixListener {
 
 impl TransportStream for UnixStream {}
 
-#[derive(Copy, Clone)]
+#[derive(Default, Copy, Clone)]
 pub struct UnixTransport {}
 
 impl UnixTransport {

src/zk/circuit/lead_contract.rs

@@ -51,7 +51,7 @@ pub struct LeadConfig {
     merkle_config_2: MerkleConfig<OrchardHashDomains, OrchardCommitDomains, OrchardFixedBases>,
     sinsemilla_config_1:
         SinsemillaConfig<OrchardHashDomains, OrchardCommitDomains, OrchardFixedBases>,
-    sinsemilla_config_2:
+    _sinsemilla_config_2:
         SinsemillaConfig<OrchardHashDomains, OrchardCommitDomains, OrchardFixedBases>,
     greaterthan_config: GreaterThanConfig,
     evenbits_config: EvenBitsConfig,
@@ -249,7 +249,7 @@ impl Circuit<pallas::Base> for LeadContract {
             merkle_config_1,
             merkle_config_2,
             sinsemilla_config_1,
-            sinsemilla_config_2,
+            _sinsemilla_config_2: sinsemilla_config_2,
             greaterthan_config,
             evenbits_config,
             arith_config,
@@ -264,7 +264,7 @@ impl Circuit<pallas::Base> for LeadContract {
         SinsemillaChip::load(config.sinsemilla_config_1.clone(), &mut layouter)?;
         let ecc_chip = config.ecc_chip();
         let ar_chip = config.arith_chip();
-        let ps_chip = config.poseidon_chip();
+        let _ps_chip = config.poseidon_chip();
         let eb_chip = config.evenbits_chip();
         let greater_than_chip = config.greaterthan_chip();
 
@@ -311,9 +311,9 @@ impl Circuit<pallas::Base> for LeadContract {
             self.coin_pk_y,
         )?;
 
-        let slot = self.load_private(layouter.namespace(|| ""), config.advices[0], self.slot)?;
+        let _slot = self.load_private(layouter.namespace(|| ""), config.advices[0], self.slot)?;
 
-        let root_sk =
+        let _root_sk =
             self.load_private(layouter.namespace(|| ""), config.advices[0], self.root_sk)?;
 
         // ===============
@@ -472,12 +472,11 @@ impl Circuit<pallas::Base> for LeadContract {
         };
          */
         let coin_val = {
-            let coin_val_pt =
-                ar_chip.mul(layouter.namespace(|| ""), coin_pk_y.clone(), coin_pk_x.clone())?;
+            let coin_val_pt = ar_chip.mul(layouter.namespace(|| ""), coin_pk_y, coin_pk_x)?;
 
             let coin_val0 =
                 ar_chip.mul(layouter.namespace(|| ""), coin_nonce.clone(), coin_value.clone())?;
-            ar_chip.mul(layouter.namespace(|| ""), coin_val_pt.clone(), coin_val0.clone())?
+            ar_chip.mul(layouter.namespace(|| ""), coin_val_pt, coin_val0)?
         };
 
         let (com, _) = {
@@ -486,7 +485,7 @@ impl Circuit<pallas::Base> for LeadContract {
             let coin_val = ScalarFixedShort::new(
                 ecc_chip.clone(),
                 layouter.namespace(|| "coin_val*1"),
-                (coin_val.clone(), one.clone()),
+                (coin_val, one.clone()),
             )?;
             coin_commit_v.mul(layouter.namespace(|| "coin commit v"), coin_val)?
         };
@@ -554,8 +553,7 @@ impl Circuit<pallas::Base> for LeadContract {
             coin2_nonce.inner().x(),
             coin2_nonce.inner().y(),
         )?;
-        let coin2_hash2 =
-            ar_chip.mul(layouter.namespace(|| ""), coin2_hash0.clone(), coin2_hash1.clone())?;
+        let coin2_hash2 = ar_chip.mul(layouter.namespace(|| ""), coin2_hash0, coin2_hash1)?;
         let coin2_hash = ar_chip.mul(layouter.namespace(|| ""), coin_value.clone(), coin2_hash2)?;
 
         let (com, _) = {
@@ -619,7 +617,7 @@ impl Circuit<pallas::Base> for LeadContract {
         };
 
         let computed_final_root = merkle_inputs
-            .calculate_root(layouter.namespace(|| "calculate root"), coin_commit_prod.clone())?;
+            .calculate_root(layouter.namespace(|| "calculate root"), coin_commit_prod)?;
 
         layouter.constrain_instance(
             computed_final_root.cell(),
@@ -627,14 +625,14 @@ impl Circuit<pallas::Base> for LeadContract {
             LEAD_COIN_COMMIT_PATH_OFFSET,
         )?;
 
-        let node = MerkleNode::from_bytes(&self.root_sk.unwrap().to_repr()).unwrap();
+        let _node = MerkleNode::from_bytes(&self.root_sk.unwrap().to_repr()).unwrap();
         //let serialized = serde_json::to_string(&node).unwrap();
         //println!("root_sk: {}", serialized);
 
         //TODO (research) this multiplication panics!
         let y_commit_exp = ar_chip.mul(
             layouter.namespace(|| ""),
-            coin_nonce.clone(),
+            coin_nonce,
             //root_sk.clone(), //(fix)
             one.clone(),
         )?;
@@ -661,14 +659,15 @@ impl Circuit<pallas::Base> for LeadContract {
             )?;
             y_commit_r.mul(layouter.namespace(|| "coin serial number commit R"), mau_y)?
         };
-        let mut y_commit = com.add(layouter.namespace(|| "nonce commit"), &blind)?;
+        let y_commit = com.add(layouter.namespace(|| "nonce commit"), &blind)?;
 
         // ============================
-        let y_commit_bytes: [u8; 32] = y_commit.inner().point().unwrap().to_bytes();
-        let mut y_commit_base_bytes: [u8; 32] = [0; 32];
-        for i in 0..23 {
-            y_commit_base_bytes[i] = y_commit_base_bytes[i];
-        }
+        let _y_commit_bytes: [u8; 32] = y_commit.inner().point().unwrap().to_bytes();
+        let y_commit_base_bytes: [u8; 32] = [0; 32];
+        // FIXME: why is it assigning to itself?
+        // for i in 0..23 {
+        // y_commit_base_bytes[i] = y_commit_base_bytes[i];
+        // }
         let y_commit_base_temp = pallas::Base::from_repr(y_commit_base_bytes).unwrap();
 
         let y_commit_base = self.load_private(
@@ -686,7 +685,7 @@ impl Circuit<pallas::Base> for LeadContract {
             let y_commit_base = ScalarFixedShort::new(
                 ecc_chip.clone(),
                 layouter.namespace(|| "y_commit_base*1"),
-                (y_commit_base.clone(), one.clone()),
+                (y_commit_base.clone(), one),
             )?;
             rho_commit_v.mul(layouter.namespace(|| "coin commit v"), y_commit_base)?
         };
@@ -694,14 +693,11 @@ impl Circuit<pallas::Base> for LeadContract {
         let (blind, _) = {
             let rho_commit_r = OrchardFixedBasesFull::ValueCommitR;
             let rho_commit_r = FixedPoint::from_inner(ecc_chip.clone(), rho_commit_r);
-            let mau_rho = ScalarFixed::new(
-                ecc_chip.clone(),
-                layouter.namespace(|| "mau_rho scalar"),
-                self.mau_rho,
-            )?;
+            let mau_rho =
+                ScalarFixed::new(ecc_chip, layouter.namespace(|| "mau_rho scalar"), self.mau_rho)?;
             rho_commit_r.mul(layouter.namespace(|| "coin serial number commit R"), mau_rho)?
         };
-        let rho_commit = com.add(layouter.namespace(|| "nonce commit"), &blind)?;
+        let _rho_commit = com.add(layouter.namespace(|| "nonce commit"), &blind)?;
 
         // that the coin value never get past it.
         let scalar = self.load_private(

tests/network_transports.rs

@@ -15,7 +15,7 @@ async fn tcp_transport() {
     let tcp = TcpTransport::new(None, 1024);
     let url = Url::parse("tcp://127.0.0.1:5432").unwrap();
 
-    let listener = tcp.clone().listen_on(url.clone()).unwrap().await.unwrap();
+    let listener = tcp.listen_on(url.clone()).unwrap().await.unwrap();
 
     let _ = task::spawn(async move {
         let mut incoming = listener.incoming();
@@ -41,7 +41,7 @@ async fn tcp_tls_transport() {
     let tcp = TcpTransport::new(None, 1024);
     let url = Url::parse("tcp+tls://127.0.0.1:5433").unwrap();
 
-    let listener = tcp.clone().listen_on(url.clone()).unwrap().await.unwrap();
+    let listener = tcp.listen_on(url.clone()).unwrap().await.unwrap();
     let (acceptor, listener) = tcp.upgrade_listener(listener).unwrap().await.unwrap();
 
     let _ = task::spawn(async move {