chore: clippy --fix

src/bin/cashierd.rs

@@ -81,13 +81,13 @@ impl Cashierd {
         debug!(target: "CASHIER DAEMON", "Initialize");
 
         let cashier_wallet = CashierDb::new(
-            expand_path(&config.cashier_wallet_path.clone())?.as_path(),
+            expand_path(&config.cashier_wallet_path)?.as_path(),
             config.cashier_wallet_password.clone(),
         )?;
 
         let mut networks = Vec::new();
 
-        for network in config.clone().networks {
+        for network in config.networks {
             networks.push(Network {
                 name: NetworkName::from_str(&network.name)?,
                 blockchain: network.blockchain,
@@ -242,11 +242,9 @@ impl Cashierd {
         }
 
         // Check if the features list contains this network
-        if self
+        if !self
             .networks
-            .iter()
-            .find(|net| net.name == network)
-            .is_none()
+            .iter().any(|net| net.name == network)
         {
             return JsonResult::Err(jsonerr(
                 InvalidParams,
@@ -256,9 +254,9 @@ impl Cashierd {
         }
 
         let result: Result<String> = async {
-            let token_id = generate_id(&mint_address, &network)?;
+            let token_id = generate_id(mint_address, &network)?;
 
-            let mint_address_opt = Self::check_token_id(&network, &mint_address)?;
+            let mint_address_opt = Self::check_token_id(&network, mint_address)?;
 
             if mint_address_opt.is_none() {
                 mint_address = "";
@@ -328,10 +326,10 @@ impl Cashierd {
                         mint_address.into(),
                     )?;
 
-                    return Ok(token_key.public_key);
+                    Ok(token_key.public_key)
                 }
                 bridge::BridgeResponsePayload::Address(token_pub) => {
-                    return Ok(token_pub);
+                    Ok(token_pub)
                 }
                 _ => Err(Error::BridgeError(
                     "Receive unknown value from Subscription".into(),
@@ -380,11 +378,9 @@ impl Cashierd {
         }
 
         // Check if the features list contains this network
-        if self
+        if !self
             .networks
-            .iter()
-            .find(|net| net.name == network)
-            .is_none()
+            .iter().any(|net| net.name == network)
         {
             return JsonResult::Err(jsonerr(
                 InvalidParams,
@@ -394,9 +390,9 @@ impl Cashierd {
         }
 
         let result: Result<String> = async {
-            let token_id = generate_id(&mint_address, &network)?;
+            let token_id = generate_id(mint_address, &network)?;
 
-            let mint_address_opt = Self::check_token_id(&network, &mint_address)?;
+            let mint_address_opt = Self::check_token_id(&network, mint_address)?;
 
             if mint_address_opt.is_none() {
                 // empty string
@@ -457,7 +453,7 @@ impl Cashierd {
                 if _token_id != SOL_NATIVE_TOKEN_ID {
                     return Ok(Some(_token_id.to_string()));
                 }
-                return Ok(None);
+                Ok(None)
             }
             #[cfg(feature = "btc")]
             NetworkName::Bitcoin => Ok(None),
@@ -507,7 +503,7 @@ impl Cashierd {
                         }
                     } else {
                         let keypair_str = drk::cli::cli_config::load_keypair_to_str(
-                            PathBuf::from(expand_path(&network.keypair.clone())?),
+                            expand_path(&network.keypair.clone())?,
                         )?;
                         let keypair_bytes: Vec<u8> = serde_json::from_str(&keypair_str)?;
                         main_keypair = Keypair::from_bytes(&keypair_bytes)
@@ -546,7 +542,7 @@ impl Cashierd {
                         }
                     } else {
                         let keypair_str = drk::cli::cli_config::load_keypair_to_str(
-                            PathBuf::from(expand_path(&network.keypair.clone())?),
+                            expand_path(&network.keypair.clone())?,
                         )?;
                         let keypair_bytes: Vec<u8> = serde_json::from_str(&keypair_str)?;
                         main_keypair = Keypair::from_bytes(&keypair_bytes)
@@ -703,7 +699,7 @@ async fn start(
     };
 
     let cfg = RpcServerConfig {
-        socket_addr: config.rpc_listen_address.clone(),
+        socket_addr: config.rpc_listen_address,
         use_tls: config.serve_tls,
         identity_path: expand_path(&config.clone().tls_identity_path)?,
         identity_pass: config.tls_identity_password.clone(),

src/bin/darkfid.rs

@@ -142,9 +142,9 @@ impl Darkfid {
     // <-- {"result": true}
     async fn create_wallet(&self, id: Value, _params: Value) -> JsonResult {
         match self.client.lock().await.init_db().await {
-            Ok(()) => return JsonResult::Resp(jsonresp(json!(true), id)),
+            Ok(()) => JsonResult::Resp(jsonresp(json!(true), id)),
             Err(e) => {
-                return JsonResult::Err(jsonerr(ServerError(-32001), Some(e.to_string()), id))
+                JsonResult::Err(jsonerr(ServerError(-32001), Some(e.to_string()), id))
             }
         }
     }
@@ -153,9 +153,9 @@ impl Darkfid {
     // <-- {"result": true}
     async fn key_gen(&self, id: Value, _params: Value) -> JsonResult {
         match self.client.lock().await.key_gen() {
-            Ok(()) => return JsonResult::Resp(jsonresp(json!(true), id)),
+            Ok(()) => JsonResult::Resp(jsonresp(json!(true), id)),
             Err(e) => {
-                return JsonResult::Err(jsonerr(ServerError(-32002), Some(e.to_string()), id))
+                JsonResult::Err(jsonerr(ServerError(-32002), Some(e.to_string()), id))
             }
         }
     }
@@ -165,7 +165,7 @@ impl Darkfid {
     async fn get_key(&self, id: Value, _params: Value) -> JsonResult {
         let pk = self.client.lock().await.main_keypair.public;
         let b58 = bs58::encode(serialize(&pk)).into_string();
-        return JsonResult::Resp(jsonresp(json!(b58), id));
+        JsonResult::Resp(jsonresp(json!(b58), id))
     }
 
     // --> {"method": "get_balances", "params": []}
@@ -235,7 +235,7 @@ impl Darkfid {
         }
 
         let result: Result<Value> = async {
-            let network = NetworkName::from_str(&network)?;
+            let network = NetworkName::from_str(network)?;
             match network {
                 #[cfg(feature = "sol")]
                 NetworkName::Solana => {
@@ -273,9 +273,9 @@ impl Darkfid {
         }
 
         match rep {
-            JsonResult::Resp(r) => return JsonResult::Resp(r),
-            JsonResult::Err(e) => return JsonResult::Err(e),
-            JsonResult::Notif(_) => return JsonResult::Err(jsonerr(InternalError, None, id)),
+            JsonResult::Resp(r) => JsonResult::Resp(r),
+            JsonResult::Err(e) => JsonResult::Err(e),
+            JsonResult::Notif(_) => JsonResult::Err(jsonerr(InternalError, None, id)),
         }
     }
 
@@ -311,7 +311,7 @@ impl Darkfid {
             }
         }
 
-        let token_id = match assign_id(&network, &token, &self.sol_tokenlist) {
+        let token_id = match assign_id(network, token, &self.sol_tokenlist) {
             Ok(t) => t,
             Err(e) => {
                 return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
@@ -337,9 +337,9 @@ impl Darkfid {
         }
 
         match rep {
-            JsonResult::Resp(r) => return JsonResult::Resp(r),
-            JsonResult::Err(e) => return JsonResult::Err(e),
-            JsonResult::Notif(_n) => return JsonResult::Err(jsonerr(InternalError, None, id)),
+            JsonResult::Resp(r) => JsonResult::Resp(r),
+            JsonResult::Err(e) => JsonResult::Err(e),
+            JsonResult::Notif(_n) => JsonResult::Err(jsonerr(InternalError, None, id)),
         }
     }
 
@@ -394,14 +394,14 @@ impl Darkfid {
             }
         }
 
-        let amount_in_apo = match decode_base10(&amount, 8, true) {
+        let amount_in_apo = match decode_base10(amount, 8, true) {
             Ok(a) => a,
             Err(e) => {
                 return JsonResult::Err(jsonerr(InvalidAmountParam, Some(e.to_string()), id));
             }
         };
 
-        let token_id = match assign_id(&network, &token, &self.sol_tokenlist) {
+        let token_id = match assign_id(network, token, &self.sol_tokenlist) {
             Ok(t) => t,
             Err(e) => {
                 return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
@@ -441,7 +441,7 @@ impl Darkfid {
                     .lock()
                     .await
                     .transfer(
-                        token_id.clone(),
+                        *token_id,
                         cashier_public,
                         amount_in_apo,
                         self.state.clone(),
@@ -469,9 +469,9 @@ impl Darkfid {
         };
 
         match rep {
-            JsonResult::Resp(r) => return JsonResult::Resp(r),
-            JsonResult::Err(e) => return JsonResult::Err(e),
-            JsonResult::Notif(_n) => return JsonResult::Err(jsonerr(InternalError, None, id)),
+            JsonResult::Resp(r) => JsonResult::Resp(r),
+            JsonResult::Err(e) => JsonResult::Err(e),
+            JsonResult::Notif(_n) => JsonResult::Err(jsonerr(InternalError, None, id)),
         }
     }
 
@@ -522,14 +522,14 @@ impl Darkfid {
             let drk_address: jubjub::SubgroupPoint = deserialize(&drk_address)?;
 
             let decimals: usize = 8;
-            let amount = decode_base10(&amount, decimals, true)?;
+            let amount = decode_base10(amount, decimals, true)?;
 
             self.update_balances().await?;
 
             self.client
                 .lock()
                 .await
-                .transfer(token_id.clone(), drk_address, amount, self.state.clone())
+                .transfer(*token_id, drk_address, amount, self.state.clone())
                 .await?;
 
             Ok(())
@@ -619,7 +619,7 @@ async fn start(executor: Arc<Executor<'_>>, config: &DarkfidConfig) -> Result<()
     let mut darkfid = Darkfid::new(client, state, cashiers).await?;
 
     let server_config = RpcServerConfig {
-        socket_addr: config.rpc_listen_address.clone(),
+        socket_addr: config.rpc_listen_address,
         use_tls: config.serve_tls,
         identity_path: expand_path(&config.tls_identity_path.clone())?,
         identity_pass: config.tls_identity_password.clone(),

src/bin/drk.rs

@@ -49,17 +49,17 @@ impl Drk {
         match reply {
             JsonResult::Resp(r) => {
                 debug!(target: "RPC", "<-- {}", serde_json::to_string(&r)?);
-                return Ok(r.result);
+                Ok(r.result)
             }
 
             JsonResult::Err(e) => {
                 debug!(target: "RPC", "<-- {}", serde_json::to_string(&e)?);
-                return Err(Error::JsonRpcError(e.error.message.to_string()));
+                Err(Error::JsonRpcError(e.error.message.to_string()))
             }
 
             JsonResult::Notif(n) => {
                 debug!(target: "RPC", "<-- {}", serde_json::to_string(&n)?);
-                return Err(Error::JsonRpcError("Unexpected reply".to_string()));
+                Err(Error::JsonRpcError("Unexpected reply".to_string()))
             }
         }
     }
@@ -155,7 +155,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
     if let Some(matches) = options.subcommand_matches("wallet") {
         if matches.is_present("create") {
             let reply = client.create_wallet().await?;
-            if reply.as_bool().unwrap() == true {
+            if reply.as_bool().unwrap() {
                 println!("Wallet created successfully.")
             } else {
                 println!("Server replied: {}", &reply.to_string());
@@ -165,7 +165,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
 
         if matches.is_present("keygen") {
             let reply = client.key_gen().await?;
-            if reply.as_bool().unwrap() == true {
+            if reply.as_bool().unwrap() {
                 println!("Key generation successful.")
             } else {
                 println!("Server replied: {}", &reply.to_string());
@@ -212,7 +212,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
             .check_network(&NetworkName::from_str(&network)?)
             .await?;
 
-        let reply = client.get_token_id(&network, &token).await?;
+        let reply = client.get_token_id(&network, token).await?;
 
         println!("Token ID: {}", &reply.to_string());
         return Ok(());
@@ -232,7 +232,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
             .check_network(&NetworkName::from_str(&network)?)
             .await?;
 
-        let reply = client.deposit(&network, &token_sym).await?;
+        let reply = client.deposit(&network, token_sym).await?;
 
         println!(
             "Deposit your coins to the following address: {}",
@@ -253,7 +253,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
             .await?;
 
         let reply = client
-            .withdraw(&network, &token_sym, &address, amount)
+            .withdraw(&network, token_sym, address, amount)
             .await?;
 
         println!("{}", &reply.to_string());
@@ -266,7 +266,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
         let address = matches.value_of("ADDRESS").unwrap();
         let amount = matches.value_of("AMOUNT").unwrap();
 
-        client.transfer(&token_sym, &address, amount).await?;
+        client.transfer(token_sym, address, amount).await?;
 
         println!(
             "{} {} Transfered successfully",

src/bin/mint.rs

@@ -21,7 +21,7 @@ fn unpack<F: PrimeField>(value: F) -> Vec<Scalar> {
         }
         print!("{}", if bit { 1 } else { 0 });
     }
-    println!("");
+    println!();
     bits
 }
 

src/bin/tx.rs

@@ -105,7 +105,7 @@ impl MemoryState {
             match ciphertext.decrypt(secret) {
                 Ok(note) => {
                     // ... and return the decrypted note for this coin.
-                    return Some((note, secret.clone()));
+                    return Some((note, *secret));
                 }
                 Err(_) => {}
             }
@@ -149,7 +149,7 @@ async fn main() {
         mint_pvk,
         spend_pvk,
         cashier_public,
-        secrets: vec![secret.clone()],
+        secrets: vec![secret],
     };
 
     // Step 1: Cashier deposits to wallet1's address
@@ -161,13 +161,13 @@ async fn main() {
     let builder = tx::TransactionBuilder {
         clear_inputs: vec![tx::TransactionBuilderClearInputInfo {
             value: 110,
-            token_id: token_id,
+            token_id,
             signature_secret: cashier_secret,
         }],
         inputs: vec![],
         outputs: vec![tx::TransactionBuilderOutputInfo {
             value: 110,
-            token_id: token_id,
+            token_id,
             public,
         }],
     };
@@ -198,7 +198,7 @@ async fn main() {
             tree.append(cmu).unwrap();
 
             let root = tree.root();
-            state.merkle_roots.push(root.into());
+            state.merkle_roots.push(root);
         }
     }
 
@@ -235,7 +235,7 @@ async fn main() {
             assert_eq!(tree.root(), witness.root());
 
             let root = tree.root();
-            state.merkle_roots.push(root.into());
+            state.merkle_roots.push(root);
         }
 
         assert_eq!(state.merkle_roots.len(), 16);
@@ -249,12 +249,12 @@ async fn main() {
         let merkle_path = witness.path().unwrap();
 
         // Just test the path is good because we just added a bunch of fake coins
-        let node = MerkleNode::from_coin(&coin);
+        let node = MerkleNode::from_coin(coin);
         let root = tree.root();
         drop(tree);
         drop(witness);
         assert_eq!(merkle_path.root(node), root);
-        let root = root.into();
+        let root = root;
         assert!(state.is_valid_merkle(&root));
 
         merkle_path
@@ -278,14 +278,14 @@ async fn main() {
         clear_inputs: vec![],
         inputs: vec![tx::TransactionBuilderInputInfo {
             merkle_path,
-            secret: secret.clone(),
+            secret,
             note: state.own_coins[0].1.clone(),
         }],
         // We can add more outputs to this list.
         // The only constraint is that sum(value in) == sum(value out)
         outputs: vec![tx::TransactionBuilderOutputInfo {
             value: 110,
-            token_id: token_id,
+            token_id,
             public: public2,
         }],
     };

src/client.rs

@@ -187,7 +187,7 @@ impl Client {
             }
 
             if inputs_value < value {
-                return Err(ClientFailed::NotEnoughValue(inputs_value).into());
+                return Err(ClientFailed::NotEnoughValue(inputs_value));
             }
 
             if inputs_value > value {
@@ -455,7 +455,7 @@ impl State {
             // Also update all the coin witnesses
             for (coin, witness) in wallet.get_witnesses()?.iter_mut() {
                 witness.append(node).expect("Append to witness");
-                wallet.update_witness(&coin, witness.clone())?;
+                wallet.update_witness(coin, witness.clone())?;
             }
 
             debug!(target: "CLIENT STATE", "iterate over secret_keys to decrypt note");

src/crypto/note.rs

@@ -101,7 +101,7 @@ impl Decodable for EncryptedNote {
 
 impl EncryptedNote {
     pub fn decrypt(&self, secret: &jubjub::Fr) -> Result<Note> {
-        let shared_secret = sapling_ka_agree(&secret, &self.ephem_public.into());
+        let shared_secret = sapling_ka_agree(secret, &self.ephem_public.into());
         let key = kdf_sapling(shared_secret, &self.ephem_public.into());
 
         let mut plaintext = [0; ENC_CIPHERTEXT_SIZE];

src/net/channel.rs

@@ -71,7 +71,7 @@ impl Channel {
     /// the channel has been closed.
     pub async fn stop(&self) {
         debug!(target: "net", "Channel::stop() [START, address={}]", self.address());
-        assert_eq!(self.stopped.load(Ordering::Relaxed), false);
+        assert!(!self.stopped.load(Ordering::Relaxed));
         // Changes memory ordering to relaxed. We don't need strict thread locking here.
         self.stopped.store(false, Ordering::Relaxed);
         self.stop_subscriber.notify(Error::ChannelStopped).await;

src/net/messages.rs

@@ -212,7 +212,7 @@ pub async fn send_packet<W: AsyncWrite + Unpin>(stream: &mut W, packet: Packet)
         .encode_async(stream)
         .await?;
     assert!(!packet.command.is_empty());
-    stream.write_all(&packet.command.as_bytes()).await?;
+    stream.write_all(packet.command.as_bytes()).await?;
     debug!(target: "net", "sent command: {}", packet.command);
 
     assert_eq!(std::mem::size_of::<usize>(), std::mem::size_of::<u64>());

src/rpc/jsonrpc.rs

@@ -177,10 +177,10 @@ pub async fn send_raw_request(url: &str, data: Value) -> Result<JsonResult, Erro
 
     if use_tls {
         let mut stream = async_native_tls::connect(&host, stream).await?;
-        stream.write_all(&data_str.as_bytes()).await?;
+        stream.write_all(data_str.as_bytes()).await?;
         bytes_read = stream.read(&mut buf[..]).await?;
     } else {
-        stream.write_all(&data_str.as_bytes()).await?;
+        stream.write_all(data_str.as_bytes()).await?;
         bytes_read = stream.read(&mut buf[..]).await?;
     }
 
@@ -194,7 +194,7 @@ pub async fn send_unix_request(path: &str, data: Value) -> Result<JsonResult, Er
     let data_str = serde_json::to_string(&data)?;
 
     let mut stream = Async::<UnixStream>::connect(path).await?;
-    stream.write_all(&data_str.as_bytes()).await?;
+    stream.write_all(data_str.as_bytes()).await?;
     bytes_read = stream.read(&mut buf[..]).await?;
 
     let reply: JsonResult = serde_json::from_slice(&buf[0..bytes_read])?;

src/serial.rs

@@ -322,7 +322,7 @@ impl Encodable for String {
     fn encode<S: io::Write>(&self, mut s: S) -> Result<usize> {
         let b = self.as_bytes();
         let vi_len = VarInt(b.len() as u64).encode(&mut s)?;
-        s.write_slice(&b)?;
+        s.write_slice(b)?;
         Ok(vi_len + b.len())
     }
 }
@@ -341,7 +341,7 @@ impl Encodable for Cow<'static, str> {
     fn encode<S: io::Write>(&self, mut s: S) -> Result<usize> {
         let b = self.as_bytes();
         let vi_len = VarInt(b.len() as u64).encode(&mut s)?;
-        s.write_slice(&b)?;
+        s.write_slice(b)?;
         Ok(vi_len + b.len())
     }
 }
@@ -520,7 +520,7 @@ impl Decodable for SocketAddr {
 
 pub fn encode_with_size<S: io::Write>(data: &[u8], mut s: S) -> Result<usize> {
     let vi_len = VarInt(data.len() as u64).encode(&mut s)?;
-    s.write_slice(&data)?;
+    s.write_slice(data)?;
     Ok(vi_len + data.len())
 }
 

src/service/btc.rs

@@ -181,7 +181,7 @@ impl BtcClient {
 
         let main_account = Account::new(&main_keypair, network);
 
-        let electrum_client = ElectrumClient::new(&url)
+        let electrum_client = ElectrumClient::new(url)
             .map_err(|err| crate::Error::from(super::BtcFailed::from(err)))?;
 
         Ok(Arc::new(Self {
@@ -316,7 +316,7 @@ impl BtcClient {
         //Estimate fee for getting in next block
 
         let fee_per_kb = client.estimate_fee(1)?;
-        let _fee = tx_size as f64 * fee_per_kb * 100000 as f64;
+        let _fee = tx_size as f64 * fee_per_kb * 100000_f64;
         //let value = amounts - fee as u64;
 
         let transaction = Transaction {
@@ -425,7 +425,7 @@ impl NetworkClient for BtcClient {
         let main_script_pubkey = &self.main_account.script_pubkey;
 
         let main_utxo = client
-            .script_list_unspent(&main_script_pubkey)
+            .script_list_unspent(main_script_pubkey)
             .map_err(|e| Error::from(BtcFailed::from(e)))?;
 
         let transaction = Transaction {
@@ -476,7 +476,7 @@ pub fn sign_transaction(
     for (i, unsigned_input) in tx.input.iter().enumerate() {
         let sighash = tx.signature_hash(i, &script_pubkey, SigHashType::All as u32);
 
-        let msg = BtcMessage::from_slice(&sighash.as_ref())?;
+        let msg = BtcMessage::from_slice(sighash.as_ref())?;
 
         let signature = curve.sign(&msg, &priv_key);
         let byte_signature = &signature.serialize_der();

src/service/sol.rs

@@ -361,7 +361,7 @@ impl SolClient {
         instructions.push(transfer_ix);
 
         // Close the account and reap the rent if there's no more tokens on it.
-        let (tok_balance, _) = get_account_token_balance(&rpc, &temp_tok_pk, mint)?;
+        let (tok_balance, _) = get_account_token_balance(rpc, &temp_tok_pk, mint)?;
         if tok_balance - amount == 0 {
             debug!(target: "SOL BRIDGE", "Adding account close instruction because resulting balance is 0");
             let close_ix = spl_token::instruction::close_account(
@@ -375,7 +375,7 @@ impl SolClient {
         }
 
         let tx = Transaction::new_with_payer(&instructions, Some(&self.main_keypair.pubkey()));
-        let signature = sign_and_send_transaction(&rpc, tx, vec![&self.main_keypair, keypair])?;
+        let signature = sign_and_send_transaction(rpc, tx, vec![&self.main_keypair, keypair])?;
 
         debug!(target: "SOL BRIDGE", "Sent tokens to main wallet: {}", signature);
 
@@ -393,7 +393,7 @@ impl SolClient {
         let ix =
             system_instruction::transfer(&keypair.pubkey(), &self.main_keypair.pubkey(), amount);
         let tx = Transaction::new_with_payer(&[ix], Some(&self.main_keypair.pubkey()));
-        let signature = sign_and_send_transaction(&rpc, tx, vec![&self.main_keypair, keypair])?;
+        let signature = sign_and_send_transaction(rpc, tx, vec![&self.main_keypair, keypair])?;
 
         debug!(target: "SOL BRIDGE", "Sent {} SOL to main wallet: {}", lamports_to_sol(amount), signature);
         Ok(signature)

src/tx/builder.rs

@@ -101,7 +101,7 @@ impl TransactionBuilder {
                 .collect();
 
             let (proof, revealed) = create_spend_proof(
-                &spend_params,
+                spend_params,
                 input.note.value,
                 input.note.token_id,
                 input.note.valcom_blind,

src/util/parse.rs

@@ -196,15 +196,15 @@ mod tests {
     fn test_encode_base10() {
         assert_eq!(
             "23.4321111",
-            &encode_base10((234321111 as u64).to_biguint().unwrap(), 7)
+            &encode_base10(234321111_u64.to_biguint().unwrap(), 7)
         );
         assert_eq!(
             "23432111.1",
-            &encode_base10((234321111 as u64).to_biguint().unwrap(), 1)
+            &encode_base10(234321111_u64.to_biguint().unwrap(), 1)
         );
-        assert_eq!("234321.1", &encode_base10((2343211 as u64).to_biguint().unwrap(), 1));
-        assert_eq!("2343211", &encode_base10((2343211 as u64).to_biguint().unwrap(), 0));
-        assert_eq!("0.00002343", &encode_base10((2343 as u64).to_biguint().unwrap(), 8));
+        assert_eq!("234321.1", &encode_base10(2343211_u64.to_biguint().unwrap(), 1));
+        assert_eq!("2343211", &encode_base10(2343211_u64.to_biguint().unwrap(), 0));
+        assert_eq!("0.00002343", &encode_base10(2343_u64.to_biguint().unwrap(), 8));
     }
 
     #[test]

src/util/token_list.rs

@@ -142,7 +142,7 @@ mod tests {
     #[test]
     pub fn test_get_id_from_symbols() -> Result<()> {
         let tokens = _get_tokens()?;
-        let symbol = &tokens.clone().get_symbols()?[3];
+        let symbol = &tokens.get_symbols()?[3];
         let id = tokens.search_id(symbol)?;
         assert!(id.is_some());
         assert_eq!(id.unwrap(), "So11111111111111111111111111111111111111112");

src/wallet/cashierdb.rs

@@ -492,13 +492,13 @@ mod tests {
     use ff::Field;
     use rand::rngs::OsRng;
 
-    pub fn init_db(path: &PathBuf, password: String) -> Result<()> {
+    pub fn init_db(path: &Path, password: String) -> Result<()> {
         if !password.trim().is_empty() {
             let contents = include_str!("../../sql/cashier.sql");
-            let conn = Connection::open(&path)?;
+            let conn = Connection::open(path)?;
             debug!(target: "CASHIERDB", "OPENED CONNECTION AT PATH {:?}", path);
             conn.pragma_update(None, "key", &password)?;
-            conn.execute_batch(&contents)?;
+            conn.execute_batch(contents)?;
         } else {
             debug!(target: "CASHIERDB", "Password is empty. You must set a password to use the wallet.");
             return Err(Error::from(ClientFailed::EmptyPassword));
@@ -617,13 +617,13 @@ mod tests {
 
         let addr = wallet.get_withdraw_keys_by_token_public_key(&token_addr, &network)?;
 
-        assert_eq!(addr.is_some(), true);
+        assert!(addr.is_some());
 
         wallet.confirm_withdraw_key_record(&token_addr, &network)?;
 
         let addr = wallet.get_withdraw_keys_by_token_public_key(&token_addr, &network)?;
 
-        assert_eq!(addr.is_none(), true);
+        assert!(addr.is_none());
 
         std::fs::remove_file(walletdb_path)?;
 

src/wallet/walletdb.rs

@@ -407,13 +407,13 @@ mod tests {
     use crate::util::join_config_path;
     use ff::PrimeField;
 
-    pub fn init_db(path: &PathBuf, password: String) -> Result<()> {
+    pub fn init_db(path: &Path, password: String) -> Result<()> {
         if !password.trim().is_empty() {
             let contents = include_str!("../../sql/schema.sql");
-            let conn = Connection::open(&path)?;
+            let conn = Connection::open(path)?;
             debug!(target: "WALLETDB", "OPENED CONNECTION AT PATH {:?}", path);
             conn.pragma_update(None, "key", &password)?;
-            conn.execute_batch(&contents)?;
+            conn.execute_batch(contents)?;
         } else {
             debug!(
                 target: "WALLETDB", "Password is empty. You must set a password to use the wallet."
@@ -454,15 +454,15 @@ mod tests {
 
         let own_coin = OwnCoin {
             coin,
-            note: note.clone(),
+            note,
             secret,
-            witness: witness.clone(),
+            witness,
         };
 
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
-        wallet.put_own_coins(own_coin.clone())?;
+        wallet.put_own_coins(own_coin)?;
 
         let id = wallet.get_token_id()?;
 
@@ -509,15 +509,15 @@ mod tests {
 
         let own_coin = OwnCoin {
             coin,
-            note: note.clone(),
+            note,
             secret,
-            witness: witness.clone(),
+            witness,
         };
 
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
-        wallet.put_own_coins(own_coin.clone())?;
+        wallet.put_own_coins(own_coin)?;
 
         let balances = wallet.get_balances()?;
 
@@ -590,7 +590,7 @@ mod tests {
             witness: witness.clone(),
         };
 
-        wallet.put_own_coins(own_coin.clone())?;
+        wallet.put_own_coins(own_coin)?;
 
         let own_coin = wallet.get_own_coins()?[0].clone();
 
@@ -602,19 +602,19 @@ mod tests {
 
         wallet.confirm_spend_coin(&own_coin.coin)?;
 
-        let own_coins = wallet.get_own_coins()?.clone();
+        let own_coins = wallet.get_own_coins()?;
 
         assert_eq!(own_coins.len(), 0);
 
-        wallet.put_own_coins(own_coin.clone())?;
+        wallet.put_own_coins(own_coin)?;
 
-        let own_coins = wallet.get_own_coins()?.clone();
+        let own_coins = wallet.get_own_coins()?;
 
         assert_eq!(own_coins.len(), 1);
 
         wallet.remove_own_coins()?;
 
-        let own_coins = wallet.get_own_coins()?.clone();
+        let own_coins = wallet.get_own_coins()?;
 
         assert_eq!(own_coins.len(), 0);
 
@@ -665,7 +665,7 @@ mod tests {
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
-        wallet.put_own_coins(own_coin.clone())?;
+        wallet.put_own_coins(own_coin)?;
 
         let coin2 = Coin::new(bls12_381::Scalar::random(&mut OsRng).to_repr());