organize the order of using dependencies across the whole project

src/bin/cashierd.rs

@@ -1,14 +1,15 @@
 use async_std::sync::{Arc, Mutex};
+use std::collections::HashMap;
+use std::iter::FromIterator;
+use std::path::PathBuf;
+use std::str::FromStr;
+
 use async_trait::async_trait;
 use clap::clap_app;
 use ff::Field;
 use log::debug;
 use rand::rngs::OsRng;
 use serde_json::{json, Value};
-use std::collections::HashMap;
-use std::iter::FromIterator;
-use std::path::PathBuf;
-use std::str::FromStr;
 
 use drk::{
     blockchain::{rocks::columns, Rocks, RocksColumn},

src/bin/darkfid.rs

@@ -1,3 +1,13 @@
+use async_std::sync::{Arc, Mutex};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use async_trait::async_trait;
+use clap::clap_app;
+use log::debug;
+use serde_json::{json, Value};
+
 use drk::{
     blockchain::{rocks::columns, Rocks, RocksColumn},
     cli::{Config, DarkfidConfig},
@@ -19,16 +29,6 @@ use drk::{
     Error, Result,
 };
 
-use async_trait::async_trait;
-use clap::clap_app;
-use log::debug;
-use serde_json::{json, Value};
-
-use async_std::sync::{Arc, Mutex};
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::str::FromStr;
-
 #[derive(Clone, Debug)]
 pub struct Cashier {
     pub name: String,
@@ -509,7 +509,6 @@ async fn main() -> Result<()> {
     let mut cashier_keys = Vec::new();
 
     for cashier in config.clone().cashiers {
-
         if cashier.public_key.is_empty() {
             return Err(Error::CashierKeysNotFound);
         }
@@ -545,7 +544,6 @@ async fn main() -> Result<()> {
     let (mint_params, mint_pvk) = load_params(mint_params_path)?;
     let (spend_params, spend_pvk) = load_params(spend_params_path)?;
 
-
     let client = Client::new(
         rocks.clone(),
         (

src/bin/drk.rs

@@ -1,18 +1,17 @@
+use std::path::PathBuf;
+use std::str::FromStr;
+
 #[macro_use]
 extern crate prettytable;
+use clap::{clap_app, ArgMatches};
+use log::debug;
 use prettytable::Table;
+use serde_json::{json, Value};
 
 use drk::cli::{Config, DrkConfig};
 use drk::util::{join_config_path, NetworkName};
 use drk::{rpc::jsonrpc, rpc::jsonrpc::JsonResult, Error, Result};
 
-use clap::{clap_app, ArgMatches};
-use log::debug;
-use serde_json::{json, Value};
-
-use std::path::PathBuf;
-use std::str::FromStr;
-
 struct Drk {
     url: String,
 }

src/bin/gatewayd.rs

@@ -1,8 +1,9 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
 use async_executor::Executor;
 use clap::clap_app;
 use easy_parallel::Parallel;
-use std::path::PathBuf;
-use std::sync::Arc;
 
 use drk::{
     blockchain::{rocks::columns, Rocks, RocksColumn},

src/blockchain/rocks.rs

@@ -2,11 +2,11 @@ use async_std::sync::Arc;
 use std::marker::PhantomData;
 use std::path::Path;
 
+use rocksdb::{ColumnFamily, ColumnFamilyDescriptor, Options, DB};
+
 use crate::serial::{deserialize, serialize, Decodable, Encodable};
 use crate::{Error, Result};
 
-use rocksdb::{ColumnFamily, ColumnFamilyDescriptor, Options, DB};
-
 pub enum IteratorMode {
     Start,
     End,

src/blockchain/slabstore.rs

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

src/cli/cli_config.rs

@@ -1,5 +1,3 @@
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
 use std::{
     fs,
     marker::PhantomData,
@@ -8,6 +6,9 @@ use std::{
     str,
 };
 
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+
 use crate::{Error, Result};
 
 pub fn load_keypair_to_str(path: PathBuf) -> Result<String> {

src/client.rs

@@ -1,11 +1,11 @@
+use std::collections::HashMap;
+use std::net::SocketAddr;
+
 use async_std::sync::{Arc, Mutex};
 use bellman::groth16;
 use bls12_381::Bls12;
 use log::*;
 
-use std::collections::HashMap;
-use std::net::SocketAddr;
-
 use crate::{
     blockchain::{rocks::columns, Rocks, RocksColumn, Slab},
     crypto::{

src/lib.rs

@@ -1,6 +1,7 @@
+use std::collections::{HashMap, HashSet};
+
 use bellman::groth16;
 use bls12_381::{Bls12, Scalar};
-use std::collections::{HashMap, HashSet};
 
 pub mod async_serial;
 pub mod blockchain;

src/rpc/websockets.rs

@@ -1,10 +1,11 @@
+use std::net::{TcpStream, ToSocketAddrs};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
 use async_native_tls::{TlsConnector, TlsStream};
 use async_tungstenite::WebSocketStream;
 use futures::sink::Sink;
 use smol::{prelude::*, Async};
-use std::net::{TcpStream, ToSocketAddrs};
-use std::pin::Pin;
-use std::task::{Context, Poll};
 use tungstenite::handshake::client::Response;
 use tungstenite::Message;
 use url::Url;

src/serial.rs

@@ -1,9 +1,10 @@
-use bls12_381 as bls;
 use std::borrow::Cow;
 use std::io::{Cursor, Read, Write};
 use std::net::{IpAddr, SocketAddr};
 use std::{io, mem};
 
+use bls12_381 as bls;
+
 use crate::endian;
 use crate::error::{Error, Result};
 

src/service/bridge.rs

@@ -1,13 +1,13 @@
-use crate::util::NetworkName;
-use crate::{Error, Result};
+use async_std::sync::{Arc, Mutex};
+use std::collections::HashMap;
 
 use async_trait::async_trait;
 use futures::stream::FuturesUnordered;
 use futures::stream::StreamExt;
 use log::*;
 
-use async_std::sync::{Arc, Mutex};
-use std::collections::HashMap;
+use crate::util::NetworkName;
+use crate::{Error, Result};
 
 pub struct BridgeRequests {
     pub network: NetworkName,

src/service/btc.rs

@@ -1,8 +1,8 @@
-use super::bridge::{NetworkClient, TokenNotification, TokenSubscribtion};
-use crate::rpc::{jsonrpc, websockets::WsStream};
-use crate::serial::{deserialize, serialize, Decodable, Encodable};
-use crate::util::{generate_id, NetworkName};
-use crate::{Error, Result};
+use async_std::sync::Arc;
+use serde_json::json;
+use std::convert::From;
+use std::str::FromStr;
+
 use async_trait::async_trait;
 use bitcoin::blockdata::{
     script::{Builder, Script},
@@ -19,14 +19,15 @@ use secp256k1::{
     constants::{PUBLIC_KEY_SIZE, SECRET_KEY_SIZE},
     key::{PublicKey, SecretKey},
     {rand::rngs::OsRng, Secp256k1},
-    {All, Message as BtcMessage, /*Secp256k1,*/},
+    {All, Message as BtcMessage /*Secp256k1,*/},
 };
-use serde_json::json;
-use std::convert::From;
 use tungstenite::Message;
 
-use async_std::sync::Arc;
-use std::str::FromStr;
+use super::bridge::{NetworkClient, TokenNotification, TokenSubscribtion};
+use crate::rpc::{jsonrpc, websockets::WsStream};
+use crate::serial::{deserialize, serialize, Decodable, Encodable};
+use crate::util::{generate_id, NetworkName};
+use crate::{Error, Result};
 
 // Swap out these types for any future non bitcoin-rs types
 pub type PubAddress = Address;
@@ -269,7 +270,6 @@ impl BtcClient {
             let script_pubkey = BtcKeys::derive_btc_script_pubkey(*pubkey, self.network);
 
             let _ = client.script_unsubscribe(&script_pubkey).unwrap();
-
         }
 
         let unsubscription = jsonrpc::request(json!("accountUnsubscribe"), json!([sub_id]));

src/service/gateway.rs

@@ -2,11 +2,12 @@ use async_std::sync::Arc;
 use std::convert::From;
 use std::net::SocketAddr;
 
+use async_executor::Executor;
+use log::*;
+
 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 async_executor::Executor;
-use log::*;
 
 pub type GatewaySlabsSubscriber = async_channel::Receiver<Slab>;
 

src/service/reqrep.rs

@@ -3,9 +3,6 @@ use std::convert::TryFrom;
 use std::io;
 use std::net::SocketAddr;
 
-use crate::serial::{deserialize, serialize};
-use crate::{Decodable, Encodable, Result};
-
 use async_executor::Executor;
 use bytes::Bytes;
 use futures::FutureExt;
@@ -14,6 +11,9 @@ use rand::Rng;
 use signal_hook::{consts::SIGINT, iterator::Signals};
 use zeromq::*;
 
+use crate::serial::{deserialize, serialize};
+use crate::{Decodable, Encodable, Result};
+
 pub type PeerId = Vec<u8>;
 
 pub type Channels = (

src/service/sol.rs

@@ -1,9 +1,9 @@
+use async_std::sync::{Arc, Mutex};
 use std::convert::TryFrom;
 use std::str::FromStr;
 use std::time::Duration;
 
 use async_native_tls::TlsConnector;
-use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use futures::{SinkExt, StreamExt};
 use log::{debug, error, info, warn};
@@ -27,7 +27,6 @@ use crate::rpc::{jsonrpc, jsonrpc::JsonResult, websockets, websockets::WsStream}
 use crate::serial::{deserialize, serialize, Decodable, Encodable};
 use crate::util::{generate_id, NetworkName};
 use crate::{Error, Result};
-
 use super::bridge::{NetworkClient, TokenNotification, TokenSubscribtion};
 
 pub const SOL_NATIVE_TOKEN_ID: &str = "So11111111111111111111111111111111111111112";

src/state.rs

@@ -1,7 +1,8 @@
+use std::fmt;
+
 use bellman::groth16;
 use bls12_381::Bls12;
 use log::debug;
-use std::fmt;
 
 use crate::{
     crypto::{coin::Coin, merkle_node::MerkleNode, note::EncryptedNote, nullifier::Nullifier},

src/util/net_name.rs

@@ -1,8 +1,9 @@
+use std::str::FromStr;
+
 use crate::{
     serial::{Decodable, Encodable},
     Result,
 };
-use std::str::FromStr;
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub enum NetworkName {

src/util/parse.rs

@@ -1,6 +1,7 @@
-use sha2::{Digest, Sha256};
-use std::iter::FromIterator;
 use std::str::FromStr;
+use std::iter::FromIterator;
+
+use sha2::{Digest, Sha256};
 
 use crate::{
     serial::{deserialize, serialize},

src/util/token_list.rs

@@ -1,6 +1,7 @@
-use serde_json::Value;
 use std::collections::HashMap;
 
+use serde_json::Value;
+
 use crate::{
     util::{generate_id, NetworkName},
     Error, Result,

src/wallet/cashierdb.rs

@@ -1,13 +1,13 @@
-use super::{Keypair, WalletApi};
-use crate::client::ClientFailed;
-use crate::util::NetworkName;
-use crate::{Error, Result};
-
 use async_std::sync::{Arc, Mutex};
+use std::path::{Path, PathBuf};
+
 use log::*;
 use rusqlite::{named_params, params, Connection};
 
-use std::path::{Path, PathBuf};
+use super::{Keypair, WalletApi};
+use crate::client::ClientFailed;
+use crate::util::NetworkName;
+use crate::{Error, Result};
 
 pub type CashierDbPtr = Arc<CashierDb>;
 

src/wallet/wallet_api.rs

@@ -1,8 +1,8 @@
+use std::path::PathBuf;
+
 use crate::serial::{deserialize, serialize, Decodable, Encodable};
 use crate::Result;
 
-use std::path::PathBuf;
-
 pub trait WalletApi {
     fn get_password(&self) -> String;
     fn get_path(&self) -> PathBuf;

src/wallet/walletdb.rs

@@ -1,3 +1,12 @@
+use async_std::sync::{Arc, Mutex};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use ff::Field;
+use log::*;
+use rand::rngs::OsRng;
+use rusqlite::{named_params, params, Connection};
+
 use super::WalletApi;
 use crate::client::ClientFailed;
 use crate::crypto::{
@@ -6,15 +15,6 @@ use crate::crypto::{
 use crate::serial;
 use crate::{Error, Result};
 
-use async_std::sync::{Arc, Mutex};
-use ff::Field;
-use log::*;
-use rand::rngs::OsRng;
-use rusqlite::{named_params, params, Connection};
-
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-
 pub type WalletPtr = Arc<WalletDb>;
 
 #[derive(Debug, Clone)]
@@ -674,5 +674,4 @@ mod tests {
 
         Ok(())
     }
-
 }