cargo fmt with new settings.

src/async_serial.rs

@@ -1,8 +1,6 @@
 use futures::prelude::*;
 
-use crate::endian;
-use crate::serial::VarInt;
-use crate::{Error, Result};
+use crate::{endian, serial::VarInt, Error, Result};
 
 impl VarInt {
     pub async fn encode_async<W: AsyncWrite + Unpin>(&self, stream: &mut W) -> Result<usize> {
@@ -65,10 +63,7 @@ macro_rules! async_encoder_fn {
     ($name:ident, $val_type:ty, $writefn:ident) => {
         #[inline]
         pub async fn $name<W: AsyncWrite + Unpin>(stream: &mut W, v: $val_type) -> Result<()> {
-            stream
-                .write_all(&endian::$writefn(v))
-                .await
-                .map_err(|e| Error::Io(e.kind()))
+            stream.write_all(&endian::$writefn(v)).await.map_err(|e| Error::Io(e.kind()))
         }
     };
 }
@@ -78,10 +73,7 @@ macro_rules! async_decoder_fn {
         pub async fn $name<R: AsyncRead + Unpin>(stream: &mut R) -> Result<$val_type> {
             assert_eq!(::std::mem::size_of::<$val_type>(), $byte_len); // size_of isn't a constfn in 1.22
             let mut val = [0; $byte_len];
-            stream
-                .read_exact(&mut val[..])
-                .await
-                .map_err(|e| Error::Io(e.kind()))?;
+            stream.read_exact(&mut val[..]).await.map_err(|e| Error::Io(e.kind()))?;
             Ok(endian::$readfn(&val))
         }
     };
@@ -109,9 +101,6 @@ impl AsyncWriteExt {
     async_encoder_fn!(write_u16, u16, u16_to_array_le);
 
     pub async fn write_u8<W: AsyncWrite + Unpin>(stream: &mut W, v: u8) -> Result<()> {
-        stream
-            .write_all(&[v])
-            .await
-            .map_err(|e| Error::Io(e.kind()))
+        stream.write_all(&[v]).await.map_err(|e| Error::Io(e.kind()))
     }
 }

src/bin/burn.rs

@@ -1,5 +1,4 @@
-use std::iter;
-use std::time::Instant;
+use std::{iter, time::Instant};
 
 use halo2::{
     circuit::{Layouter, SimpleFloorPlanner},
@@ -25,8 +24,10 @@ use halo2_gadgets::{
     },
     sinsemilla::{
         chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::chip::{MerkleChip, MerkleConfig},
-        merkle::MerklePath,
+        merkle::{
+            chip::{MerkleChip, MerkleConfig},
+            MerklePath,
+        },
     },
     utilities::{
         copy, lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
@@ -174,11 +175,7 @@ impl Circuit<pallas::Base> for BurnCircuit {
 
         // Fixed columns for the Sinsemilla generator lookup table
         let table_idx = meta.lookup_table_column();
-        let lookup = (
-            table_idx,
-            meta.lookup_table_column(),
-            meta.lookup_table_column(),
-        );
+        let lookup = (table_idx, meta.lookup_table_column(), meta.lookup_table_column());
 
         // Instance column used for public inputs
         let primary = meta.instance_column();
@@ -324,9 +321,7 @@ impl Circuit<pallas::Base> for BurnCircuit {
                             || value.ok_or(Error::SynthesisError),
                         )?;
                         region.constrain_equal(var, message[i].cell())?;
-                        Ok(Word::<_, _, P128Pow5T3, 3, 2>::from_inner(StateWord::new(
-                            var, value,
-                        )))
+                        Ok(Word::<_, _, P128Pow5T3, 3, 2>::from_inner(StateWord::new(var, value)))
                     };
                     Ok([message_word(0)?, message_word(1)?])
                 },
@@ -355,17 +350,11 @@ impl Circuit<pallas::Base> for BurnCircuit {
         //         scalar,
         //     )?
 
-        let value = self.load_private(
-            layouter.namespace(|| "load value"),
-            config.advices[0],
-            self.value,
-        )?;
+        let value =
+            self.load_private(layouter.namespace(|| "load value"), config.advices[0], self.value)?;
 
-        let asset = self.load_private(
-            layouter.namespace(|| "load asset"),
-            config.advices[0],
-            self.asset,
-        )?;
+        let asset =
+            self.load_private(layouter.namespace(|| "load asset"), config.advices[0], self.asset)?;
 
         let coin_blind = self.load_private(
             layouter.namespace(|| "load coin_blind"),
@@ -415,10 +404,8 @@ impl Circuit<pallas::Base> for BurnCircuit {
                     ConstantLength::<2>,
                 )?;
 
-                let poseidon_output = poseidon_hasher.hash(
-                    layouter.namespace(|| "Poseidon hash (a, b)"),
-                    poseidon_message,
-                )?;
+                let poseidon_output = poseidon_hasher
+                    .hash(layouter.namespace(|| "Poseidon hash (a, b)"), poseidon_message)?;
 
                 let poseidon_output: CellValue<pallas::Base> = poseidon_output.inner().into();
                 poseidon_output
@@ -489,11 +476,8 @@ impl Circuit<pallas::Base> for BurnCircuit {
             Some(pallas::Base::one()),
         )?;
 
-        let value = self.load_private(
-            layouter.namespace(|| "load value"),
-            config.advices[0],
-            self.value,
-        )?;
+        let value =
+            self.load_private(layouter.namespace(|| "load value"), config.advices[0], self.value)?;
 
         // v * G_1
         let (commitment, _) = {
@@ -527,11 +511,8 @@ impl Circuit<pallas::Base> for BurnCircuit {
         // Asset commitment
         // ================
 
-        let asset = self.load_private(
-            layouter.namespace(|| "load asset"),
-            config.advices[0],
-            self.asset,
-        )?;
+        let asset =
+            self.load_private(layouter.namespace(|| "load asset"), config.advices[0], self.asset)?;
 
         // a * G_1
         let (commitment, _) = {
@@ -594,11 +575,7 @@ fn root(path: [pallas::Base; 32], leaf_pos: u32, leaf: pallas::Base) -> pallas::
 
     let mut node = leaf;
     for (l, (sibling, pos)) in path.iter().zip(pos_bool.iter()).enumerate() {
-        let (left, right) = if *pos {
-            (*sibling, node)
-        } else {
-            (node, *sibling)
-        };
+        let (left, right) = if *pos { (*sibling, node) } else { (node, *sibling) };
 
         let l_star = i2lebsp::<10>(l as u64);
         let left: Vec<_> = left.to_le_bits().iter().by_val().take(255).collect();

src/bin/cashierd.rs

@@ -1,6 +1,5 @@
 use async_std::sync::{Arc, Mutex};
-use std::path::PathBuf;
-use std::str::FromStr;
+use std::{path::PathBuf, str::FromStr};
 
 use async_executor::Executor;
 use async_trait::async_trait;
@@ -19,8 +18,7 @@ use drk::{
         load_params, merkle::CommitmentTree, save_params, setup_mint_prover, setup_spend_prover,
     },
     rpc::{
-        jsonrpc::{error as jsonerr, response as jsonresp},
-        jsonrpc::{ErrorCode::*, JsonRequest, JsonResult},
+        jsonrpc::{error as jsonerr, response as jsonresp, ErrorCode::*, JsonRequest, JsonResult},
         rpcserver::{listen_and_serve, RequestHandler, RpcServerConfig},
     },
     serial::{deserialize, serialize},
@@ -33,9 +31,7 @@ use drk::{
 fn handle_bridge_error(error_code: u32) -> Result<()> {
     match error_code {
         1 => Err(Error::BridgeError("Not Supported Client".into())),
-        2 => Err(Error::BridgeError(
-            "Unable to watch the deposit address".into(),
-        )),
+        2 => Err(Error::BridgeError("Unable to watch the deposit address".into())),
         3 => Err(Error::BridgeError("Unable to send the token".into())),
         _ => Err(Error::BridgeError("Unknown error_code".into())),
     }
@@ -60,7 +56,7 @@ struct Cashierd {
 impl RequestHandler for Cashierd {
     async fn handle_request(&self, req: JsonRequest, executor: Arc<Executor<'_>>) -> JsonResult {
         if req.params.as_array().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, req.id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, req.id))
         }
 
         debug!(target: "RPC", "--> {}", serde_json::to_string(&req).unwrap());
@@ -73,7 +69,7 @@ impl RequestHandler for Cashierd {
             None => {}
         };
 
-        return JsonResult::Err(jsonerr(MethodNotFound, None, req.id));
+        return JsonResult::Err(jsonerr(MethodNotFound, None, req.id))
     }
 }
 
@@ -99,13 +95,7 @@ impl Cashierd {
 
         let bridge = bridge::Bridge::new();
 
-        Ok(Self {
-            bridge,
-            cashier_wallet,
-            networks,
-            public_key: String::from(""),
-            config,
-        })
+        Ok(Self { bridge, cashier_wallet, networks, public_key: String::from(""), config })
     }
     async fn listen_for_receiving_coins(
         bridge: Arc<Bridge>,
@@ -125,11 +115,7 @@ impl Cashierd {
         // received drk coin to token publickey
         if let Some(withdraw_token) = token {
             let bridge_subscribtion = bridge
-                .subscribe(
-                    drk_pub_key,
-                    Some(withdraw_token.mint_address),
-                    executor.clone(),
-                )
+                .subscribe(drk_pub_key, Some(withdraw_token.mint_address), executor.clone())
                 .await;
 
             // send a request to the bridge to send amount of token
@@ -152,7 +138,7 @@ impl Cashierd {
             let error_code = res.error as u32;
 
             if error_code != 0 {
-                return handle_bridge_error(error_code);
+                return handle_bridge_error(error_code)
             }
 
             match res.payload {
@@ -163,9 +149,7 @@ impl Cashierd {
                     )?;
                 }
                 _ => {
-                    return Err(Error::BridgeError(
-                        "Receive unknown value from Subscription".into(),
-                    ));
+                    return Err(Error::BridgeError("Receive unknown value from Subscription".into()))
                 }
             }
         }
@@ -179,7 +163,7 @@ impl Cashierd {
         let args: &Vec<serde_json::Value> = params.as_array().unwrap();
 
         if args.len() != 3 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let network: NetworkName;
@@ -189,20 +173,20 @@ impl Cashierd {
         match (args[0].as_str(), args[1].as_str(), args[2].as_str()) {
             (Some(n), Some(m), Some(d)) => {
                 if NetworkName::from_str(n).is_err() {
-                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
                 }
                 network = NetworkName::from_str(n).unwrap();
                 mint_address = m;
                 drk_pub_key = d;
             }
             (None, _, _) => {
-                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
             }
             (_, None, _) => {
-                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
             }
             (_, _, None) => {
-                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id))
             }
         }
 
@@ -212,7 +196,7 @@ impl Cashierd {
                 InvalidParams,
                 Some(format!("Cashier doesn't support this network: {}", network)),
                 id,
-            ));
+            ))
         }
 
         let result: Result<String> = async {
@@ -245,9 +229,8 @@ impl Cashierd {
             // record in cashierdb with the network name and token id
 
             let bridge = self.bridge.clone();
-            let bridge_subscribtion = bridge
-                .subscribe(drk_pub_key, mint_address_opt, executor)
-                .await;
+            let bridge_subscribtion =
+                bridge.subscribe(drk_pub_key, mint_address_opt, executor).await;
 
             if check.is_empty() {
                 bridge_subscribtion
@@ -273,7 +256,7 @@ impl Cashierd {
             let error_code = bridge_res.error as u32;
 
             if error_code != 0 {
-                return handle_bridge_error(error_code).map(|_| String::new());
+                return handle_bridge_error(error_code).map(|_| String::new())
             }
 
             match bridge_res.payload {
@@ -291,9 +274,7 @@ impl Cashierd {
                     Ok(token_key.public_key)
                 }
                 bridge::BridgeResponsePayload::Address(token_pub) => Ok(token_pub),
-                _ => Err(Error::BridgeError(
-                    "Receive unknown value from Subscription".into(),
-                )),
+                _ => Err(Error::BridgeError("Receive unknown value from Subscription".into())),
             }
         }
         .await;
@@ -310,7 +291,7 @@ impl Cashierd {
         let args: &Vec<serde_json::Value> = params.as_array().unwrap();
 
         if args.len() != 4 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let network: NetworkName;
@@ -320,20 +301,20 @@ impl Cashierd {
         match (args[0].as_str(), args[1].as_str(), args[2].as_str()) {
             (Some(n), Some(m), Some(a)) => {
                 if NetworkName::from_str(n).is_err() {
-                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
                 }
                 network = NetworkName::from_str(n).unwrap();
                 mint_address = m;
                 address = a;
             }
             (None, _, _) => {
-                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
             }
             (_, None, _) => {
-                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
             }
             (_, _, None) => {
-                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id))
             }
         }
 
@@ -343,7 +324,7 @@ impl Cashierd {
                 InvalidParams,
                 Some(format!("Cashier doesn't support this network: {}", network)),
                 id,
-            ));
+            ))
         }
 
         let result: Result<String> = async {
@@ -360,9 +341,8 @@ impl Cashierd {
 
             let cashier_public: jubjub::SubgroupPoint;
 
-            if let Some(addr) = self
-                .cashier_wallet
-                .get_withdraw_keys_by_token_public_key(&address, &network)?
+            if let Some(addr) =
+                self.cashier_wallet.get_withdraw_keys_by_token_public_key(&address, &network)?
             {
                 cashier_public = addr.public;
             } else {
@@ -429,15 +409,12 @@ impl Cashierd {
         );
 
         for network in self.networks.iter() {
-            resp.as_object_mut().unwrap()["networks"]
-                .as_array_mut()
-                .unwrap()
-                .push(json!(
-                        {
-                            network.name.to_string().to_lowercase():
-                            {"chain": network.blockchain.to_lowercase()}
-                        }
-                ));
+            resp.as_object_mut().unwrap()["networks"].as_array_mut().unwrap().push(json!(
+                    {
+                        network.name.to_string().to_lowercase():
+                        {"chain": network.blockchain.to_lowercase()}
+                    }
+            ));
         }
 
         JsonResult::Resp(jsonresp(resp, id))
@@ -449,7 +426,7 @@ impl Cashierd {
             NetworkName::Solana => {
                 use drk::service::sol::SOL_NATIVE_TOKEN_ID;
                 if _token_id != SOL_NATIVE_TOKEN_ID {
-                    return Ok(Some(_token_id.to_string()));
+                    return Ok(Some(_token_id.to_string()))
                 }
                 Ok(None)
             }
@@ -457,7 +434,7 @@ impl Cashierd {
             NetworkName::Ethereum => {
                 use drk::service::eth::ETH_NATIVE_TOKEN_ID;
                 if _token_id != ETH_NATIVE_TOKEN_ID {
-                    return Ok(Some(_token_id.to_string()));
+                    return Ok(Some(_token_id.to_string()))
                 }
                 Ok(None)
             }
@@ -520,7 +497,10 @@ impl Cashierd {
                 #[cfg(feature = "eth")]
                 NetworkName::Ethereum => {
                     debug!(target: "CASHIER DAEMON", "Add eth network");
-                    use drk::service::{eth::generate_privkey, eth::Keypair, EthClient};
+                    use drk::service::{
+                        eth::{generate_privkey, Keypair},
+                        EthClient,
+                    };
 
                     let bridge2 = self.bridge.clone();
 
@@ -532,10 +512,7 @@ impl Cashierd {
                     let passphrase = self.config.geth_passphrase.clone();
 
                     let mut eth_client = EthClient::new(
-                        expand_path(&self.config.geth_socket)?
-                            .to_str()
-                            .unwrap()
-                            .into(),
+                        expand_path(&self.config.geth_socket)?.to_str().unwrap().into(),
                         passphrase.clone(),
                     );
 
@@ -556,10 +533,8 @@ impl Cashierd {
                             &NetworkName::Ethereum,
                         )?;
 
-                        main_keypair = Keypair {
-                            private_key: main_private_key,
-                            public_key: main_public_key,
-                        };
+                        main_keypair =
+                            Keypair { private_key: main_private_key, public_key: main_public_key };
                     } else {
                         let last_keypair = &main_keypairs[main_keypairs.len() - 1];
 
@@ -571,9 +546,7 @@ impl Cashierd {
 
                     eth_client.set_main_keypair(&main_keypair);
 
-                    bridge2
-                        .add_clients(NetworkName::Ethereum, Arc::new(eth_client))
-                        .await?;
+                    bridge2.add_clients(NetworkName::Ethereum, Arc::new(eth_client)).await?;
                 }
 
                 #[cfg(feature = "btc")]
@@ -612,9 +585,7 @@ impl Cashierd {
 
                     let btc_client = BtcClient::new(main_keypair, &network.blockchain).await?;
 
-                    bridge2
-                        .add_clients(NetworkName::Bitcoin, btc_client)
-                        .await?;
+                    bridge2.add_clients(NetworkName::Bitcoin, btc_client).await?;
                 }
                 _ => {}
             }
@@ -676,10 +647,7 @@ impl Cashierd {
                 Ok(())
             });
 
-        Ok((
-            listen_for_receiving_coins_task,
-            listen_for_notification_from_bridge_task,
-        ))
+        Ok((listen_for_receiving_coins_task, listen_for_notification_from_bridge_task))
     }
 }
 
@@ -720,10 +688,7 @@ async fn start(
 
     let client = Client::new(
         rocks.clone(),
-        (
-            config.gateway_protocol_url.parse()?,
-            config.gateway_publisher_url.parse()?,
-        ),
+        (config.gateway_protocol_url.parse()?, config.gateway_publisher_url.parse()?),
         client_wallet.clone(),
         mint_params,
         spend_params,
@@ -750,7 +715,7 @@ async fn start(
 
     if get_address_flag {
         println!("Public Key: {}", cashier_public_str);
-        return Ok(());
+        return Ok(())
     };
 
     let cfg = RpcServerConfig {
@@ -785,11 +750,7 @@ async fn main() -> Result<()> {
         join_config_path(&PathBuf::from("cashierd.toml"))?
     };
 
-    let loglevel = if args.is_present("verbose") {
-        log::Level::Debug
-    } else {
-        log::Level::Info
-    };
+    let loglevel = if args.is_present("verbose") { log::Level::Debug } else { log::Level::Info };
 
     simple_logger::init_with_level(loglevel)?;
 
@@ -819,7 +780,7 @@ async fn main() -> Result<()> {
 
         println!("Wallet got updated successfully.");
 
-        return Ok(());
+        return Ok(())
     }
 
     let ex = Arc::new(Executor::new());
@@ -833,9 +794,7 @@ async fn main() -> Result<()> {
     debug!(target: "CASHIER DAEMON", "Run {} executor threads", nthreads);
 
     let (_, result) = Parallel::new()
-        .each(0..nthreads, |_| {
-            smol::future::block_on(ex.run(shutdown.recv()))
-        })
+        .each(0..nthreads, |_| smol::future::block_on(ex.run(shutdown.recv())))
         // Run the main future on the current thread.
         .finish(|| {
             smol::future::block_on(async move {

src/bin/darkfid.rs

@@ -1,7 +1,5 @@
 use async_std::sync::{Arc, Mutex};
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::str::FromStr;
+use std::{collections::HashMap, path::PathBuf, str::FromStr};
 
 use async_executor::Executor;
 use async_trait::async_trait;
@@ -20,8 +18,10 @@ use drk::{
         load_params, merkle::CommitmentTree, save_params, setup_mint_prover, setup_spend_prover,
     },
     rpc::{
-        jsonrpc::{error as jsonerr, request as jsonreq, response as jsonresp, send_raw_request},
-        jsonrpc::{ErrorCode::*, JsonRequest, JsonResult},
+        jsonrpc::{
+            error as jsonerr, request as jsonreq, response as jsonresp, send_raw_request,
+            ErrorCode::*, JsonRequest, JsonResult,
+        },
         rpcserver::{listen_and_serve, RequestHandler, RpcServerConfig},
     },
     serial::{deserialize, serialize},
@@ -45,17 +45,17 @@ pub struct Cashier {
 impl RequestHandler for Darkfid {
     async fn handle_request(&self, req: JsonRequest, _executor: Arc<Executor<'_>>) -> JsonResult {
         if req.params.as_array().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, req.id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, req.id))
         }
 
         debug!(target: "RPC", "--> {}", serde_json::to_string(&req).unwrap());
 
         if self.update_balances().await.is_err() {
             return JsonResult::Err(jsonerr(
-                    InternalError,
-                    Some("Unable to update balances".into()),
-                    req.id,
-            ));
+                InternalError,
+                Some("Unable to update balances".into()),
+                req.id,
+            ))
         }
 
         match req.method.as_str() {
@@ -108,11 +108,7 @@ impl Darkfid {
 
     async fn start(&mut self, executor: Arc<Executor<'_>>) -> Result<()> {
         self.client.lock().await.start().await?;
-        self.client
-            .lock()
-            .await
-            .connect_to_subscriber(self.state.clone(), executor)
-            .await?;
+        self.client.lock().await.connect_to_subscriber(self.state.clone(), executor).await?;
 
         Ok(())
     }
@@ -121,17 +117,10 @@ impl Darkfid {
         let own_coins = self.client.lock().await.get_own_coins()?;
 
         for own_coin in own_coins.iter() {
-            let nullifier_exists = self
-                .state
-                .lock()
-                .await
-                .nullifier_exists(&own_coin.nullifier);
+            let nullifier_exists = self.state.lock().await.nullifier_exists(&own_coin.nullifier);
 
             if nullifier_exists {
-                self.client
-                    .lock()
-                    .await
-                    .confirm_spend_coin(&own_coin.coin)?;
+                self.client.lock().await.confirm_spend_coin(&own_coin.coin)?;
             }
         }
 
@@ -186,10 +175,7 @@ impl Darkfid {
                 } else {
                     // TODO: SQL needs to have the mint address for show, not the internal hash.
                     // TODO: SQL needs to have the network name
-                    symbols.insert(
-                        balance.token_id.to_string(),
-                        (amount, String::from("UNKNOWN")),
-                    );
+                    symbols.insert(balance.token_id.to_string(), (amount, String::from("UNKNOWN")));
                 }
             }
             Ok(symbols)
@@ -207,13 +193,13 @@ impl Darkfid {
         let args = params.as_array();
 
         if args.is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let args = args.unwrap();
 
         if args.len() != 2 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let network: &str;
@@ -225,10 +211,10 @@ impl Darkfid {
                 symbol = sym;
             }
             (None, _) => {
-                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
             }
             (_, None) => {
-                return JsonResult::Err(jsonerr(InvalidSymbolParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidSymbolParam, None, id))
             }
         }
 
@@ -281,9 +267,7 @@ impl Darkfid {
         // NOTE: this just selects the first cashier in the list
         match send_raw_request(&self.cashiers[0].rpc_url, json!(req)).await {
             Ok(v) => rep = v,
-            Err(e) => {
-                return JsonResult::Err(jsonerr(ServerError(-32004), Some(e.to_string()), id))
-            }
+            Err(e) => return JsonResult::Err(jsonerr(ServerError(-32004), Some(e.to_string()), id)),
         }
 
         match rep {
@@ -301,12 +285,12 @@ impl Darkfid {
         let args = params.as_array();
 
         if args.is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let args = args.unwrap();
         if args.len() != 2 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let network: NetworkName;
@@ -315,23 +299,29 @@ impl Darkfid {
         match (args[0].as_str(), args[1].as_str()) {
             (Some(net), Some(tkn)) => {
                 if NetworkName::from_str(net).is_err() {
-                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
                 }
                 network = NetworkName::from_str(net).unwrap();
                 token = tkn;
             }
             (None, _) => {
-                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
             }
             (_, None) => {
-                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
             }
         }
 
-        let token_id = match assign_id(&network, token, &self.sol_tokenlist, &self.eth_tokenlist, &self.btc_tokenlist) {
+        let token_id = match assign_id(
+            &network,
+            token,
+            &self.sol_tokenlist,
+            &self.eth_tokenlist,
+            &self.btc_tokenlist,
+        ) {
             Ok(t) => t,
             Err(e) => {
-                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
+                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id))
             }
         };
 
@@ -349,7 +339,7 @@ impl Darkfid {
             Ok(v) => rep = v,
             Err(e) => {
                 debug!(target: "DARKFID", "REQUEST IS ERR");
-                return JsonResult::Err(jsonerr(ServerError(-32004), Some(e.to_string()), id));
+                return JsonResult::Err(jsonerr(ServerError(-32004), Some(e.to_string()), id))
             }
         }
 
@@ -371,13 +361,13 @@ impl Darkfid {
         let args = params.as_array();
 
         if args.is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let args = args.unwrap();
 
         if args.len() != 4 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let network: NetworkName;
@@ -385,15 +375,10 @@ impl Darkfid {
         let address: &str;
         let amount: &str;
 
-        match (
-            args[0].as_str(),
-            args[1].as_str(),
-            args[2].as_str(),
-            args[3].as_str(),
-        ) {
+        match (args[0].as_str(), args[1].as_str(), args[2].as_str(), args[3].as_str()) {
             (Some(net), Some(tkn), Some(addr), Some(val)) => {
                 if NetworkName::from_str(net).is_err() {
-                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
                 }
                 network = NetworkName::from_str(net).unwrap();
                 token = tkn;
@@ -401,42 +386,45 @@ impl Darkfid {
                 amount = val;
             }
             (None, _, _, _) => {
-                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
             }
             (_, None, _, _) => {
-                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
             }
             (_, _, None, _) => {
-                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id))
             }
             (_, _, _, None) => {
-                return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidAmountParam, None, id))
             }
         }
 
         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));
+                return JsonResult::Err(jsonerr(InvalidAmountParam, Some(e.to_string()), id))
             }
         };
 
-        let token_id = match assign_id(&network, token, &self.sol_tokenlist, &self.eth_tokenlist,&self.btc_tokenlist ) {
+        let token_id = match assign_id(
+            &network,
+            token,
+            &self.sol_tokenlist,
+            &self.eth_tokenlist,
+            &self.btc_tokenlist,
+        ) {
             Ok(t) => t,
             Err(e) => {
-                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
+                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id))
             }
         };
 
-        let req = jsonreq(
-            json!("withdraw"),
-            json!([network, token_id, address, amount_in_apo]),
-        );
+        let req = jsonreq(json!("withdraw"), json!([network, token_id, address, amount_in_apo]));
         let mut rep: JsonResult;
         match send_raw_request(&self.cashiers[0].rpc_url, json!(req)).await {
             Ok(v) => rep = v,
             Err(e) => {
-                return JsonResult::Err(jsonerr(ServerError(-32004), Some(e.to_string()), id));
+                return JsonResult::Err(jsonerr(ServerError(-32004), Some(e.to_string()), id))
             }
         }
 
@@ -445,7 +433,7 @@ impl Darkfid {
         if let Some(tk_id) = self.drk_tokenlist.tokens[&network].get(&token.to_uppercase()) {
             token_id = tk_id;
         } else {
-            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
         }
 
         // send drk to cashier_public
@@ -477,11 +465,11 @@ impl Darkfid {
                 }
                 Ok(_) => {
                     rep = JsonResult::Resp(jsonresp(
-                            json!(format!(
-                                    "Sent request to withdraw {} amount of {}",
-                                    amount, token_id
-                            )),
-                            id.clone(),
+                        json!(format!(
+                            "Sent request to withdraw {} amount of {}",
+                            amount, token_id
+                        )),
+                        id.clone(),
                     ))
                 }
             }
@@ -499,11 +487,11 @@ impl Darkfid {
     async fn transfer(&self, id: Value, params: Value) -> JsonResult {
         let args = params.as_array();
         if args.is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
         let args = args.unwrap();
         if args.len() != 4 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
         }
 
         let network: NetworkName;
@@ -511,15 +499,10 @@ impl Darkfid {
         let address: &str;
         let amount: &str;
 
-        match (
-            args[0].as_str(),
-            args[1].as_str(),
-            args[2].as_str(),
-            args[3].as_str(),
-        ) {
+        match (args[0].as_str(), args[1].as_str(), args[2].as_str(), args[3].as_str()) {
             (Some(net), Some(tkn), Some(addr), Some(val)) => {
                 if NetworkName::from_str(net).is_err() {
-                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                    return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
                 }
                 network = NetworkName::from_str(net).unwrap();
                 token = tkn;
@@ -527,16 +510,16 @@ impl Darkfid {
                 amount = val;
             }
             (None, _, _, _) => {
-                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id))
             }
             (_, None, _, _) => {
-                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
             }
             (_, _, None, _) => {
-                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidAddressParam, None, id))
             }
             (_, _, _, None) => {
-                return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
+                return JsonResult::Err(jsonerr(InvalidAmountParam, None, id))
             }
         }
 
@@ -546,7 +529,7 @@ impl Darkfid {
         if let Some(tk_id) = self.drk_tokenlist.tokens[&network].get(&token.to_uppercase()) {
             token_id = tk_id;
         } else {
-            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id))
         }
 
         let result: Result<()> = async {
@@ -559,12 +542,7 @@ impl Darkfid {
             self.client
                 .lock()
                 .await
-                .transfer(
-                    *token_id,
-                    drk_address,
-                    amount.try_into()?,
-                    self.state.clone(),
-                )
+                .transfer(*token_id, drk_address, amount.try_into()?, self.state.clone())
                 .await?;
 
             Ok(())
@@ -583,10 +561,8 @@ async fn start(
     local_cashier: Option<&str>,
     config: &DarkfidConfig,
 ) -> Result<()> {
-    let wallet = WalletDb::new(
-        expand_path(&config.wallet_path)?.as_path(),
-        config.wallet_password.clone(),
-    )?;
+    let wallet =
+        WalletDb::new(expand_path(&config.wallet_path)?.as_path(), config.wallet_password.clone())?;
 
     let rocks = Rocks::new(expand_path(&config.database_path.clone())?.as_path())?;
 
@@ -606,7 +582,7 @@ async fn start(
     } else {
         for cashier in config.clone().cashiers {
             if cashier.public_key.is_empty() {
-                return Err(Error::CashierKeysNotFound);
+                return Err(Error::CashierKeysNotFound)
             }
 
             let cashier_public: jubjub::SubgroupPoint =
@@ -643,15 +619,12 @@ async fn start(
 
     let client = Client::new(
         rocks.clone(),
-        (
-            Url::parse(&config.gateway_protocol_url)?,
-            Url::parse(&config.gateway_publisher_url)?,
-        ),
+        (Url::parse(&config.gateway_protocol_url)?, Url::parse(&config.gateway_publisher_url)?),
         wallet.clone(),
         mint_params,
         spend_params,
     )
-        .await?;
+    .await?;
 
     let client = Arc::new(Mutex::new(client));
 
@@ -688,7 +661,7 @@ async fn main() -> Result<()> {
         (@arg refresh: -r --refresh "Refresh the wallet and slabstore")
         (@arg cashier: --cashier +takes_value "Local cashier public key")
     )
-        .get_matches();
+    .get_matches();
 
     let config_path = if args.is_present("CONFIG") {
         expand_path(args.value_of("CONFIG").unwrap())?
@@ -696,11 +669,7 @@ async fn main() -> Result<()> {
         join_config_path(&PathBuf::from("darkfid.toml"))?
     };
 
-    let loglevel = if args.is_present("verbose") {
-        log::Level::Debug
-    } else {
-        log::Level::Info
-    };
+    let loglevel = if args.is_present("verbose") { log::Level::Debug } else { log::Level::Info };
 
     simple_logger::init_with_level(loglevel)?;
 
@@ -723,7 +692,7 @@ async fn main() -> Result<()> {
 
         println!("Wallet got updated successfully.");
 
-        return Ok(());
+        return Ok(())
     }
 
     let mut local_cashier: Option<&str> = None;
@@ -741,17 +710,15 @@ async fn main() -> Result<()> {
     debug!(target: "DARKFI DAEMON", "Run {} executor threads", nthreads);
 
     let (_, result) = Parallel::new()
-        .each(0..nthreads, |_| {
-            smol::future::block_on(ex.run(shutdown.recv()))
-        })
-    // Run the main future on the current thread.
-    .finish(|| {
-        smol::future::block_on(async move {
-            start(ex2, local_cashier, &config).await?;
-            drop(signal);
-            Ok::<(), drk::Error>(())
-        })
-    });
+        .each(0..nthreads, |_| smol::future::block_on(ex.run(shutdown.recv())))
+        // Run the main future on the current thread.
+        .finish(|| {
+            smol::future::block_on(async move {
+                start(ex2, local_cashier, &config).await?;
+                drop(signal);
+                Ok::<(), drk::Error>(())
+            })
+        });
 
     result
 }

src/bin/drk.rs

@@ -1,5 +1,4 @@
-use std::path::PathBuf;
-use std::str::FromStr;
+use std::{path::PathBuf, str::FromStr};
 
 #[macro_use]
 extern crate prettytable;
@@ -8,9 +7,12 @@ use log::debug;
 use prettytable::{format, Table};
 use serde_json::{json, Value};
 
-use drk::cli::{Config, DrkConfig};
-use drk::util::{join_config_path, path::expand_path, NetworkName};
-use drk::{rpc::jsonrpc, rpc::jsonrpc::JsonResult, Error, Result};
+use drk::{
+    cli::{Config, DrkConfig},
+    rpc::{jsonrpc, jsonrpc::JsonResult},
+    util::{join_config_path, path::expand_path, NetworkName},
+    Error, Result,
+};
 
 struct Drk {
     url: String,
@@ -26,25 +28,17 @@ impl Drk {
     async fn check_network(&self, network: &NetworkName) -> Result<()> {
         let features = self.features().await?;
 
-        if features.as_object().is_none()
-            && features.as_object().unwrap()["networks"]
-                .as_array()
-                .is_none()
-            && features.as_object().unwrap()["networks"]
-                .as_array()
-                .unwrap()
-                .is_empty()
+        if features.as_object().is_none() &&
+            features.as_object().unwrap()["networks"].as_array().is_none() &&
+            features.as_object().unwrap()["networks"].as_array().unwrap().is_empty()
         {
-            return Err(Error::NotSupportedNetwork);
+            return Err(Error::NotSupportedNetwork)
         }
 
-        for nets in features.as_object().unwrap()["networks"]
-            .as_array()
-            .unwrap()
-        {
+        for nets in features.as_object().unwrap()["networks"].as_array().unwrap() {
             for (net, _) in nets.as_object().unwrap() {
                 if network == &NetworkName::from_str(net.as_str())? {
-                    return Ok(());
+                    return Ok(())
                 }
             }
         }
@@ -134,8 +128,8 @@ impl Drk {
     }
 
     // --> {"jsonrpc": "2.0", "method": "withdraw",
-    //      "params": ["solana", "usdc", "Ht5G1RhkcKnpLVLMhqJc5aqZ4wYUEbxbtZwGCVbgU7DL", 13.37"], "id": 42}
-    // <-- {"jsonrpc": "2.0", "result": "txID", "id": 42}
+    //      "params": ["solana", "usdc", "Ht5G1RhkcKnpLVLMhqJc5aqZ4wYUEbxbtZwGCVbgU7DL", 13.37"],
+    // "id": 42} <-- {"jsonrpc": "2.0", "result": "txID", "id": 42}
     async fn withdraw(
         &self,
         network: &str,
@@ -168,7 +162,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
     if options.is_present("hello") {
         let reply = client.say_hello().await?;
         println!("Server replied: {}", &reply.to_string());
-        return Ok(());
+        return Ok(())
     }
 
     if let Some(matches) = options.subcommand_matches("wallet") {
@@ -179,7 +173,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
             } else {
                 println!("Server replied: {}", &reply.to_string());
             }
-            return Ok(());
+            return Ok(())
         }
 
         if matches.is_present("keygen") {
@@ -189,13 +183,13 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
             } else {
                 println!("Server replied: {}", &reply.to_string());
             }
-            return Ok(());
+            return Ok(())
         }
 
         if matches.is_present("address") {
             let reply = client.get_key().await?;
             println!("Wallet address: {}", &reply.to_string());
-            return Ok(());
+            return Ok(())
         }
 
         if matches.is_present("balances") {
@@ -207,11 +201,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
                 table.set_titles(row!["token", "amount", "network"]);
 
                 for (tkn, data) in reply.as_object().unwrap() {
-                    table.add_row(row![
-                        tkn,
-                        data[0].as_str().unwrap(),
-                        data[1].as_str().unwrap()
-                    ]);
+                    table.add_row(row![tkn, data[0].as_str().unwrap(), data[1].as_str().unwrap()]);
                 }
 
                 table.printstd();
@@ -219,7 +209,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
                 println!("Balances: {}", "0".to_string());
             }
 
-            return Ok(());
+            return Ok(())
         }
     }
 
@@ -227,38 +217,31 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
         let token = matches.value_of("TOKEN").unwrap();
         let network = matches.value_of("network").unwrap().to_lowercase();
 
-        client
-            .check_network(&NetworkName::from_str(&network)?)
-            .await?;
+        client.check_network(&NetworkName::from_str(&network)?).await?;
 
         let reply = client.get_token_id(&network, token).await?;
 
         println!("Token ID: {}", &reply.to_string());
-        return Ok(());
+        return Ok(())
     }
 
     if options.is_present("features") {
         let reply = client.features().await?;
         println!("Features: {}", &reply.to_string());
-        return Ok(());
+        return Ok(())
     }
 
     if let Some(matches) = options.subcommand_matches("deposit") {
         let network = matches.value_of("network").unwrap().to_lowercase();
         let token_sym = matches.value_of("TOKENSYM").unwrap();
 
-        client
-            .check_network(&NetworkName::from_str(&network)?)
-            .await?;
+        client.check_network(&NetworkName::from_str(&network)?).await?;
 
         let reply = client.deposit(&network, token_sym).await?;
 
-        println!(
-            "Deposit your coins to the following address: {}",
-            &reply.to_string()
-        );
+        println!("Deposit your coins to the following address: {}", &reply.to_string());
 
-        return Ok(());
+        return Ok(())
     }
 
     if let Some(matches) = options.subcommand_matches("withdraw") {
@@ -267,17 +250,13 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
         let address = matches.value_of("ADDRESS").unwrap();
         let amount = matches.value_of("AMOUNT").unwrap();
 
-        client
-            .check_network(&NetworkName::from_str(&network)?)
-            .await?;
+        client.check_network(&NetworkName::from_str(&network)?).await?;
 
-        let reply = client
-            .withdraw(&network, token_sym, address, amount)
-            .await?;
+        let reply = client.withdraw(&network, token_sym, address, amount).await?;
 
         println!("{}", &reply.to_string());
 
-        return Ok(());
+        return Ok(())
     }
 
     if let Some(matches) = options.subcommand_matches("transfer") {
@@ -286,13 +265,9 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
         let address = matches.value_of("ADDRESS").unwrap();
         let amount = matches.value_of("AMOUNT").unwrap();
 
-        client
-            .check_network(&NetworkName::from_str(&network)?)
-            .await?;
+        client.check_network(&NetworkName::from_str(&network)?).await?;
 
-        client
-            .transfer(&network, token_sym, address, amount)
-            .await?;
+        client.transfer(&network, token_sym, address, amount).await?;
 
         println!(
             "{} {} Transfered successfully",
@@ -300,7 +275,7 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
             token_sym.to_string().to_uppercase(),
         );
 
-        return Ok(());
+        return Ok(())
     }
 
     println!("Please run 'drk help' to see usage.");
@@ -364,11 +339,7 @@ async fn main() -> Result<()> {
         join_config_path(&PathBuf::from("drk.toml"))?
     };
 
-    let loglevel = if args.is_present("verbose") {
-        log::Level::Debug
-    } else {
-        log::Level::Info
-    };
+    let loglevel = if args.is_present("verbose") { log::Level::Debug } else { log::Level::Info };
 
     simple_logger::init_with_level(loglevel)?;
     let config = Config::<DrkConfig>::load(config_path)?;

src/bin/eth.rs

@@ -18,10 +18,7 @@ async fn main() -> Result<()> {
         String::from("foobar"),
     );
 
-    eth.set_main_keypair(&Keypair {
-        private_key: key,
-        public_key: acc.clone(),
-    });
+    eth.set_main_keypair(&Keypair { private_key: key, public_key: acc.clone() });
 
     //let key = generate_privkey();
     //let passphrase = "foobar".to_string();

src/bin/gatewayd.rs

@@ -1,5 +1,4 @@
-use std::path::PathBuf;
-use std::sync::Arc;
+use std::{path::PathBuf, sync::Arc};
 
 use async_executor::Executor;
 use clap::clap_app;
@@ -41,11 +40,7 @@ async fn main() -> Result<()> {
         join_config_path(&PathBuf::from("gatewayd.toml"))?
     };
 
-    let loglevel = if args.is_present("verbose") {
-        log::Level::Debug
-    } else {
-        log::Level::Info
-    };
+    let loglevel = if args.is_present("verbose") { log::Level::Debug } else { log::Level::Info };
 
     simple_logger::init_with_level(loglevel)?;
 
@@ -62,9 +57,7 @@ async fn main() -> Result<()> {
     debug!(target: "GATEWAY DAEMON", "Run {} executor threads", nthreads);
 
     let (_, result) = Parallel::new()
-        .each(0..nthreads, |_| {
-            smol::future::block_on(ex.run(shutdown.recv()))
-        })
+        .each(0..nthreads, |_| smol::future::block_on(ex.run(shutdown.recv())))
         // Run the main future on the current thread.
         .finish(|| {
             smol::future::block_on(async move {

src/bin/mint.rs

@@ -21,8 +21,10 @@ use halo2_gadgets::{
     primitives::poseidon::{ConstantLength, P128Pow5T3},
     sinsemilla::{
         chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::chip::{MerkleChip, MerkleConfig},
-        merkle::MerklePath,
+        merkle::{
+            chip::{MerkleChip, MerkleConfig},
+            MerklePath,
+        },
     },
     utilities::{
         copy, lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
@@ -140,11 +142,7 @@ impl Circuit<pallas::Base> for MintCircuit {
 
         // Fixed columns for the Sinsemilla generator lookup table
         let table_idx = meta.lookup_table_column();
-        let lookup = (
-            table_idx,
-            meta.lookup_table_column(),
-            meta.lookup_table_column(),
-        );
+        let lookup = (table_idx, meta.lookup_table_column(), meta.lookup_table_column());
 
         // Instance column used for public inputs
         let primary = meta.instance_column();
@@ -268,17 +266,11 @@ impl Circuit<pallas::Base> for MintCircuit {
             self.pub_y,
         )?;
 
-        let value = self.load_private(
-            layouter.namespace(|| "load value"),
-            config.advices[0],
-            self.value,
-        )?;
+        let value =
+            self.load_private(layouter.namespace(|| "load value"), config.advices[0], self.value)?;
 
-        let asset = self.load_private(
-            layouter.namespace(|| "load asset"),
-            config.advices[0],
-            self.asset,
-        )?;
+        let asset =
+            self.load_private(layouter.namespace(|| "load asset"), config.advices[0], self.asset)?;
 
         let serial = self.load_private(
             layouter.namespace(|| "load serial"),
@@ -326,10 +318,8 @@ impl Circuit<pallas::Base> for MintCircuit {
                     ConstantLength::<2>,
                 )?;
 
-                let poseidon_output = poseidon_hasher.hash(
-                    layouter.namespace(|| "Poseidon hash (a, b)"),
-                    poseidon_message,
-                )?;
+                let poseidon_output = poseidon_hasher
+                    .hash(layouter.namespace(|| "Poseidon hash (a, b)"), poseidon_message)?;
 
                 let poseidon_output: CellValue<pallas::Base> = poseidon_output.inner().into();
                 poseidon_output
@@ -477,13 +467,8 @@ fn main() {
     let asset_commit = pedersen_commitment_u64(asset, asset_blind);
     let asset_coords = asset_commit.to_affine().coordinates().unwrap();
 
-    let public_inputs = vec![
-        coin,
-        *value_coords.x(),
-        *value_coords.y(),
-        *asset_coords.x(),
-        *asset_coords.y(),
-    ];
+    let public_inputs =
+        vec![coin, *value_coords.x(), *value_coords.y(), *asset_coords.x(), *asset_coords.y()];
 
     let circuit = MintCircuit {
         pub_x: Some(*coords.x()),

src/bin/tx.rs

@@ -4,18 +4,20 @@ use ff::{Field, PrimeField};
 use rand::rngs::OsRng;
 use std::path::Path;
 
-use drk::crypto::{
-    coin::Coin,
-    load_params,
-    merkle::{CommitmentTree, IncrementalWitness},
-    merkle_node::MerkleNode,
-    note::{EncryptedNote, Note},
-    nullifier::Nullifier,
-    save_params, setup_mint_prover, setup_spend_prover,
+use drk::{
+    crypto::{
+        coin::Coin,
+        load_params,
+        merkle::{CommitmentTree, IncrementalWitness},
+        merkle_node::MerkleNode,
+        note::{EncryptedNote, Note},
+        nullifier::Nullifier,
+        save_params, setup_mint_prover, setup_spend_prover,
+    },
+    serial::{Decodable, Encodable},
+    state::{ProgramState, StateUpdate},
+    tx,
 };
-use drk::serial::{Decodable, Encodable};
-use drk::state::{ProgramState, StateUpdate};
-use drk::tx;
 
 struct MemoryState {
     // The entire merkle tree state
@@ -104,7 +106,7 @@ impl MemoryState {
             // ... attempt to decrypt the note ...
             if let Ok(note) = ciphertext.decrypt(secret) {
                 // ... and return the decrypted note for this coin.
-                return Some((note, *secret));
+                return Some((note, *secret))
             }
         }
         // We weren't able to decrypt the note with any of our keys.
@@ -162,11 +164,7 @@ async fn main() {
             signature_secret: cashier_secret,
         }],
         inputs: vec![],
-        outputs: vec![tx::TransactionBuilderOutputInfo {
-            value: 110,
-            token_id,
-            public,
-        }],
+        outputs: vec![tx::TransactionBuilderOutputInfo { value: 110, token_id, public }],
     };
 
     // We will 'compile' the tx, and then serialize it to this Vec<u8>
@@ -280,11 +278,7 @@ async fn main() {
         }],
         // 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,
-            public: public2,
-        }],
+        outputs: vec![tx::TransactionBuilderOutputInfo { value: 110, token_id, public: public2 }],
     };
     // Build the tx
     let mut tx_data = vec![];
@@ -317,7 +311,7 @@ pub fn state_transition<S: ProgramState>(
 
         if !state.is_valid_cashier_public_key(&input.signature_public) {
             log::error!(target: "STATE TRANSITION", "Not valid cashier public key");
-            return Err(VerifyFailed::InvalidCashierKey(i));
+            return Err(VerifyFailed::InvalidCashierKey(i))
         }
     }
 
@@ -330,7 +324,7 @@ pub fn state_transition<S: ProgramState>(
         // Merkle is used to know whether this is a coin that existed
         // in a previous state.
         if !state.is_valid_merkle(merkle) {
-            return Err(VerifyFailed::InvalidMerkle(i));
+            return Err(VerifyFailed::InvalidMerkle(i))
         }
 
         // The nullifiers should not already exist
@@ -338,7 +332,7 @@ pub fn state_transition<S: ProgramState>(
         let nullifier = &input.revealed.nullifier;
 
         if state.nullifier_exists(nullifier) {
-            return Err(VerifyFailed::DuplicateNullifier(i));
+            return Err(VerifyFailed::DuplicateNullifier(i))
         }
     }
 
@@ -360,9 +354,5 @@ pub fn state_transition<S: ProgramState>(
         enc_notes.push(output.enc_note);
     }
 
-    Ok(StateUpdate {
-        nullifiers,
-        coins,
-        enc_notes,
-    })
+    Ok(StateUpdate { nullifiers, coins, enc_notes })
 }

src/bin/tx2.rs

@@ -2,8 +2,7 @@ use rand::rngs::OsRng;
 use std::{fmt, time::Instant};
 
 use halo2_gadgets::ecc::FixedPoints;
-use incrementalmerkletree::Hashable;
-use incrementalmerkletree::{bridgetree::BridgeTree, Frontier, Tree};
+use incrementalmerkletree::{bridgetree::BridgeTree, Frontier, Hashable, Tree};
 use pasta_curves::{
     arithmetic::{CurveAffine, Field, FieldExt},
     pallas,
@@ -19,8 +18,7 @@ use drk::{
         nullifier::Nullifier,
         proof::{Proof, ProvingKey, VerifyingKey},
         schnorr,
-        util::mod_r_p,
-        util::{pedersen_commitment_scalar, pedersen_commitment_u64},
+        util::{mod_r_p, pedersen_commitment_scalar, pedersen_commitment_u64},
     },
     state::{state_transition, ProgramState, StateUpdate},
     tx,
@@ -95,7 +93,7 @@ impl MemoryState {
             // ... attempt to decrypt the note ...
             if let Ok(note) = ciphertext.decrypt(secret) {
                 // ... and return the decrypted note for this coin.
-                return Some((note, *secret));
+                return Some((note, *secret))
             }
         }
         // We weren't able to decrypt the note with any of our keys.
@@ -134,17 +132,12 @@ fn main() -> std::result::Result<(), failure::Error> {
             signature_secret: cashier_secret,
         }],
         inputs: vec![],
-        outputs: vec![tx::TransactionBuilderOutputInfo {
-            value: 110,
-            token_id,
-            public,
-        }],
+        outputs: vec![tx::TransactionBuilderOutputInfo { value: 110, token_id, public }],
     };
 
     let tx = builder.build()?;
 
-    tx.verify(&state.mint_vk, &state.spend_vk)
-        .expect("tx verify");
+    tx.verify(&state.mint_vk, &state.spend_vk).expect("tx verify");
 
     let note = tx.outputs[0].enc_note.decrypt(&secret)?;
 
@@ -164,11 +157,7 @@ fn main() -> std::result::Result<(), failure::Error> {
             secret,
             note: note.clone(),
         }],
-        outputs: vec![tx::TransactionBuilderOutputInfo {
-            value: 110,
-            token_id,
-            public,
-        }],
+        outputs: vec![tx::TransactionBuilderOutputInfo { value: 110, token_id, public }],
     };
 
     let tx = builder.build()?;

src/bin/vm2.rs

@@ -22,8 +22,10 @@ use halo2_gadgets::{
     },
     sinsemilla::{
         chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::chip::{MerkleChip, MerkleConfig},
-        merkle::MerklePath,
+        merkle::{
+            chip::{MerkleChip, MerkleConfig},
+            MerklePath,
+        },
     },
     utilities::{
         lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
@@ -101,23 +103,12 @@ fn main() -> std::result::Result<(), failure::Error> {
     let asset_commit = pedersen_commitment_u64(asset, asset_blind);
     let asset_coords = asset_commit.to_affine().coordinates().unwrap();
 
-    let mut public_inputs = vec![
-        coin,
-        *value_coords.x(),
-        *value_coords.y(),
-        *asset_coords.x(),
-        *asset_coords.y(),
-    ];
+    let mut public_inputs =
+        vec![coin, *value_coords.x(), *value_coords.y(), *asset_coords.x(), *asset_coords.y()];
 
     let mut const_fixed_points = HashMap::new();
-    const_fixed_points.insert(
-        "VALUE_COMMIT_VALUE".to_string(),
-        OrchardFixedBases::ValueCommitV,
-    );
-    const_fixed_points.insert(
-        "VALUE_COMMIT_RANDOM".to_string(),
-        OrchardFixedBases::ValueCommitR,
-    );
+    const_fixed_points.insert("VALUE_COMMIT_VALUE".to_string(), OrchardFixedBases::ValueCommitV);
+    const_fixed_points.insert("VALUE_COMMIT_RANDOM".to_string(), OrchardFixedBases::ValueCommitR);
 
     let mut circuit = vm2::ZkCircuit::new(const_fixed_points, &zkbin.constants, contract);
     let empty_circuit = circuit.clone();

src/bin/vm2_burn.rs

@@ -24,8 +24,10 @@ use halo2_gadgets::{
     },
     sinsemilla::{
         chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::chip::{MerkleChip, MerkleConfig},
-        merkle::MerklePath,
+        merkle::{
+            chip::{MerkleChip, MerkleConfig},
+            MerklePath,
+        },
     },
     utilities::{
         lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
@@ -61,11 +63,7 @@ fn root(path: [pallas::Base; 32], leaf_pos: u32, leaf: pallas::Base) -> pallas::
 
     let mut node = leaf;
     for (l, (sibling, pos)) in path.iter().zip(pos_bool.iter()).enumerate() {
-        let (left, right) = if *pos {
-            (*sibling, node)
-        } else {
-            (node, *sibling)
-        };
+        let (left, right) = if *pos { (*sibling, node) } else { (node, *sibling) };
 
         let l_star = i2lebsp::<10>(l as u64);
         let left: Vec<_> = left.to_le_bits().iter().by_val().take(255).collect();
@@ -165,14 +163,8 @@ fn main() -> std::result::Result<(), failure::Error> {
     //
 
     let mut const_fixed_points = HashMap::new();
-    const_fixed_points.insert(
-        "VALUE_COMMIT_VALUE".to_string(),
-        OrchardFixedBases::ValueCommitV,
-    );
-    const_fixed_points.insert(
-        "VALUE_COMMIT_RANDOM".to_string(),
-        OrchardFixedBases::ValueCommitR,
-    );
+    const_fixed_points.insert("VALUE_COMMIT_VALUE".to_string(), OrchardFixedBases::ValueCommitV);
+    const_fixed_points.insert("VALUE_COMMIT_RANDOM".to_string(), OrchardFixedBases::ValueCommitR);
     const_fixed_points.insert("SPEND_AUTH_G".to_string(), OrchardFixedBases::SpendAuthG);
 
     let mut circuit = vm2::ZkCircuit::new(const_fixed_points, &zkbin.constants, contract);

src/blockchain/rocks.rs

@@ -1,11 +1,12 @@
-use std::marker::PhantomData;
-use std::path::Path;
+use std::{marker::PhantomData, path::Path};
 
 use async_std::sync::Arc;
 use rocksdb::{ColumnFamily, ColumnFamilyDescriptor, Options, DB};
 
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::{Error, Result};
+use crate::{
+    serial::{deserialize, serialize, Decodable, Encodable},
+    Error, Result,
+};
 
 pub enum IteratorMode {
     Start,
@@ -71,9 +72,7 @@ impl Rocks {
     where
         C: Column,
     {
-        self.db
-            .cf_handle(C::NAME)
-            .ok_or_else(|| Error::RocksdbError("unknown column".to_string()))
+        self.db.cf_handle(C::NAME).ok_or_else(|| Error::RocksdbError("unknown column".to_string()))
     }
 
     pub fn put_cf(&self, cf: &ColumnFamily, key: Vec<u8>, value: Vec<u8>) -> Result<()> {
@@ -112,10 +111,7 @@ pub struct RocksColumn<T: Column> {
 
 impl<T: Column> RocksColumn<T> {
     pub fn new(rocks: Arc<Rocks>) -> RocksColumn<T> {
-        RocksColumn {
-            rocks,
-            column: PhantomData,
-        }
+        RocksColumn { rocks, column: PhantomData }
     }
     fn cf_handle(&self) -> Result<&ColumnFamily> {
         self.rocks.cf_handle::<T>()

src/blockchain/slab.rs

@@ -1,5 +1,7 @@
-use crate::serial::{Decodable, Encodable};
-use crate::Result;
+use crate::{
+    serial::{Decodable, Encodable},
+    Result,
+};
 
 #[derive(Clone, Debug)]
 pub struct Slab {
@@ -37,9 +39,6 @@ impl Encodable for Slab {
 
 impl Decodable for Slab {
     fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            index: Decodable::decode(&mut d)?,
-            payload: Decodable::decode(&mut d)?,
-        })
+        Ok(Self { index: Decodable::decode(&mut d)?, payload: Decodable::decode(&mut d)? })
     }
 }

src/blockchain/slabstore.rs

@@ -2,10 +2,14 @@ use std::sync::Arc;
 
 use log::debug;
 
-use super::rocks::{columns, IteratorMode, RocksColumn};
-use super::slab::Slab;
-use crate::serial::{deserialize, serialize};
-use crate::Result;
+use super::{
+    rocks::{columns, IteratorMode, RocksColumn},
+    slab::Slab,
+};
+use crate::{
+    serial::{deserialize, serialize},
+    Result,
+};
 
 pub struct SlabStore {
     rocks: RocksColumn<columns::Slabs>,

src/circuit/mint_contract.rs

@@ -126,11 +126,7 @@ impl Circuit<pallas::Base> for MintContract {
 
         // Fixed columns for the Sinsemilla generator lookup table
         let table_idx = meta.lookup_table_column();
-        let lookup = (
-            table_idx,
-            meta.lookup_table_column(),
-            meta.lookup_table_column(),
-        );
+        let lookup = (table_idx, meta.lookup_table_column(), meta.lookup_table_column());
 
         // Instance column used for public inputs
         let primary = meta.instance_column();
@@ -254,17 +250,11 @@ impl Circuit<pallas::Base> for MintContract {
             self.pub_y,
         )?;
 
-        let value = self.load_private(
-            layouter.namespace(|| "load value"),
-            config.advices[0],
-            self.value,
-        )?;
+        let value =
+            self.load_private(layouter.namespace(|| "load value"), config.advices[0], self.value)?;
 
-        let asset = self.load_private(
-            layouter.namespace(|| "load asset"),
-            config.advices[0],
-            self.asset,
-        )?;
+        let asset =
+            self.load_private(layouter.namespace(|| "load asset"), config.advices[0], self.asset)?;
 
         let serial = self.load_private(
             layouter.namespace(|| "load serial"),
@@ -312,10 +302,8 @@ impl Circuit<pallas::Base> for MintContract {
                     ConstantLength::<2>,
                 )?;
 
-                let poseidon_output = poseidon_hasher.hash(
-                    layouter.namespace(|| "Poseidon hash (a, b)"),
-                    poseidon_message,
-                )?;
+                let poseidon_output = poseidon_hasher
+                    .hash(layouter.namespace(|| "Poseidon hash (a, b)"), poseidon_message)?;
 
                 let poseidon_output: CellValue<pallas::Base> = poseidon_output.inner().into();
                 poseidon_output

src/circuit/spend_contract.rs

@@ -19,8 +19,10 @@ use halo2_gadgets::{
     primitives::poseidon::{ConstantLength, P128Pow5T3},
     sinsemilla::{
         chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::chip::{MerkleChip, MerkleConfig},
-        merkle::MerklePath,
+        merkle::{
+            chip::{MerkleChip, MerkleConfig},
+            MerklePath,
+        },
     },
     utilities::{
         copy, lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
@@ -148,11 +150,7 @@ impl Circuit<pasta::Fp> for SpendContract {
 
         // Fixed columns for the Sinsemilla generator lookup table
         let table_idx = meta.lookup_table_column();
-        let lookup = (
-            table_idx,
-            meta.lookup_table_column(),
-            meta.lookup_table_column(),
-        );
+        let lookup = (table_idx, meta.lookup_table_column(), meta.lookup_table_column());
 
         // Instance column used for public inputs
         let primary = meta.instance_column();
@@ -298,9 +296,7 @@ impl Circuit<pasta::Fp> for SpendContract {
                             || value.ok_or(Error::SynthesisError),
                         )?;
                         region.constrain_equal(var, message[i].cell())?;
-                        Ok(Word::<_, _, P128Pow5T3, 3, 2>::from_inner(StateWord::new(
-                            var, value,
-                        )))
+                        Ok(Word::<_, _, P128Pow5T3, 3, 2>::from_inner(StateWord::new(var, value)))
                     };
                     Ok([message_word(0)?, message_word(1)?])
                 },
@@ -329,17 +325,11 @@ impl Circuit<pasta::Fp> for SpendContract {
         //         scalar,
         //     )?
 
-        let value = self.load_private(
-            layouter.namespace(|| "load value"),
-            config.advices[0],
-            self.value,
-        )?;
+        let value =
+            self.load_private(layouter.namespace(|| "load value"), config.advices[0], self.value)?;
 
-        let asset = self.load_private(
-            layouter.namespace(|| "load asset"),
-            config.advices[0],
-            self.asset,
-        )?;
+        let asset =
+            self.load_private(layouter.namespace(|| "load asset"), config.advices[0], self.asset)?;
 
         let coin_blind = self.load_private(
             layouter.namespace(|| "load coin_blind"),
@@ -389,10 +379,8 @@ impl Circuit<pasta::Fp> for SpendContract {
                     ConstantLength::<2>,
                 )?;
 
-                let poseidon_output = poseidon_hasher.hash(
-                    layouter.namespace(|| "Poseidon hash (a, b)"),
-                    poseidon_message,
-                )?;
+                let poseidon_output = poseidon_hasher
+                    .hash(layouter.namespace(|| "Poseidon hash (a, b)"), poseidon_message)?;
 
                 let poseidon_output: CellValue<pasta::Fp> = poseidon_output.inner().into();
                 poseidon_output
@@ -458,11 +446,8 @@ impl Circuit<pasta::Fp> for SpendContract {
             Some(pasta::Fp::one()),
         )?;
 
-        let value = self.load_private(
-            layouter.namespace(|| "load value"),
-            config.advices[0],
-            self.value,
-        )?;
+        let value =
+            self.load_private(layouter.namespace(|| "load value"), config.advices[0], self.value)?;
 
         // v * G_1
         let (commitment, _) = {
@@ -496,11 +481,8 @@ impl Circuit<pasta::Fp> for SpendContract {
         // Asset commitment
         // ================
 
-        let asset = self.load_private(
-            layouter.namespace(|| "load asset"),
-            config.advices[0],
-            self.asset,
-        )?;
+        let asset =
+            self.load_private(layouter.namespace(|| "load asset"), config.advices[0], self.asset)?;
 
         // a * G_1
         let (commitment, _) = {

src/cli/cli_config.rs

@@ -6,8 +6,7 @@ use std::{
     str,
 };
 
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 use crate::{Error, Result};
 

src/crypto/arith_chip.rs

@@ -91,12 +91,7 @@ impl ArithmeticChip {
         });
         */
 
-        ArithmeticChipConfig {
-            a_col,
-            b_col,
-            /*permute,*/ s_add,
-            s_mul, /*, s_pub*/
-        }
+        ArithmeticChipConfig { a_col, b_col, /* permute, */ s_add, s_mul /* , s_pub */ }
     }
 
     pub fn add(

src/crypto/constants/fixed_bases.rs

@@ -3,10 +3,10 @@ use halo2_gadgets::ecc::{
     chip::{compute_lagrange_coeffs, NUM_WINDOWS, NUM_WINDOWS_SHORT},
     FixedPoints, H,
 };
-use pasta_curves::pallas;
 use pasta_curves::{
     arithmetic::{CurveAffine, Field, FieldExt},
     group::Curve,
+    pallas,
 };
 
 pub mod commit_ivk_r;
@@ -105,8 +105,8 @@ fn compute_window_table<C: CurveAffine>(base: C, num_windows: usize) -> Vec<[C;
             (0..H)
                 .map(|k| {
                     // scalar = (k+2)*(8^w)
-                    let scalar = C::ScalarExt::from_u64(k as u64 + 2)
-                        * C::ScalarExt::from_u64(H as u64).pow(&[w as u64, 0, 0, 0]);
+                    let scalar = C::ScalarExt::from_u64(k as u64 + 2) *
+                        C::ScalarExt::from_u64(H as u64).pow(&[w as u64, 0, 0, 0]);
                     (base * scalar).to_affine()
                 })
                 .collect::<ArrayVec<C, H>>()
@@ -130,9 +130,9 @@ fn compute_window_table<C: CurveAffine>(base: C, num_windows: usize) -> Vec<[C;
         (0..H)
             .map(|k| {
                 // scalar = k * (2^3)^w - sum, where w = `num_windows - 1`
-                let scalar = C::ScalarExt::from_u64(k as u64)
-                    * C::ScalarExt::from_u64(H as u64).pow(&[(num_windows - 1) as u64, 0, 0, 0])
-                    - sum;
+                let scalar = C::ScalarExt::from_u64(k as u64) *
+                    C::ScalarExt::from_u64(H as u64).pow(&[(num_windows - 1) as u64, 0, 0, 0]) -
+                    sum;
                 (base * scalar).to_affine()
             })
             .collect::<ArrayVec<C, H>>()
@@ -158,9 +158,9 @@ fn test_lagrange_coeffs<C: CurveAffine>(base: C, num_windows: usize) {
                 let interpolated_x = super::util::evaluate::<C>(bits, coeffs);
 
                 // Compute the actual x-coordinate of the multiple [(k+2)*(8^w)]B.
-                let point = base
-                    * C::Scalar::from_u64(bits as u64 + 2)
-                    * C::Scalar::from_u64(H as u64).pow(&[idx as u64, 0, 0, 0]);
+                let point = base *
+                    C::Scalar::from_u64(bits as u64 + 2) *
+                    C::Scalar::from_u64(H as u64).pow(&[idx as u64, 0, 0, 0]);
                 let x = *point.to_affine().coordinates().unwrap().x();
 
                 // Check that the interpolated x-coordinate matches the actual one.
@@ -184,9 +184,9 @@ fn test_lagrange_coeffs<C: CurveAffine>(base: C, num_windows: usize) {
                 0,
             ])
         });
-        let scalar = C::Scalar::from_u64(bits as u64)
-            * C::Scalar::from_u64(H as u64).pow(&[(num_windows - 1) as u64, 0, 0, 0])
-            - offset;
+        let scalar = C::Scalar::from_u64(bits as u64) *
+            C::Scalar::from_u64(H as u64).pow(&[(num_windows - 1) as u64, 0, 0, 0]) -
+            offset;
         let point = base * scalar;
         let x = *point.to_affine().coordinates().unwrap().x();
 

src/crypto/constants/fixed_bases/commit_ivk_r.rs

@@ -2930,10 +2930,10 @@ pub fn generator() -> pallas::Affine {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{
-        test_lagrange_coeffs, test_zs_and_us, COMMIT_IVK_PERSONALIZATION, NUM_WINDOWS,
+    use super::{
+        super::{test_lagrange_coeffs, test_zs_and_us, COMMIT_IVK_PERSONALIZATION, NUM_WINDOWS},
+        *,
     };
-    use super::*;
     use group::Curve;
     use halo2_gadgets::primitives::sinsemilla::CommitDomain;
     use pasta_curves::{

src/crypto/constants/fixed_bases/note_commit_r.rs

@@ -2930,10 +2930,12 @@ pub fn generator() -> pallas::Affine {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{
-        test_lagrange_coeffs, test_zs_and_us, NOTE_COMMITMENT_PERSONALIZATION, NUM_WINDOWS,
+    use super::{
+        super::{
+            test_lagrange_coeffs, test_zs_and_us, NOTE_COMMITMENT_PERSONALIZATION, NUM_WINDOWS,
+        },
+        *,
     };
-    use super::*;
     use group::Curve;
     use halo2_gadgets::primitives::sinsemilla::CommitDomain;
     use pasta_curves::{

src/crypto/constants/fixed_bases/nullifier_k.rs

@@ -2929,10 +2929,10 @@ pub fn generator() -> pallas::Affine {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{
-        test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS, ORCHARD_PERSONALIZATION,
+    use super::{
+        super::{test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS, ORCHARD_PERSONALIZATION},
+        *,
     };
-    use super::*;
     use group::Curve;
     use pasta_curves::{
         arithmetic::{CurveExt, FieldExt},

src/crypto/constants/fixed_bases/spend_auth_g.rs

@@ -2931,10 +2931,10 @@ pub fn generator() -> pallas::Affine {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{
-        test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS, ORCHARD_PERSONALIZATION,
+    use super::{
+        super::{test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS, ORCHARD_PERSONALIZATION},
+        *,
     };
-    use super::*;
     use group::Curve;
     use pasta_curves::{
         arithmetic::{CurveAffine, CurveExt, FieldExt},

src/crypto/constants/fixed_bases/value_commit_r.rs

@@ -2931,10 +2931,12 @@ pub fn generator() -> pallas::Affine {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{
-        test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS, VALUE_COMMITMENT_PERSONALIZATION,
+    use super::{
+        super::{
+            test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS, VALUE_COMMITMENT_PERSONALIZATION,
+        },
+        *,
     };
-    use super::*;
     use group::Curve;
     use pasta_curves::{
         arithmetic::{CurveAffine, CurveExt, FieldExt},

src/crypto/constants/fixed_bases/value_commit_v.rs

@@ -784,10 +784,13 @@ pub fn generator() -> pallas::Affine {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{
-        test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS_SHORT, VALUE_COMMITMENT_PERSONALIZATION,
+    use super::{
+        super::{
+            test_lagrange_coeffs, test_zs_and_us, NUM_WINDOWS_SHORT,
+            VALUE_COMMITMENT_PERSONALIZATION,
+        },
+        *,
     };
-    use super::*;
     use group::Curve;
     use pasta_curves::{
         arithmetic::{CurveAffine, CurveExt, FieldExt},

src/crypto/constants/sinsemilla.rs

@@ -78,9 +78,7 @@ pub fn i2lebsp<const NUM_BITS: usize>(int: u64) -> [bool; NUM_BITS] {
 #[allow(dead_code)]
 fn lebs2ip_k(bits: &[bool]) -> u32 {
     assert!(bits.len() == K);
-    bits.iter()
-        .enumerate()
-        .fold(0u32, |acc, (i, b)| acc + if *b { 1 << i } else { 0 })
+    bits.iter().enumerate().fold(0u32, |acc, (i, b)| acc + if *b { 1 << i } else { 0 })
 }
 
 /// The sequence of K bits in little-endian order representing an integer
@@ -180,26 +178,17 @@ mod tests {
     fn i2lebsp_k_round_trip() {
         {
             let bitstring = (0..K).map(|_| rand::random()).collect::<Vec<_>>();
-            assert_eq!(
-                i2lebsp_k(lebs2ip_k(&bitstring) as usize).to_vec(),
-                bitstring
-            );
+            assert_eq!(i2lebsp_k(lebs2ip_k(&bitstring) as usize).to_vec(), bitstring);
         }
 
         {
             let bitstring = [false; K];
-            assert_eq!(
-                i2lebsp_k(lebs2ip_k(&bitstring) as usize).to_vec(),
-                bitstring
-            );
+            assert_eq!(i2lebsp_k(lebs2ip_k(&bitstring) as usize).to_vec(), bitstring);
         }
 
         {
             let bitstring = [true; K];
-            assert_eq!(
-                i2lebsp_k(lebs2ip_k(&bitstring) as usize).to_vec(),
-                bitstring
-            );
+            assert_eq!(i2lebsp_k(lebs2ip_k(&bitstring) as usize).to_vec(), bitstring);
         }
     }
 
@@ -225,14 +214,8 @@ mod tests {
         let point = domain.Q();
         let coords = point.to_affine().coordinates().unwrap();
 
-        assert_eq!(
-            *coords.x(),
-            pallas::Base::from_bytes(&Q_COMMIT_IVK_M_GENERATOR.0).unwrap()
-        );
-        assert_eq!(
-            *coords.y(),
-            pallas::Base::from_bytes(&Q_COMMIT_IVK_M_GENERATOR.1).unwrap()
-        );
+        assert_eq!(*coords.x(), pallas::Base::from_bytes(&Q_COMMIT_IVK_M_GENERATOR.0).unwrap());
+        assert_eq!(*coords.y(), pallas::Base::from_bytes(&Q_COMMIT_IVK_M_GENERATOR.1).unwrap());
     }
 
     #[test]
@@ -241,14 +224,8 @@ mod tests {
         let point = domain.Q();
         let coords = point.to_affine().coordinates().unwrap();
 
-        assert_eq!(
-            *coords.x(),
-            pallas::Base::from_bytes(&Q_MERKLE_CRH.0).unwrap()
-        );
-        assert_eq!(
-            *coords.y(),
-            pallas::Base::from_bytes(&Q_MERKLE_CRH.1).unwrap()
-        );
+        assert_eq!(*coords.x(), pallas::Base::from_bytes(&Q_MERKLE_CRH.0).unwrap());
+        assert_eq!(*coords.y(), pallas::Base::from_bytes(&Q_MERKLE_CRH.1).unwrap());
     }
 
     #[test]

src/crypto/constants/util.rs

@@ -3,12 +3,7 @@ use pasta_curves::arithmetic::{CurveAffine, Field, FieldExt};
 /// Evaluate y = f(x) given the coefficients of f(x)
 pub fn evaluate<C: CurveAffine>(x: u8, coeffs: &[C::Base]) -> C::Base {
     let x = C::Base::from_u64(x as u64);
-    coeffs
-        .iter()
-        .rev()
-        .cloned()
-        .reduce(|acc, coeff| acc * x + coeff)
-        .unwrap_or_else(C::Base::zero)
+    coeffs.iter().rev().cloned().reduce(|acc, coeff| acc * x + coeff).unwrap_or_else(C::Base::zero)
 }
 
 /// Takes in an FnMut closure and returns a constant-length array with elements of

src/crypto/merkle.rs

@@ -25,13 +25,11 @@ lazy_static! {
     pub(crate) static ref EMPTY_ROOTS: Vec<MerkleHash> = {
         iter::empty()
             .chain(Some(MerkleHash::empty_leaf()))
-            .chain(
-                (0..MERKLE_DEPTH_ORCHARD).scan(MerkleHash::empty_leaf(), |state, l| {
-                    let l = l as u8;
-                    *state = MerkleHash::combine(l.into(), state, state);
-                    Some(*state)
-                }),
-            )
+            .chain((0..MERKLE_DEPTH_ORCHARD).scan(MerkleHash::empty_leaf(), |state, l| {
+                let l = l as u8;
+                *state = MerkleHash::combine(l.into(), state, state);
+                Some(*state)
+            }))
             .collect()
     };
 }

src/crypto/merkle_node2.rs

@@ -1,15 +1,12 @@
-use halo2_gadgets::primitives::sinsemilla::HashDomain;
-use halo2_gadgets::utilities::Var;
-use incrementalmerkletree::Altitude;
-use incrementalmerkletree::Hashable;
+use halo2_gadgets::{primitives::sinsemilla::HashDomain, utilities::Var};
+use incrementalmerkletree::{Altitude, Hashable};
 use lazy_static::lazy_static;
 use pasta_curves::{
     arithmetic::{Field, FieldExt},
     group::ff::PrimeFieldBits,
     pallas,
 };
-use std::io;
-use std::iter;
+use std::{io, iter};
 use subtle::ConstantTimeEq;
 
 use crate::{
@@ -26,13 +23,11 @@ lazy_static! {
     static ref EMPTY_ROOTS: Vec<MerkleNode> = {
         iter::empty()
             .chain(Some(MerkleNode::empty_leaf()))
-            .chain(
-                (0..MERKLE_DEPTH_ORCHARD).scan(MerkleNode::empty_leaf(), |state, l| {
-                    let l = l as u8;
-                    *state = MerkleNode::combine(l.into(), state, state);
-                    Some(state.clone())
-                }),
-            )
+            .chain((0..MERKLE_DEPTH_ORCHARD).scan(MerkleNode::empty_leaf(), |state, l| {
+                let l = l as u8;
+                *state = MerkleNode::combine(l.into(), state, state);
+                Some(state.clone())
+            }))
             .collect()
     };
 }
@@ -48,9 +43,7 @@ impl std::cmp::PartialEq for MerkleNode {
 
 impl std::hash::Hash for MerkleNode {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        <Option<pallas::Base>>::from(self.0)
-            .map(|b| b.to_bytes())
-            .hash(state)
+        <Option<pallas::Base>>::from(self.0).map(|b| b.to_bytes()).hash(state)
     }
 }
 
@@ -66,8 +59,8 @@ impl Hashable for MerkleNode {
     ///      - leaves are at layer MERKLE_DEPTH_ORCHARD = 32;
     ///      - the root is at layer 0.
     /// `l` is MERKLE_DEPTH_ORCHARD - layer - 1.
-    ///      - when hashing two leaves, we produce a node on the layer above the leaves, i.e.
-    ///        layer = 31, l = 0
+    ///      - when hashing two leaves, we produce a node on the layer above the leaves, i.e. layer
+    ///        = 31, l = 0
     ///      - when hashing to the final root, we produce the anchor with layer = 0, l = 31.
     fn combine(altitude: Altitude, left: &Self, right: &Self) -> Self {
         // MerkleCRH Sinsemilla hash domain.

src/crypto/mint_proof.rs

@@ -1,8 +1,9 @@
-use std::io;
-use std::time::Instant;
+use std::{io, time::Instant};
 
-use halo2_gadgets::primitives;
-use halo2_gadgets::primitives::poseidon::{ConstantLength, P128Pow5T3};
+use halo2_gadgets::{
+    primitives,
+    primitives::poseidon::{ConstantLength, P128Pow5T3},
+};
 use log::debug;
 use pasta_curves::{
     arithmetic::{CurveAffine, FieldExt},
@@ -55,11 +56,7 @@ impl MintRevealedValues {
 
         //let coin = hash.to_bytes();
 
-        MintRevealedValues {
-            value_commit,
-            token_commit,
-            coin,
-        }
+        MintRevealedValues { value_commit, token_commit, coin }
     }
 
     fn make_outputs(&self) -> [DrkCircuitField; 5] {

src/crypto/mod.rs

@@ -13,7 +13,9 @@ pub mod schnorr;
 pub mod spend_proof;
 pub mod util;
 
-pub(crate) use {mint_proof::MintRevealedValues, proof::Proof, spend_proof::SpendRevealedValues};
+pub(crate) use mint_proof::MintRevealedValues;
+pub(crate) use proof::Proof;
+pub(crate) use spend_proof::SpendRevealedValues;
 
 use crate::types::DrkSecretKey;
 

src/crypto/note.rs

@@ -73,10 +73,7 @@ impl Note {
             ENC_CIPHERTEXT_SIZE
         );
 
-        Ok(EncryptedNote {
-            ciphertext,
-            ephem_public,
-        })
+        Ok(EncryptedNote { ciphertext, ephem_public })
     }
 }
 
@@ -99,10 +96,7 @@ impl Decodable for EncryptedNote {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
         let mut ciphertext = [0u8; ENC_CIPHERTEXT_SIZE];
         d.read_slice(&mut ciphertext[..])?;
-        Ok(Self {
-            ciphertext,
-            ephem_public: Decodable::decode(d)?,
-        })
+        Ok(Self { ciphertext, ephem_public: Decodable::decode(d)? })
     }
 }
 
@@ -114,13 +108,7 @@ impl EncryptedNote {
         let mut plaintext = [0; ENC_CIPHERTEXT_SIZE];
         assert_eq!(
             ChachaPolyIetf::aead_cipher()
-                .open_to(
-                    &mut plaintext,
-                    &self.ciphertext,
-                    &[],
-                    key.as_ref(),
-                    &[0u8; 12]
-                )
+                .open_to(&mut plaintext, &self.ciphertext, &[], key.as_ref(), &[0u8; 12])
                 .map_err(|_| Error::NoteDecryptionFailed)?,
             NOTE_PLAINTEXT_SIZE
         );

src/crypto/proof.rs

@@ -9,9 +9,11 @@ use halo2::{
 };
 use pasta_curves::vesta;
 
-use crate::serial::{Decodable, Encodable, ReadExt, VarInt, WriteExt};
-use crate::types::*;
-use crate::Result;
+use crate::{
+    serial::{Decodable, Encodable, ReadExt, VarInt, WriteExt},
+    types::*,
+    Result,
+};
 
 #[derive(Debug)]
 pub struct VerifyingKey {
@@ -59,13 +61,7 @@ impl Proof {
     ) -> std::result::Result<Self, plonk::Error> {
         let mut transcript = Blake2bWrite::<_, vesta::Affine, _>::init(vec![]);
 
-        plonk::create_proof(
-            &pk.params,
-            &pk.pk,
-            circuits,
-            &[&[pubinputs]],
-            &mut transcript,
-        )?;
+        plonk::create_proof(&pk.params, &pk.pk, circuits, &[&[pubinputs]], &mut transcript)?;
 
         Ok(Proof(transcript.finalize()))
     }

src/crypto/schnorr.rs

@@ -60,18 +60,15 @@ impl Encodable for Signature {
 
 impl Decodable for Signature {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            commit: Decodable::decode(&mut d)?,
-            response: Decodable::decode(d)?,
-        })
+        Ok(Self { commit: Decodable::decode(&mut d)?, response: Decodable::decode(d)? })
     }
 }
 
 impl PublicKey {
     pub fn verify(&self, message: &[u8], signature: &Signature) -> bool {
         let challenge = hash_to_scalar(DRK_SCHNORR_DOMAIN, &signature.commit.to_bytes(), message);
-        OrchardFixedBases::SpendAuthG.generator() * signature.response - self.0 * challenge
-            == signature.commit
+        OrchardFixedBases::SpendAuthG.generator() * signature.response - self.0 * challenge ==
+            signature.commit
     }
 }
 

src/crypto/spend_proof.rs

@@ -1,5 +1,4 @@
-use std::io;
-use std::time::Instant;
+use std::{io, time::Instant};
 
 use halo2_gadgets::{
     primitives,

src/endian.rs

@@ -90,9 +90,8 @@ macro_rules! define_chunk_slice_to_int {
         #[inline]
         pub fn $name(inp: &[u8], outp: &mut [$type]) {
             assert_eq!(inp.len(), outp.len() * ::std::mem::size_of::<$type>());
-            for (outp_val, data_bytes) in outp
-                .iter_mut()
-                .zip(inp.chunks(::std::mem::size_of::<$type>()))
+            for (outp_val, data_bytes) in
+                outp.iter_mut().zip(inp.chunks(::std::mem::size_of::<$type>()))
             {
                 *outp_val = $converter(data_bytes);
             }

src/error.rs

@@ -1,7 +1,6 @@
 use std::fmt;
 
-use crate::client;
-use crate::state;
+use crate::{client, state};
 
 pub type Result<T> = std::result::Result<T, Error>;
 

src/net/acceptor.rs

@@ -1,12 +1,16 @@
 use log::*;
 use smol::{Async, Executor};
-use std::net::{SocketAddr, TcpListener};
-use std::sync::Arc;
+use std::{
+    net::{SocketAddr, TcpListener},
+    sync::Arc,
+};
 
 use crate::error::{Error, Result};
 //use crate::net::error::{, Result};
-use crate::net::{Channel, ChannelPtr};
-use crate::system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription};
+use crate::{
+    net::{Channel, ChannelPtr},
+    system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription},
+};
 
 /// Atomic pointer to Acceptor class.
 pub type AcceptorPtr = Arc<Acceptor>;
@@ -20,10 +24,7 @@ pub struct Acceptor {
 impl Acceptor {
     /// Create new Acceptor object.
     pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            channel_subscriber: Subscriber::new(),
-            task: StoppableTask::new(),
-        })
+        Arc::new(Self { channel_subscriber: Subscriber::new(), task: StoppableTask::new() })
     }
     /// Start accepting inbound socket connections. Creates a listener to start
     /// listening on a local socket address. Then runs an accept loop in a new
@@ -58,14 +59,14 @@ impl Acceptor {
             Ok(listener) => listener,
             Err(err) => {
                 error!("Bind listener failed: {}", err);
-                return Err(Error::OperationFailed);
+                return Err(Error::OperationFailed)
             }
         };
         let local_addr = match listener.get_ref().local_addr() {
             Ok(addr) => addr,
             Err(err) => {
                 error!("Failed to get local address: {}", err);
-                return Err(Error::OperationFailed);
+                return Err(Error::OperationFailed)
             }
         };
         info!("Listening on {}", local_addr);
@@ -112,7 +113,7 @@ impl Acceptor {
             Ok((s, a)) => (s, a),
             Err(err) => {
                 error!("Error listening for connections: {}", err);
-                return Err(Error::ServiceStopped);
+                return Err(Error::ServiceStopped)
             }
         };
         info!("Accepted client: {}", peer_addr);

src/net/channel.rs

@@ -1,18 +1,26 @@
 use async_std::sync::Mutex;
-use futures::io::{ReadHalf, WriteHalf};
-use futures::AsyncReadExt;
+use futures::{
+    io::{ReadHalf, WriteHalf},
+    AsyncReadExt,
+};
 use log::*;
 use smol::{Async, Executor};
 
 use std::net::{SocketAddr, TcpStream};
 
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
 
-use crate::error::{Error, Result};
-use crate::net::message_subscriber::{MessageSubscription, MessageSubsystem};
-use crate::net::messages;
-use crate::system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription};
+use crate::{
+    error::{Error, Result},
+    net::{
+        message_subscriber::{MessageSubscription, MessageSubsystem},
+        messages,
+    },
+    system::{StoppableTask, StoppableTaskPtr, Subscriber, SubscriberPtr, Subscription},
+};
 
 /// Atomic pointer to async channel.
 pub type ChannelPtr = Arc<Channel>;
@@ -76,9 +84,7 @@ impl Channel {
         self.stopped.store(false, Ordering::Relaxed);
         self.stop_subscriber.notify(Error::ChannelStopped).await;
         self.receive_task.stop().await;
-        self.message_subsystem
-            .trigger_error(Error::ChannelStopped)
-            .await;
+        self.message_subsystem.trigger_error(Error::ChannelStopped).await;
         debug!(target: "net", "Channel::stop() [END, address={}]", self.address());
     }
 
@@ -108,7 +114,7 @@ impl Channel {
             self.address()
         );
         if self.stopped.load(Ordering::Relaxed) {
-            return Err(Error::ChannelStopped);
+            return Err(Error::ChannelStopped)
         }
 
         // Catch failure and stop channel, return a net error
@@ -135,10 +141,7 @@ impl Channel {
     async fn send_message<M: messages::Message>(&self, message: M) -> Result<()> {
         let mut payload = Vec::new();
         message.encode(&mut payload)?;
-        let packet = messages::Packet {
-            command: String::from(M::name()),
-            payload,
-        };
+        let packet = messages::Packet { command: String::from(M::name()), payload };
 
         let stream = &mut *self.writer.lock().await;
         messages::send_packet(stream, packet).await
@@ -175,24 +178,12 @@ impl Channel {
 
     /// Perform network handshake for message subsystem dispatchers.
     async fn setup_dispatchers(message_subsystem: &MessageSubsystem) {
-        message_subsystem
-            .add_dispatch::<messages::VersionMessage>()
-            .await;
-        message_subsystem
-            .add_dispatch::<messages::VerackMessage>()
-            .await;
-        message_subsystem
-            .add_dispatch::<messages::PingMessage>()
-            .await;
-        message_subsystem
-            .add_dispatch::<messages::PongMessage>()
-            .await;
-        message_subsystem
-            .add_dispatch::<messages::GetAddrsMessage>()
-            .await;
-        message_subsystem
-            .add_dispatch::<messages::AddrsMessage>()
-            .await;
+        message_subsystem.add_dispatch::<messages::VersionMessage>().await;
+        message_subsystem.add_dispatch::<messages::VerackMessage>().await;
+        message_subsystem.add_dispatch::<messages::PingMessage>().await;
+        message_subsystem.add_dispatch::<messages::PongMessage>().await;
+        message_subsystem.add_dispatch::<messages::GetAddrsMessage>().await;
+        message_subsystem.add_dispatch::<messages::AddrsMessage>().await;
     }
 
     /// Convenience function that returns the Message Subsystem.
@@ -224,14 +215,12 @@ impl Channel {
                         self.address()
                     );
                     self.stop().await;
-                    return Err(Error::ChannelStopped);
+                    return Err(Error::ChannelStopped)
                 }
             };
 
             // Send result to our subscribers
-            self.message_subsystem
-                .notify(&packet.command, packet.payload)
-                .await;
+            self.message_subsystem.notify(&packet.command, packet.payload).await;
         }
     }
 

src/net/connector.rs

@@ -4,8 +4,7 @@ use std::net::{SocketAddr, TcpStream};
 
 use crate::error::{Error, Result};
 //use crate::net::error::{Error, Result};
-use crate::net::utility::sleep;
-use crate::net::{Channel, ChannelPtr, SettingsPtr};
+use crate::net::{utility::sleep, Channel, ChannelPtr, SettingsPtr};
 
 /// Create outbound socket connections.
 pub struct Connector {

src/net/hosts.rs

@@ -1,8 +1,6 @@
 use async_std::sync::Mutex;
 use rand::seq::SliceRandom;
-use std::collections::HashSet;
-use std::net::SocketAddr;
-use std::sync::Arc;
+use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 
 /// Pointer to hosts class.
 pub type HostsPtr = Arc<Hosts>;
@@ -15,19 +13,13 @@ pub struct Hosts {
 impl Hosts {
     /// Create a new host list.
     pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            addrs: Mutex::new(Vec::new()),
-        })
+        Arc::new(Self { addrs: Mutex::new(Vec::new()) })
     }
 
     /// Checks if a host address is in the host list.
     async fn contains(&self, addrs: &[SocketAddr]) -> bool {
         let a_set: HashSet<_> = addrs.iter().copied().collect();
-        self.addrs
-            .lock()
-            .await
-            .iter()
-            .any(|item| a_set.contains(item))
+        self.addrs.lock().await.iter().any(|item| a_set.contains(item))
     }
 
     /// Add a new host to the host list.
@@ -39,11 +31,7 @@ impl Hosts {
 
     /// Return a single host address.
     pub async fn load_single(&self) -> Option<SocketAddr> {
-        self.addrs
-            .lock()
-            .await
-            .choose(&mut rand::thread_rng())
-            .cloned()
+        self.addrs.lock().await.choose(&mut rand::thread_rng()).cloned()
     }
 
     /// Return the list of hosts.

src/net/message_subscriber.rs

@@ -2,15 +2,13 @@ use async_std::sync::Mutex;
 use async_trait::async_trait;
 use log::*;
 use rand::Rng;
-use std::any::Any;
-use std::collections::HashMap;
-use std::io;
-use std::io::Cursor;
-use std::sync::Arc;
+use std::{any::Any, collections::HashMap, io, io::Cursor, sync::Arc};
 
-use crate::error::{Error, Result};
-use crate::net::messages::Message;
-use crate::serial::{Decodable, Encodable};
+use crate::{
+    error::{Error, Result},
+    net::messages::Message,
+    serial::{Decodable, Encodable},
+};
 
 /// 64bit identifier for message subscription.
 pub type MessageSubscriptionId = u64;
@@ -60,9 +58,7 @@ struct MessageDispatcher<M: Message> {
 impl<M: Message> MessageDispatcher<M> {
     /// Create a new message dispatcher.
     fn new() -> Self {
-        MessageDispatcher {
-            subs: Mutex::new(HashMap::new()),
-        }
+        MessageDispatcher { subs: Mutex::new(HashMap::new()) }
     }
 
     /// Create a random ID.
@@ -78,11 +74,7 @@ impl<M: Message> MessageDispatcher<M> {
         let sub_id = Self::random_id();
         self.subs.lock().await.insert(sub_id, sender);
 
-        MessageSubscription {
-            id: sub_id,
-            recv_queue: recvr,
-            parent: self,
-        }
+        MessageSubscription { id: sub_id, recv_queue: recvr, parent: self }
     }
 
     /// Unsubcribe from a channel. Removes the associated ID from the subscriber
@@ -173,17 +165,12 @@ pub struct MessageSubsystem {
 impl MessageSubsystem {
     /// Create a new message subsystem.
     pub fn new() -> Self {
-        MessageSubsystem {
-            dispatchers: Mutex::new(HashMap::new()),
-        }
+        MessageSubsystem { dispatchers: Mutex::new(HashMap::new()) }
     }
 
     /// Add a new message dispatcher.
     pub async fn add_dispatch<M: Message>(&self) {
-        self.dispatchers
-            .lock()
-            .await
-            .insert(M::name(), Arc::new(MessageDispatcher::<M>::new()));
+        self.dispatchers.lock().await.insert(M::name(), Arc::new(MessageDispatcher::<M>::new()));
     }
 
     /// Add a dispatcher to the list of subscribers.
@@ -202,7 +189,7 @@ impl MessageSubsystem {
             None => {
                 // normall return failure here
                 // for now panic
-                return Err(Error::OperationFailed);
+                return Err(Error::OperationFailed)
             }
         };
 
@@ -268,9 +255,7 @@ async fn _do_message_subscriber_test() {
 
     impl Decodable for MyVersionMessage {
         fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-            Ok(Self {
-                x: Decodable::decode(&mut d)?,
-            })
+            Ok(Self { x: Decodable::decode(&mut d)? })
         }
     }
     println!("hello");

src/net/messages.rs

@@ -1,10 +1,11 @@
 use futures::prelude::*;
 use log::*;
-use std::io;
-use std::net::SocketAddr;
+use std::{io, net::SocketAddr};
 
-use crate::error::{Error, Result};
-use crate::serial::{Decodable, Encodable, VarInt};
+use crate::{
+    error::{Error, Result},
+    serial::{Decodable, Encodable, VarInt},
+};
 
 const MAGIC_BYTES: [u8; 4] = [0xd9, 0xef, 0xb6, 0x7d];
 
@@ -84,9 +85,7 @@ impl Encodable for PingMessage {
 
 impl Decodable for PingMessage {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            nonce: Decodable::decode(&mut d)?,
-        })
+        Ok(Self { nonce: Decodable::decode(&mut d)? })
     }
 }
 
@@ -100,9 +99,7 @@ impl Encodable for PongMessage {
 
 impl Decodable for PongMessage {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            nonce: Decodable::decode(&mut d)?,
-        })
+        Ok(Self { nonce: Decodable::decode(&mut d)? })
     }
 }
 
@@ -129,9 +126,7 @@ impl Encodable for AddrsMessage {
 
 impl Decodable for AddrsMessage {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            addrs: Decodable::decode(&mut d)?,
-        })
+        Ok(Self { addrs: Decodable::decode(&mut d)? })
     }
 }
 
@@ -175,7 +170,7 @@ pub async fn read_packet<R: AsyncRead + Unpin>(stream: &mut R) -> Result<Packet>
     stream.read_exact(&mut magic).await?;
     debug!(target: "net", "read magic {:?}", magic);
     if magic != MAGIC_BYTES {
-        return Err(Error::MalformedPacket);
+        return Err(Error::MalformedPacket)
     }
 
     // The type of the message
@@ -196,10 +191,7 @@ pub async fn read_packet<R: AsyncRead + Unpin>(stream: &mut R) -> Result<Packet>
     }
     debug!(target: "net", "read payload {} bytes", payload_len);
 
-    Ok(Packet {
-        command: cmd,
-        payload,
-    })
+    Ok(Packet { command: cmd, payload })
 }
 
 /// Sends an outbound packet by writing data to TCP stream.
@@ -208,17 +200,13 @@ pub async fn send_packet<W: AsyncWrite + Unpin>(stream: &mut W, packet: Packet)
     stream.write_all(&MAGIC_BYTES).await?;
     debug!(target: "net", "sent magic...");
 
-    VarInt(packet.command.len() as u64)
-        .encode_async(stream)
-        .await?;
+    VarInt(packet.command.len() as u64).encode_async(stream).await?;
     assert!(!packet.command.is_empty());
     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>());
-    VarInt(packet.payload.len() as u64)
-        .encode_async(stream)
-        .await?;
+    VarInt(packet.payload.len() as u64).encode_async(stream).await?;
 
     if !packet.payload.is_empty() {
         stream.write_all(&packet.payload).await?;

src/net/p2p.rs

@@ -1,15 +1,21 @@
 use async_executor::Executor;
 use async_std::sync::Mutex;
 use log::*;
-use std::collections::{HashMap, HashSet};
-use std::net::SocketAddr;
-use std::sync::Arc;
-
-use crate::error::{Error, Result};
-use crate::net::messages::Message;
-use crate::net::sessions::{InboundSession, OutboundSession, SeedSession};
-use crate::net::{Channel, ChannelPtr, Hosts, HostsPtr, Settings, SettingsPtr};
-use crate::system::{Subscriber, SubscriberPtr, Subscription};
+use std::{
+    collections::{HashMap, HashSet},
+    net::SocketAddr,
+    sync::Arc,
+};
+
+use crate::{
+    error::{Error, Result},
+    net::{
+        messages::Message,
+        sessions::{InboundSession, OutboundSession, SeedSession},
+        Channel, ChannelPtr, Hosts, HostsPtr, Settings, SettingsPtr,
+    },
+    system::{Subscriber, SubscriberPtr, Subscription},
+};
 
 /// List of channels that are awaiting connection.
 pub type PendingChannels = Mutex<HashSet<SocketAddr>>;
@@ -90,10 +96,7 @@ impl P2p {
 
     /// Add channel address to the list of connected channels.
     pub async fn store(&self, channel: ChannelPtr) {
-        self.channels
-            .lock()
-            .await
-            .insert(channel.address(), channel.clone());
+        self.channels.lock().await.insert(channel.address(), channel.clone());
         self.channel_subscriber.notify(Ok(channel)).await;
     }
 

src/net/protocols/protocol_address.rs

@@ -2,11 +2,15 @@ use log::*;
 use smol::Executor;
 use std::sync::Arc;
 
-use crate::error::Result;
-use crate::net::message_subscriber::MessageSubscription;
-use crate::net::messages;
-use crate::net::protocols::{ProtocolJobsManager, ProtocolJobsManagerPtr};
-use crate::net::{ChannelPtr, HostsPtr};
+use crate::{
+    error::Result,
+    net::{
+        message_subscriber::MessageSubscription,
+        messages,
+        protocols::{ProtocolJobsManager, ProtocolJobsManagerPtr},
+        ChannelPtr, HostsPtr,
+    },
+};
 
 /// Defines address and get-address messages.
 pub struct ProtocolAddress {
@@ -50,14 +54,8 @@ impl ProtocolAddress {
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) {
         debug!(target: "net", "ProtocolAddress::start() [START]");
         self.jobsman.clone().start(executor.clone());
-        self.jobsman
-            .clone()
-            .spawn(self.clone().handle_receive_addrs(), executor.clone())
-            .await;
-        self.jobsman
-            .clone()
-            .spawn(self.clone().handle_receive_get_addrs(), executor)
-            .await;
+        self.jobsman.clone().spawn(self.clone().handle_receive_addrs(), executor.clone()).await;
+        self.jobsman.clone().spawn(self.clone().handle_receive_get_addrs(), executor).await;
 
         // Send get_address message.
         let get_addrs = messages::GetAddrsMessage {};

src/net/protocols/protocol_jobs_manager.rs

@@ -4,9 +4,7 @@ use log::*;
 use smol::Task;
 use std::sync::Arc;
 
-use crate::error::Result;
-use crate::net::ChannelPtr;
-use crate::system::ExecutorPtr;
+use crate::{error::Result, net::ChannelPtr, system::ExecutorPtr};
 
 /// Pointer to protocol jobs manager.
 pub type ProtocolJobsManagerPtr = Arc<ProtocolJobsManager>;
@@ -23,11 +21,7 @@ pub struct ProtocolJobsManager {
 impl ProtocolJobsManager {
     /// Create a new protocol jobs manager.
     pub fn new(name: &'static str, channel: ChannelPtr) -> Arc<Self> {
-        Arc::new(Self {
-            name,
-            channel,
-            tasks: Mutex::new(Vec::new()),
-        })
+        Arc::new(Self { name, channel, tasks: Mutex::new(Vec::new()) })
     }
 
     /// Runs the task on an executor. Prepares to stop all tasks when the

src/net/protocols/protocol_ping.rs

@@ -1,14 +1,17 @@
 use log::*;
 use rand::Rng;
 use smol::Executor;
-use std::sync::Arc;
-use std::time::Instant;
+use std::{sync::Arc, time::Instant};
 
-use crate::error::{Error, Result};
-use crate::net::messages;
-use crate::net::protocols::{ProtocolJobsManager, ProtocolJobsManagerPtr};
-use crate::net::utility::sleep;
-use crate::net::{ChannelPtr, SettingsPtr};
+use crate::{
+    error::{Error, Result},
+    net::{
+        messages,
+        protocols::{ProtocolJobsManager, ProtocolJobsManagerPtr},
+        utility::sleep,
+        ChannelPtr, SettingsPtr,
+    },
+};
 
 /// Defines ping and pong messages.
 pub struct ProtocolPing {
@@ -33,14 +36,8 @@ impl ProtocolPing {
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) {
         debug!(target: "net", "ProtocolPing::start() [START]");
         self.jobsman.clone().start(executor.clone());
-        self.jobsman
-            .clone()
-            .spawn(self.clone().run_ping_pong(), executor.clone())
-            .await;
-        self.jobsman
-            .clone()
-            .spawn(self.reply_to_ping(), executor)
-            .await;
+        self.jobsman.clone().spawn(self.clone().run_ping_pong(), executor.clone()).await;
+        self.jobsman.clone().spawn(self.reply_to_ping(), executor).await;
         debug!(target: "net", "ProtocolPing::start() [END]");
     }
 
@@ -77,7 +74,7 @@ impl ProtocolPing {
             if pong_msg.nonce != nonce {
                 error!("Wrong nonce for ping reply. Disconnecting from channel.");
                 self.channel.stop().await;
-                return Err(Error::ChannelStopped);
+                return Err(Error::ChannelStopped)
             }
             let duration = start.elapsed().as_millis();
             debug!(target: "net", "Received Pong message {}ms from [{:?}]", duration, self.channel.address());

src/net/protocols/protocol_seed.rs

@@ -2,9 +2,10 @@ use log::*;
 use smol::Executor;
 use std::sync::Arc;
 
-use crate::error::Result;
-use crate::net::messages;
-use crate::net::{ChannelPtr, HostsPtr, SettingsPtr};
+use crate::{
+    error::Result,
+    net::{messages, ChannelPtr, HostsPtr, SettingsPtr},
+};
 
 /// Implements the seed protocol.
 pub struct ProtocolSeed {
@@ -16,11 +17,7 @@ pub struct ProtocolSeed {
 impl ProtocolSeed {
     /// Create a new seed protocol.
     pub fn new(channel: ChannelPtr, hosts: HostsPtr, settings: SettingsPtr) -> Arc<Self> {
-        Arc::new(Self {
-            channel,
-            hosts,
-            settings,
-        })
+        Arc::new(Self { channel, hosts, settings })
     }
 
     /// Starts the seed protocol. Creates a subscription to the address message,

src/net/protocols/protocol_version.rs

@@ -3,11 +3,12 @@ use log::*;
 use smol::Executor;
 use std::sync::Arc;
 
-use crate::error::{Error, Result};
-use crate::net::message_subscriber::MessageSubscription;
-use crate::net::messages;
-use crate::net::utility::sleep;
-use crate::net::{ChannelPtr, SettingsPtr};
+use crate::{
+    error::{Error, Result},
+    net::{
+        message_subscriber::MessageSubscription, messages, utility::sleep, ChannelPtr, SettingsPtr,
+    },
+};
 
 /// Implements the protocol version handshake sent out by nodes at the beginning
 /// of a connection.
@@ -37,12 +38,7 @@ impl ProtocolVersion {
             .await
             .expect("Missing verack dispatcher!");
 
-        Arc::new(Self {
-            channel,
-            version_sub,
-            verack_sub,
-            settings,
-        })
+        Arc::new(Self { channel, version_sub, verack_sub, settings })
     }
     /// Start version information exchange. Start the timer. Send version info
     /// and wait for version acknowledgement. Wait for version info and send

src/net/sessions/inbound_session.rs

@@ -1,15 +1,20 @@
 use async_executor::Executor;
 use log::*;
-use std::net::SocketAddr;
-use std::sync::{Arc, Weak};
+use std::{
+    net::SocketAddr,
+    sync::{Arc, Weak},
+};
 
 use crate::error::{Error, Result};
 //use crate::net::error::{Error, Result};
-use crate::net::protocols::{ProtocolAddress, ProtocolPing};
-use crate::net::sessions::Session;
-use crate::net::{Acceptor, AcceptorPtr};
-use crate::net::{ChannelPtr, P2p};
-use crate::system::{StoppableTask, StoppableTaskPtr};
+use crate::{
+    net::{
+        protocols::{ProtocolAddress, ProtocolPing},
+        sessions::Session,
+        Acceptor, AcceptorPtr, ChannelPtr, P2p,
+    },
+    system::{StoppableTask, StoppableTaskPtr},
+};
 
 /// Defines inbound connections session.
 pub struct InboundSession {
@@ -23,11 +28,7 @@ impl InboundSession {
     pub fn new(p2p: Weak<P2p>) -> Arc<Self> {
         let acceptor = Acceptor::new();
 
-        Arc::new(Self {
-            p2p,
-            acceptor,
-            accept_task: StoppableTask::new(),
-        })
+        Arc::new(Self { p2p, acceptor, accept_task: StoppableTask::new() })
     }
     /// Starts the inbound session. Begins by accepting connections and fails if
     /// the address is not configured. Then runs the channel subscription
@@ -35,12 +36,11 @@ impl InboundSession {
     pub fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
         match self.p2p().settings().inbound {
             Some(accept_addr) => {
-                self.clone()
-                    .start_accept_session(accept_addr, executor.clone())?;
+                self.clone().start_accept_session(accept_addr, executor.clone())?;
             }
             None => {
                 info!("Not configured for accepting incoming connections.");
-                return Ok(());
+                return Ok(())
             }
         }
 
@@ -81,9 +81,7 @@ impl InboundSession {
             let channel = channel_sub.receive().await?;
             // Spawn a detached task to process the channel
             // This will just perform the channel setup then exit.
-            executor
-                .spawn(self.clone().setup_channel(channel, executor.clone()))
-                .detach();
+            executor.spawn(self.clone().setup_channel(channel, executor.clone())).detach();
         }
     }
 
@@ -97,9 +95,7 @@ impl InboundSession {
     ) -> Result<()> {
         info!("Connected inbound [{}]", channel.address());
 
-        self.clone()
-            .register_channel(channel.clone(), executor.clone())
-            .await?;
+        self.clone().register_channel(channel.clone(), executor.clone()).await?;
 
         self.attach_protocols(channel, executor).await
     }

src/net/sessions/outbound_session.rs

@@ -1,14 +1,20 @@
 use async_executor::Executor;
 use async_std::sync::Mutex;
 use log::*;
-use std::net::SocketAddr;
-use std::sync::{Arc, Weak};
-
-use crate::error::{Error, Result};
-use crate::net::protocols::{ProtocolAddress, ProtocolPing};
-use crate::net::sessions::Session;
-use crate::net::{ChannelPtr, Connector, P2p};
-use crate::system::{StoppableTask, StoppableTaskPtr};
+use std::{
+    net::SocketAddr,
+    sync::{Arc, Weak},
+};
+
+use crate::{
+    error::{Error, Result},
+    net::{
+        protocols::{ProtocolAddress, ProtocolPing},
+        sessions::Session,
+        ChannelPtr, Connector, P2p,
+    },
+    system::{StoppableTask, StoppableTaskPtr},
+};
 
 /// Defines outbound connections session.
 pub struct OutboundSession {
@@ -19,10 +25,7 @@ pub struct OutboundSession {
 impl OutboundSession {
     /// Create a new outbound session.
     pub fn new(p2p: Weak<P2p>) -> Arc<Self> {
-        Arc::new(Self {
-            p2p,
-            connect_slots: Mutex::new(Vec::new()),
-        })
+        Arc::new(Self { p2p, connect_slots: Mutex::new(Vec::new()) })
     }
     /// Start the outbound session. Runs the channel connect loop.
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
@@ -81,18 +84,14 @@ impl OutboundSession {
 
                     let stop_sub = channel.subscribe_stop().await;
 
-                    self.clone()
-                        .register_channel(channel.clone(), executor.clone())
-                        .await?;
+                    self.clone().register_channel(channel.clone(), executor.clone()).await?;
 
                     // Channel is now connected but not yet setup
 
                     // Remove pending lock since register_channel will add the channel to p2p
                     self.p2p().remove_pending(&addr).await;
 
-                    self.clone()
-                        .attach_protocols(channel, executor.clone())
-                        .await?;
+                    self.clone().attach_protocols(channel, executor.clone()).await?;
 
                     // Wait for channel to close
                     stop_sub.receive().await;
@@ -118,28 +117,25 @@ impl OutboundSession {
             let addr = hosts.load_single().await;
 
             if addr.is_none() {
-                error!(
-                    "Hosts address pool is empty. Closing connect slot #{}",
-                    slot_number
-                );
-                return Err(Error::ServiceStopped);
+                error!("Hosts address pool is empty. Closing connect slot #{}", slot_number);
+                return Err(Error::ServiceStopped)
             }
             let addr = addr.unwrap();
 
             if Self::is_self_inbound(&addr, &inbound_addr) {
-                continue;
+                continue
             }
 
             if p2p.exists(&addr).await {
-                continue;
+                continue
             }
 
             // Obtain a lock on this address to prevent duplicate connections
             if !p2p.add_pending(addr).await {
-                continue;
+                continue
             }
 
-            return Ok(addr);
+            return Ok(addr)
         }
     }
 

src/net/sessions/seed_session.rs

@@ -1,15 +1,19 @@
 use async_executor::Executor;
 use futures::FutureExt;
 use log::*;
-use std::net::SocketAddr;
-use std::sync::{Arc, Weak};
+use std::{
+    net::SocketAddr,
+    sync::{Arc, Weak},
+};
 
 use crate::error::{Error, Result};
 //use crate::net::error::{Error, Result};
-use crate::net::protocols::{ProtocolPing, ProtocolSeed};
-use crate::net::sessions::Session;
-use crate::net::utility::sleep;
-use crate::net::{ChannelPtr, Connector, HostsPtr, P2p, SettingsPtr};
+use crate::net::{
+    protocols::{ProtocolPing, ProtocolSeed},
+    sessions::Session,
+    utility::sleep,
+    ChannelPtr, Connector, HostsPtr, P2p, SettingsPtr,
+};
 
 /// Defines seed connections session.
 pub struct SeedSession {
@@ -30,7 +34,7 @@ impl SeedSession {
 
         if settings.seeds.is_empty() {
             warn!("Skipping seed sync process since no seeds are configured.");
-            return Ok(());
+            return Ok(())
         }
 
         // if cached addresses then quit
@@ -64,7 +68,7 @@ impl SeedSession {
         // Seed process complete
         if self.p2p().hosts().is_empty().await {
             error!("Hosts pool still empty after seeding");
-            return Err(Error::OperationFailed);
+            return Err(Error::OperationFailed)
         }
 
         debug!(target: "net", "SeedSession::start() [END]");
@@ -93,21 +97,15 @@ impl SeedSession {
 
                 info!("Connected seed #{} [{}]", seed_index, seed);
 
-                self.clone()
-                    .register_channel(channel.clone(), executor.clone())
-                    .await?;
+                self.clone().register_channel(channel.clone(), executor.clone()).await?;
 
-                self.attach_protocols(channel, hosts, settings, executor)
-                    .await?;
+                self.attach_protocols(channel, hosts, settings, executor).await?;
 
                 debug!(target: "net", "SeedSession::start_seed(i={}) [END]", seed_index);
                 Ok(())
             }
             Err(err) => {
-                info!(
-                    "Failure contacting seed #{} [{}]: {}",
-                    seed_index, seed, err
-                );
+                info!("Failure contacting seed #{} [{}]: {}", seed_index, seed, err);
                 Err(err)
             }
         }

src/net/sessions/session.rs

@@ -3,10 +3,10 @@ use log::*;
 use smol::Executor;
 use std::sync::Arc;
 
-use crate::error::Result;
-use crate::net::p2p::P2pPtr;
-use crate::net::protocols::ProtocolVersion;
-use crate::net::ChannelPtr;
+use crate::{
+    error::Result,
+    net::{p2p::P2pPtr, protocols::ProtocolVersion, ChannelPtr},
+};
 
 /// Removes channel from the list of connected channels when a stop signal is
 /// received.
@@ -68,9 +68,7 @@ pub trait Session: Sync {
         self.p2p().store(channel.clone()).await;
 
         // Subscribe to stop, so can remove from p2p
-        executor
-            .spawn(remove_sub_on_stop(self.p2p(), channel))
-            .detach();
+        executor.spawn(remove_sub_on_stop(self.p2p(), channel)).detach();
 
         // Channel is ready for use
         Ok(())

src/net/settings.rs

@@ -1,5 +1,4 @@
-use std::net::SocketAddr;
-use std::sync::Arc;
+use std::{net::SocketAddr, sync::Arc};
 
 /// Atomic pointer to network settings.
 pub type SettingsPtr = Arc<Settings>;

src/rpc/jsonrpc.rs

@@ -1,6 +1,8 @@
-use std::net::{TcpStream, ToSocketAddrs};
-use std::os::unix::net::UnixStream;
-use std::str;
+use std::{
+    net::{TcpStream, ToSocketAddrs},
+    os::unix::net::UnixStream,
+    str,
+};
 
 use async_std::io::{ReadExt, WriteExt};
 use rand::Rng;
@@ -106,45 +108,24 @@ pub struct JsonNotification {
 pub fn request(m: Value, p: Value) -> JsonRequest {
     let mut rng = rand::thread_rng();
 
-    JsonRequest {
-        jsonrpc: json!("2.0"),
-        method: m,
-        params: p,
-        id: json!(rng.gen::<u32>()),
-    }
+    JsonRequest { jsonrpc: json!("2.0"), method: m, params: p, id: json!(rng.gen::<u32>()) }
 }
 
 pub fn response(r: Value, i: Value) -> JsonResponse {
-    JsonResponse {
-        jsonrpc: json!("2.0"),
-        result: r,
-        id: i,
-    }
+    JsonResponse { jsonrpc: json!("2.0"), result: r, id: i }
 }
 
 pub fn error(c: ErrorCode, m: Option<String>, i: Value) -> JsonError {
     let ev = JsonErrorVal {
         code: json!(c.code()),
-        message: if m.is_none() {
-            json!(c.description())
-        } else {
-            json!(Some(m))
-        },
+        message: if m.is_none() { json!(c.description()) } else { json!(Some(m)) },
     };
 
-    JsonError {
-        jsonrpc: json!("2.0"),
-        error: ev,
-        id: i,
-    }
+    JsonError { jsonrpc: json!("2.0"), error: ev, id: i }
 }
 
 pub fn notification(m: Value, p: Value) -> JsonNotification {
-    JsonNotification {
-        jsonrpc: json!("2.0"),
-        method: m,
-        params: p,
-    }
+    JsonNotification { jsonrpc: json!("2.0"), method: m, params: p }
 }
 
 pub async fn send_raw_request(url: &str, data: Value) -> Result<JsonResult, Error> {
@@ -154,9 +135,7 @@ pub async fn send_raw_request(url: &str, data: Value) -> Result<JsonResult, Erro
     match parsed_url.scheme() {
         "tcp" => use_tls = false,
         "tls" => use_tls = true,
-        _ => {
-            return Err(Error::UrlParseError)
-        }
+        _ => return Err(Error::UrlParseError),
     }
 
     // TODO: Error handling

src/rpc/rpcserver.rs

@@ -1,6 +1,8 @@
-use std::net::{SocketAddr, TcpListener, TcpStream};
-use std::path::PathBuf;
-use std::sync::Arc;
+use std::{
+    net::{SocketAddr, TcpListener, TcpStream},
+    path::PathBuf,
+    sync::Arc,
+};
 
 use async_executor::Executor;
 use async_native_tls::{Identity, TlsAcceptor};
@@ -11,8 +13,10 @@ use smol::{
     Async,
 };
 
-use crate::rpc::jsonrpc::{JsonRequest, JsonResult};
-use crate::Result;
+use crate::{
+    rpc::jsonrpc::{JsonRequest, JsonResult},
+    Result,
+};
 
 pub struct RpcServerConfig {
     pub socket_addr: SocketAddr,
@@ -41,13 +45,13 @@ async fn serve(
             let n = match stream.read(&mut buf).await {
                 Ok(n) if n == 0 => {
                     debug!(target: "RPC SERVER", "Closed connection");
-                    return Ok(());
+                    return Ok(())
                 }
                 Ok(n) => n,
                 Err(e) => {
                     debug!(target: "RPC SERVER", "Failed to read from socket: {:#?}", e);
                     debug!(target: "RPC SERVER", "Closed connection");
-                    return Ok(());
+                    return Ok(())
                 }
             };
 
@@ -56,7 +60,7 @@ async fn serve(
                 Err(e) => {
                     debug!(target: "RPC SERVER", "Received invalid JSON: {:#?}", e);
                     debug!(target: "RPC SERVER", "Closed connection");
-                    return Ok(());
+                    return Ok(())
                 }
             };
 
@@ -67,7 +71,7 @@ async fn serve(
             if let Err(e) = stream.write_all(j.as_bytes()).await {
                 debug!(target: "RPC SERVER", "Failed to write to socket: {:#?}", e);
                 debug!(target: "RPC SERVER", "Closed connection");
-                return Ok(());
+                return Ok(())
             }
         },
         Some(tls) => match tls.accept(stream).await {
@@ -75,13 +79,13 @@ async fn serve(
                 let n = match stream.read(&mut buf).await {
                     Ok(n) if n == 0 => {
                         debug!(target: "RPC SERVER", "Closed connection");
-                        return Ok(());
+                        return Ok(())
                     }
                     Ok(n) => n,
                     Err(e) => {
                         debug!(target: "RPC SERVER", "Failed to read from socket: {:#?}", e);
                         debug!(target: "RPC SERVER", "Closed connection");
-                        return Ok(());
+                        return Ok(())
                     }
                 };
 
@@ -90,7 +94,7 @@ async fn serve(
                     Err(e) => {
                         debug!(target: "RPC SERVER", "Received invalid JSON: {:#?}", e);
                         debug!(target: "RPC SERVER", "Closed connection");
-                        return Ok(());
+                        return Ok(())
                     }
                 };
 
@@ -100,7 +104,7 @@ async fn serve(
 
                 if let Err(e) = stream.write_all(j.as_bytes()).await {
                     debug!(target: "RPC SERVER", "Failed to write to socket: {:#?}", e);
-                    return Ok(());
+                    return Ok(())
                 }
             },
             Err(e) => {
@@ -157,11 +161,6 @@ pub async fn listen_and_serve(
         tls = None;
     }
 
-    let listener = listen(
-        Async::<TcpListener>::bind(cfg.socket_addr)?,
-        tls,
-        rh,
-        executor,
-    );
+    let listener = listen(Async::<TcpListener>::bind(cfg.socket_addr)?, tls, rh, executor);
     listener.await
 }

src/rpc/websockets.rs

@@ -1,13 +1,14 @@
-use std::net::{TcpStream, ToSocketAddrs};
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    net::{TcpStream, ToSocketAddrs},
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use async_native_tls::{TlsConnector, TlsStream};
 use async_tungstenite::WebSocketStream;
 use futures::sink::Sink;
 use smol::{prelude::*, Async};
-use tungstenite::handshake::client::Response;
-use tungstenite::Message;
+use tungstenite::{handshake::client::Response, Message};
 use url::Url;
 
 use crate::{Error, Result as DrkResult};
@@ -63,13 +64,8 @@ impl Stream for WsStream {
 /// Connects to a WebSocket address (optionally secured by TLS).
 pub async fn connect(addr: &str, tls: TlsConnector) -> DrkResult<(WsStream, Response)> {
     let url = Url::parse(addr)?;
-    let host = url
-        .host_str()
-        .ok_or(Error::UrlParseError)?
-        .to_string();
-    let port = url
-        .port_or_known_default()
-        .ok_or_else(|| Error::UrlParseError)?;
+    let host = url.host_str().ok_or(Error::UrlParseError)?.to_string();
+    let port = url.port_or_known_default().ok_or_else(|| Error::UrlParseError)?;
 
     let socket_addr = {
         let host = host.clone();

src/serial.rs

@@ -1,10 +1,15 @@
-use std::borrow::Cow;
-use std::io::{Cursor, Read, Write};
-use std::net::{IpAddr, SocketAddr};
-use std::{io, mem};
-
-use crate::endian;
-use crate::error::{Error, Result};
+use std::{
+    borrow::Cow,
+    io,
+    io::{Cursor, Read, Write},
+    mem,
+    net::{IpAddr, SocketAddr},
+};
+
+use crate::{
+    endian,
+    error::{Error, Result},
+};
 
 /// Encode an object into a vector
 pub fn serialize<T: Encodable + ?Sized>(data: &T) -> Vec<u8> {
@@ -28,9 +33,7 @@ pub fn deserialize<T: Decodable>(data: &[u8]) -> Result<T> {
     if consumed == data.len() {
         Ok(rv)
     } else {
-        Err(Error::ParseFailed(
-            "data not consumed entirely when explicitly deserializing",
-        ))
+        Err(Error::ParseFailed("data not consumed entirely when explicitly deserializing"))
     }
 }
 
@@ -102,8 +105,7 @@ macro_rules! encoder_fn {
     ($name:ident, $val_type:ty, $writefn:ident) => {
         #[inline]
         fn $name(&mut self, v: $val_type) -> Result<()> {
-            self.write_all(&endian::$writefn(v))
-                .map_err(|e| Error::Io(e.kind()))
+            self.write_all(&endian::$writefn(v)).map_err(|e| Error::Io(e.kind()))
         }
     };
 }
@@ -114,8 +116,7 @@ macro_rules! decoder_fn {
         fn $name(&mut self) -> Result<$val_type> {
             assert_eq!(::std::mem::size_of::<$val_type>(), $byte_len); // size_of isn't a constfn in 1.22
             let mut val = [0; $byte_len];
-            self.read_exact(&mut val[..])
-                .map_err(|e| Error::Io(e.kind()))?;
+            self.read_exact(&mut val[..]).map_err(|e| Error::Io(e.kind()))?;
             Ok(endian::$readfn(&val))
         }
     };
@@ -569,11 +570,9 @@ tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
 
 #[cfg(test)]
 mod tests {
-    use super::{deserialize, serialize, Error, Result, VarInt};
-    use super::{deserialize_partial, Encodable};
+    use super::{deserialize, deserialize_partial, serialize, Encodable, Error, Result, VarInt};
     use crate::endian::{u16_to_array_le, u32_to_array_le, u64_to_array_le};
-    use std::io;
-    use std::mem::discriminant;
+    use std::{io, mem::discriminant};
 
     #[test]
     fn serialize_int_test() {
@@ -610,27 +609,12 @@ mod tests {
         assert_eq!(serialize(&256u64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
         assert_eq!(serialize(&5000u64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
         assert_eq!(serialize(&500000u64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
-        assert_eq!(
-            serialize(&723401728380766730u64),
-            vec![10u8, 10, 10, 10, 10, 10, 10, 10]
-        );
+        assert_eq!(serialize(&723401728380766730u64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
         // i64
-        assert_eq!(
-            serialize(&-1i64),
-            vec![255u8, 255, 255, 255, 255, 255, 255, 255]
-        );
-        assert_eq!(
-            serialize(&-256i64),
-            vec![0u8, 255, 255, 255, 255, 255, 255, 255]
-        );
-        assert_eq!(
-            serialize(&-5000i64),
-            vec![120u8, 236, 255, 255, 255, 255, 255, 255]
-        );
-        assert_eq!(
-            serialize(&-500000i64),
-            vec![224u8, 94, 248, 255, 255, 255, 255, 255]
-        );
+        assert_eq!(serialize(&-1i64), vec![255u8, 255, 255, 255, 255, 255, 255, 255]);
+        assert_eq!(serialize(&-256i64), vec![0u8, 255, 255, 255, 255, 255, 255, 255]);
+        assert_eq!(serialize(&-5000i64), vec![120u8, 236, 255, 255, 255, 255, 255, 255]);
+        assert_eq!(serialize(&-500000i64), vec![224u8, 94, 248, 255, 255, 255, 255, 255]);
         assert_eq!(
             serialize(&-723401728380766730i64),
             vec![246u8, 245, 245, 245, 245, 245, 245, 245]
@@ -639,10 +623,7 @@ mod tests {
         assert_eq!(serialize(&256i64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
         assert_eq!(serialize(&5000i64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
         assert_eq!(serialize(&500000i64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
-        assert_eq!(
-            serialize(&723401728380766730i64),
-            vec![10u8, 10, 10, 10, 10, 10, 10, 10]
-        );
+        assert_eq!(serialize(&723401728380766730i64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
     }
 
     #[test]
@@ -651,10 +632,7 @@ mod tests {
         assert_eq!(serialize(&VarInt(0xFC)), vec![0xFCu8]);
         assert_eq!(serialize(&VarInt(0xFD)), vec![0xFDu8, 0xFD, 0]);
         assert_eq!(serialize(&VarInt(0xFFF)), vec![0xFDu8, 0xFF, 0xF]);
-        assert_eq!(
-            serialize(&VarInt(0xF0F0F0F)),
-            vec![0xFEu8, 0xF, 0xF, 0xF, 0xF]
-        );
+        assert_eq!(serialize(&VarInt(0xF0F0F0F)), vec![0xFEu8, 0xF, 0xF, 0xF, 0xF]);
         assert_eq!(
             serialize(&VarInt(0xF0F0F0F0F0E0)),
             vec![0xFFu8, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0, 0]
@@ -663,14 +641,8 @@ mod tests {
             test_varint_encode(0xFF, &u64_to_array_le(0x100000000)).unwrap(),
             VarInt(0x100000000)
         );
-        assert_eq!(
-            test_varint_encode(0xFE, &u64_to_array_le(0x10000)).unwrap(),
-            VarInt(0x10000)
-        );
-        assert_eq!(
-            test_varint_encode(0xFD, &u64_to_array_le(0xFD)).unwrap(),
-            VarInt(0xFD)
-        );
+        assert_eq!(test_varint_encode(0xFE, &u64_to_array_le(0x10000)).unwrap(), VarInt(0x10000));
+        assert_eq!(test_varint_encode(0xFD, &u64_to_array_le(0xFD)).unwrap(), VarInt(0xFD));
 
         // Test that length calc is working correctly
         test_varint_len(VarInt(0), 1);
@@ -768,10 +740,7 @@ mod tests {
 
     #[test]
     fn serialize_strbuf_test() {
-        assert_eq!(
-            serialize(&"Andrew".to_string()),
-            vec![6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]
-        );
+        assert_eq!(serialize(&"Andrew".to_string()), vec![6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]);
     }
 
     #[test]
@@ -795,26 +764,17 @@ mod tests {
 
         // u32
         assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABu32));
-        assert_eq!(
-            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD]).ok(),
-            Some(0xCDAB0DA0u32)
-        );
+        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD]).ok(), Some(0xCDAB0DA0u32));
         let failure32: Result<u32> = deserialize(&[1u8, 2, 3]);
         assert!(failure32.is_err());
         // TODO: test negative numbers
         assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABi32));
-        assert_eq!(
-            deserialize(&[0xA0u8, 0x0D, 0xAB, 0x2D]).ok(),
-            Some(0x2DAB0DA0i32)
-        );
+        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0x2D]).ok(), Some(0x2DAB0DA0i32));
         let failurei32: Result<i32> = deserialize(&[1u8, 2, 3]);
         assert!(failurei32.is_err());
 
         // u64
-        assert_eq!(
-            deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(),
-            Some(0xCDABu64)
-        );
+        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABu64));
         assert_eq!(
             deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
             Some(0x99000099CDAB0DA0u64)
@@ -822,10 +782,7 @@ mod tests {
         let failure64: Result<u64> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
         assert!(failure64.is_err());
         // TODO: test negative numbers
-        assert_eq!(
-            deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(),
-            Some(0xCDABi64)
-        );
+        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABi64));
         assert_eq!(
             deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
             Some(-0x66ffff663254f260i64)

src/service/bridge.rs

@@ -3,13 +3,10 @@ use std::collections::HashMap;
 use async_executor::Executor;
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
-use futures::stream::FuturesUnordered;
-use futures::stream::StreamExt;
+use futures::stream::{FuturesUnordered, StreamExt};
 use log::*;
 
-use crate::util::NetworkName;
-use crate::wallet::cashierdb::TokenKey;
-use crate::{types::*, Error, Result};
+use crate::{types::*, util::NetworkName, wallet::cashierdb::TokenKey, Error, Result};
 
 pub struct BridgeRequests {
     pub network: NetworkName,
@@ -68,10 +65,7 @@ pub struct Bridge {
 
 impl Bridge {
     pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            clients: Mutex::new(HashMap::new()),
-            notifiers: FuturesUnordered::new(),
-        })
+        Arc::new(Self { clients: Mutex::new(HashMap::new()), notifiers: FuturesUnordered::new() })
     }
 
     pub async fn add_clients(
@@ -149,7 +143,7 @@ impl Bridge {
                 payload: BridgeResponsePayload::Empty,
             };
             rep.send(res).await?;
-            return Ok(());
+            return Ok(())
         }
 
         let mut mint_address: Option<String> = mint.clone();

src/service/btc.rs

@@ -1,10 +1,12 @@
-use std::cmp::max;
-use std::collections::BTreeMap;
-use std::convert::{From, TryFrom, TryInto};
-use std::fmt;
-use std::ops::Add;
-use std::str::FromStr;
-use std::time::{Duration, Instant};
+use std::{
+    cmp::max,
+    collections::BTreeMap,
+    convert::{From, TryFrom, TryInto},
+    fmt,
+    ops::Add,
+    str::FromStr,
+    time::{Duration, Instant},
+};
 
 use anyhow::Context;
 use async_executor::Executor;
@@ -14,28 +16,35 @@ use async_trait::async_trait;
 use bdk::electrum_client::{
     Client as ElectrumClient, ElectrumApi, GetBalanceRes, GetHistoryRes, HeaderNotification,
 };
-use bitcoin::blockdata::{
-    script::{Builder, Script},
-    transaction::{OutPoint, SigHashType, Transaction, TxIn, TxOut},
+use bitcoin::{
+    blockdata::{
+        script::{Builder, Script},
+        transaction::{OutPoint, SigHashType, Transaction, TxIn, TxOut},
+    },
+    consensus::encode::serialize_hex,
+    hash_types::PubkeyHash as BtcPubKeyHash,
+    network::constants::Network,
+    util::{
+        address::Address,
+        ecdsa::{PrivateKey as BtcPrivKey, PublicKey as BtcPubKey},
+        psbt::serialize::Serialize,
+    },
 };
-use bitcoin::consensus::encode::serialize_hex;
-use bitcoin::hash_types::PubkeyHash as BtcPubKeyHash;
-use bitcoin::network::constants::Network;
-use bitcoin::util::address::Address;
-use bitcoin::util::ecdsa::{PrivateKey as BtcPrivKey, PublicKey as BtcPubKey};
-use bitcoin::util::psbt::serialize::Serialize;
 use log::*;
 use secp256k1::{
     constants::{PUBLIC_KEY_SIZE, SECRET_KEY_SIZE},
     key::{PublicKey, SecretKey},
-    {rand::rngs::OsRng, Secp256k1},
-    {All, Message as BtcMessage /*Secp256k1,*/},
+    rand::rngs::OsRng,
+    All, Message as BtcMessage, Secp256k1,
 };
 
 use super::bridge::{NetworkClient, TokenNotification, TokenSubscribtion};
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::util::{generate_id, NetworkName};
-use crate::{types::*, Error, Result};
+use crate::{
+    serial::{deserialize, serialize, Decodable, Encodable},
+    types::*,
+    util::{generate_id, NetworkName},
+    Error, Result,
+};
 
 // Swap out these types for any future non bitcoin-rs types
 pub type PubAddress = Address;
@@ -56,12 +65,7 @@ impl From<BlockHeight> for u32 {
 impl TryFrom<HeaderNotification> for BlockHeight {
     type Error = BtcFailed;
     fn try_from(value: HeaderNotification) -> BtcResult<Self> {
-        Ok(Self(
-            value
-                .height
-                .try_into()
-                .context("Failed to fit usize into u32")?,
-        ))
+        Ok(Self(value.height.try_into().context("Failed to fit usize into u32")?))
     }
 }
 
@@ -91,11 +95,7 @@ impl Keypair {
         let mut rng = OsRng::new().expect("OsRng");
 
         let (secret, public) = secp.generate_keypair(&mut rng);
-        Self {
-            secret,
-            public,
-            context: secp,
-        }
+        Self { secret, public, context: secp }
     }
 
     pub fn to_bytes(&self) -> [u8; KEYPAIR_LENGTH] {
@@ -109,18 +109,14 @@ impl Keypair {
 
     pub fn from_bytes(bytes: &[u8]) -> BtcResult<Keypair> {
         if bytes.len() != KEYPAIR_LENGTH {
-            return Err(BtcFailed::KeypairError("Not right size".to_string()));
+            return Err(BtcFailed::KeypairError("Not right size".to_string()))
         }
         let secp = Secp256k1::new();
 
         let secret = SecretKey::from_slice(&bytes[..SECRET_KEY_SIZE])?;
         let public = PublicKey::from_slice(&bytes[SECRET_KEY_SIZE..])?;
 
-        Ok(Keypair {
-            secret,
-            public,
-            context: secp,
-        })
+        Ok(Keypair { secret, public, context: secp })
     }
     fn secret(&self) -> SecretKey {
         self.secret
@@ -226,9 +222,7 @@ pub struct Client {
 }
 impl Client {
     pub fn new(electrum_url: &str) -> BtcResult<Self> {
-        let config = bdk::electrum_client::ConfigBuilder::default()
-            .retry(5)
-            .build();
+        let config = bdk::electrum_client::ConfigBuilder::default().retry(5).build();
         let _client = ElectrumClient::from_config(electrum_url, config)?;
 
         let electrum = ElectrumClient::new(electrum_url)
@@ -252,7 +246,7 @@ impl Client {
     fn update_state(&mut self) -> Result<()> {
         let now = Instant::now();
         if now < self.last_sync + self.sync_interval {
-            return Ok(());
+            return Ok(())
         }
 
         self.last_sync = now;
@@ -277,9 +271,7 @@ impl Client {
     }
 
     fn update_script_histories(&mut self) -> BtcResult<()> {
-        let histories = self
-            .electrum
-            .batch_script_get_history(self.script_history.keys())?;
+        let histories = self.electrum.batch_script_get_history(self.script_history.keys())?;
 
         if histories.len() != self.script_history.len() {
             debug!(
@@ -311,12 +303,10 @@ impl Client {
                 if last.height <= 0 {
                     Ok(ScriptStatus::InMempool)
                 } else {
-                    Ok(ScriptStatus::Confirmed(
-                        Confirmed::from_inclusion_and_latest_block(
-                            u32::try_from(last.height).map_err(|_| crate::Error::TryFromError)?,
-                            u32::from(self.latest_block_height),
-                        ),
-                    ))
+                    Ok(ScriptStatus::Confirmed(Confirmed::from_inclusion_and_latest_block(
+                        u32::try_from(last.height).map_err(|_| crate::Error::TryFromError)?,
+                        u32::from(self.latest_block_height),
+                    )))
                 }
             }
         }
@@ -325,10 +315,8 @@ impl Client {
 pub struct BtcClient {
     main_account: Account,
     client: Arc<Mutex<Client>>,
-    notify_channel: (
-        async_channel::Sender<TokenNotification>,
-        async_channel::Receiver<TokenNotification>,
-    ),
+    notify_channel:
+        (async_channel::Sender<TokenNotification>, async_channel::Receiver<TokenNotification>),
     network: Network,
 }
 impl BtcClient {
@@ -365,7 +353,7 @@ impl BtcClient {
         let script = keys_clone.script_pubkey;
 
         if client.lock().await.subscriptions.contains(&script) {
-            return Ok(());
+            return Ok(())
         } else {
             client.lock().await.subscriptions.push(script.clone());
         }
@@ -380,9 +368,7 @@ impl BtcClient {
                 Ok(new_status) => new_status,
                 Err(error) => {
                     debug!(target: "BTC BRIDGE", "Failed to get status of script: {:#}", error);
-                    return Err(BtcFailed::BtcError(
-                        "Failed to get status of script".to_string(),
-                    ));
+                    return Err(BtcFailed::BtcError("Failed to get status of script".to_string()))
                 }
             };
 
@@ -391,24 +377,19 @@ impl BtcClient {
             match new_status {
                 ScriptStatus::Unseen => continue,
                 ScriptStatus::InMempool => {
-                    break;
+                    break
                 }
                 ScriptStatus::Confirmed(inner) => {
                     //Only break when confirmations happen
                     let confirmations = inner.confirmations();
                     if confirmations > 1 {
-                        break;
+                        break
                     }
                 }
             }
         }
 
-        let index = &mut client
-            .lock()
-            .await
-            .subscriptions
-            .iter()
-            .position(|p| p == &script);
+        let index = &mut client.lock().await.subscriptions.iter().position(|p| p == &script);
 
         if let Some(ind) = index {
             debug!(target: "BTC BRIDGE", "Removing subscription from list");
@@ -420,9 +401,7 @@ impl BtcClient {
         let send_notification = self.notify_channel.0.clone();
         //FIXME: dev
         if cur_balance.unconfirmed < prev_balance.unconfirmed {
-            return Err(BtcFailed::Notification(
-                "New balance is less than previous balance".into(),
-            ));
+            return Err(BtcFailed::Notification("New balance is less than previous balance".into()))
         }
         //Just check unconfirmed for now
         let amnt = cur_balance.confirmed - prev_balance.confirmed;
@@ -461,10 +440,7 @@ impl BtcClient {
         let mut amounts: u64 = 0;
         for tx in utxo {
             let tx_in = TxIn {
-                previous_output: OutPoint {
-                    txid: tx.tx_hash,
-                    vout: tx.tx_pos as u32,
-                },
+                previous_output: OutPoint { txid: tx.tx_hash, vout: tx.tx_pos as u32 },
                 sequence: 0xffffffff,
                 witness: Vec::new(),
                 script_sig: Script::new(),
@@ -477,10 +453,7 @@ impl BtcClient {
         //TODO: Change to PSBT
         let transaction = Transaction {
             input: inputs.clone(),
-            output: vec![TxOut {
-                script_pubkey: main_script_pubkey.clone(),
-                value: amounts,
-            }],
+            output: vec![TxOut { script_pubkey: main_script_pubkey.clone(), value: amounts }],
             lock_time: 0,
             version: 2,
         };
@@ -550,10 +523,7 @@ impl NetworkClient for BtcClient {
             })
             .detach();
 
-        Ok(TokenSubscribtion {
-            private_key,
-            public_key,
-        })
+        Ok(TokenSubscribtion { private_key, public_key })
     }
 
     async fn subscribe_with_keypair(
@@ -654,10 +624,8 @@ pub fn sign_transaction(
         let mut with_hashtype = byte_signature.to_vec();
         with_hashtype.push(SigHashType::All as u8);
 
-        let redeem_script = Builder::new()
-            .push_slice(with_hashtype.as_slice())
-            .push_key(&pub_key)
-            .into_script();
+        let redeem_script =
+            Builder::new().push_slice(with_hashtype.as_slice()).push_key(&pub_key).into_script();
         signed_inputs.push(TxIn {
             previous_output: unsigned_input.previous_output,
             script_sig: redeem_script,
@@ -833,9 +801,7 @@ impl Decodable for Keypair {
     fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
         let key: Vec<u8> = Decodable::decode(&mut d)?;
         let key = Keypair::from_bytes(key.as_slice()).map_err(|_| {
-            crate::Error::from(BtcFailed::DecodeAndEncodeError(
-                "load keypair from slice".into(),
-            ))
+            crate::Error::from(BtcFailed::DecodeAndEncodeError("load keypair from slice".into()))
         })?;
         Ok(key)
     }

src/service/eth.rs

@@ -1,5 +1,4 @@
-use std::convert::TryInto;
-use std::time::Duration;
+use std::{convert::TryInto, time::Duration};
 
 use async_executor::Executor;
 use async_std::sync::{Arc, Mutex};
@@ -14,8 +13,7 @@ use serde_json::{json, Value};
 
 use super::bridge::{NetworkClient, TokenNotification, TokenSubscribtion};
 use crate::{
-    rpc::jsonrpc,
-    rpc::jsonrpc::JsonResult,
+    rpc::{jsonrpc, jsonrpc::JsonResult},
     serial::{deserialize, serialize},
     types::*,
     util::{generate_id, parse::truncate, NetworkName},
@@ -86,12 +84,7 @@ pub fn erc20_transfer_data(recipient: &str, amount: BigUint) -> String {
     let amnt_hex = hex::encode(amnt_bytes);
     let amnt_hex_padded = format!("{:0>64}", amnt_hex);
 
-    format!(
-        "0x{}{}{}",
-        hex::encode(*ERC20_TRANSFER_METHOD),
-        rec_padded,
-        amnt_hex_padded
-    )
+    format!("0x{}{}{}", hex::encode(*ERC20_TRANSFER_METHOD), rec_padded, amnt_hex_padded)
 }
 
 pub fn erc20_balanceof_data(account: &str) -> String {
@@ -179,10 +172,8 @@ pub struct EthClient {
     passphrase: String,
     socket_path: String,
     subscriptions: Arc<Mutex<Vec<String>>>,
-    notify_channel: (
-        async_channel::Sender<TokenNotification>,
-        async_channel::Receiver<TokenNotification>,
-    ),
+    notify_channel:
+        (async_channel::Sender<TokenNotification>, async_channel::Receiver<TokenNotification>),
 }
 
 impl EthClient {
@@ -193,27 +184,13 @@ impl EthClient {
     ) -> Arc<Self> {
         let notify_channel = async_channel::unbounded();
         let subscriptions = Arc::new(Mutex::new(Vec::new()));
-        Arc::new(Self {
-            main_keypair,
-            passphrase,
-            socket_path,
-            subscriptions,
-            notify_channel,
-        })
-        }
+        Arc::new(Self { main_keypair, passphrase, socket_path, subscriptions, notify_channel })
+    }
 
     async fn send_eth_to_main_wallet(&self, acc: &str, amount: BigUint) -> Result<()> {
         debug!(target: "ETH BRIDGE", "Send eth to main wallet");
 
-        let tx = EthTx::new(
-            acc,
-            &self.main_keypair.1,
-            None,
-            None,
-            Some(amount),
-            None,
-            None,
-        );
+        let tx = EthTx::new(acc, &self.main_keypair.1, None, None, Some(amount), None, None);
 
         self.send_transaction(&tx, &self.passphrase).await?;
 
@@ -225,9 +202,8 @@ impl EthClient {
         addr: String,
         drk_pub_key: DrkPublicKey,
     ) -> Result<()> {
-
         if self.subscriptions.lock().await.contains(&addr) {
-            return Ok(());
+            return Ok(())
         }
 
         let decimals = 18;
@@ -243,7 +219,7 @@ impl EthClient {
             if sub_iter > 60 * 10 {
                 // 10 minutes
                 self.unsubscribe(&addr).await;
-                return Err(crate::Error::ClientFailed("Deposit for expired".into()));
+                return Err(crate::Error::ClientFailed("Deposit for expired".into()))
             }
 
             sub_iter += iter_interval;
@@ -252,7 +228,7 @@ impl EthClient {
             current_balance = self.get_current_balance(&addr, None).await?;
 
             if current_balance != prev_balance {
-                break;
+                break
             }
         }
 
@@ -263,7 +239,7 @@ impl EthClient {
         if current_balance < prev_balance {
             return Err(crate::Error::ClientFailed(
                 "New balance is less than previous balance".into(),
-            ));
+            ))
         }
 
         let received_balance = current_balance - prev_balance;
@@ -282,11 +258,10 @@ impl EthClient {
             .await
             .map_err(Error::from)?;
 
-        self.send_eth_to_main_wallet(&addr, received_balance)
-            .await?;
+        self.send_eth_to_main_wallet(&addr, received_balance).await?;
 
         debug!(target: "ETH BRIDGE", "Received {} eth", received_balance_ui );
-        
+
         Ok(())
     }
 
@@ -350,15 +325,7 @@ impl EthClient {
     }
 
     pub async fn get_erc20_balance(&self, acc: &str, mint: &str) -> EthResult<Value> {
-        let tx = EthTx::new(
-            acc,
-            mint,
-            None,
-            None,
-            None,
-            Some(erc20_balanceof_data(acc)),
-            None,
-        );
+        let tx = EthTx::new(acc, mint, None, None, None, Some(erc20_balanceof_data(acc)), None);
         let req = jsonrpc::request(json!("eth_call"), json!([tx, "latest"]));
         Ok(self.request(req).await?)
     }
@@ -374,7 +341,6 @@ impl EthClient {
         let balance = BigUint::parse_bytes(hexbalance.as_bytes(), 16).unwrap();
 
         Ok(balance)
-
     }
 
     pub async fn send_transaction(&self, tx: &EthTx, passphrase: &str) -> EthResult<Value> {
@@ -398,15 +364,13 @@ impl NetworkClient for EthClient {
         let address: String = if addr.as_str().is_some() {
             addr.as_str().unwrap().to_string()
         } else {
-            return Err(Error::from(EthFailed::ImportPrivateError));
+            return Err(Error::from(EthFailed::ImportPrivateError))
         };
 
         let addr_cloned = address.clone();
         executor
             .spawn(async move {
-                let result = self
-                    .handle_subscribe_request(addr_cloned, drk_pub_key)
-                    .await;
+                let result = self.handle_subscribe_request(addr_cloned, drk_pub_key).await;
                 if let Err(e) = result {
                     error!(target: "ETH BRIDGE SUBSCRIPTION","{}", e.to_string());
                 }
@@ -415,10 +379,7 @@ impl NetworkClient for EthClient {
 
         let private_key: Vec<u8> = serialize(&private_key);
 
-        Ok(TokenSubscribtion {
-            private_key,
-            public_key: address,
-        })
+        Ok(TokenSubscribtion { private_key, public_key: address })
     }
 
     async fn subscribe_with_keypair(

src/service/gateway.rs

@@ -1,15 +1,19 @@
-use std::convert::From;
-use std::net::SocketAddr;
-use std::net::ToSocketAddrs;
-use std::sync::Arc;
+use std::{
+    convert::From,
+    net::{SocketAddr, ToSocketAddrs},
+    sync::Arc,
+};
 
 use async_executor::Executor;
 use log::debug;
 use url::Url;
 
 use super::reqrep::{PeerId, Publisher, RepProtocol, Reply, ReqProtocol, Request, Subscriber};
-use crate::blockchain::{rocks::columns, RocksColumn, Slab, SlabStore};
-use crate::{serial::deserialize, serial::serialize, Error, Result};
+use crate::{
+    blockchain::{rocks::columns, RocksColumn, Slab, SlabStore},
+    serial::{deserialize, serialize},
+    Error, Result,
+};
 
 pub type GatewaySlabsSubscriber = async_channel::Receiver<Slab>;
 
@@ -41,11 +45,7 @@ impl GatewayService {
     ) -> Result<Arc<GatewayService>> {
         let slabstore = SlabStore::new(rocks)?;
 
-        Ok(Arc::new(GatewayService {
-            slabstore,
-            addr,
-            pub_addr,
-        }))
+        Ok(Arc::new(GatewayService { slabstore, addr, pub_addr }))
     }
 
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
@@ -163,7 +163,7 @@ impl GatewayService {
                 // GETLASTINDEX
             }
             _ => {
-                return Err(Error::ServicesError("received wrong command"));
+                return Err(Error::ServicesError("received wrong command"))
             }
         }
         Ok(())
@@ -192,10 +192,7 @@ impl GatewayClient {
 
         let (gateway_slabs_sub_s, gateway_slabs_sub_rv) = async_channel::unbounded::<Slab>();
 
-        let sub_addr_sock = (
-            sub_addr.host().unwrap().to_string(),
-            sub_addr.port().unwrap(),
-        )
+        let sub_addr_sock = (sub_addr.host().unwrap().to_string(), sub_addr.port().unwrap())
             .to_socket_addrs()?
             .next()
             .ok_or(Error::UrlParseError)?;
@@ -229,13 +226,13 @@ impl GatewayClient {
                 "Local slabstore has higher index than gateway's slabstore.
                  Run \" darkfid -r \" to refresh the database."
                     .into(),
-            ));
+            ))
         }
 
         if last_index > 0 {
             for index in (local_last_index + 1)..(last_index + 1) {
                 if self.get_slab(index).await?.is_none() {
-                    break;
+                    break
                 }
             }
         }
@@ -250,18 +247,14 @@ impl GatewayClient {
         let handle_error = Arc::new(handle_error);
         let rep = self
             .protocol
-            .request(
-                GatewayCommand::GetSlab as u8,
-                serialize(&index),
-                handle_error,
-            )
+            .request(GatewayCommand::GetSlab as u8, serialize(&index), handle_error)
             .await?;
 
         if let Some(slab) = rep {
             let slab: Slab = deserialize(&slab)?;
             self.gateway_slabs_sub_s.send(slab.clone()).await?;
             self.slabstore.put(slab.clone())?;
-            return Ok(Some(slab));
+            return Ok(Some(slab))
         }
 
         Ok(None)
@@ -283,7 +276,7 @@ impl GatewayClient {
                 .await?;
 
             if rep.is_some() {
-                break;
+                break
             }
         }
         Ok(())
@@ -294,12 +287,10 @@ impl GatewayClient {
 
         let handle_error = Arc::new(handle_error);
 
-        let rep = self
-            .protocol
-            .request(GatewayCommand::GetLastIndex as u8, vec![], handle_error)
-            .await?;
+        let rep =
+            self.protocol.request(GatewayCommand::GetLastIndex as u8, vec![], handle_error).await?;
         if let Some(index) = rep {
-            return deserialize(&index);
+            return deserialize(&index)
         }
         Ok(0)
     }

src/service/reqrep.rs

@@ -1,6 +1,4 @@
-use std::io;
-use std::net::SocketAddr;
-use std::sync::Arc;
+use std::{io, net::SocketAddr, sync::Arc};
 
 use async_executor::Executor;
 use async_std::prelude::*;
@@ -12,15 +10,15 @@ use signal_hook::consts::SIGINT;
 use signal_hook_async_std::Signals;
 use zeromq::*;
 
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::Result;
+use crate::{
+    serial::{deserialize, serialize, Decodable, Encodable},
+    Result,
+};
 
 pub type PeerId = Vec<u8>;
 
-pub type Channels = (
-    async_channel::Sender<(PeerId, Reply)>,
-    async_channel::Receiver<(PeerId, Request)>,
-);
+pub type Channels =
+    (async_channel::Sender<(PeerId, Reply)>, async_channel::Receiver<(PeerId, Request)>);
 
 enum NetEvent {
     Receive(zeromq::ZmqMessage),
@@ -49,22 +47,13 @@ impl RepProtocol {
 
         let channels = (send_channel, recv_channel);
 
-        RepProtocol {
-            addr,
-            socket,
-            recv_queue,
-            send_queue,
-            channels,
-            service_name,
-        }
+        RepProtocol { addr, socket, recv_queue, send_queue, channels, service_name }
     }
 
     pub async fn start(
         &mut self,
-    ) -> Result<(
-        async_channel::Sender<(PeerId, Reply)>,
-        async_channel::Receiver<(PeerId, Request)>,
-    )> {
+    ) -> Result<(async_channel::Sender<(PeerId, Reply)>, async_channel::Receiver<(PeerId, Request)>)>
+    {
         let addr = addr_to_string(self.addr);
         self.socket.bind(addr.as_str()).await?;
         debug!(target: "REP PROTOCOL API", "{} SERVICE: Bound To {}", self.service_name, addr);
@@ -85,7 +74,7 @@ impl RepProtocol {
                 match signal {
                     SIGINT => {
                         stop_s.send(()).await?;
-                        break;
+                        break
                     }
                     _ => unreachable!(),
                 }
@@ -143,11 +132,7 @@ pub struct ReqProtocol {
 impl ReqProtocol {
     pub fn new(addr: SocketAddr, service_name: String) -> ReqProtocol {
         let socket = zeromq::DealerSocket::new();
-        ReqProtocol {
-            addr,
-            socket,
-            service_name,
-        }
+        ReqProtocol { addr, socket, service_name }
     }
 
     pub async fn start(&mut self) -> Result<()> {
@@ -190,19 +175,17 @@ impl ReqProtocol {
 
             if reply.has_error() {
                 handle_error(reply.get_error());
-                return Ok(None);
+                return Ok(None)
             }
 
             if reply.get_id() != request.get_id() {
                 warn!("Reply id is not equal to Request id");
-                return Ok(None);
+                return Ok(None)
             }
 
             Ok(Some(reply.get_payload()))
         } else {
-            Err(crate::Error::ZmqError(
-                "Couldn't parse ZmqMessage".to_string(),
-            ))
+            Err(crate::Error::ZmqError("Couldn't parse ZmqMessage".to_string()))
         }
     }
 }
@@ -216,11 +199,7 @@ pub struct Publisher {
 impl Publisher {
     pub fn new(addr: SocketAddr, service_name: String) -> Publisher {
         let socket = zeromq::PubSocket::new();
-        Publisher {
-            addr,
-            socket,
-            service_name,
-        }
+        Publisher { addr, socket, service_name }
     }
 
     pub async fn start(&mut self, recv_queue: async_channel::Receiver<Vec<u8>>) -> Result<()> {
@@ -253,11 +232,7 @@ pub struct Subscriber {
 impl Subscriber {
     pub fn new(addr: SocketAddr, service_name: String) -> Subscriber {
         let socket = zeromq::SubSocket::new();
-        Subscriber {
-            addr,
-            socket,
-            service_name,
-        }
+        Subscriber { addr, socket, service_name }
     }
 
     pub async fn start(&mut self) -> Result<()> {
@@ -281,9 +256,7 @@ impl Subscriber {
                 let data: T = deserialize(&data)?;
                 Ok(data)
             }
-            None => Err(crate::Error::ZmqError(
-                "Couldn't parse ZmqMessage".to_string(),
-            )),
+            None => Err(crate::Error::ZmqError("Couldn't parse ZmqMessage".to_string())),
         }
     }
 }
@@ -298,11 +271,7 @@ pub struct Request {
 impl Request {
     pub fn new(command: u8, payload: Vec<u8>) -> Request {
         let id = Self::gen_id();
-        Request {
-            command,
-            id,
-            payload,
-        }
+        Request { command, id, payload }
     }
     fn gen_id() -> u32 {
         let mut rng = rand::thread_rng();
@@ -331,11 +300,7 @@ pub struct Reply {
 
 impl Reply {
     pub fn from(request: &Request, error: u32, payload: Vec<u8>) -> Reply {
-        Reply {
-            id: request.get_id(),
-            error,
-            payload,
-        }
+        Reply { id: request.get_id(), error, payload }
     }
 
     pub fn has_error(&self) -> bool {

src/service/sol.rs

@@ -1,5 +1,4 @@
-use std::str::FromStr;
-use std::time::Duration;
+use std::{str::FromStr, time::Duration};
 
 use async_executor::Executor;
 use async_native_tls::TlsConnector;
@@ -23,10 +22,13 @@ use spl_associated_token_account::{create_associated_token_account, get_associat
 use tungstenite::Message;
 
 use super::bridge::{NetworkClient, TokenNotification, TokenSubscribtion};
-use crate::rpc::{jsonrpc, jsonrpc::JsonResult, websockets, websockets::WsStream};
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::util::{generate_id, parse::truncate, NetworkName};
-use crate::{types::*, Error, Result};
+use crate::{
+    rpc::{jsonrpc, jsonrpc::JsonResult, websockets, websockets::WsStream},
+    serial::{deserialize, serialize, Decodable, Encodable},
+    types::*,
+    util::{generate_id, parse::truncate, NetworkName},
+    Error, Result,
+};
 
 pub const SOL_NATIVE_TOKEN_ID: &str = "So11111111111111111111111111111111111111112";
 
@@ -40,10 +42,8 @@ pub struct SolClient {
     main_keypair: Keypair,
     // Subscriptions vector of pubkey
     subscriptions: Arc<Mutex<Vec<Pubkey>>>,
-    notify_channel: (
-        async_channel::Sender<TokenNotification>,
-        async_channel::Receiver<TokenNotification>,
-    ),
+    notify_channel:
+        (async_channel::Sender<TokenNotification>, async_channel::Receiver<TokenNotification>),
     rpc_server: &'static str,
     wss_server: &'static str,
 }
@@ -55,18 +55,9 @@ impl SolClient {
         info!(target: "SOL BRIDGE", "Main SOL wallet pubkey: {:?}", &main_keypair.pubkey());
 
         let (rpc_server, wss_server) = match network {
-            "mainnet" => (
-                "https://api.mainnet-beta.solana.com",
-                "wss://api.devnet.solana.com",
-            ),
-            "devnet" => (
-                "https://api.devnet.solana.com",
-                "wss://api.devnet.solana.com",
-            ),
-            "testnet" => (
-                "https://api.testnet.solana.com",
-                "wss://api.testnet.solana.com",
-            ),
+            "mainnet" => ("https://api.mainnet-beta.solana.com", "wss://api.devnet.solana.com"),
+            "devnet" => ("https://api.devnet.solana.com", "wss://api.devnet.solana.com"),
+            "testnet" => ("https://api.testnet.solana.com", "wss://api.testnet.solana.com"),
             "localhost" => ("http://localhost:8899", "ws://localhost:8900"),
             _ => return Err(Error::NotSupportedNetwork),
         };
@@ -81,9 +72,8 @@ impl SolClient {
     }
 
     fn check_main_account_balance(&self, rpc: &RpcClient) -> SolResult<bool> {
-        let main_sol_balance = rpc
-            .get_balance(&self.main_keypair.pubkey())
-            .map_err(SolFailed::from)?;
+        let main_sol_balance =
+            rpc.get_balance(&self.main_keypair.pubkey()).map_err(SolFailed::from)?;
 
         let fees = rpc.get_fees()?;
         let lamports_per_signature = fees.fee_calculator.lamports_per_signature;
@@ -118,7 +108,7 @@ impl SolClient {
 
         // Check if we're already subscribed
         if self.subscriptions.lock().await.contains(&pubkey) {
-            return Ok(());
+            return Ok(())
         }
 
         let rpc = RpcClient::new(self.rpc_server.to_string());
@@ -134,7 +124,7 @@ impl SolClient {
                     let (exists, decimals) = account_is_initialized_mint(&rpc, &mint);
                     if !exists {
                         debug!("Could not figure out the number of decimals in SPL token");
-                        return Err(SolFailed::MintIsNotValid(mint.to_string()));
+                        return Err(SolFailed::MintIsNotValid(mint.to_string()))
                     }
                     (0, decimals)
                 }
@@ -148,10 +138,8 @@ impl SolClient {
         let (mut write, mut read) = stream.split();
 
         // Subscription request build
-        let sub_params = SubscribeParams {
-            encoding: json!("jsonParsed"),
-            commitment: json!("finalized"),
-        };
+        let sub_params =
+            SubscribeParams { encoding: json!("jsonParsed"), commitment: json!("finalized") };
 
         let subscription = jsonrpc::request(
             json!("accountSubscribe"),
@@ -159,9 +147,7 @@ impl SolClient {
         );
 
         debug!(target: "SOLANA RPC", "--> {}", serde_json::to_string(&subscription)?);
-        write
-            .send(Message::text(serde_json::to_string(&subscription)?))
-            .await?;
+        write.send(Message::text(serde_json::to_string(&subscription)?)).await?;
 
         // Subscription ID used for unsubscribing later.
         let mut sub_id: i64 = 0;
@@ -175,25 +161,19 @@ impl SolClient {
         let mut sub_iter = 0;
 
         loop {
-            let message = read
-                .next()
-                .await
-                .ok_or_else(|| Error::TungsteniteError)?;
+            let message = read.next().await.ok_or_else(|| Error::TungsteniteError)?;
             let message = message?;
 
             if let Message::Pong(_) = message.clone() {
                 if sub_iter > 60 * 10 {
                     // 10 minutes
                     self.unsubscribe(&mut write, &pubkey, &sub_id).await?;
-                    return Err(SolFailed::RpcError(format!(
-                        "Deposit for {:?} expired",
-                        pubkey
-                    )));
+                    return Err(SolFailed::RpcError(format!("Deposit for {:?} expired", pubkey)))
                 }
                 sub_iter += iter_interval;
                 async_std::task::sleep(Duration::from_secs(iter_interval)).await;
                 write.send(Message::Ping(ping_payload.clone())).await?;
-                continue;
+                continue
             };
 
             match serde_json::from_slice(&message.into_data())? {
@@ -210,7 +190,7 @@ impl SolClient {
                     debug!(target: "SOLANA RPC", "<-- {}", serde_json::to_string(&e)?);
 
                     self.unsubscribe(&mut write, &pubkey, &sub_id).await?;
-                    return Err(SolFailed::RpcError(e.error.message.to_string()));
+                    return Err(SolFailed::RpcError(e.error.message.to_string()))
                 }
                 JsonResult::Notif(n) => {
                     // Account updated
@@ -226,7 +206,7 @@ impl SolClient {
                     } else {
                         cur_balance = params["lamports"].as_u64().unwrap();
                     }
-                    break;
+                    break
                 }
             }
         }
@@ -237,9 +217,7 @@ impl SolClient {
         self2.unsubscribe(&mut write, &pubkey, &sub_id).await?;
 
         if cur_balance < prev_balance {
-            return Err(SolFailed::Notification(
-                "New balance is less than previous balance".into(),
-            ));
+            return Err(SolFailed::Notification("New balance is less than previous balance".into()))
         }
 
         let amnt = cur_balance - prev_balance;
@@ -298,9 +276,7 @@ impl SolClient {
 
         let unsubscription = jsonrpc::request(json!("accountUnsubscribe"), json!([sub_id]));
 
-        write
-            .send(Message::text(serde_json::to_string(&unsubscription)?))
-            .await?;
+        write.send(Message::text(serde_json::to_string(&unsubscription)?)).await?;
 
         Ok(())
     }
@@ -403,7 +379,7 @@ impl SolClient {
             let rpc = RpcClient::new(self.rpc_server.to_string());
 
             if !account_is_initialized_mint(&rpc, &pubkey).0 {
-                return Err(SolFailed::MintIsNotValid(mint_addr));
+                return Err(SolFailed::MintIsNotValid(mint_addr))
             }
 
             Ok(Some(pubkey))
@@ -432,24 +408,19 @@ impl NetworkClient for SolClient {
 
         if !self.check_main_account_balance(&rpc)? {
             warn!(target: "SOL BRIDGE", "Main account has no enough funds");
-            return Err(Error::from(SolFailed::MainAccountNotEnoughValue));
+            return Err(Error::from(SolFailed::MainAccountNotEnoughValue))
         }
 
         executor
             .spawn(async move {
-                let result = self
-                    .handle_subscribe_request(keypair, drk_pub_key, mint)
-                    .await;
+                let result = self.handle_subscribe_request(keypair, drk_pub_key, mint).await;
                 if let Err(e) = result {
                     error!(target: "SOL BRIDGE SUBSCRIPTION","{}", e.to_string());
                 }
             })
             .detach();
 
-        Ok(TokenSubscribtion {
-            private_key,
-            public_key,
-        })
+        Ok(TokenSubscribtion { private_key, public_key })
     }
 
     // in solana case private key it's the same as keypair
@@ -470,14 +441,12 @@ impl NetworkClient for SolClient {
         let rpc = RpcClient::new(self.rpc_server.to_string());
 
         if !self.check_main_account_balance(&rpc)? {
-            return Err(Error::from(SolFailed::MainAccountNotEnoughValue));
+            return Err(Error::from(SolFailed::MainAccountNotEnoughValue))
         }
 
         executor
             .spawn(async move {
-                let result = self
-                    .handle_subscribe_request(keypair, drk_pub_key, mint)
-                    .await;
+                let result = self.handle_subscribe_request(keypair, drk_pub_key, mint).await;
                 if let Err(e) = result {
                     error!(target: "SOL BRIDGE SUBSCRIPTION","{}", e.to_string());
                 }
@@ -525,9 +494,7 @@ impl NetworkClient for SolClient {
             Ok(v) => tx.sign(&[&self.main_keypair], v.0),
         }
 
-        let _signature = rpc
-            .send_and_confirm_transaction(&tx)
-            .map_err(SolFailed::from)?;
+        let _signature = rpc.send_and_confirm_transaction(&tx).map_err(SolFailed::from)?;
 
         Ok(())
     }
@@ -585,9 +552,7 @@ impl Decodable for Keypair {
     fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
         let key: Vec<u8> = Decodable::decode(&mut d)?;
         let key = Keypair::from_bytes(key.as_slice()).map_err(|_| {
-            crate::Error::from(SolFailed::DecodeAndEncodeError(
-                "load keypair from slice".into(),
-            ))
+            crate::Error::from(SolFailed::DecodeAndEncodeError("load keypair from slice".into()))
         })?;
         Ok(key)
     }
@@ -605,9 +570,7 @@ impl Decodable for Pubkey {
     fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
         let key: String = Decodable::decode(&mut d)?;
         let key = Pubkey::try_from(key.as_str()).map_err(|_| {
-            crate::Error::from(SolFailed::DecodeAndEncodeError(
-                "load public key from slice".into(),
-            ))
+            crate::Error::from(SolFailed::DecodeAndEncodeError("load public key from slice".into()))
         })?;
         Ok(key)
     }

src/state.rs

@@ -82,7 +82,7 @@ pub fn state_transition<S: ProgramState>(state: &S, tx: Transaction) -> VerifyRe
 
         if !state.is_valid_cashier_public_key(&input.signature_public) {
             log::error!(target: "STATE TRANSITION", "Not valid cashier public key");
-            return Err(VerifyFailed::InvalidCashierKey(i));
+            return Err(VerifyFailed::InvalidCashierKey(i))
         }
     }
 
@@ -94,7 +94,7 @@ pub fn state_transition<S: ProgramState>(state: &S, tx: Transaction) -> VerifyRe
         // Merkle is used to know whether this is a coin that existed
         // in a previous state.
         if !state.is_valid_merkle(merkle) {
-            return Err(VerifyFailed::InvalidMerkle(i));
+            return Err(VerifyFailed::InvalidMerkle(i))
         }
 
         // The nullifiers should not already exist
@@ -102,7 +102,7 @@ pub fn state_transition<S: ProgramState>(state: &S, tx: Transaction) -> VerifyRe
         let nullifier = &input.revealed.nullifier;
 
         if state.nullifier_exists(nullifier) {
-            return Err(VerifyFailed::DuplicateNullifier(i));
+            return Err(VerifyFailed::DuplicateNullifier(i))
         }
     }
 
@@ -124,9 +124,5 @@ pub fn state_transition<S: ProgramState>(state: &S, tx: Transaction) -> VerifyRe
         enc_notes.push(output.enc_note);
     }
 
-    Ok(StateUpdate {
-        nullifiers,
-        coins,
-        enc_notes,
-    })
+    Ok(StateUpdate { nullifiers, coins, enc_notes })
 }

src/system/stoppable_task.rs

@@ -1,6 +1,5 @@
 use async_executor::Executor;
-use futures::Future;
-use futures::FutureExt;
+use futures::{Future, FutureExt};
 use std::sync::Arc;
 
 pub type StoppableTaskPtr = Arc<StoppableTask>;
@@ -13,10 +12,7 @@ pub struct StoppableTask {
 impl StoppableTask {
     pub fn new() -> Arc<Self> {
         let (stop_send, stop_recv) = async_channel::unbounded();
-        Arc::new(Self {
-            stop_send,
-            stop_recv,
-        })
+        Arc::new(Self { stop_send, stop_recv })
     }
 
     pub async fn stop(&self) {

src/system/subscriber.rs

@@ -1,7 +1,6 @@
 use async_std::sync::Mutex;
 use rand::Rng;
-use std::collections::HashMap;
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 
 pub type SubscriberPtr<T> = Arc<Subscriber<T>>;
 
@@ -38,9 +37,7 @@ pub struct Subscriber<T> {
 
 impl<T: Clone> Subscriber<T> {
     pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            subs: Mutex::new(HashMap::new()),
-        })
+        Arc::new(Self { subs: Mutex::new(HashMap::new()) })
     }
 
     fn random_id() -> SubscriptionId {
@@ -55,11 +52,7 @@ impl<T: Clone> Subscriber<T> {
 
         self.subs.lock().await.insert(sub_id, sender);
 
-        Subscription {
-            id: sub_id,
-            recv_queue: recvr,
-            parent: self.clone(),
-        }
+        Subscription { id: sub_id, recv_queue: recvr, parent: self.clone() }
     }
 
     async fn unsubscribe(self: Arc<Self>, sub_id: SubscriptionId) {

src/tx/builder.rs

@@ -5,11 +5,11 @@ use super::{
     partial::{PartialTransaction, PartialTransactionClearInput, PartialTransactionInput},
     Transaction, TransactionClearInput, TransactionInput, TransactionOutput,
 };
-use crate::crypto::{
-    mint_proof::create_mint_proof, note::Note, schnorr, spend_proof::create_spend_proof,
-};
 use crate::{
-    crypto::merkle_node2::MerkleNode,
+    crypto::{
+        merkle_node2::MerkleNode, mint_proof::create_mint_proof, note::Note, schnorr,
+        spend_proof::create_spend_proof,
+    },
     serial::Encodable,
     types::{DrkCoinBlind, DrkPublicKey, DrkSecretKey, DrkSerial, DrkTokenId, DrkValueBlind},
     Result,
@@ -104,10 +104,7 @@ impl TransactionBuilder {
             // First we make the tx then sign after
             signature_secrets.push(signature_secret);
 
-            let input = PartialTransactionInput {
-                spend_proof: proof,
-                revealed,
-            };
+            let input = PartialTransactionInput { spend_proof: proof, revealed };
             inputs.push(input);
         }
 
@@ -147,19 +144,11 @@ impl TransactionBuilder {
 
             let encrypted_note = note.encrypt(&output.public)?;
 
-            let output = TransactionOutput {
-                mint_proof,
-                revealed,
-                enc_note: encrypted_note,
-            };
+            let output = TransactionOutput { mint_proof, revealed, enc_note: encrypted_note };
             outputs.push(output);
         }
 
-        let partial_tx = PartialTransaction {
-            clear_inputs,
-            inputs,
-            outputs,
-        };
+        let partial_tx = PartialTransaction { clear_inputs, inputs, outputs };
 
         let mut unsigned_tx_data = vec![];
         partial_tx.encode(&mut unsigned_tx_data)?;
@@ -173,20 +162,14 @@ impl TransactionBuilder {
         }
 
         let mut inputs = vec![];
-        for (input, signature_secret) in partial_tx
-            .inputs
-            .into_iter()
-            .zip(signature_secrets.into_iter())
+        for (input, signature_secret) in
+            partial_tx.inputs.into_iter().zip(signature_secrets.into_iter())
         {
             let signature = signature_secret.sign(&unsigned_tx_data[..]);
             let input = TransactionInput::from_partial(input, signature);
             inputs.push(input);
         }
 
-        Ok(Transaction {
-            clear_inputs,
-            inputs,
-            outputs: partial_tx.outputs,
-        })
+        Ok(Transaction { clear_inputs, inputs, outputs: partial_tx.outputs })
     }
 }

src/tx/mod.rs

@@ -70,19 +70,14 @@ impl Transaction {
         assert_ne!(self.outputs.len(), 0);
         let token_commit_value = self.outputs[0].revealed.token_commit;
 
-        let mut failed = self
-            .inputs
-            .iter()
-            .any(|input| input.revealed.token_commit != token_commit_value);
-        failed = failed
-            || self
-                .outputs
-                .iter()
-                .any(|output| output.revealed.token_commit != token_commit_value);
-        failed = failed
-            || self.clear_inputs.iter().any(|input| {
-                pedersen_commitment_scalar(mod_r_p(input.token_id), input.token_blind)
-                    != token_commit_value
+        let mut failed =
+            self.inputs.iter().any(|input| input.revealed.token_commit != token_commit_value);
+        failed = failed ||
+            self.outputs.iter().any(|output| output.revealed.token_commit != token_commit_value);
+        failed = failed ||
+            self.clear_inputs.iter().any(|input| {
+                pedersen_commitment_scalar(mod_r_p(input.token_id), input.token_blind) !=
+                    token_commit_value
             });
         !failed
     }
@@ -100,41 +95,40 @@ impl Transaction {
 
         for (i, input) in self.inputs.iter().enumerate() {
             if verify_spend_proof(spend_pvk, input.spend_proof.clone(), &input.revealed).is_err() {
-                return Err(state::VerifyFailed::SpendProof(i));
+                return Err(state::VerifyFailed::SpendProof(i))
             }
             valcom_total += &input.revealed.value_commit;
         }
 
         for (i, output) in self.outputs.iter().enumerate() {
             if verify_mint_proof(mint_pvk, &output.mint_proof, &output.revealed).is_err() {
-                return Err(state::VerifyFailed::MintProof(i));
+                return Err(state::VerifyFailed::MintProof(i))
             }
             valcom_total -= &output.revealed.value_commit;
         }
 
         if valcom_total != DrkValueCommit::identity() {
-            return Err(state::VerifyFailed::MissingFunds);
+            return Err(state::VerifyFailed::MissingFunds)
         }
 
         // Verify token commitments match
         if !self.verify_token_commitments() {
-            return Err(state::VerifyFailed::AssetMismatch);
+            return Err(state::VerifyFailed::AssetMismatch)
         }
 
         // Verify signatures
         let mut unsigned_tx_data = vec![];
-        self.encode_without_signature(&mut unsigned_tx_data)
-            .expect("TODO handle this");
+        self.encode_without_signature(&mut unsigned_tx_data).expect("TODO handle this");
         for (i, input) in self.clear_inputs.iter().enumerate() {
             let public = &input.signature_public;
             if !public.verify(&unsigned_tx_data[..], &input.signature) {
-                return Err(state::VerifyFailed::ClearInputSignature(i));
+                return Err(state::VerifyFailed::ClearInputSignature(i))
             }
         }
         for (i, input) in self.inputs.iter().enumerate() {
             let public = &input.revealed.signature_public;
             if !public.verify(&unsigned_tx_data[..], &input.signature) {
-                return Err(state::VerifyFailed::InputSignature(i));
+                return Err(state::VerifyFailed::InputSignature(i))
             }
         }
 
@@ -173,11 +167,7 @@ impl TransactionInput {
         partial: partial::PartialTransactionInput,
         signature: schnorr::Signature,
     ) -> Self {
-        Self {
-            spend_proof: partial.spend_proof,
-            revealed: partial.revealed,
-            signature,
-        }
+        Self { spend_proof: partial.spend_proof, revealed: partial.revealed, signature }
     }
 
     fn encode_without_signature<S: io::Write>(&self, mut s: S) -> Result<usize> {

src/tx/partial.rs

@@ -82,10 +82,7 @@ impl Encodable for PartialTransactionInput {
 
 impl Decodable for PartialTransactionInput {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            spend_proof: Decodable::decode(&mut d)?,
-            revealed: Decodable::decode(d)?,
-        })
+        Ok(Self { spend_proof: Decodable::decode(&mut d)?, revealed: Decodable::decode(d)? })
     }
 }
 

src/util/address.rs

@@ -1,6 +1,6 @@
+use crate::types::*;
 use group::GroupEncoding;
 use sha2::Digest;
-use crate::types::*;
 
 #[derive(Clone, Debug)]
 pub struct Address {

src/util/parse.rs

@@ -1,5 +1,4 @@
-use std::iter::FromIterator;
-use std::str::FromStr;
+use std::{iter::FromIterator, str::FromStr};
 
 use num_bigint::BigUint;
 use sha2::{Digest, Sha256};
@@ -34,9 +33,9 @@ pub fn generate_id(tkn_str: &str, network: &NetworkName) -> Result<DrkTokenId> {
                 let token_id = deserialize::<DrkTokenId>(&hash);
                 if token_id.is_err() {
                     counter += 1;
-                    continue;
+                    continue
                 }
-                return Ok(token_id.unwrap());
+                return Ok(token_id.unwrap())
             }
         }
     };
@@ -77,8 +76,7 @@ pub fn assign_id(
             // (== 42) can represent a erc20 token mint address
             if token.len() == 42 {
                 Ok(token.to_string())
-            }
-            else if token == "eth" {
+            } else if token == "eth" {
                 Ok(ETH_NATIVE_TOKEN_ID.to_string())
             } else {
                 let tok_lower = token.to_lowercase();
@@ -131,7 +129,7 @@ pub fn decode_base10(amount: &str, decimal_places: usize, strict: bool) -> Resul
     // Only digits should remain
     for i in &s {
         if !is_digit(*i) {
-            return Err(Error::ParseFailed("Found non-digits"));
+            return Err(Error::ParseFailed("Found non-digits"))
         }
     }
 
@@ -148,14 +146,14 @@ pub fn decode_base10(amount: &str, decimal_places: usize, strict: bool) -> Resul
         for i in &s[end..s.len()] {
             if !char_eq(*i, '0') {
                 round = true;
-                break;
+                break
             }
         }
         s.truncate(end);
     }
 
     if strict && round {
-        return Err(Error::ParseFailed("Would end up rounding while strict"));
+        return Err(Error::ParseFailed("Would end up rounding while strict"))
     }
 
     // Convert to an integer
@@ -163,24 +161,20 @@ pub fn decode_base10(amount: &str, decimal_places: usize, strict: bool) -> Resul
 
     // Round and return
     /*
-       if round && number == u64::MAX {
-       return Err(Error::ParseFailed("u64 overflow"));
-       }
-       */
+    if round && number == u64::MAX {
+    return Err(Error::ParseFailed("u64 overflow"));
+    }
+    */
 
     Ok(number + round as u64)
 }
 
 pub fn encode_base10(amount: BigUint, decimal_places: usize) -> String {
-    let mut s: Vec<char> = format!("{:0width$}", amount, width = 1 + decimal_places)
-        .chars()
-        .collect();
+    let mut s: Vec<char> =
+        format!("{:0width$}", amount, width = 1 + decimal_places).chars().collect();
     s.insert(s.len() - decimal_places, '.');
 
-    String::from_iter(&s)
-        .trim_end_matches('0')
-        .trim_end_matches('.')
-        .to_string()
+    String::from_iter(&s).trim_end_matches('0').trim_end_matches('.').to_string()
 }
 
 pub fn truncate(amount: u64, decimals: u16, token_decimals: u16) -> Result<u64> {
@@ -188,7 +182,7 @@ pub fn truncate(amount: u64, decimals: u16, token_decimals: u16) -> Result<u64>
 
     if token_decimals > decimals {
         if amount.len() <= (token_decimals - decimals) as usize {
-            return Ok(0);
+            return Ok(0)
         }
         amount.truncate(amount.len() - (token_decimals - decimals) as usize);
     }
@@ -209,47 +203,20 @@ mod tests {
 
     #[test]
     fn test_decode_base10() {
-        assert_eq!(
-            124.to_biguint().unwrap(),
-            decode_base10("12.33", 1, false).unwrap()
-        );
-        assert_eq!(
-            1233000.to_biguint().unwrap(),
-            decode_base10("12.33", 5, false).unwrap()
-        );
-        assert_eq!(
-            1200000.to_biguint().unwrap(),
-            decode_base10("12.", 5, false).unwrap()
-        );
-        assert_eq!(
-            1200000.to_biguint().unwrap(),
-            decode_base10("12", 5, false).unwrap()
-        );
+        assert_eq!(124.to_biguint().unwrap(), decode_base10("12.33", 1, false).unwrap());
+        assert_eq!(1233000.to_biguint().unwrap(), decode_base10("12.33", 5, false).unwrap());
+        assert_eq!(1200000.to_biguint().unwrap(), decode_base10("12.", 5, false).unwrap());
+        assert_eq!(1200000.to_biguint().unwrap(), decode_base10("12", 5, false).unwrap());
         assert!(decode_base10("12.33", 1, true).is_err());
     }
 
     #[test]
     fn test_encode_base10() {
-        assert_eq!(
-            "23.4321111",
-            &encode_base10(234321111_u64.to_biguint().unwrap(), 7)
-        );
-        assert_eq!(
-            "23432111.1",
-            &encode_base10(234321111_u64.to_biguint().unwrap(), 1)
-        );
-        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)
-        );
+        assert_eq!("23.4321111", &encode_base10(234321111_u64.to_biguint().unwrap(), 7));
+        assert_eq!("23432111.1", &encode_base10(234321111_u64.to_biguint().unwrap(), 1));
+        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

@@ -16,10 +16,7 @@ pub struct TokenList {
 impl TokenList {
     pub fn new(data: &[u8]) -> Result<Self> {
         let tokenlist: Value = serde_json::from_slice(data)?;
-        let tokens = tokenlist["tokens"]
-            .as_array()
-            .ok_or(Error::TokenParseError)?
-            .clone();
+        let tokens = tokenlist["tokens"].as_array().ok_or(Error::TokenParseError)?.clone();
         Ok(Self { tokens })
     }
 
@@ -37,7 +34,7 @@ impl TokenList {
             if item["symbol"] == symbol.to_uppercase() {
                 let address = item["address"].clone();
                 let address = address.as_str().ok_or(Error::TokenParseError)?;
-                return Ok(Some(address.to_string()));
+                return Ok(Some(address.to_string()))
             }
         }
         Ok(None)
@@ -49,7 +46,7 @@ impl TokenList {
                 let decimals = item["decimals"].clone();
                 let decimals = decimals.as_u64().ok_or(Error::TokenParseError)?;
                 let decimals = decimals as usize;
-                return Ok(Some(decimals));
+                return Ok(Some(decimals))
             }
         }
         Ok(None)
@@ -68,22 +65,19 @@ impl DrkTokenList {
         let mut tokens: HashMap<String, DrkTokenId> = sol_symbols
             .iter()
             .filter_map(|symbol| Self::generate_hash_pair(&sol_list, symbol).ok())
-        .collect();
+            .collect();
 
-         tokens.insert(
+        tokens.insert(
             "BTC".to_string(),
             generate_id("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", &NetworkName::Bitcoin)?,
-         );
+        );
 
         Ok(Self { tokens })
     }
 
     fn generate_hash_pair(sol_list: &TokenList, symbol: &str) -> Result<(String, DrkTokenId)> {
         if let Some(token_id) = &sol_list.search_id(symbol)? {
-            Ok((
-                symbol.to_string(),
-                generate_id(token_id, &NetworkName::Solana)?,
-            ))
+            Ok((symbol.to_string(), generate_id(token_id, &NetworkName::Solana)?))
         } else {
             Err(Error::NotSupportedToken)
         }
@@ -107,17 +101,16 @@ impl DrkTokenList {
 #[allow(unused_imports)]
 mod tests {
     use super::*;
-    use crate::util::{DrkTokenList, TokenList};
-    use crate::Result;
+    use crate::{
+        util::{DrkTokenList, TokenList},
+        Result,
+    };
 
     fn _get_sol_tokens() -> Result<TokenList> {
         let file_contents = include_bytes!("../../testdata/solanatokenlisttest.json");
         let sol_tokenlist: Value = serde_json::from_slice(file_contents)?;
 
-        let tokens = sol_tokenlist["tokens"]
-            .as_array()
-            .ok_or(Error::TokenParseError)?
-            .clone();
+        let tokens = sol_tokenlist["tokens"].as_array().ok_or(Error::TokenParseError)?.clone();
 
         let sol_tokenlist = TokenList { tokens };
         Ok(sol_tokenlist)
@@ -127,10 +120,7 @@ mod tests {
         let file_contents = include_bytes!("../../testdata/erc20tokenlisttest.json");
         let eth_tokenlist: Value = serde_json::from_slice(file_contents)?;
 
-        let tokens = eth_tokenlist["tokens"]
-            .as_array()
-            .ok_or(Error::TokenParseError)?
-            .clone();
+        let tokens = eth_tokenlist["tokens"].as_array().ok_or(Error::TokenParseError)?.clone();
 
         let eth_tokenlist = TokenList { tokens };
         Ok(eth_tokenlist)
@@ -140,10 +130,7 @@ mod tests {
         let file_contents = include_bytes!("../../token/bitcoin_token_list.json");
         let btc_tokenlist: Value = serde_json::from_slice(file_contents)?;
 
-        let tokens = btc_tokenlist["tokens"]
-            .as_array()
-            .ok_or(Error::TokenParseError)?
-            .clone();
+        let tokens = btc_tokenlist["tokens"].as_array().ok_or(Error::TokenParseError)?.clone();
 
         let btc_tokenlist = TokenList { tokens };
         Ok(btc_tokenlist)
@@ -189,26 +176,17 @@ mod tests {
 
         assert_eq!(
             drk_token.tokens[&NetworkName::Solana]["SOL"],
-            generate_id(
-                &sol_tokens2.search_id("SOL")?.unwrap(),
-                &NetworkName::Solana
-            )?
+            generate_id(&sol_tokens2.search_id("SOL")?.unwrap(), &NetworkName::Solana)?
         );
 
         assert_eq!(
             drk_token.tokens[&NetworkName::Bitcoin]["BTC"],
-            generate_id(
-                &btc_tokens2.search_id("BTC")?.unwrap(),
-                &NetworkName::Bitcoin
-            )?
+            generate_id(&btc_tokens2.search_id("BTC")?.unwrap(), &NetworkName::Bitcoin)?
         );
 
         assert_eq!(
             drk_token.tokens[&NetworkName::Ethereum]["WBTC"],
-            generate_id(
-                &eth_tokens2.search_id("WBTC")?.unwrap(),
-                &NetworkName::Ethereum
-            )?
+            generate_id(&eth_tokens2.search_id("WBTC")?.unwrap(), &NetworkName::Ethereum)?
         );
 
         Ok(())

src/vm2.rs

@@ -1,5 +1,4 @@
-use std::collections::HashMap;
-use std::convert::TryInto;
+use std::{collections::HashMap, convert::TryInto};
 
 use halo2::{
     circuit::{Layouter, SimpleFloorPlanner},
@@ -18,8 +17,10 @@ use halo2_gadgets::{
     primitives::poseidon::{ConstantLength, P128Pow5T3},
     sinsemilla::{
         chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::chip::{MerkleChip, MerkleConfig},
-        merkle::MerklePath,
+        merkle::{
+            chip::{MerkleChip, MerkleConfig},
+            MerklePath,
+        },
     },
     utilities::{
         lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
@@ -168,29 +169,29 @@ impl<'a> ZkCircuit<'a> {
     pub fn witness_base(&mut self, name: &str, value: pallas::Base) -> Result<()> {
         for (variable, type_id) in self.contract.witness.iter() {
             if name != variable {
-                continue;
+                continue
             }
             if *type_id != ZkType::Base {
-                return Err(Error::InvalidParamType);
+                return Err(Error::InvalidParamType)
             }
             *self.witness_base.get_mut(name).unwrap() = Some(value);
-            return Ok(());
+            return Ok(())
         }
-        return Err(Error::InvalidParamName);
+        return Err(Error::InvalidParamName)
     }
 
     pub fn witness_scalar(&mut self, name: &str, value: pallas::Scalar) -> Result<()> {
         for (variable, type_id) in self.contract.witness.iter() {
             if name != variable {
-                continue;
+                continue
             }
             if *type_id != ZkType::Scalar {
-                return Err(Error::InvalidParamType);
+                return Err(Error::InvalidParamType)
             }
             *self.witness_scalar.get_mut(name).unwrap() = Some(value);
-            return Ok(());
+            return Ok(())
         }
-        return Err(Error::InvalidParamName);
+        return Err(Error::InvalidParamName)
     }
 
     pub fn witness_merkle_path(
@@ -201,15 +202,15 @@ impl<'a> ZkCircuit<'a> {
     ) -> Result<()> {
         for (variable, type_id) in self.contract.witness.iter() {
             if name != variable {
-                continue;
+                continue
             }
             if *type_id != ZkType::MerklePath {
-                return Err(Error::InvalidParamType);
+                return Err(Error::InvalidParamType)
             }
             *self.witness_merkle_path.get_mut(name).unwrap() = (Some(leaf_pos), Some(path));
-            return Ok(());
+            return Ok(())
         }
-        return Err(Error::InvalidParamName);
+        return Err(Error::InvalidParamName)
     }
 }
 
@@ -226,16 +227,8 @@ impl<'a> Circuit<pallas::Base> for ZkCircuit<'a> {
             const_fixed_points: self.const_fixed_points.clone(),
             constants: self.constants,
             contract: &self.contract,
-            witness_base: self
-                .witness_base
-                .keys()
-                .map(|key| (key.clone(), None))
-                .collect(),
-            witness_scalar: self
-                .witness_scalar
-                .keys()
-                .map(|key| (key.clone(), None))
-                .collect(),
+            witness_base: self.witness_base.keys().map(|key| (key.clone(), None)).collect(),
+            witness_scalar: self.witness_scalar.keys().map(|key| (key.clone(), None)).collect(),
             witness_merkle_path: self
                 .witness_scalar
                 .keys()
@@ -261,11 +254,7 @@ impl<'a> Circuit<pallas::Base> for ZkCircuit<'a> {
         let q_add = meta.selector();
 
         let table_idx = meta.lookup_table_column();
-        let lookup = (
-            table_idx,
-            meta.lookup_table_column(),
-            meta.lookup_table_column(),
-        );
+        let lookup = (table_idx, meta.lookup_table_column(), meta.lookup_table_column());
 
         let primary = meta.instance_column();
 
@@ -424,10 +413,8 @@ impl<'a> Circuit<pallas::Base> for ZkCircuit<'a> {
                     unimplemented!();
                 }
                 ZkType::MerklePath => {
-                    let value = self
-                        .witness_merkle_path
-                        .get(variable)
-                        .expect("witness merkle path set");
+                    let value =
+                        self.witness_merkle_path.get(variable).expect("witness merkle path set");
                     stack_merkle_path.push(value.clone());
                 }
             }

src/vm2_serial.rs

@@ -1,9 +1,11 @@
 use std::io;
 
-use crate::error::{Error, Result};
-use crate::impl_vec;
-use crate::serial::{Decodable, Encodable, ReadExt, VarInt};
-use crate::vm2::{ZkBinary, ZkContract, ZkFunctionCall, ZkType};
+use crate::{
+    error::{Error, Result},
+    impl_vec,
+    serial::{Decodable, Encodable, ReadExt, VarInt},
+    vm2::{ZkBinary, ZkContract, ZkFunctionCall, ZkType},
+};
 
 impl_vec!((String, ZkType));
 impl_vec!(ZkFunctionCall);
@@ -84,9 +86,7 @@ impl Decodable for ZkBinary {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
         Ok(Self {
             constants: Decodable::decode(&mut d)?,
-            contracts: Vec::<(String, ZkContract)>::decode(&mut d)?
-                .into_iter()
-                .collect(),
+            contracts: Vec::<(String, ZkContract)>::decode(&mut d)?.into_iter().collect(),
         })
     }
 }
@@ -100,9 +100,6 @@ impl Encodable for ZkContract {
 
 impl Decodable for ZkContract {
     fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            witness: Decodable::decode(&mut d)?,
-            code: Decodable::decode(&mut d)?,
-        })
+        Ok(Self { witness: Decodable::decode(&mut d)?, code: Decodable::decode(&mut d)? })
     }
 }

src/wallet/cashierdb.rs

@@ -5,9 +5,7 @@ use log::{debug, error, info};
 use rusqlite::{named_params, params, Connection};
 
 use super::{Keypair, WalletApi};
-use crate::client::ClientFailed;
-use crate::util::NetworkName;
-use crate::{types::*, Error, Result};
+use crate::{client::ClientFailed, types::*, util::NetworkName, Error, Result};
 
 pub type CashierDbPtr = Arc<CashierDb>;
 
@@ -43,17 +41,14 @@ impl CashierDb {
         debug!(target: "CASHIERDB", "new() Constructor called");
         if password.trim().is_empty() {
             error!(target: "CASHIERDB", "Password is empty. You must set a password to use the wallet.");
-            return Err(Error::from(ClientFailed::EmptyPassword));
+            return Err(Error::from(ClientFailed::EmptyPassword))
         }
 
         let conn = Connection::open(path)?;
         conn.pragma_update(None, "key", &password)?;
         info!(target: "CASHIERDB", "Opened connection at path: {:?}", path);
 
-        Ok(Arc::new(Self {
-            conn,
-            initialized: Mutex::new(false),
-        }))
+        Ok(Arc::new(Self { conn, initialized: Mutex::new(false) }))
     }
 
     pub async fn init_db(&self) -> Result<()> {
@@ -61,7 +56,7 @@ impl CashierDb {
             let contents = include_str!("../../sql/cashier.sql");
             self.conn.execute_batch(contents)?;
             *self.initialized.lock().await = true;
-            return Ok(());
+            return Ok(())
         }
 
         error!(target: "WALLETDB", "Wallet already initialized.");
@@ -106,10 +101,7 @@ impl CashierDb {
 
         for k in keys_iter {
             let k = k?;
-            keys.push(TokenKey {
-                private_key: k.0,
-                public_key: k.1,
-            });
+            keys.push(TokenKey { private_key: k.0, public_key: k.1 });
         }
 
         Ok(keys)
@@ -231,10 +223,10 @@ impl CashierDb {
             WHERE d_key_public = :d_key_public AND confirm = :confirm;",
         )?;
 
-        let addr_iter = stmt.query_map(
-            &[(":d_key_public", &d_key_public), (":confirm", &confirm)],
-            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
-        )?;
+        let addr_iter = stmt
+            .query_map(&[(":d_key_public", &d_key_public), (":confirm", &confirm)], |row| {
+                Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?))
+            })?;
 
         let mut token_addresses = vec![];
 
@@ -274,11 +266,7 @@ impl CashierDb {
         )?;
 
         let keys_iter = stmt.query_map::<(Vec<u8>, Vec<u8>), _, _>(
-            &[
-                (":d_key_public", &d_key_public),
-                (":network", &network),
-                (":confirm", &confirm),
-            ],
+            &[(":d_key_public", &d_key_public), (":network", &network), (":confirm", &confirm)],
             |row| Ok((row.get(0)?, row.get(1)?)),
         )?;
 
@@ -286,10 +274,7 @@ impl CashierDb {
 
         for k in keys_iter {
             let k = k?;
-            keys.push(TokenKey {
-                private_key: k.0,
-                public_key: k.1,
-            });
+            keys.push(TokenKey { private_key: k.0, public_key: k.1 });
         }
 
         Ok(keys)
@@ -310,15 +295,9 @@ impl CashierDb {
             AND confirm = :confirm ;",
         )?;
 
-        let keys_iter =
-            stmt.query_map(&[(":network", &network), (":confirm", &confirm)], |row| {
-                Ok((
-                    row.get(0)?,
-                    row.get(1)?,
-                    row.get(2)?,
-                    row.get(3)?,
-                    row.get(4)?,
-                ))
+        let keys_iter = stmt
+            .query_map(&[(":network", &network), (":confirm", &confirm)], |row| {
+                Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?, row.get(4)?))
             })?;
 
         let mut keys = vec![];
@@ -332,10 +311,7 @@ impl CashierDb {
             let mint_address: String = self.get_value_deserialized(key.4)?;
             keys.push(DepositToken {
                 drk_public_key,
-                token_key: TokenKey {
-                    private_key,
-                    public_key,
-                },
+                token_key: TokenKey { private_key, public_key },
                 token_id,
                 mint_address,
             });
@@ -428,9 +404,7 @@ impl CashierDb {
 mod tests {
 
     use super::*;
-    use crate::crypto::types::derive_publickey;
-    use crate::serial::serialize;
-    use crate::util::join_config_path;
+    use crate::{crypto::types::derive_publickey, serial::serialize, util::join_config_path};
 
     use ff::Field;
     use rand::rngs::OsRng;
@@ -444,7 +418,7 @@ mod tests {
             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));
+            return Err(Error::from(ClientFailed::EmptyPassword))
         }
         Ok(())
     }
@@ -463,10 +437,7 @@ mod tests {
         let network = NetworkName::Bitcoin;
 
         wallet.put_main_keys(
-            &TokenKey {
-                private_key: token_addr_private.clone(),
-                public_key: token_addr.clone(),
-            },
+            &TokenKey { private_key: token_addr_private.clone(), public_key: token_addr.clone() },
             &network,
         )?;
 

src/wallet/wallet_api.rs

@@ -1,5 +1,7 @@
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::Result;
+use crate::{
+    serial::{deserialize, serialize, Decodable, Encodable},
+    Result,
+};
 
 pub trait WalletApi {
     fn get_value_serialized<T: Encodable>(&self, data: &T) -> Result<Vec<u8>> {

src/wallet/walletdb.rs

@@ -1,6 +1,4 @@
-use std::collections::HashMap;
-use std::path::Path;
-use std::sync::Arc;
+use std::{collections::HashMap, path::Path, sync::Arc};
 
 use log::{debug, error, info};
 use pasta_curves::arithmetic::Field;
@@ -8,8 +6,13 @@ use rand::rngs::OsRng;
 use rusqlite::{named_params, params, Connection};
 
 use super::WalletApi;
-use crate::crypto::{coin::Coin, note::Note, nullifier::Nullifier, OwnCoin, OwnCoins};
-use crate::{client::ClientFailed, serial, types::*, Error, Result};
+use crate::{
+    client::ClientFailed,
+    crypto::{coin::Coin, note::Note, nullifier::Nullifier, OwnCoin, OwnCoins},
+    serial,
+    types::*,
+    Error, Result,
+};
 
 pub type WalletPtr = Arc<WalletDb>;
 
@@ -32,10 +35,8 @@ pub struct Balances {
 }
 impl Balances {
     pub fn add(&mut self, balance: &Balance) {
-        if let Some(mut saved_balance) = self
-            .list
-            .iter_mut()
-            .find(|b| b.token_id == balance.token_id)
+        if let Some(mut saved_balance) =
+            self.list.iter_mut().find(|b| b.token_id == balance.token_id)
         {
             saved_balance.value += balance.value;
         } else {
@@ -55,7 +56,7 @@ impl WalletDb {
         debug!(target: "WALLETDB", "new() Constructor called");
         if password.trim().is_empty() {
             error!(target: "WALLETDB", "Password is empty. You must set a password to use the wallet.");
-            return Err(Error::from(ClientFailed::EmptyPassword));
+            return Err(Error::from(ClientFailed::EmptyPassword))
         }
 
         let conn = Connection::open(path)?;
@@ -81,7 +82,7 @@ impl WalletDb {
             let secret = DrkSecretKey::random(&mut OsRng);
             let public = derive_public_key(secret);
             self.put_keypair(&public, &secret)?;
-            return Ok(());
+            return Ok(())
         }
 
         error!(target: "WALLETDB", "Keys already exist.");
@@ -125,9 +126,7 @@ impl WalletDb {
         debug!(target: "WALLETDB", "Get own coins");
         let is_spent = 0;
 
-        let mut coins = self
-            .conn
-            .prepare("SELECT * FROM coins WHERE is_spent = :is_spent ;")?;
+        let mut coins = self.conn.prepare("SELECT * FROM coins WHERE is_spent = :is_spent ;")?;
 
         let rows = coins.query_map(&[(":is_spent", &is_spent)], |row| {
             Ok((
@@ -156,13 +155,7 @@ impl WalletDb {
             let value: u64 = row.4;
             let token_id = self.get_value_deserialized(row.5)?;
 
-            let note = Note {
-                serial,
-                value,
-                token_id,
-                coin_blind,
-                value_blind,
-            };
+            let note = Note { serial, value, token_id, coin_blind, value_blind };
 
             // TODO:
             // let witness = self.get_value_deserialized(row.6)?;
@@ -310,11 +303,7 @@ impl WalletDb {
             let value: u64 = row.0;
             let token_id: DrkTokenId = self.get_value_deserialized(row.1)?;
             let nullifier: Nullifier = self.get_value_deserialized(row.2)?;
-            balances.add(&Balance {
-                token_id,
-                value,
-                nullifier,
-            });
+            balances.add(&Balance { token_id, value, nullifier });
         }
 
         Ok(balances)
@@ -324,9 +313,8 @@ impl WalletDb {
         debug!(target: "WALLETDB", "Get token ID...");
         let is_spent = 0;
 
-        let mut stmt = self
-            .conn
-            .prepare("SELECT token_id FROM coins WHERE is_spent = :is_spent ;")?;
+        let mut stmt =
+            self.conn.prepare("SELECT token_id FROM coins WHERE is_spent = :is_spent ;")?;
 
         let rows = stmt.query_map(&[(":is_spent", &is_spent)], |row| row.get(0))?;
 
@@ -346,9 +334,8 @@ impl WalletDb {
         let is_spent = 0;
         let id = self.get_value_serialized(token_id)?;
 
-        let mut stmt = self
-            .conn
-            .prepare("SELECT * FROM coins WHERE token_id = ? AND is_spent = ? ;")?;
+        let mut stmt =
+            self.conn.prepare("SELECT * FROM coins WHERE token_id = ? AND is_spent = ? ;")?;
 
         let id_check = stmt.exists(params![id, is_spent])?;
 
@@ -366,12 +353,14 @@ impl WalletDb {
 mod tests {
     // TODO: Clean up, there's a lot of duplicated code here.
     use super::*;
-    use crate::crypto::{
-        coin::Coin,
-        types::{derive_public_key, CoinBlind, NullifierSerial, ValueCommitBlind},
-        OwnCoin,
+    use crate::{
+        crypto::{
+            coin::Coin,
+            types::{derive_public_key, CoinBlind, NullifierSerial, ValueCommitBlind},
+            OwnCoin,
+        },
+        util::join_config_path,
     };
-    use crate::util::join_config_path;
     use ff::PrimeField;
 
     pub fn init_db(path: &Path, password: String) -> Result<()> {
@@ -385,7 +374,7 @@ mod tests {
             debug!(
                 target: "WALLETDB", "Password is empty. You must set a password to use the wallet."
             );
-            return Err(Error::from(ClientFailed::EmptyPassword));
+            return Err(Error::from(ClientFailed::EmptyPassword))
         }
         Ok(())
     }
@@ -421,13 +410,7 @@ mod tests {
 
         let nullifier = Nullifier::new(coin.repr);
 
-        let own_coin = OwnCoin {
-            coin,
-            note,
-            secret,
-            witness,
-            nullifier,
-        };
+        let own_coin = OwnCoin { coin, note, secret, witness, nullifier };
 
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
@@ -479,13 +462,7 @@ mod tests {
 
         let nullifier = Nullifier::new(coin.repr);
 
-        let own_coin = OwnCoin {
-            coin,
-            note,
-            secret,
-            witness,
-            nullifier,
-        };
+        let own_coin = OwnCoin { coin, note, secret, witness, nullifier };
 
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;
@@ -631,13 +608,7 @@ mod tests {
         // for testing
         let nullifier = Nullifier::new(coin.repr);
 
-        let own_coin = OwnCoin {
-            coin,
-            note,
-            secret,
-            witness,
-            nullifier,
-        };
+        let own_coin = OwnCoin { coin, note, secret, witness, nullifier };
 
         wallet.put_own_coins(own_coin.clone())?;
         wallet.put_own_coins(own_coin.clone())?;