Revert "Reformat imports to a consistent style for imports"

This reverts commit 139d15cd84.

account-decoder/src/lib.rs

@@ -17,10 +17,8 @@ pub mod validator_info;
 use {
     crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount},
     solana_sdk::{
-        account::{ReadableAccount, WritableAccount},
-        clock::Epoch,
-        fee_calculator::FeeCalculator,
-        pubkey::Pubkey,
+        account::ReadableAccount, account::WritableAccount, clock::Epoch,
+        fee_calculator::FeeCalculator, pubkey::Pubkey,
     },
     std::{
         io::{Read, Write},
@@ -204,10 +202,8 @@ fn slice_data(data: &[u8], data_slice_config: Option<UiDataSliceConfig>) -> &[u8
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_sdk::account::{Account, AccountSharedData},
-    };
+    use super::*;
+    use solana_sdk::account::{Account, AccountSharedData};
 
     #[test]
     fn test_slice_data() {

account-decoder/src/parse_account_data.rs

@@ -1,5 +1,4 @@
-use {
-    crate::{
+use crate::{
     parse_bpf_loader::parse_bpf_upgradeable_loader,
     parse_config::parse_config,
     parse_nonce::parse_nonce,
@@ -7,13 +6,12 @@ use {
     parse_sysvar::parse_sysvar,
     parse_token::{parse_token, spl_token_id},
     parse_vote::parse_vote,
-    },
-    inflector::Inflector,
-    serde_json::Value,
-    solana_sdk::{instruction::InstructionError, pubkey::Pubkey, stake, system_program, sysvar},
-    std::collections::HashMap,
-    thiserror::Error,
 };
+use inflector::Inflector;
+use serde_json::Value;
+use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, stake, system_program, sysvar};
+use std::collections::HashMap;
+use thiserror::Error;
 
 lazy_static! {
     static ref BPF_UPGRADEABLE_LOADER_PROGRAM_ID: Pubkey = solana_sdk::bpf_loader_upgradeable::id();
@@ -114,14 +112,12 @@ pub fn parse_account_data(
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_sdk::nonce::{
+    use super::*;
+    use solana_sdk::nonce::{
         state::{Data, Versions},
         State,
-        },
-        solana_vote_program::vote_state::{VoteState, VoteStateVersions},
     };
+    use solana_vote_program::vote_state::{VoteState, VoteStateVersions};
 
     #[test]
     fn test_parse_account_data() {

account-decoder/src/parse_bpf_loader.rs

@@ -1,11 +1,9 @@
-use {
-    crate::{
+use crate::{
     parse_account_data::{ParsableAccount, ParseAccountError},
     UiAccountData, UiAccountEncoding,
-    },
-    bincode::{deserialize, serialized_size},
-    solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey},
 };
+use bincode::{deserialize, serialized_size};
+use solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey};
 
 pub fn parse_bpf_upgradeable_loader(
     data: &[u8],
@@ -92,7 +90,9 @@ pub struct UiProgramData {
 
 #[cfg(test)]
 mod test {
-    use {super::*, bincode::serialize, solana_sdk::pubkey::Pubkey};
+    use super::*;
+    use bincode::serialize;
+    use solana_sdk::pubkey::Pubkey;
 
     #[test]
     fn test_parse_bpf_upgradeable_loader_accounts() {

account-decoder/src/parse_config.rs

@@ -1,16 +1,12 @@
-use {
-    crate::{
+use crate::{
     parse_account_data::{ParsableAccount, ParseAccountError},
     validator_info,
-    },
-    bincode::deserialize,
-    serde_json::Value,
-    solana_config_program::{get_config_data, ConfigKeys},
-    solana_sdk::{
-        pubkey::Pubkey,
-        stake::config::{self as stake_config, Config as StakeConfig},
-    },
 };
+use bincode::deserialize;
+use serde_json::Value;
+use solana_config_program::{get_config_data, ConfigKeys};
+use solana_sdk::pubkey::Pubkey;
+use solana_sdk::stake::config::{self as stake_config, Config as StakeConfig};
 
 pub fn parse_config(data: &[u8], pubkey: &Pubkey) -> Result<ConfigAccountType, ParseAccountError> {
     let parsed_account = if pubkey == &stake_config::id() {
@@ -91,10 +87,11 @@ pub struct UiConfig<T> {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*, crate::validator_info::ValidatorInfo, serde_json::json,
-        solana_config_program::create_config_account, solana_sdk::account::ReadableAccount,
-    };
+    use super::*;
+    use crate::validator_info::ValidatorInfo;
+    use serde_json::json;
+    use solana_config_program::create_config_account;
+    use solana_sdk::account::ReadableAccount;
 
     #[test]
     fn test_parse_config() {

account-decoder/src/parse_nonce.rs

@@ -1,9 +1,7 @@
-use {
-    crate::{parse_account_data::ParseAccountError, UiFeeCalculator},
-    solana_sdk::{
+use crate::{parse_account_data::ParseAccountError, UiFeeCalculator};
+use solana_sdk::{
     instruction::InstructionError,
     nonce::{state::Versions, State},
-    },
 };
 
 pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> {
@@ -44,16 +42,14 @@ pub struct UiNonceData {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_sdk::{
+    use super::*;
+    use solana_sdk::{
         hash::Hash,
         nonce::{
             state::{Data, Versions},
             State,
         },
         pubkey::Pubkey,
-        },
     };
 
     #[test]

account-decoder/src/parse_stake.rs

@@ -1,14 +1,10 @@
-use {
-    crate::{
+use crate::{
     parse_account_data::{ParsableAccount, ParseAccountError},
     StringAmount,
-    },
-    bincode::deserialize,
-    solana_sdk::{
-        clock::{Epoch, UnixTimestamp},
-        stake::state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState},
-    },
 };
+use bincode::deserialize;
+use solana_sdk::clock::{Epoch, UnixTimestamp};
+use solana_sdk::stake::state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState};
 
 pub fn parse_stake(data: &[u8]) -> Result<StakeAccountType, ParseAccountError> {
     let stake_state: StakeState = deserialize(data)
@@ -136,7 +132,8 @@ impl From<Delegation> for UiDelegation {
 
 #[cfg(test)]
 mod test {
-    use {super::*, bincode::serialize};
+    use super::*;
+    use bincode::serialize;
 
     #[test]
     fn test_parse_stake() {

account-decoder/src/parse_sysvar.rs

@@ -1,11 +1,10 @@
-use {
-    crate::{
+use crate::{
     parse_account_data::{ParsableAccount, ParseAccountError},
     StringAmount, UiFeeCalculator,
-    },
-    bincode::deserialize,
-    bv::BitVec,
-    solana_sdk::{
+};
+use bincode::deserialize;
+use bv::BitVec;
+use solana_sdk::{
     clock::{Clock, Epoch, Slot, UnixTimestamp},
     epoch_schedule::EpochSchedule,
     pubkey::Pubkey,
@@ -14,7 +13,6 @@ use {
     slot_history::{self, SlotHistory},
     stake_history::{StakeHistory, StakeHistoryEntry},
     sysvar::{self, fees::Fees, recent_blockhashes::RecentBlockhashes, rewards::Rewards},
-    },
 };
 
 pub fn parse_sysvar(data: &[u8], pubkey: &Pubkey) -> Result<SysvarAccountType, ParseAccountError> {
@@ -214,12 +212,10 @@ pub struct UiStakeHistoryEntry {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_sdk::{
+    use super::*;
+    use solana_sdk::{
         account::create_account_for_test, fee_calculator::FeeCalculator, hash::Hash,
         sysvar::recent_blockhashes::IterItem,
-        },
     };
 
     #[test]

account-decoder/src/parse_token.rs

@@ -1,17 +1,15 @@
-use {
-    crate::{
+use crate::{
     parse_account_data::{ParsableAccount, ParseAccountError},
     StringAmount, StringDecimals,
-    },
-    solana_sdk::pubkey::Pubkey,
-    spl_token::{
+};
+use solana_sdk::pubkey::Pubkey;
+use spl_token::{
     solana_program::{
         program_option::COption, program_pack::Pack, pubkey::Pubkey as SplTokenPubkey,
     },
     state::{Account, AccountState, Mint, Multisig},
-    },
-    std::str::FromStr,
 };
+use std::str::FromStr;
 
 // A helper function to convert spl_token::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey

account-decoder/src/parse_vote.rs

@@ -1,11 +1,9 @@
-use {
-    crate::{parse_account_data::ParseAccountError, StringAmount},
-    solana_sdk::{
+use crate::{parse_account_data::ParseAccountError, StringAmount};
+use solana_sdk::{
     clock::{Epoch, Slot},
     pubkey::Pubkey,
-    },
-    solana_vote_program::vote_state::{BlockTimestamp, Lockout, VoteState},
 };
+use solana_vote_program::vote_state::{BlockTimestamp, Lockout, VoteState};
 
 pub fn parse_vote(data: &[u8]) -> Result<VoteAccountType, ParseAccountError> {
     let mut vote_state = VoteState::deserialize(data).map_err(ParseAccountError::from)?;
@@ -123,7 +121,8 @@ struct UiEpochCredits {
 
 #[cfg(test)]
 mod test {
-    use {super::*, solana_vote_program::vote_state::VoteStateVersions};
+    use super::*;
+    use solana_vote_program::vote_state::VoteStateVersions;
 
     #[test]
     fn test_parse_vote() {

accounts-bench/src/main.rs

@@ -1,19 +1,17 @@
 #![allow(clippy::integer_arithmetic)]
 #[macro_use]
 extern crate log;
-use {
-    clap::{crate_description, crate_name, value_t, App, Arg},
-    rayon::prelude::*,
-    solana_measure::measure::Measure,
-    solana_runtime::{
+use clap::{crate_description, crate_name, value_t, App, Arg};
+use rayon::prelude::*;
+use solana_measure::measure::Measure;
+use solana_runtime::{
     accounts::{create_test_accounts, update_accounts_bench, Accounts},
     accounts_db::AccountShrinkThreshold,
     accounts_index::AccountSecondaryIndexes,
     ancestors::Ancestors,
-    },
-    solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey},
-    std::{env, fs, path::PathBuf},
 };
+use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
+use std::{env, fs, path::PathBuf};
 
 fn main() {
     solana_logger::setup();

accounts-cluster-bench/src/main.rs

@@ -1,17 +1,16 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    clap::{crate_description, crate_name, value_t, values_t_or_exit, App, Arg},
-    log::*,
-    rand::{thread_rng, Rng},
-    rayon::prelude::*,
-    solana_account_decoder::parse_token::spl_token_pubkey,
-    solana_clap_utils::input_parsers::pubkey_of,
-    solana_client::rpc_client::RpcClient,
-    solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT},
-    solana_gossip::gossip_service::discover,
-    solana_measure::measure::Measure,
-    solana_runtime::inline_spl_token,
-    solana_sdk::{
+use clap::{crate_description, crate_name, value_t, values_t_or_exit, App, Arg};
+use log::*;
+use rand::{thread_rng, Rng};
+use rayon::prelude::*;
+use solana_account_decoder::parse_token::spl_token_pubkey;
+use solana_clap_utils::input_parsers::pubkey_of;
+use solana_client::rpc_client::RpcClient;
+use solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT};
+use solana_gossip::gossip_service::discover;
+use solana_measure::measure::Measure;
+use solana_runtime::inline_spl_token;
+use solana_sdk::{
     commitment_config::CommitmentConfig,
     message::Message,
     pubkey::Pubkey,
@@ -20,10 +19,10 @@ use {
     system_instruction, system_program,
     timing::timestamp,
     transaction::Transaction,
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    solana_transaction_status::parse_token::spl_token_instruction,
-    std::{
+};
+use solana_streamer::socket::SocketAddrSpace;
+use solana_transaction_status::parse_token::spl_token_instruction;
+use std::{
     net::SocketAddr,
     process::exit,
     sync::{
@@ -32,7 +31,6 @@ use {
     },
     thread::{sleep, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 // Create and close messages both require 2 signatures; if transaction construction changes, update
@@ -703,15 +701,13 @@ fn main() {
 
 #[cfg(test)]
 pub mod test {
-    use {
-        super::*,
-        solana_core::validator::ValidatorConfig,
-        solana_local_cluster::{
+    use super::*;
+    use solana_core::validator::ValidatorConfig;
+    use solana_local_cluster::{
         local_cluster::{ClusterConfig, LocalCluster},
         validator_configs::make_identical_validator_configs,
-        },
-        solana_sdk::poh_config::PohConfig,
     };
+    use solana_sdk::poh_config::PohConfig;
 
     #[test]
     fn test_accounts_cluster_bench() {

accountsdb-plugin-postgres/src/accountsdb_plugin_postgres.rs

@@ -1,4 +1,5 @@
 use solana_measure::measure::Measure;
+
 /// Main entry for the PostgreSQL plugin
 use {
     crate::{

banking-bench/src/main.rs

@@ -1,37 +1,36 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    clap::{crate_description, crate_name, value_t, App, Arg},
-    crossbeam_channel::unbounded,
-    log::*,
-    rand::{thread_rng, Rng},
-    rayon::prelude::*,
-    solana_core::banking_stage::BankingStage,
-    solana_gossip::cluster_info::{ClusterInfo, Node},
-    solana_ledger::{
+use clap::{crate_description, crate_name, value_t, App, Arg};
+use crossbeam_channel::unbounded;
+use log::*;
+use rand::{thread_rng, Rng};
+use rayon::prelude::*;
+use solana_core::banking_stage::BankingStage;
+use solana_gossip::{cluster_info::ClusterInfo, cluster_info::Node};
+use solana_ledger::{
     blockstore::Blockstore,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
     get_tmp_ledger_path,
-    },
-    solana_measure::measure::Measure,
-    solana_perf::packet::to_packets_chunked,
-    solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry},
-    solana_runtime::{
+};
+use solana_measure::measure::Measure;
+use solana_perf::packet::to_packets_chunked;
+use solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry};
+use solana_runtime::{
     accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
     cost_model::CostModel,
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     hash::Hash,
-        signature::{Keypair, Signature},
+    signature::Keypair,
+    signature::Signature,
     system_transaction,
     timing::{duration_as_us, timestamp},
     transaction::Transaction,
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    std::{
+};
+use solana_streamer::socket::SocketAddrSpace;
+use std::{
     sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex, RwLock},
     thread::sleep,
     time::{Duration, Instant},
-    },
 };
 
 fn check_txs(

banks-client/src/lib.rs

@@ -5,38 +5,37 @@
 //! but they are undocumented, may change over time, and are generally more
 //! cumbersome to use.
 
+use borsh::BorshDeserialize;
+use futures::{future::join_all, Future, FutureExt};
 pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
-use {
-    borsh::BorshDeserialize,
-    futures::{future::join_all, Future, FutureExt},
-    solana_banks_interface::{BanksRequest, BanksResponse},
-    solana_program::{
-        clock::{Clock, Slot},
+use solana_banks_interface::{BanksRequest, BanksResponse};
+use solana_program::{
+    clock::Clock,
+    clock::Slot,
     fee_calculator::FeeCalculator,
     hash::Hash,
     program_pack::Pack,
     pubkey::Pubkey,
     rent::Rent,
     sysvar::{self, Sysvar},
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     account::{from_account, Account},
     commitment_config::CommitmentLevel,
     signature::Signature,
     transaction::{self, Transaction},
     transport,
-    },
-    std::io::{self, Error, ErrorKind},
-    tarpc::{
+};
+use std::io::{self, Error, ErrorKind};
+use tarpc::{
     client::{self, channel::RequestDispatch, NewClient},
     context::{self, Context},
     rpc::{ClientMessage, Response},
     serde_transport::tcp,
     Transport,
-    },
-    tokio::{net::ToSocketAddrs, time::Duration},
-    tokio_serde::formats::Bincode,
 };
+use tokio::{net::ToSocketAddrs, time::Duration};
+use tokio_serde::formats::Bincode;
 
 // This exists only for backward compatibility
 pub trait BanksClientExt {}
@@ -349,18 +348,16 @@ pub async fn start_tcp_client<T: ToSocketAddrs>(addr: T) -> io::Result<BanksClie
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_banks_server::banks_server::start_local_server,
-        solana_runtime::{
+    use super::*;
+    use solana_banks_server::banks_server::start_local_server;
+    use solana_runtime::{
         bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache,
         genesis_utils::create_genesis_config,
-        },
-        solana_sdk::{message::Message, signature::Signer, system_instruction},
-        std::sync::{Arc, RwLock},
-        tarpc::transport,
-        tokio::{runtime::Runtime, time::sleep},
     };
+    use solana_sdk::{message::Message, signature::Signer, system_instruction};
+    use std::sync::{Arc, RwLock};
+    use tarpc::transport;
+    use tokio::{runtime::Runtime, time::sleep};
 
     #[test]
     fn test_banks_client_new() {

banks-interface/src/lib.rs

@@ -1,6 +1,5 @@
-use {
-    serde::{Deserialize, Serialize},
-    solana_sdk::{
+use serde::{Deserialize, Serialize};
+use solana_sdk::{
     account::Account,
     clock::Slot,
     commitment_config::CommitmentLevel,
@@ -9,7 +8,6 @@ use {
     pubkey::Pubkey,
     signature::Signature,
     transaction::{self, Transaction, TransactionError},
-    },
 };
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -49,10 +47,8 @@ pub trait Banks {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        tarpc::{client, transport},
-    };
+    use super::*;
+    use tarpc::{client, transport};
 
     #[test]
     fn test_banks_client_new() {

banks-server/src/banks_server.rs

@@ -1,15 +1,14 @@
-use {
-    crate::send_transaction_service::{SendTransactionService, TransactionInfo},
-    bincode::{deserialize, serialize},
-    futures::{
+use crate::send_transaction_service::{SendTransactionService, TransactionInfo};
+use bincode::{deserialize, serialize};
+use futures::{
     future,
     prelude::stream::{self, StreamExt},
-    },
-    solana_banks_interface::{
+};
+use solana_banks_interface::{
     Banks, BanksRequest, BanksResponse, TransactionConfirmationStatus, TransactionStatus,
-    },
-    solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache},
-    solana_sdk::{
+};
+use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache};
+use solana_sdk::{
     account::Account,
     clock::Slot,
     commitment_config::CommitmentLevel,
@@ -19,8 +18,8 @@ use {
     pubkey::Pubkey,
     signature::Signature,
     transaction::{self, Transaction},
-    },
-    std::{
+};
+use std::{
     io,
     net::{Ipv4Addr, SocketAddr},
     sync::{
@@ -29,17 +28,16 @@ use {
     },
     thread::Builder,
     time::Duration,
-    },
-    tarpc::{
+};
+use tarpc::{
     context::Context,
     rpc::{transport::channel::UnboundedChannel, ClientMessage, Response},
     serde_transport::tcp,
     server::{self, Channel, Handler},
     transport,
-    },
-    tokio::time::sleep,
-    tokio_serde::formats::Bincode,
 };
+use tokio::time::sleep;
+use tokio_serde::formats::Bincode;
 
 #[derive(Clone)]
 struct BanksServer {

banks-server/src/rpc_banks_service.rs

@@ -1,23 +1,21 @@
 //! The `rpc_banks_service` module implements the Solana Banks RPC API.
 
-use {
-    crate::banks_server::start_tcp_server,
-    futures::{future::FutureExt, pin_mut, prelude::stream::StreamExt, select},
-    solana_runtime::{bank_forks::BankForks, commitment::BlockCommitmentCache},
-    std::{
+use crate::banks_server::start_tcp_server;
+use futures::{future::FutureExt, pin_mut, prelude::stream::StreamExt, select};
+use solana_runtime::{bank_forks::BankForks, commitment::BlockCommitmentCache};
+use std::{
     net::SocketAddr,
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc, RwLock,
     },
     thread::{self, Builder, JoinHandle},
-    },
-    tokio::{
+};
+use tokio::{
     runtime::Runtime,
     time::{self, Duration},
-    },
-    tokio_stream::wrappers::IntervalStream,
 };
+use tokio_stream::wrappers::IntervalStream;
 
 pub struct RpcBanksService {
     thread_hdl: JoinHandle<()>,
@@ -103,7 +101,8 @@ impl RpcBanksService {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, solana_runtime::bank::Bank};
+    use super::*;
+    use solana_runtime::bank::Bank;
 
     #[test]
     fn test_rpc_banks_server_exit() {

banks-server/src/send_transaction_service.rs

@@ -1,10 +1,9 @@
 // TODO: Merge this implementation with the one at `core/src/send_transaction_service.rs`
-use {
-    log::*,
-    solana_metrics::{datapoint_warn, inc_new_counter_info},
-    solana_runtime::{bank::Bank, bank_forks::BankForks},
-    solana_sdk::signature::Signature,
-    std::{
+use log::*;
+use solana_metrics::{datapoint_warn, inc_new_counter_info};
+use solana_runtime::{bank::Bank, bank_forks::BankForks};
+use solana_sdk::signature::Signature;
+use std::{
     collections::HashMap,
     net::{SocketAddr, UdpSocket},
     sync::{
@@ -13,7 +12,6 @@ use {
     },
     thread::{self, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 /// Maximum size of the transaction queue
@@ -185,14 +183,12 @@ impl SendTransactionService {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_sdk::{
+    use super::*;
+    use solana_sdk::{
         genesis_config::create_genesis_config, pubkey::Pubkey, signature::Signer,
         system_transaction,
-        },
-        std::sync::mpsc::channel,
     };
+    use std::sync::mpsc::channel;
 
     #[test]
     fn service_exit() {

bench-exchange/src/bench.rs

@@ -1,29 +1,28 @@
 #![allow(clippy::useless_attribute)]
 #![allow(clippy::integer_arithmetic)]
 
-use {
-    crate::order_book::*,
-    itertools::izip,
-    log::*,
-    rand::{thread_rng, Rng},
-    rayon::prelude::*,
-    solana_client::perf_utils::{sample_txs, SampleStats},
-    solana_core::gen_keys::GenKeys,
-    solana_exchange_program::{exchange_instruction, exchange_state::*, id},
-    solana_faucet::faucet::request_airdrop_transaction,
-    solana_genesis::Base64Account,
-    solana_metrics::datapoint_info,
-    solana_sdk::{
+use crate::order_book::*;
+use itertools::izip;
+use log::*;
+use rand::{thread_rng, Rng};
+use rayon::prelude::*;
+use solana_client::perf_utils::{sample_txs, SampleStats};
+use solana_core::gen_keys::GenKeys;
+use solana_exchange_program::{exchange_instruction, exchange_state::*, id};
+use solana_faucet::faucet::request_airdrop_transaction;
+use solana_genesis::Base64Account;
+use solana_metrics::datapoint_info;
+use solana_sdk::{
     client::{Client, SyncClient},
     commitment_config::CommitmentConfig,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
-        system_instruction, system_program,
     timing::{duration_as_ms, duration_as_s},
     transaction::Transaction,
-    },
-    std::{
+    {system_instruction, system_program},
+};
+use std::{
     cmp,
     collections::{HashMap, VecDeque},
     fs::File,
@@ -39,7 +38,6 @@ use {
     },
     thread::{sleep, Builder},
     time::{Duration, Instant},
-    },
 };
 
 // TODO Chunk length as specified results in a bunch of failures, divide by 10 helps...

bench-exchange/src/cli.rs

@@ -1,10 +1,10 @@
-use {
-    clap::{crate_description, crate_name, value_t, App, Arg, ArgMatches},
-    solana_core::gen_keys::GenKeys,
-    solana_faucet::faucet::FAUCET_PORT,
-    solana_sdk::signature::{read_keypair_file, Keypair},
-    std::{net::SocketAddr, process::exit, time::Duration},
-};
+use clap::{crate_description, crate_name, value_t, App, Arg, ArgMatches};
+use solana_core::gen_keys::GenKeys;
+use solana_faucet::faucet::FAUCET_PORT;
+use solana_sdk::signature::{read_keypair_file, Keypair};
+use std::net::SocketAddr;
+use std::process::exit;
+use std::time::Duration;
 
 pub struct Config {
     pub entrypoint_addr: SocketAddr,

bench-exchange/src/main.rs

@@ -3,13 +3,11 @@ pub mod bench;
 mod cli;
 pub mod order_book;
 
-use {
-    crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config},
-    log::*,
-    solana_gossip::gossip_service::{discover_cluster, get_multi_client},
-    solana_sdk::signature::Signer,
-    solana_streamer::socket::SocketAddrSpace,
-};
+use crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config};
+use log::*;
+use solana_gossip::gossip_service::{discover_cluster, get_multi_client};
+use solana_sdk::signature::Signer;
+use solana_streamer::socket::SocketAddrSpace;
 
 fn main() {
     solana_logger::setup();

bench-exchange/src/order_book.rs

@@ -1,13 +1,11 @@
-use {
-    itertools::{
-        EitherOrBoth::{Both, Left, Right},
-        Itertools,
-    },
-    log::*,
-    solana_exchange_program::exchange_state::*,
-    solana_sdk::pubkey::Pubkey,
-    std::{cmp::Ordering, collections::BinaryHeap, error, fmt},
-};
+use itertools::EitherOrBoth::{Both, Left, Right};
+use itertools::Itertools;
+use log::*;
+use solana_exchange_program::exchange_state::*;
+use solana_sdk::pubkey::Pubkey;
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+use std::{error, fmt};
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ToOrder {

bench-exchange/tests/bench_exchange.rs

@@ -1,24 +1,22 @@
-use {
-    log::*,
-    solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config},
-    solana_core::validator::ValidatorConfig,
-    solana_exchange_program::{
+use log::*;
+use solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config};
+use solana_core::validator::ValidatorConfig;
+use solana_exchange_program::{
     exchange_processor::process_instruction, id, solana_exchange_program,
-    },
-    solana_faucet::faucet::run_local_faucet_with_port,
-    solana_gossip::gossip_service::{discover_cluster, get_multi_client},
-    solana_local_cluster::{
+};
+use solana_faucet::faucet::run_local_faucet_with_port;
+use solana_gossip::gossip_service::{discover_cluster, get_multi_client};
+use solana_local_cluster::{
     local_cluster::{ClusterConfig, LocalCluster},
     validator_configs::make_identical_validator_configs,
-    },
-    solana_runtime::{bank::Bank, bank_client::BankClient},
-    solana_sdk::{
+};
+use solana_runtime::{bank::Bank, bank_client::BankClient};
+use solana_sdk::{
     genesis_config::create_genesis_config,
     signature::{Keypair, Signer},
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    std::{process::exit, sync::mpsc::channel, time::Duration},
 };
+use solana_streamer::socket::SocketAddrSpace;
+use std::{process::exit, sync::mpsc::channel, time::Duration};
 
 #[test]
 #[ignore]

bench-streamer/src/main.rs

@@ -1,22 +1,16 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    clap::{crate_description, crate_name, App, Arg},
-    solana_streamer::{
-        packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE},
-        streamer::{receiver, PacketReceiver},
-    },
-    std::{
-        cmp::max,
-        net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
-        sync::{
-            atomic::{AtomicBool, AtomicUsize, Ordering},
-            mpsc::channel,
-            Arc,
-        },
-        thread::{sleep, spawn, JoinHandle, Result},
-        time::{Duration, SystemTime},
-    },
-};
+use clap::{crate_description, crate_name, App, Arg};
+use solana_streamer::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE};
+use solana_streamer::streamer::{receiver, PacketReceiver};
+use std::cmp::max;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::Arc;
+use std::thread::sleep;
+use std::thread::{spawn, JoinHandle, Result};
+use std::time::Duration;
+use std::time::SystemTime;
 
 fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
     let send = UdpSocket::bind("0.0.0.0:0").unwrap();

bench-tps/src/bench.rs

@@ -1,13 +1,12 @@
-use {
-    crate::cli::Config,
-    log::*,
-    rayon::prelude::*,
-    solana_client::perf_utils::{sample_txs, SampleStats},
-    solana_core::gen_keys::GenKeys,
-    solana_faucet::faucet::request_airdrop_transaction,
-    solana_measure::measure::Measure,
-    solana_metrics::{self, datapoint_info},
-    solana_sdk::{
+use crate::cli::Config;
+use log::*;
+use rayon::prelude::*;
+use solana_client::perf_utils::{sample_txs, SampleStats};
+use solana_core::gen_keys::GenKeys;
+use solana_faucet::faucet::request_airdrop_transaction;
+use solana_measure::measure::Measure;
+use solana_metrics::{self, datapoint_info};
+use solana_sdk::{
     client::Client,
     clock::{DEFAULT_S_PER_SLOT, MAX_PROCESSING_AGE},
     commitment_config::CommitmentConfig,
@@ -19,8 +18,8 @@ use {
     system_instruction, system_transaction,
     timing::{duration_as_ms, duration_as_s, duration_as_us, timestamp},
     transaction::Transaction,
-    },
-    std::{
+};
+use std::{
     collections::{HashSet, VecDeque},
     net::SocketAddr,
     process::exit,
@@ -30,7 +29,6 @@ use {
     },
     thread::{sleep, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 // The point at which transactions become "too old", in seconds.
@@ -926,14 +924,12 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_runtime::{bank::Bank, bank_client::BankClient},
-        solana_sdk::{
-            client::SyncClient, fee_calculator::FeeRateGovernor,
-            genesis_config::create_genesis_config,
-        },
-    };
+    use super::*;
+    use solana_runtime::bank::Bank;
+    use solana_runtime::bank_client::BankClient;
+    use solana_sdk::client::SyncClient;
+    use solana_sdk::fee_calculator::FeeRateGovernor;
+    use solana_sdk::genesis_config::create_genesis_config;
 
     #[test]
     fn test_bench_tps_bank_client() {

bench-tps/src/cli.rs

@@ -1,13 +1,11 @@
-use {
-    clap::{crate_description, crate_name, App, Arg, ArgMatches},
-    solana_faucet::faucet::FAUCET_PORT,
-    solana_sdk::{
-        fee_calculator::FeeRateGovernor,
+use clap::{crate_description, crate_name, App, Arg, ArgMatches};
+use solana_faucet::faucet::FAUCET_PORT;
+use solana_sdk::fee_calculator::FeeRateGovernor;
+use solana_sdk::{
     pubkey::Pubkey,
     signature::{read_keypair_file, Keypair},
-    },
-    std::{net::SocketAddr, process::exit, time::Duration},
 };
+use std::{net::SocketAddr, process::exit, time::Duration};
 
 const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;
 

bench-tps/src/main.rs

@@ -1,20 +1,14 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    log::*,
-    solana_bench_tps::{
-        bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs},
-        cli,
-    },
-    solana_genesis::Base64Account,
-    solana_gossip::gossip_service::{discover_cluster, get_client, get_multi_client},
-    solana_sdk::{
-        fee_calculator::FeeRateGovernor,
-        signature::{Keypair, Signer},
-        system_program,
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc},
-};
+use log::*;
+use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs};
+use solana_bench_tps::cli;
+use solana_genesis::Base64Account;
+use solana_gossip::gossip_service::{discover_cluster, get_client, get_multi_client};
+use solana_sdk::fee_calculator::FeeRateGovernor;
+use solana_sdk::signature::{Keypair, Signer};
+use solana_sdk::system_program;
+use solana_streamer::socket::SocketAddrSpace;
+use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc};
 
 /// Number of signatures for all transactions in ~1 week at ~100K TPS
 pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 7;

bench-tps/tests/bench_tps.rs

@@ -1,24 +1,22 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    serial_test::serial,
-    solana_bench_tps::{
+use serial_test::serial;
+use solana_bench_tps::{
     bench::{do_bench_tps, generate_and_fund_keypairs},
     cli::Config,
-    },
-    solana_client::thin_client::create_client,
-    solana_core::validator::ValidatorConfig,
-    solana_faucet::faucet::run_local_faucet_with_port,
-    solana_gossip::cluster_info::VALIDATOR_PORT_RANGE,
-    solana_local_cluster::{
+};
+use solana_client::thin_client::create_client;
+use solana_core::validator::ValidatorConfig;
+use solana_faucet::faucet::run_local_faucet_with_port;
+use solana_gossip::cluster_info::VALIDATOR_PORT_RANGE;
+use solana_local_cluster::{
     local_cluster::{ClusterConfig, LocalCluster},
     validator_configs::make_identical_validator_configs,
-    },
-    solana_sdk::signature::{Keypair, Signer},
-    solana_streamer::socket::SocketAddrSpace,
-    std::{
+};
+use solana_sdk::signature::{Keypair, Signer};
+use solana_streamer::socket::SocketAddrSpace;
+use std::{
     sync::{mpsc::channel, Arc},
     time::Duration,
-    },
 };
 
 fn test_bench_tps_local_cluster(config: Config) {

clap-utils/src/input_parsers.rs

@@ -196,12 +196,10 @@ pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentC
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        clap::{App, Arg},
-        solana_sdk::signature::write_keypair_file,
-        std::fs,
-    };
+    use super::*;
+    use clap::{App, Arg};
+    use solana_sdk::signature::write_keypair_file;
+    use std::fs;
 
     fn app<'ab, 'v>() -> App<'ab, 'v> {
         App::new("test")

clap-utils/src/input_validators.rs

@@ -7,7 +7,8 @@ use {
         pubkey::{Pubkey, MAX_SEED_LEN},
         signature::{read_keypair_file, Signature},
     },
-    std::{fmt::Display, str::FromStr},
+    std::fmt::Display,
+    std::str::FromStr,
 };
 
 fn is_parsable_generic<U, T>(string: T) -> Result<(), String>

clap-utils/src/keypair.rs

@@ -1123,14 +1123,14 @@ fn sanitize_seed_phrase(seed_phrase: &str) -> String {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::offline::OfflineArgs,
-        clap::{value_t_or_exit, App, Arg},
-        solana_remote_wallet::{locator::Manufacturer, remote_wallet::initialize_wallet_manager},
-        solana_sdk::{signer::keypair::write_keypair_file, system_instruction},
-        tempfile::{NamedTempFile, TempDir},
-    };
+    use super::*;
+    use crate::offline::OfflineArgs;
+    use clap::{value_t_or_exit, App, Arg};
+    use solana_remote_wallet::locator::Manufacturer;
+    use solana_remote_wallet::remote_wallet::initialize_wallet_manager;
+    use solana_sdk::signer::keypair::write_keypair_file;
+    use solana_sdk::system_instruction;
+    use tempfile::{NamedTempFile, TempDir};
 
     #[test]
     fn test_sanitize_seed_phrase() {

cli-config/src/config.rs

@@ -1,9 +1,7 @@
 // Wallet settings that can be configured for long-term use
-use {
-    serde_derive::{Deserialize, Serialize},
-    std::{collections::HashMap, io, path::Path},
-    url::Url,
-};
+use serde_derive::{Deserialize, Serialize};
+use std::{collections::HashMap, io, path::Path};
+use url::Url;
 
 lazy_static! {
     pub static ref CONFIG_FILE: Option<String> = {

cli-config/src/lib.rs

@@ -3,6 +3,7 @@ extern crate lazy_static;
 
 mod config;
 pub use config::{Config, CONFIG_FILE};
+
 use std::{
     fs::{create_dir_all, File},
     io::{self, Write},

cli-output/src/cli_output.rs

@@ -2525,16 +2525,14 @@ impl VerboseDisplay for CliGossipNodes {}
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        clap::{App, Arg},
-        solana_sdk::{
+    use super::*;
+    use clap::{App, Arg};
+    use solana_sdk::{
         message::Message,
         pubkey::Pubkey,
         signature::{keypair_from_seed, NullSigner, Signature, Signer, SignerError},
         system_instruction,
         transaction::Transaction,
-        },
     };
 
     #[test]

cli-output/src/display.rs

@@ -8,7 +8,8 @@ use {
         program_utils::limited_deserialize, pubkey::Pubkey, stake, transaction::Transaction,
     },
     solana_transaction_status::UiTransactionStatusMeta,
-    spl_memo::{id as spl_memo_id, v1::id as spl_memo_v1_id},
+    spl_memo::id as spl_memo_id,
+    spl_memo::v1::id as spl_memo_v1_id,
     std::{collections::HashMap, fmt, io},
 };
 
@@ -430,7 +431,8 @@ pub fn unix_timestamp_to_string(unix_timestamp: UnixTimestamp) -> String {
 
 #[cfg(test)]
 mod test {
-    use {super::*, solana_sdk::pubkey::Pubkey};
+    use super::*;
+    use solana_sdk::pubkey::Pubkey;
 
     #[test]
     fn test_format_labeled_address() {

cli/src/checks.rs

@@ -1,13 +1,11 @@
-use {
-    crate::cli::CliError,
-    solana_client::{
+use crate::cli::CliError;
+use solana_client::{
     client_error::{ClientError, Result as ClientResult},
     rpc_client::RpcClient,
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message,
     native_token::lamports_to_sol, pubkey::Pubkey,
-    },
 };
 
 pub fn check_account_for_fee(
@@ -151,16 +149,14 @@ pub fn check_unique_pubkeys(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        serde_json::json,
-        solana_client::{
+    use super::*;
+    use serde_json::json;
+    use solana_client::{
         rpc_request::RpcRequest,
         rpc_response::{Response, RpcResponseContext},
-        },
-        solana_sdk::system_instruction,
-        std::collections::HashMap,
     };
+    use solana_sdk::system_instruction;
+    use std::collections::HashMap;
 
     #[test]
     fn test_check_account_for_fees() {

cli/src/clap_app.rs

@@ -1,12 +1,10 @@
-use {
-    crate::{
+use crate::{
     cli::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*, stake::*,
     validator_info::*, vote::*, wallet::*,
-    },
-    clap::{App, AppSettings, Arg, ArgGroup, SubCommand},
-    solana_clap_utils::{self, input_validators::*, keypair::*},
-    solana_cli_config::CONFIG_FILE,
 };
+use clap::{App, AppSettings, Arg, ArgGroup, SubCommand};
+use solana_clap_utils::{self, input_validators::*, keypair::*};
+use solana_cli_config::CONFIG_FILE;
 
 pub fn get_clap_app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, 'v> {
     App::new(name)

cli/src/cli.rs

@@ -1,27 +1,24 @@
-use {
-    crate::{
-        clap_app::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*,
-        spend_utils::*, stake::*, validator_info::*, vote::*, wallet::*,
-    },
-    clap::{crate_description, crate_name, value_t_or_exit, ArgMatches, Shell},
-    log::*,
-    num_traits::FromPrimitive,
-    serde_json::{self, Value},
-    solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*},
-    solana_cli_output::{
+use crate::{
+    clap_app::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*, spend_utils::*,
+    stake::*, validator_info::*, vote::*, wallet::*,
+};
+use clap::{crate_description, crate_name, value_t_or_exit, ArgMatches, Shell};
+use log::*;
+use num_traits::FromPrimitive;
+use serde_json::{self, Value};
+use solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*};
+use solana_cli_output::{
     display::println_name_value, CliSignature, CliValidatorsSortOrder, OutputFormat,
-    },
-    solana_client::{
+};
+use solana_client::{
     blockhash_query::BlockhashQuery,
     client_error::{ClientError, Result as ClientResult},
     nonce_utils,
     rpc_client::RpcClient,
-        rpc_config::{
-            RpcLargestAccountsFilter, RpcSendTransactionConfig, RpcTransactionLogsFilter,
-        },
-    },
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+    rpc_config::{RpcLargestAccountsFilter, RpcSendTransactionConfig, RpcTransactionLogsFilter},
+};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     clock::{Epoch, Slot},
     commitment_config::CommitmentConfig,
     decode_error::DecodeError,
@@ -31,11 +28,10 @@ use {
     signature::{Signature, Signer, SignerError},
     stake::{instruction::LockupArgs, state::Lockup},
     transaction::{Transaction, TransactionError},
-    },
-    solana_vote_program::vote_state::VoteAuthorize,
-    std::{collections::HashMap, error, io::stdout, str::FromStr, sync::Arc, time::Duration},
-    thiserror::Error,
 };
+use solana_vote_program::vote_state::VoteAuthorize;
+use std::{collections::HashMap, error, io::stdout, str::FromStr, sync::Arc, time::Duration};
+use thiserror::Error;
 
 pub const DEFAULT_RPC_TIMEOUT_SECONDS: &str = "30";
 pub const DEFAULT_CONFIRM_TX_TIMEOUT_SECONDS: &str = "5";
@@ -1589,26 +1585,22 @@ where
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        serde_json::{json, Value},
-        solana_client::{
+    use super::*;
+    use serde_json::{json, Value};
+    use solana_client::{
         blockhash_query,
         mock_sender::SIGNATURE,
         rpc_request::RpcRequest,
         rpc_response::{Response, RpcResponseContext},
-        },
-        solana_sdk::{
+    };
+    use solana_sdk::{
         pubkey::Pubkey,
-            signature::{
-                keypair_from_seed, read_keypair_file, write_keypair_file, Keypair, Presigner,
-            },
+        signature::{keypair_from_seed, read_keypair_file, write_keypair_file, Keypair, Presigner},
         stake, system_program,
         transaction::TransactionError,
-        },
-        solana_transaction_status::TransactionConfirmationStatus,
-        std::path::PathBuf,
     };
+    use solana_transaction_status::TransactionConfirmationStatus;
+    use std::path::PathBuf;
 
     fn make_tmp_path(name: &str) -> String {
         let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());

cli/src/cluster_query.rs

@@ -1,39 +1,38 @@
-use {
-    crate::{
+use crate::{
     cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
-    },
-    clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand},
-    console::{style, Emoji},
-    serde::{Deserialize, Serialize},
-    solana_clap_utils::{
+};
+use clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
+use console::{style, Emoji};
+use serde::{Deserialize, Serialize};
+use solana_clap_utils::{
     input_parsers::*,
     input_validators::*,
     keypair::DefaultSigner,
     offline::{blockhash_arg, BLOCKHASH_ARG},
-    },
-    solana_cli_output::{
+};
+use solana_cli_output::{
     display::{
         build_balance_message, format_labeled_address, new_spinner_progress_bar,
         println_name_value, println_transaction, unix_timestamp_to_string, writeln_name_value,
     },
     *,
-    },
-    solana_client::{
+};
+use solana_client::{
     client_error::ClientErrorKind,
     pubsub_client::PubsubClient,
     rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient},
     rpc_config::{
-            RpcAccountInfoConfig, RpcBlockConfig, RpcGetVoteAccountsConfig,
-            RpcLargestAccountsConfig, RpcLargestAccountsFilter, RpcProgramAccountsConfig,
-            RpcTransactionConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
+        RpcAccountInfoConfig, RpcBlockConfig, RpcGetVoteAccountsConfig, RpcLargestAccountsConfig,
+        RpcLargestAccountsFilter, RpcProgramAccountsConfig, RpcTransactionConfig,
+        RpcTransactionLogsConfig, RpcTransactionLogsFilter,
     },
     rpc_filter,
     rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE,
     rpc_response::SlotInfo,
-    },
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::from_account,
     account_utils::StateMut,
     clock::{self, Clock, Slot},
@@ -57,10 +56,10 @@ use {
     },
     timing,
     transaction::Transaction,
-    },
-    solana_transaction_status::UiTransactionEncoding,
-    solana_vote_program::vote_state::VoteState,
-    std::{
+};
+use solana_transaction_status::UiTransactionEncoding;
+use solana_vote_program::vote_state::VoteState;
+use std::{
     collections::{BTreeMap, HashMap, VecDeque},
     fmt,
     str::FromStr,
@@ -70,9 +69,8 @@ use {
     },
     thread::sleep,
     time::{Duration, Instant, SystemTime, UNIX_EPOCH},
-    },
-    thiserror::Error,
 };
+use thiserror::Error;
 
 static CHECK_MARK: Emoji = Emoji("✅ ", "");
 static CROSS_MARK: Emoji = Emoji("❌ ", "");
@@ -2142,13 +2140,11 @@ pub fn process_calculate_rent(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{clap_app::get_clap_app, cli::parse_command},
-        solana_sdk::signature::{write_keypair, Keypair},
-        std::str::FromStr,
-        tempfile::NamedTempFile,
-    };
+    use super::*;
+    use crate::{clap_app::get_clap_app, cli::parse_command};
+    use solana_sdk::signature::{write_keypair, Keypair};
+    use std::str::FromStr;
+    use tempfile::NamedTempFile;
 
     fn make_tmp_file() -> (String, NamedTempFile) {
         let tmp_file = NamedTempFile::new().unwrap();

cli/src/feature.rs

@@ -1,16 +1,15 @@
-use {
-    crate::{
+use crate::{
     cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
-    },
-    clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
-    console::style,
-    serde::{Deserialize, Serialize},
-    solana_clap_utils::{input_parsers::*, input_validators::*, keypair::*},
-    solana_cli_output::{QuietDisplay, VerboseDisplay},
-    solana_client::{client_error::ClientError, rpc_client::RpcClient},
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
+use console::style;
+use serde::{Deserialize, Serialize};
+use solana_clap_utils::{input_parsers::*, input_validators::*, keypair::*};
+use solana_cli_output::{QuietDisplay, VerboseDisplay};
+use solana_client::{client_error::ClientError, rpc_client::RpcClient};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::Account,
     clock::Slot,
     feature::{self, Feature},
@@ -18,13 +17,12 @@ use {
     message::Message,
     pubkey::Pubkey,
     transaction::Transaction,
-    },
-    std::{
+};
+use std::{
     cmp::Ordering,
     collections::{HashMap, HashSet},
     fmt,
     sync::Arc,
-    },
 };
 
 #[derive(Copy, Clone, Debug, PartialEq)]

cli/src/inflation.rs

@@ -1,19 +1,17 @@
-use {
-    crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
-    clap::{App, Arg, ArgMatches, SubCommand},
-    solana_clap_utils::{
+use crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult};
+use clap::{App, Arg, ArgMatches, SubCommand};
+use solana_clap_utils::{
     input_parsers::{pubkeys_of, value_of},
     input_validators::is_valid_pubkey,
     keypair::*,
-    },
-    solana_cli_output::{
-        CliEpochRewardshMetadata, CliInflation, CliKeyedEpochReward, CliKeyedEpochRewards,
-    },
-    solana_client::rpc_client::RpcClient,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{clock::Epoch, pubkey::Pubkey},
-    std::sync::Arc,
 };
+use solana_cli_output::{
+    CliEpochRewardshMetadata, CliInflation, CliKeyedEpochReward, CliKeyedEpochRewards,
+};
+use solana_client::rpc_client::RpcClient;
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{clock::Epoch, pubkey::Pubkey};
+use std::sync::Arc;
 
 #[derive(Debug, PartialEq)]
 pub enum InflationCliCommand {

cli/src/main.rs

@@ -1,21 +1,19 @@
-use {
-    clap::{crate_description, crate_name, value_t_or_exit, ArgMatches},
-    console::style,
-    solana_clap_utils::{
+use clap::{crate_description, crate_name, value_t_or_exit, ArgMatches};
+use console::style;
+use solana_clap_utils::{
     input_validators::normalize_to_url_if_moniker,
     keypair::{CliSigners, DefaultSigner},
     DisplayError,
-    },
-    solana_cli::{
+};
+use solana_cli::{
     clap_app::get_clap_app,
     cli::{parse_command, process_command, CliCommandInfo, CliConfig, SettingType},
-    },
-    solana_cli_config::Config,
-    solana_cli_output::{display::println_name_value, OutputFormat},
-    solana_client::rpc_config::RpcSendTransactionConfig,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    std::{collections::HashMap, error, path::PathBuf, sync::Arc, time::Duration},
 };
+use solana_cli_config::Config;
+use solana_cli_output::{display::println_name_value, OutputFormat};
+use solana_client::rpc_config::RpcSendTransactionConfig;
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use std::{collections::HashMap, error, path::PathBuf, sync::Arc, time::Duration};
 
 pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) {
     let description = match setting_type {

cli/src/memo.rs

@@ -1,7 +1,6 @@
-use {
-    solana_sdk::{instruction::Instruction, pubkey::Pubkey},
-    spl_memo::id,
-};
+use solana_sdk::instruction::Instruction;
+use solana_sdk::pubkey::Pubkey;
+use spl_memo::id;
 
 pub trait WithMemo {
     fn with_memo<T: AsRef<str>>(self, memo: Option<T>) -> Self;

cli/src/nonce.rs

@@ -1,26 +1,25 @@
-use {
-    crate::{
+use crate::{
     checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
-            log_instruction_custom_error, log_instruction_custom_error_ex, CliCommand,
-            CliCommandInfo, CliConfig, CliError, ProcessResult,
+        log_instruction_custom_error, log_instruction_custom_error_ex, CliCommand, CliCommandInfo,
+        CliConfig, CliError, ProcessResult,
     },
     feature::get_feature_is_active,
     memo::WithMemo,
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
-    },
-    clap::{App, Arg, ArgMatches, SubCommand},
-    solana_clap_utils::{
+};
+use clap::{App, Arg, ArgMatches, SubCommand};
+use solana_clap_utils::{
     input_parsers::*,
     input_validators::*,
     keypair::{DefaultSigner, SignerIndex},
     memo::{memo_arg, MEMO_ARG},
     nonce::*,
-    },
-    solana_cli_output::CliNonceAccount,
-    solana_client::{nonce_utils::*, rpc_client::RpcClient},
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_cli_output::CliNonceAccount;
+use solana_client::{nonce_utils::*, rpc_client::RpcClient};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::Account,
     feature_set::merge_nonce_error_into_system_error,
     hash::Hash,
@@ -35,9 +34,8 @@ use {
     },
     system_program,
     transaction::{Transaction, TransactionError},
-    },
-    std::sync::Arc,
 };
+use std::sync::Arc;
 
 pub trait NonceSubCommands {
     fn nonce_subcommands(self) -> Self;
@@ -652,10 +650,9 @@ pub fn process_withdraw_from_nonce_account(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{clap_app::get_clap_app, cli::parse_command},
-        solana_sdk::{
+    use super::*;
+    use crate::{clap_app::get_clap_app, cli::parse_command};
+    use solana_sdk::{
         account::Account,
         account_utils::StateMut,
         fee_calculator::FeeCalculator,
@@ -664,9 +661,8 @@ mod tests {
         nonce_account,
         signature::{read_keypair_file, write_keypair, Keypair, Signer},
         system_program,
-        },
-        tempfile::NamedTempFile,
     };
+    use tempfile::NamedTempFile;
 
     fn make_tmp_file() -> (String, NamedTempFile) {
         let tmp_file = NamedTempFile::new().unwrap();

cli/src/program.rs

@@ -1,37 +1,38 @@
-use {
-    crate::{
+use crate::{
     checks::*,
     cli::{
         log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
         ProcessResult,
     },
-    },
-    bip39::{Language, Mnemonic, MnemonicType, Seed},
-    clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
-    log::*,
-    solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig},
-    solana_bpf_loader_program::{bpf_verifier, BpfError, ThisInstructionMeter},
-    solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*},
-    solana_cli_output::{
+};
+use bip39::{Language, Mnemonic, MnemonicType, Seed};
+use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
+use log::*;
+use solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig};
+use solana_bpf_loader_program::{bpf_verifier, BpfError, ThisInstructionMeter};
+use solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*};
+use solana_cli_output::{
     CliProgram, CliProgramAccountType, CliProgramAuthority, CliProgramBuffer, CliProgramId,
     CliUpgradeableBuffer, CliUpgradeableBuffers, CliUpgradeableProgram,
     CliUpgradeableProgramClosed, CliUpgradeablePrograms,
-    },
-    solana_client::{
+};
+use solana_client::{
     client_error::ClientErrorKind,
     rpc_client::RpcClient,
-        rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig, RpcSendTransactionConfig},
+    rpc_config::RpcSendTransactionConfig,
+    rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig},
     rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType},
     tpu_client::{TpuClient, TpuClientConfig},
-    },
-    solana_rbpf::vm::{Config, Executable},
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_rbpf::vm::{Config, Executable};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::Account,
     account_utils::StateMut,
     bpf_loader, bpf_loader_deprecated,
     bpf_loader_upgradeable::{self, UpgradeableLoaderState},
-        instruction::{Instruction, InstructionError},
+    instruction::Instruction,
+    instruction::InstructionError,
     loader_instruction,
     message::Message,
     native_token::Sol,
@@ -40,16 +41,16 @@ use {
     signature::{keypair_from_seed, read_keypair_file, Keypair, Signature, Signer},
     system_instruction::{self, SystemError},
     system_program,
-        transaction::{Transaction, TransactionError},
-    },
-    std::{
+    transaction::Transaction,
+    transaction::TransactionError,
+};
+use std::{
     fs::File,
     io::{Read, Write},
     mem::size_of,
     path::PathBuf,
     str::FromStr,
     sync::Arc,
-    },
 };
 
 #[derive(Debug, PartialEq)]
@@ -2191,16 +2192,14 @@ fn report_ephemeral_mnemonic(words: usize, mnemonic: bip39::Mnemonic) {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{
+    use super::*;
+    use crate::{
         clap_app::get_clap_app,
         cli::{parse_command, process_command},
-        },
-        serde_json::Value,
-        solana_cli_output::OutputFormat,
-        solana_sdk::signature::write_keypair_file,
     };
+    use serde_json::Value;
+    use solana_cli_output::OutputFormat;
+    use solana_sdk::signature::write_keypair_file;
 
     fn make_tmp_path(name: &str) -> String {
         let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());

cli/src/spend_utils.rs

@@ -1,15 +1,13 @@
-use {
-    crate::{
+use crate::{
     checks::{calculate_fee, check_account_for_balance_with_commitment},
     cli::CliError,
-    },
-    clap::ArgMatches,
-    solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG},
-    solana_client::rpc_client::RpcClient,
-    solana_sdk::{
+};
+use clap::ArgMatches;
+use solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG};
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::{
     commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message,
     native_token::lamports_to_sol, pubkey::Pubkey,
-    },
 };
 
 #[derive(Debug, PartialEq, Clone, Copy)]

cli/src/stake.rs

@@ -1,5 +1,4 @@
-use {
-    crate::{
+use crate::{
     checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
         log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
@@ -8,9 +7,9 @@ use {
     memo::WithMemo,
     nonce::check_nonce_account,
     spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
-    },
-    clap::{value_t, App, Arg, ArgGroup, ArgMatches, SubCommand},
-    solana_clap_utils::{
+};
+use clap::{value_t, App, Arg, ArgGroup, ArgMatches, SubCommand};
+use solana_clap_utils::{
     fee_payer::{fee_payer_arg, FEE_PAYER_ARG},
     input_parsers::*,
     input_validators::*,
@@ -19,17 +18,17 @@ use {
     nonce::*,
     offline::*,
     ArgConstant,
-    },
-    solana_cli_output::{
+};
+use solana_cli_output::{
     return_signers_with_config, CliEpochReward, CliStakeHistory, CliStakeHistoryEntry,
     CliStakeState, CliStakeType, OutputFormat, ReturnSignersConfig,
-    },
-    solana_client::{
+};
+use solana_client::{
     blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
     rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE, rpc_response::RpcInflationReward,
-    },
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::from_account,
     account_utils::StateMut,
     clock::{Clock, UnixTimestamp, SECONDS_PER_DAY},
@@ -46,10 +45,9 @@ use {
     system_instruction::SystemError,
     sysvar::{clock, stake_history},
     transaction::Transaction,
-    },
-    solana_vote_program::vote_state::VoteState,
-    std::{ops::Deref, sync::Arc},
 };
+use solana_vote_program::vote_state::VoteState;
+use std::{ops::Deref, sync::Arc};
 
 pub const STAKE_AUTHORITY_ARG: ArgConstant<'static> = ArgConstant {
     name: "stake_authority",
@@ -2440,18 +2438,16 @@ pub fn process_delegate_stake(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{clap_app::get_clap_app, cli::parse_command},
-        solana_client::blockhash_query,
-        solana_sdk::{
+    use super::*;
+    use crate::{clap_app::get_clap_app, cli::parse_command};
+    use solana_client::blockhash_query;
+    use solana_sdk::{
         hash::Hash,
         signature::{
             keypair_from_seed, read_keypair_file, write_keypair, Keypair, Presigner, Signer,
         },
-        },
-        tempfile::NamedTempFile,
     };
+    use tempfile::NamedTempFile;
 
     fn make_tmp_file() -> (String, NamedTempFile) {
         let tmp_file = NamedTempFile::new().unwrap();

cli/src/test_utils.rs

@@ -1,8 +1,6 @@
-use {
-    solana_client::rpc_client::RpcClient,
-    solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig, pubkey::Pubkey},
-    std::{thread::sleep, time::Duration},
-};
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig, pubkey::Pubkey};
+use std::{thread::sleep, time::Duration};
 
 pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
     (0..5).for_each(|tries| {

cli/src/validator_info.rs

@@ -1,33 +1,31 @@
-use {
-    crate::{
+use crate::{
     cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
-    },
-    bincode::deserialize,
-    clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
-    reqwest::blocking::Client,
-    serde_json::{Map, Value},
-    solana_account_decoder::validator_info::{
+};
+use bincode::deserialize;
+use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
+use reqwest::blocking::Client;
+use serde_json::{Map, Value};
+use solana_account_decoder::validator_info::{
     self, ValidatorInfo, MAX_LONG_FIELD_LENGTH, MAX_SHORT_FIELD_LENGTH,
-    },
-    solana_clap_utils::{
+};
+use solana_clap_utils::{
     input_parsers::pubkey_of,
     input_validators::{is_pubkey, is_url},
     keypair::DefaultSigner,
-    },
-    solana_cli_output::{CliValidatorInfo, CliValidatorInfoVec},
-    solana_client::rpc_client::RpcClient,
-    solana_config_program::{config_instruction, get_config_data, ConfigKeys, ConfigState},
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_cli_output::{CliValidatorInfo, CliValidatorInfoVec};
+use solana_client::rpc_client::RpcClient;
+use solana_config_program::{config_instruction, get_config_data, ConfigKeys, ConfigState};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::Account,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
-    },
-    std::{error, sync::Arc},
 };
+use std::{error, sync::Arc};
 
 // Return an error if a validator details are longer than the max length.
 pub fn check_details_length(string: String) -> Result<(), String> {
@@ -409,12 +407,10 @@ pub fn process_get_validator_info(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::clap_app::get_clap_app,
-        bincode::{serialize, serialized_size},
-        serde_json::json,
-    };
+    use super::*;
+    use crate::clap_app::get_clap_app;
+    use bincode::{serialize, serialized_size};
+    use serde_json::json;
 
     #[test]
     fn test_check_url() {

cli/src/vote.rs

@@ -1,5 +1,4 @@
-use {
-    crate::{
+use crate::{
     checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
         log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
@@ -8,28 +7,27 @@ use {
     memo::WithMemo,
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
     stake::check_current_authority,
-    },
-    clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand},
-    solana_clap_utils::{
+};
+use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
+use solana_clap_utils::{
     input_parsers::*,
     input_validators::*,
     keypair::{DefaultSigner, SignerIndex},
     memo::{memo_arg, MEMO_ARG},
-    },
-    solana_cli_output::{CliEpochVotingHistory, CliLockout, CliVoteAccount},
-    solana_client::rpc_client::RpcClient,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_cli_output::{CliEpochVotingHistory, CliLockout, CliVoteAccount};
+use solana_client::rpc_client::RpcClient;
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     account::Account, commitment_config::CommitmentConfig, message::Message,
     native_token::lamports_to_sol, pubkey::Pubkey, system_instruction::SystemError,
     transaction::Transaction,
-    },
-    solana_vote_program::{
+};
+use solana_vote_program::{
     vote_instruction::{self, withdraw, VoteError},
     vote_state::{VoteAuthorize, VoteInit, VoteState},
-    },
-    std::sync::Arc,
 };
+use std::sync::Arc;
 
 pub trait VoteSubCommands {
     fn vote_subcommands(self) -> Self;
@@ -939,12 +937,10 @@ pub fn process_withdraw_from_vote_account(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{clap_app::get_clap_app, cli::parse_command},
-        solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer},
-        tempfile::NamedTempFile,
-    };
+    use super::*;
+    use crate::{clap_app::get_clap_app, cli::parse_command};
+    use solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer};
+    use tempfile::NamedTempFile;
 
     fn make_tmp_file() -> (String, NamedTempFile) {
         let tmp_file = NamedTempFile::new().unwrap();

cli/src/wallet.rs

@@ -1,5 +1,4 @@
-use {
-    crate::{
+use crate::{
     cli::{
         log_instruction_custom_error, request_and_confirm_airdrop, CliCommand, CliCommandInfo,
         CliConfig, CliError, ProcessResult,
@@ -7,10 +6,10 @@ use {
     memo::WithMemo,
     nonce::check_nonce_account,
     spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
-    },
-    clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand},
-    solana_account_decoder::{UiAccount, UiAccountEncoding},
-    solana_clap_utils::{
+};
+use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
+use solana_account_decoder::{UiAccount, UiAccountEncoding};
+use solana_clap_utils::{
     fee_payer::*,
     input_parsers::*,
     input_validators::*,
@@ -18,18 +17,18 @@ use {
     memo::*,
     nonce::*,
     offline::*,
-    },
-    solana_cli_output::{
+};
+use solana_cli_output::{
     display::build_balance_message, return_signers_with_config, CliAccount,
     CliSignatureVerificationStatus, CliTransaction, CliTransactionConfirmation, OutputFormat,
     ReturnSignersConfig,
-    },
-    solana_client::{
+};
+use solana_client::{
     blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
     rpc_config::RpcTransactionConfig, rpc_response::RpcKeyedAccount,
-    },
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
+};
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
     commitment_config::CommitmentConfig,
     message::Message,
     pubkey::Pubkey,
@@ -38,10 +37,9 @@ use {
     system_instruction::{self, SystemError},
     system_program,
     transaction::Transaction,
-    },
-    solana_transaction_status::{EncodedTransaction, UiTransactionEncoding},
-    std::{fmt::Write as FmtWrite, fs::File, io::Write, sync::Arc},
 };
+use solana_transaction_status::{EncodedTransaction, UiTransactionEncoding};
+use std::{fmt::Write as FmtWrite, fs::File, io::Write, sync::Arc};
 
 pub trait WalletSubCommands {
     fn wallet_subcommands(self) -> Self;

cli/tests/nonce.rs

@@ -1,26 +1,24 @@
-use {
-    solana_cli::{
+use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     spend_utils::SpendAmount,
     test_utils::{check_ready, check_recent_balance},
-    },
-    solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
-    solana_client::{
+};
+use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
+use solana_client::{
     blockhash_query::{self, BlockhashQuery},
     nonce_utils,
     rpc_client::RpcClient,
-    },
-    solana_core::test_validator::TestValidator,
-    solana_faucet::faucet::run_local_faucet,
-    solana_sdk::{
+};
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
     commitment_config::CommitmentConfig,
     hash::Hash,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, Signer},
     system_program,
-    },
-    solana_streamer::socket::SocketAddrSpace,
 };
+use solana_streamer::socket::SocketAddrSpace;
 
 #[test]
 fn test_nonce() {

cli/tests/program.rs

@@ -1,24 +1,22 @@
-use {
-    serde_json::Value,
-    solana_cli::{
+use serde_json::Value;
+use solana_cli::{
     cli::{process_command, CliCommand, CliConfig},
     program::ProgramCliCommand,
-    },
-    solana_cli_output::OutputFormat,
-    solana_client::rpc_client::RpcClient,
-    solana_core::test_validator::TestValidator,
-    solana_faucet::faucet::run_local_faucet,
-    solana_sdk::{
+};
+use solana_cli_output::OutputFormat;
+use solana_client::rpc_client::RpcClient;
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
     account_utils::StateMut,
     bpf_loader,
     bpf_loader_upgradeable::{self, UpgradeableLoaderState},
     commitment_config::CommitmentConfig,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    std::{env, fs::File, io::Read, path::PathBuf, str::FromStr},
 };
+use solana_streamer::socket::SocketAddrSpace;
+use std::{env, fs::File, io::Read, path::PathBuf, str::FromStr};
 
 #[test]
 fn test_cli_program_deploy_non_upgradeable() {

cli/tests/request_airdrop.rs

@@ -1,14 +1,12 @@
-use {
-    solana_cli::cli::{process_command, CliCommand, CliConfig},
-    solana_client::rpc_client::RpcClient,
-    solana_core::test_validator::TestValidator,
-    solana_faucet::faucet::run_local_faucet,
-    solana_sdk::{
+use solana_cli::cli::{process_command, CliCommand, CliConfig};
+use solana_client::rpc_client::RpcClient;
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
     commitment_config::CommitmentConfig,
     signature::{Keypair, Signer},
-    },
-    solana_streamer::socket::SocketAddrSpace,
 };
+use solana_streamer::socket::SocketAddrSpace;
 
 #[test]
 fn test_cli_request_airdrop() {

cli/tests/stake.rs

@@ -1,19 +1,18 @@
-use {
-    solana_cli::{
+use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     spend_utils::SpendAmount,
     stake::StakeAuthorizationIndexed,
     test_utils::{check_ready, check_recent_balance},
-    },
-    solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
-    solana_client::{
+};
+use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
+use solana_client::{
     blockhash_query::{self, BlockhashQuery},
     nonce_utils,
     rpc_client::RpcClient,
-    },
-    solana_core::test_validator::TestValidator,
-    solana_faucet::faucet::run_local_faucet,
-    solana_sdk::{
+};
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
     account_utils::StateMut,
     commitment_config::CommitmentConfig,
     nonce::State as NonceState,
@@ -24,9 +23,8 @@ use {
         instruction::LockupArgs,
         state::{Lockup, StakeAuthorize, StakeState},
     },
-    },
-    solana_streamer::socket::SocketAddrSpace,
 };
+use solana_streamer::socket::SocketAddrSpace;
 
 #[test]
 fn test_stake_delegation_force() {

cli/tests/transfer.rs

@@ -1,26 +1,24 @@
-use {
-    solana_cli::{
+use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     spend_utils::SpendAmount,
     test_utils::{check_ready, check_recent_balance},
-    },
-    solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
-    solana_client::{
+};
+use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
+use solana_client::{
     blockhash_query::{self, BlockhashQuery},
     nonce_utils,
     rpc_client::RpcClient,
-    },
-    solana_core::test_validator::TestValidator,
-    solana_faucet::faucet::run_local_faucet,
-    solana_sdk::{
+};
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
     commitment_config::CommitmentConfig,
     nonce::State as NonceState,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, NullSigner, Signer},
     stake,
-    },
-    solana_streamer::socket::SocketAddrSpace,
 };
+use solana_streamer::socket::SocketAddrSpace;
 
 #[test]
 fn test_transfer() {

cli/tests/vote.rs

@@ -1,23 +1,21 @@
-use {
-    solana_cli::{
+use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     spend_utils::SpendAmount,
     test_utils::check_recent_balance,
-    },
-    solana_client::{
+};
+use solana_client::{
     blockhash_query::{self, BlockhashQuery},
     rpc_client::RpcClient,
-    },
-    solana_core::test_validator::TestValidator,
-    solana_faucet::faucet::run_local_faucet,
-    solana_sdk::{
+};
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
     account_utils::StateMut,
     commitment_config::CommitmentConfig,
     signature::{Keypair, Signer},
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersions},
 };
+use solana_streamer::socket::SocketAddrSpace;
+use solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersions};
 
 #[test]
 fn test_vote_authorize_and_withdraw() {

client/src/blockhash_query.rs

@@ -118,19 +118,17 @@ impl Default for BlockhashQuery {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{
+    use super::*;
+    use crate::{
         blockhash_query,
         rpc_request::RpcRequest,
         rpc_response::{Response, RpcFeeCalculator, RpcFees, RpcResponseContext},
-        },
-        clap::App,
-        serde_json::{self, json},
-        solana_account_decoder::{UiAccount, UiAccountEncoding},
-        solana_sdk::{account::Account, hash::hash, nonce, system_program},
-        std::collections::HashMap,
     };
+    use clap::App;
+    use serde_json::{self, json};
+    use solana_account_decoder::{UiAccount, UiAccountEncoding};
+    use solana_sdk::{account::Account, hash::hash, nonce, system_program};
+    use std::collections::HashMap;
 
     #[test]
     fn test_blockhash_query_new_ok() {

client/src/client_error.rs

@@ -1,4 +1,3 @@
-pub use reqwest;
 use {
     crate::{rpc_request, rpc_response},
     solana_faucet::faucet::FaucetError,
@@ -7,7 +6,9 @@ use {
     },
     std::io,
     thiserror::Error,
-}; // export `reqwest` for clients
+};
+
+pub use reqwest; // export `reqwest` for clients
 
 #[derive(Error, Debug)]
 pub enum ClientErrorKind {

client/src/rpc_client.rs

@@ -16,7 +16,8 @@ use {
         client_error::{ClientError, ClientErrorKind, Result as ClientResult},
         http_sender::HttpSender,
         mock_sender::{MockSender, Mocks},
-        rpc_config::{RpcAccountInfoConfig, *},
+        rpc_config::RpcAccountInfoConfig,
+        rpc_config::*,
         rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
         rpc_response::*,
         rpc_sender::*,
@@ -4783,21 +4784,19 @@ pub fn create_rpc_client_mocks() -> crate::mock_sender::Mocks {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{client_error::ClientErrorKind, mock_sender::PUBKEY},
-        assert_matches::assert_matches,
-        jsonrpc_core::{futures::prelude::*, Error, IoHandler, Params},
-        jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder},
-        serde_json::Number,
-        solana_sdk::{
+    use super::*;
+    use crate::{client_error::ClientErrorKind, mock_sender::PUBKEY};
+    use assert_matches::assert_matches;
+    use jsonrpc_core::{futures::prelude::*, Error, IoHandler, Params};
+    use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder};
+    use serde_json::Number;
+    use solana_sdk::{
         instruction::InstructionError,
         signature::{Keypair, Signer},
         system_transaction,
         transaction::TransactionError,
-        },
-        std::{io, sync::mpsc::channel, thread},
     };
+    use std::{io, sync::mpsc::channel, thread};
 
     #[test]
     fn test_send() {

client/src/rpc_custom_error.rs

@@ -1,9 +1,9 @@
 //! Implementation defined RPC server errors
+use thiserror::Error;
 use {
     crate::rpc_response::RpcSimulateTransactionResult,
     jsonrpc_core::{Error, ErrorCode},
     solana_sdk::clock::Slot,
-    thiserror::Error,
 };
 
 pub const JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: i64 = -32001;

client/src/rpc_request.rs

@@ -241,11 +241,9 @@ pub enum TokenAccountsFilter {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::rpc_config::RpcTokenAccountsFilter,
-        solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel},
-    };
+    use super::*;
+    use crate::rpc_config::RpcTokenAccountsFilter;
+    use solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel};
 
     #[test]
     fn test_build_request_json() {

client/src/thin_client.rs

@@ -622,7 +622,8 @@ pub fn create_client_with_timeout(
 
 #[cfg(test)]
 mod tests {
-    use {super::*, rayon::prelude::*};
+    use super::*;
+    use rayon::prelude::*;
 
     #[test]
     fn test_client_optimizer() {

client/src/tpu_client.rs

@@ -1,15 +1,14 @@
-use {
-    crate::{
+use crate::{
     client_error::ClientError,
     pubsub_client::{PubsubClient, PubsubClientError, PubsubClientSubscription},
     rpc_client::RpcClient,
     rpc_request::MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS,
     rpc_response::{Fees, SlotUpdate},
     spinner,
-    },
-    bincode::serialize,
-    log::*,
-    solana_sdk::{
+};
+use bincode::serialize;
+use log::*;
+use solana_sdk::{
     clock::Slot,
     commitment_config::CommitmentConfig,
     message::Message,
@@ -17,8 +16,8 @@ use {
     signature::SignerError,
     signers::Signers,
     transaction::{Transaction, TransactionError},
-    },
-    std::{
+};
+use std::{
     collections::{HashMap, HashSet, VecDeque},
     net::{SocketAddr, UdpSocket},
     str::FromStr,
@@ -28,9 +27,8 @@ use {
     },
     thread::{sleep, JoinHandle},
     time::{Duration, Instant},
-    },
-    thiserror::Error,
 };
+use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum TpuSenderError {

core/benches/banking_stage.rs

@@ -3,41 +3,40 @@
 
 extern crate test;
 
-use {
-    crossbeam_channel::unbounded,
-    log::*,
-    rand::{thread_rng, Rng},
-    rayon::prelude::*,
-    solana_core::banking_stage::{BankingStage, BankingStageStats},
-    solana_gossip::cluster_info::{ClusterInfo, Node},
-    solana_ledger::{
-        blockstore::Blockstore,
-        blockstore_processor::process_entries,
-        entry::{next_hash, Entry},
-        genesis_utils::{create_genesis_config, GenesisConfigInfo},
-        get_tmp_ledger_path,
-    },
-    solana_perf::{packet::to_packets_chunked, test_tx::test_tx},
-    solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry},
-    solana_runtime::{bank::Bank, cost_model::CostModel},
-    solana_sdk::{
-        genesis_config::GenesisConfig,
-        hash::Hash,
-        message::Message,
-        pubkey,
-        signature::{Keypair, Signature, Signer},
-        system_instruction, system_transaction,
-        timing::{duration_as_us, timestamp},
-        transaction::Transaction,
-    },
-    solana_streamer::socket::SocketAddrSpace,
-    std::{
-        collections::VecDeque,
-        sync::{atomic::Ordering, mpsc::Receiver, Arc, RwLock},
-        time::{Duration, Instant},
-    },
-    test::Bencher,
-};
+use crossbeam_channel::unbounded;
+use log::*;
+use rand::{thread_rng, Rng};
+use rayon::prelude::*;
+use solana_core::banking_stage::{BankingStage, BankingStageStats};
+use solana_gossip::cluster_info::ClusterInfo;
+use solana_gossip::cluster_info::Node;
+use solana_ledger::blockstore_processor::process_entries;
+use solana_ledger::entry::{next_hash, Entry};
+use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
+use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
+use solana_perf::packet::to_packets_chunked;
+use solana_perf::test_tx::test_tx;
+use solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry};
+use solana_runtime::bank::Bank;
+use solana_runtime::cost_model::CostModel;
+use solana_sdk::genesis_config::GenesisConfig;
+use solana_sdk::hash::Hash;
+use solana_sdk::message::Message;
+use solana_sdk::pubkey;
+use solana_sdk::signature::Keypair;
+use solana_sdk::signature::Signature;
+use solana_sdk::signature::Signer;
+use solana_sdk::system_instruction;
+use solana_sdk::system_transaction;
+use solana_sdk::timing::{duration_as_us, timestamp};
+use solana_sdk::transaction::Transaction;
+use solana_streamer::socket::SocketAddrSpace;
+use std::collections::VecDeque;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc::Receiver;
+use std::sync::{Arc, RwLock};
+use std::time::{Duration, Instant};
+use test::Bencher;
 
 fn check_txs(receiver: &Arc<Receiver<WorkingBankEntry>>, ref_tx_count: usize) {
     let mut total = 0;

core/benches/blockstore.rs

@@ -3,17 +3,15 @@
 extern crate solana_ledger;
 extern crate test;
 
-use {
-    rand::Rng,
-    solana_ledger::{
+use rand::Rng;
+use solana_ledger::{
     blockstore::{entries_to_test_shreds, Blockstore},
     entry::{create_ticks, Entry},
     get_tmp_ledger_path,
-    },
-    solana_sdk::{clock::Slot, hash::Hash},
-    std::path::Path,
-    test::Bencher,
 };
+use solana_sdk::{clock::Slot, hash::Hash};
+use std::path::Path;
+use test::Bencher;
 
 // Given some shreds and a ledger at ledger_path, benchmark writing the shreds to the ledger
 fn bench_write_shreds(bench: &mut Bencher, entries: Vec<Entry>, ledger_path: &Path) {

core/benches/consensus.rs

@@ -3,17 +3,16 @@
 extern crate solana_core;
 extern crate test;
 
-use {
-    solana_core::consensus::Tower,
-    solana_runtime::{bank::Bank, bank_forks::BankForks},
-    solana_sdk::{
+use solana_core::consensus::Tower;
+use solana_runtime::bank::Bank;
+use solana_runtime::bank_forks::BankForks;
+use solana_sdk::{
     pubkey::Pubkey,
     signature::{Keypair, Signer},
-    },
-    std::sync::Arc,
-    tempfile::TempDir,
-    test::Bencher,
 };
+use std::sync::Arc;
+use tempfile::TempDir;
+use test::Bencher;
 
 #[bench]
 fn bench_save_tower(bench: &mut Bencher) {

core/benches/gen_keys.rs

@@ -2,7 +2,8 @@
 
 extern crate test;
 
-use {solana_core::gen_keys::GenKeys, test::Bencher};
+use solana_core::gen_keys::GenKeys;
+use test::Bencher;
 
 #[bench]
 fn bench_gen_keys(b: &mut Bencher) {

core/benches/shredder.rs

@@ -3,22 +3,19 @@
 
 extern crate test;
 
-use {
-    rand::seq::SliceRandom,
-    raptorq::{Decoder, Encoder},
-    solana_ledger::{
-        entry::{create_ticks, Entry},
-        shred::{
+use rand::seq::SliceRandom;
+use raptorq::{Decoder, Encoder};
+use solana_ledger::entry::{create_ticks, Entry};
+use solana_ledger::shred::{
     max_entries_per_n_shred, max_ticks_per_n_shreds, ProcessShredsStats, Shred, Shredder,
     MAX_DATA_SHREDS_PER_FEC_BLOCK, SHRED_PAYLOAD_SIZE, SIZE_OF_CODING_SHRED_HEADERS,
     SIZE_OF_DATA_SHRED_PAYLOAD,
-        },
-    },
-    solana_perf::test_tx,
-    solana_sdk::{hash::Hash, signature::Keypair},
-    std::sync::Arc,
-    test::Bencher,
 };
+use solana_perf::test_tx;
+use solana_sdk::hash::Hash;
+use solana_sdk::signature::Keypair;
+use std::sync::Arc;
+use test::Bencher;
 
 fn make_test_entry(txs_per_entry: u64) -> Entry {
     Entry {

core/benches/sigverify_stage.rs

@@ -3,24 +3,20 @@
 extern crate solana_core;
 extern crate test;
 
-use {
-    crossbeam_channel::unbounded,
-    log::*,
-    rand::{thread_rng, Rng},
-    solana_core::{sigverify::TransactionSigVerifier, sigverify_stage::SigVerifyStage},
-    solana_perf::{packet::to_packets_chunked, test_tx::test_tx},
-    solana_sdk::{
-        hash::Hash,
-        signature::{Keypair, Signer},
-        system_transaction,
-        timing::duration_as_ms,
-    },
-    std::{
-        sync::mpsc::channel,
-        time::{Duration, Instant},
-    },
-    test::Bencher,
-};
+use crossbeam_channel::unbounded;
+use log::*;
+use rand::{thread_rng, Rng};
+use solana_core::sigverify::TransactionSigVerifier;
+use solana_core::sigverify_stage::SigVerifyStage;
+use solana_perf::packet::to_packets_chunked;
+use solana_perf::test_tx::test_tx;
+use solana_sdk::hash::Hash;
+use solana_sdk::signature::{Keypair, Signer};
+use solana_sdk::system_transaction;
+use solana_sdk::timing::duration_as_ms;
+use std::sync::mpsc::channel;
+use std::time::{Duration, Instant};
+use test::Bencher;
 
 #[bench]
 fn bench_packet_discard(bencher: &mut Bencher) {

core/src/accounts_hash_verifier.rs

@@ -4,17 +4,16 @@
 // hash on gossip. Monitor gossip for messages from validators in the `--known-validator`s
 // set and halt the node if a mismatch is detected.
 
-use {
-    crate::snapshot_packager_service::PendingSnapshotPackage,
-    rayon::ThreadPool,
-    solana_gossip::cluster_info::{ClusterInfo, MAX_SNAPSHOT_HASHES},
-    solana_runtime::{
+use crate::snapshot_packager_service::PendingSnapshotPackage;
+use rayon::ThreadPool;
+use solana_gossip::cluster_info::{ClusterInfo, MAX_SNAPSHOT_HASHES};
+use solana_runtime::{
     accounts_db,
     snapshot_package::{AccountsPackage, AccountsPackagePre, AccountsPackageReceiver},
-    },
-    solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey},
-    std::{
-        collections::{HashMap, HashSet},
+};
+use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey};
+use std::collections::{HashMap, HashSet};
+use std::{
     sync::{
         atomic::{AtomicBool, Ordering},
         mpsc::RecvTimeoutError,
@@ -22,7 +21,6 @@ use {
     },
     thread::{self, Builder, JoinHandle},
     time::Duration,
-    },
 };
 
 pub struct AccountsHashVerifier {
@@ -131,10 +129,8 @@ impl AccountsHashVerifier {
             && accounts_package.slot % fault_injection_rate_slots == 0
         {
             // For testing, publish an invalid hash to gossip.
-            use {
-                rand::{thread_rng, Rng},
-                solana_sdk::hash::extend_and_hash,
-            };
+            use rand::{thread_rng, Rng};
+            use solana_sdk::hash::extend_and_hash;
             warn!("inserting fault at slot: {}", accounts_package.slot);
             let rand = thread_rng().gen_range(0, 10);
             let hash = extend_and_hash(&hash, &[rand]);
@@ -219,16 +215,15 @@ impl AccountsHashVerifier {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_gossip::{cluster_info::make_accounts_hashes_message, contact_info::ContactInfo},
-        solana_runtime::{bank_forks::ArchiveFormat, snapshot_utils::SnapshotVersion},
-        solana_sdk::{
+    use super::*;
+    use solana_gossip::{cluster_info::make_accounts_hashes_message, contact_info::ContactInfo};
+    use solana_runtime::bank_forks::ArchiveFormat;
+    use solana_runtime::snapshot_utils::SnapshotVersion;
+    use solana_sdk::{
         hash::hash,
         signature::{Keypair, Signer},
-        },
-        solana_streamer::socket::SocketAddrSpace,
     };
+    use solana_streamer::socket::SocketAddrSpace;
 
     fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo {
         ClusterInfo::new(
@@ -274,7 +269,8 @@ mod tests {
     #[test]
     fn test_max_hashes() {
         solana_logger::setup();
-        use {std::path::PathBuf, tempfile::TempDir};
+        use std::path::PathBuf;
+        use tempfile::TempDir;
         let keypair = Keypair::new();
 
         let contact_info = ContactInfo::new_localhost(&keypair.pubkey(), 0);

core/src/banking_stage.rs

@@ -1,24 +1,23 @@
 //! The `banking_stage` processes Transaction messages. It is intended to be used
 //! to contruct a software pipeline. The stage uses all available CPU cores and
 //! can do its processing in parallel with signature verification on the GPU.
-use {
-    crate::packet_hasher::PacketHasher,
-    crossbeam_channel::{Receiver as CrossbeamReceiver, RecvTimeoutError},
-    itertools::Itertools,
-    lru::LruCache,
-    retain_mut::RetainMut,
-    solana_gossip::{cluster_info::ClusterInfo, contact_info::ContactInfo},
-    solana_ledger::{blockstore_processor::TransactionStatusSender, entry::hash_transactions},
-    solana_measure::measure::Measure,
-    solana_metrics::{inc_new_counter_debug, inc_new_counter_info},
-    solana_perf::{
+use crate::packet_hasher::PacketHasher;
+use crossbeam_channel::{Receiver as CrossbeamReceiver, RecvTimeoutError};
+use itertools::Itertools;
+use lru::LruCache;
+use retain_mut::RetainMut;
+use solana_gossip::{cluster_info::ClusterInfo, contact_info::ContactInfo};
+use solana_ledger::{blockstore_processor::TransactionStatusSender, entry::hash_transactions};
+use solana_measure::measure::Measure;
+use solana_metrics::{inc_new_counter_debug, inc_new_counter_info};
+use solana_perf::{
     cuda_runtime::PinnedVec,
     data_budget::DataBudget,
     packet::{limited_deserialize, Packet, Packets, PACKETS_PER_BATCH},
     perf_libs,
-    },
-    solana_poh::poh_recorder::{PohRecorder, PohRecorderError, TransactionRecorder},
-    solana_runtime::{
+};
+use solana_poh::poh_recorder::{PohRecorder, PohRecorderError, TransactionRecorder};
+use solana_runtime::{
     accounts_db::ErrorCounters,
     bank::{
         Bank, ExecuteTimings, TransactionBalancesSet, TransactionCheckResult,
@@ -30,8 +29,8 @@ use {
     hashed_transaction::HashedTransaction,
     transaction_batch::TransactionBatch,
     vote_sender_types::ReplayVoteSender,
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     clock::{
         Slot, DEFAULT_TICKS_PER_SLOT, MAX_PROCESSING_AGE, MAX_TRANSACTION_FORWARDING_DELAY,
         MAX_TRANSACTION_FORWARDING_DELAY_GPU,
@@ -43,11 +42,11 @@ use {
     signature::Signature,
     timing::{duration_as_ms, timestamp, AtomicInterval},
     transaction::{self, Transaction, TransactionError},
-    },
-    solana_transaction_status::token_balances::{
+};
+use solana_transaction_status::token_balances::{
     collect_token_balances, TransactionTokenBalancesSet,
-    },
-    std::{
+};
+use std::{
     borrow::Cow,
     cmp,
     collections::{HashMap, VecDeque},
@@ -55,13 +54,11 @@ use {
     mem::size_of,
     net::{SocketAddr, UdpSocket},
     ops::DerefMut,
-        sync::{
-            atomic::{AtomicU64, AtomicUsize, Ordering},
-            Arc, Mutex, RwLock, RwLockReadGuard,
-        },
+    sync::atomic::{AtomicU64, AtomicUsize, Ordering},
+    sync::{Arc, Mutex, RwLock, RwLockReadGuard},
     thread::{self, Builder, JoinHandle},
-        time::{Duration, Instant},
-    },
+    time::Duration,
+    time::Instant,
 };
 
 /// (packets, valid_indexes, forwarded)
@@ -1663,26 +1660,25 @@ where
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crossbeam_channel::unbounded,
-        itertools::Itertools,
-        solana_gossip::{cluster_info::Node, contact_info::ContactInfo},
-        solana_ledger::{
+    use super::*;
+    use crossbeam_channel::unbounded;
+    use itertools::Itertools;
+    use solana_gossip::{cluster_info::Node, contact_info::ContactInfo};
+    use solana_ledger::{
         blockstore::{entries_to_test_shreds, Blockstore},
         entry::{next_entry, Entry, EntrySlice},
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
         get_tmp_ledger_path,
         leader_schedule_cache::LeaderScheduleCache,
-        },
-        solana_perf::packet::to_packets_chunked,
-        solana_poh::{
+    };
+    use solana_perf::packet::to_packets_chunked;
+    use solana_poh::{
         poh_recorder::{create_test_recorder, Record, WorkingBank, WorkingBankEntry},
         poh_service::PohService,
-        },
-        solana_rpc::transaction_status_service::TransactionStatusService,
-        solana_runtime::cost_model::CostModel,
-        solana_sdk::{
+    };
+    use solana_rpc::transaction_status_service::TransactionStatusService;
+    use solana_runtime::cost_model::CostModel;
+    use solana_sdk::{
         hash::Hash,
         instruction::InstructionError,
         poh_config::PohConfig,
@@ -1690,11 +1686,11 @@ mod tests {
         system_instruction::SystemError,
         system_transaction,
         transaction::TransactionError,
-        },
-        solana_streamer::socket::SocketAddrSpace,
-        solana_transaction_status::TransactionWithStatusMeta,
-        solana_vote_program::vote_transaction,
-        std::{
+    };
+    use solana_streamer::socket::SocketAddrSpace;
+    use solana_transaction_status::TransactionWithStatusMeta;
+    use solana_vote_program::vote_transaction;
+    use std::{
         net::SocketAddr,
         path::Path,
         sync::{
@@ -1702,7 +1698,6 @@ mod tests {
             mpsc::Receiver,
         },
         thread::sleep,
-        },
     };
 
     fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo {

core/src/broadcast_stage.rs

@@ -23,9 +23,8 @@ use {
     solana_poh::poh_recorder::WorkingBankEntry,
     solana_runtime::{bank::Bank, bank_forks::BankForks},
     solana_sdk::{
-        clock::Slot,
-        pubkey::Pubkey,
         timing::{timestamp, AtomicInterval},
+        {clock::Slot, pubkey::Pubkey},
     },
     solana_streamer::{
         sendmmsg::{batch_send, SendPktsError},
@@ -450,28 +449,24 @@ pub fn broadcast_shreds(
 
 #[cfg(test)]
 pub mod test {
-    use {
-        super::*,
-        crossbeam_channel::unbounded,
-        solana_gossip::cluster_info::{ClusterInfo, Node},
-        solana_ledger::{
+    use super::*;
+    use crossbeam_channel::unbounded;
+    use solana_gossip::cluster_info::{ClusterInfo, Node};
+    use solana_ledger::{
         blockstore::{make_slot_entries, Blockstore},
         entry::create_ticks,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
         get_tmp_ledger_path,
         shred::{max_ticks_per_n_shreds, ProcessShredsStats, Shredder},
-        },
-        solana_runtime::bank::Bank,
-        solana_sdk::{
+    };
+    use solana_runtime::bank::Bank;
+    use solana_sdk::{
         hash::Hash,
         pubkey::Pubkey,
         signature::{Keypair, Signer},
-        },
-        std::{
-            path::Path,
-            sync::{atomic::AtomicBool, mpsc::channel, Arc},
-            thread::sleep,
-        },
+    };
+    use std::{
+        path::Path, sync::atomic::AtomicBool, sync::mpsc::channel, sync::Arc, thread::sleep,
     };
 
     #[allow(clippy::implicit_hasher)]

core/src/broadcast_stage/broadcast_fake_shreds_run.rs

@@ -1,8 +1,8 @@
-use {
-    super::*,
-    solana_ledger::{entry::Entry, shred::Shredder},
-    solana_sdk::{hash::Hash, signature::Keypair},
-};
+use super::*;
+use solana_ledger::entry::Entry;
+use solana_ledger::shred::Shredder;
+use solana_sdk::hash::Hash;
+use solana_sdk::signature::Keypair;
 
 #[derive(Clone)]
 pub(super) struct BroadcastFakeShredsRun {
@@ -139,12 +139,10 @@ impl BroadcastRun for BroadcastFakeShredsRun {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_gossip::contact_info::ContactInfo,
-        solana_streamer::socket::SocketAddrSpace,
-        std::net::{IpAddr, Ipv4Addr, SocketAddr},
-    };
+    use super::*;
+    use solana_gossip::contact_info::ContactInfo;
+    use solana_streamer::socket::SocketAddrSpace;
+    use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 
     #[test]
     fn test_tvu_peers_ordering() {

core/src/broadcast_stage/broadcast_utils.rs

@@ -1,13 +1,12 @@
-use {
-    crate::result::Result,
-    solana_ledger::{entry::Entry, shred::Shred},
-    solana_poh::poh_recorder::WorkingBankEntry,
-    solana_runtime::bank::Bank,
-    solana_sdk::clock::Slot,
-    std::{
-        sync::{mpsc::Receiver, Arc},
+use crate::result::Result;
+use solana_ledger::{entry::Entry, shred::Shred};
+use solana_poh::poh_recorder::WorkingBankEntry;
+use solana_runtime::bank::Bank;
+use solana_sdk::clock::Slot;
+use std::{
+    sync::mpsc::Receiver,
+    sync::Arc,
     time::{Duration, Instant},
-    },
 };
 
 pub(super) struct ReceiveResults {
@@ -80,15 +79,13 @@ pub(super) fn recv_slot_entries(receiver: &Receiver<WorkingBankEntry>) -> Result
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo},
-        solana_sdk::{
-            genesis_config::GenesisConfig, pubkey::Pubkey, system_transaction,
-            transaction::Transaction,
-        },
-        std::sync::mpsc::channel,
-    };
+    use super::*;
+    use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
+    use solana_sdk::genesis_config::GenesisConfig;
+    use solana_sdk::pubkey::Pubkey;
+    use solana_sdk::system_transaction;
+    use solana_sdk::transaction::Transaction;
+    use std::sync::mpsc::channel;
 
     fn setup_test() -> (GenesisConfig, Arc<Bank>, Transaction) {
         let GenesisConfigInfo {

core/src/broadcast_stage/standard_broadcast_run.rs

@@ -511,21 +511,21 @@ impl BroadcastRun for StandardBroadcastRun {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_gossip::cluster_info::{ClusterInfo, Node},
-        solana_ledger::{
-            blockstore::Blockstore, entry::create_ticks, genesis_utils::create_genesis_config,
-            get_tmp_ledger_path, shred::max_ticks_per_n_shreds,
-        },
-        solana_runtime::bank::Bank,
-        solana_sdk::{
+    use super::*;
+    use solana_gossip::cluster_info::{ClusterInfo, Node};
+    use solana_ledger::genesis_utils::create_genesis_config;
+    use solana_ledger::{
+        blockstore::Blockstore, entry::create_ticks, get_tmp_ledger_path,
+        shred::max_ticks_per_n_shreds,
+    };
+    use solana_runtime::bank::Bank;
+    use solana_sdk::{
         genesis_config::GenesisConfig,
         signature::{Keypair, Signer},
-        },
-        solana_streamer::socket::SocketAddrSpace,
-        std::{sync::Arc, time::Duration},
     };
+    use solana_streamer::socket::SocketAddrSpace;
+    use std::sync::Arc;
+    use std::time::Duration;
 
     #[allow(clippy::type_complexity)]
     fn setup(

core/src/cluster_info_vote_listener.rs

@@ -1,56 +1,53 @@
-use {
-    crate::{
+use crate::{
     optimistic_confirmation_verifier::OptimisticConfirmationVerifier,
     replay_stage::DUPLICATE_THRESHOLD,
     result::{Error, Result},
     sigverify,
     verified_vote_packets::VerifiedVotePackets,
     vote_stake_tracker::VoteStakeTracker,
-    },
-    crossbeam_channel::{
-        unbounded, Receiver as CrossbeamReceiver, RecvTimeoutError, Select,
-        Sender as CrossbeamSender,
-    },
-    itertools::izip,
-    log::*,
-    solana_gossip::{
+};
+use crossbeam_channel::{
+    unbounded, Receiver as CrossbeamReceiver, RecvTimeoutError, Select, Sender as CrossbeamSender,
+};
+use itertools::izip;
+use log::*;
+use solana_gossip::{
     cluster_info::{ClusterInfo, GOSSIP_SLEEP_MILLIS},
     crds::Cursor,
     crds_value::CrdsValueLabel,
-    },
-    solana_ledger::blockstore::Blockstore,
-    solana_metrics::inc_new_counter_debug,
-    solana_perf::packet::{self, Packets},
-    solana_poh::poh_recorder::PohRecorder,
-    solana_rpc::{
+};
+use solana_ledger::blockstore::Blockstore;
+use solana_metrics::inc_new_counter_debug;
+use solana_perf::packet::{self, Packets};
+use solana_poh::poh_recorder::PohRecorder;
+use solana_rpc::{
     optimistically_confirmed_bank_tracker::{BankNotification, BankNotificationSender},
     rpc_subscriptions::RpcSubscriptions,
-    },
-    solana_runtime::{
+};
+use solana_runtime::{
     bank::Bank,
     bank_forks::BankForks,
     commitment::VOTE_THRESHOLD_SIZE,
     epoch_stakes::{EpochAuthorizedVoters, EpochStakes},
     stakes::Stakes,
     vote_sender_types::{ReplayVoteReceiver, ReplayedVote},
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     clock::{Epoch, Slot, DEFAULT_MS_PER_SLOT, DEFAULT_TICKS_PER_SLOT},
     epoch_schedule::EpochSchedule,
     hash::Hash,
     pubkey::Pubkey,
     transaction::Transaction,
-    },
-    solana_vote_program::{self, vote_state::Vote, vote_transaction},
-    std::{
+};
+use solana_vote_program::{self, vote_state::Vote, vote_transaction};
+use std::{
     collections::HashMap,
     sync::{
         atomic::{AtomicBool, Ordering},
-            Arc, Mutex, RwLock,
+        {Arc, Mutex, RwLock},
     },
     thread::{self, sleep, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 // Map from a vote account to the authorized voter for an epoch
@@ -838,23 +835,21 @@ impl ClusterInfoVoteListener {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_perf::packet,
-        solana_rpc::optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank,
-        solana_runtime::{
+    use super::*;
+    use solana_perf::packet;
+    use solana_rpc::optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank;
+    use solana_runtime::{
         bank::Bank,
         commitment::BlockCommitmentCache,
         genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
         vote_sender_types::ReplayVoteSender,
-        },
-        solana_sdk::{
+    };
+    use solana_sdk::{
         hash::Hash,
         signature::{Keypair, Signature, Signer},
-        },
-        solana_vote_program::vote_state::Vote,
-        std::collections::BTreeSet,
     };
+    use solana_vote_program::vote_state::Vote;
+    use std::collections::BTreeSet;
 
     #[test]
     fn test_max_vote_tx_fits() {

core/src/cluster_slot_state_verifier.rs

@@ -1,11 +1,9 @@
-use {
-    crate::{
+use crate::{
     fork_choice::ForkChoice, heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice,
     progress_map::ProgressMap,
-    },
-    solana_sdk::{clock::Slot, hash::Hash},
-    std::collections::{BTreeMap, BTreeSet},
 };
+use solana_sdk::{clock::Slot, hash::Hash};
+use std::collections::{BTreeMap, BTreeSet};
 
 pub(crate) type DuplicateSlotsTracker = BTreeSet<Slot>;
 pub(crate) type GossipDuplicateConfirmedSlots = BTreeMap<Slot, Hash>;
@@ -307,16 +305,14 @@ pub(crate) fn check_slot_agrees_with_cluster(
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        crate::consensus::test::VoteSimulator,
-        solana_runtime::bank_forks::BankForks,
-        std::{
+    use super::*;
+    use crate::consensus::test::VoteSimulator;
+    use solana_runtime::bank_forks::BankForks;
+    use std::{
         collections::{HashMap, HashSet},
         sync::RwLock,
-        },
-        trees::tr,
     };
+    use trees::tr;
 
     struct InitialState {
         heaviest_subtree_fork_choice: HeaviestSubtreeForkChoice,

core/src/cluster_slots.rs

@@ -186,7 +186,8 @@ impl ClusterSlots {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, solana_runtime::epoch_stakes::NodeVoteAccounts};
+    use super::*;
+    use solana_runtime::epoch_stakes::NodeVoteAccounts;
 
     #[test]
     fn test_default() {

core/src/cluster_slots_service.rs

@@ -1,19 +1,17 @@
-use {
-    crate::cluster_slots::ClusterSlots,
-    crossbeam_channel::{Receiver, RecvTimeoutError, Sender},
-    solana_gossip::cluster_info::ClusterInfo,
-    solana_ledger::blockstore::Blockstore,
-    solana_measure::measure::Measure,
-    solana_runtime::bank_forks::BankForks,
-    solana_sdk::clock::Slot,
-    std::{
+use crate::cluster_slots::ClusterSlots;
+use crossbeam_channel::{Receiver, RecvTimeoutError, Sender};
+use solana_gossip::cluster_info::ClusterInfo;
+use solana_ledger::blockstore::Blockstore;
+use solana_measure::measure::Measure;
+use solana_runtime::bank_forks::BankForks;
+use solana_sdk::clock::Slot;
+use std::{
     sync::{
         atomic::{AtomicBool, Ordering},
-            Arc, RwLock,
+        {Arc, RwLock},
     },
     thread::{self, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 pub type ClusterSlotsUpdateReceiver = Receiver<Vec<Slot>>;

core/src/commitment_service.rs

@@ -1,25 +1,21 @@
-use {
-    crate::consensus::Stake,
-    solana_measure::measure::Measure,
-    solana_metrics::datapoint_info,
-    solana_rpc::rpc_subscriptions::RpcSubscriptions,
-    solana_runtime::{
+use crate::consensus::Stake;
+use solana_measure::measure::Measure;
+use solana_metrics::datapoint_info;
+use solana_rpc::rpc_subscriptions::RpcSubscriptions;
+use solana_runtime::{
     bank::Bank,
     commitment::{BlockCommitment, BlockCommitmentCache, CommitmentSlots, VOTE_THRESHOLD_SIZE},
-    },
-    solana_sdk::clock::Slot,
-    solana_vote_program::vote_state::VoteState,
-    std::{
+};
+use solana_sdk::clock::Slot;
+use solana_vote_program::vote_state::VoteState;
+use std::{
     cmp::max,
     collections::HashMap,
-        sync::{
-            atomic::{AtomicBool, Ordering},
-            mpsc::{channel, Receiver, RecvTimeoutError, Sender},
-            Arc, RwLock,
-        },
+    sync::atomic::{AtomicBool, Ordering},
+    sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender},
+    sync::{Arc, RwLock},
     thread::{self, Builder, JoinHandle},
     time::Duration,
-    },
 };
 
 pub struct CommitmentAggregationData {
@@ -251,20 +247,18 @@ impl AggregateCommitmentService {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo},
-        solana_runtime::{
+    use super::*;
+    use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
+    use solana_runtime::{
         accounts_background_service::AbsRequestSender,
         bank_forks::BankForks,
         genesis_utils::{create_genesis_config_with_vote_accounts, ValidatorVoteKeypairs},
-        },
-        solana_sdk::{account::Account, pubkey::Pubkey, signature::Signer},
-        solana_stake_program::stake_state,
-        solana_vote_program::{
+    };
+    use solana_sdk::{account::Account, pubkey::Pubkey, signature::Signer};
+    use solana_stake_program::stake_state;
+    use solana_vote_program::{
         vote_state::{self, VoteStateVersions},
         vote_transaction,
-        },
     };
 
     #[test]

core/src/completed_data_sets_service.rs

@@ -1,19 +1,15 @@
-use {
-    crossbeam_channel::{Receiver, RecvTimeoutError, Sender},
-    solana_ledger::{
-        blockstore::{Blockstore, CompletedDataSetInfo},
-        entry::Entry,
-    },
-    solana_rpc::{max_slots::MaxSlots, rpc_subscriptions::RpcSubscriptions},
-    solana_sdk::signature::Signature,
-    std::{
+use crossbeam_channel::{Receiver, RecvTimeoutError, Sender};
+use solana_ledger::blockstore::{Blockstore, CompletedDataSetInfo};
+use solana_ledger::entry::Entry;
+use solana_rpc::{max_slots::MaxSlots, rpc_subscriptions::RpcSubscriptions};
+use solana_sdk::signature::Signature;
+use std::{
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc,
     },
     thread::{self, Builder, JoinHandle},
     time::Duration,
-    },
 };
 
 pub type CompletedDataSetsReceiver = Receiver<Vec<CompletedDataSetInfo>>;
@@ -104,14 +100,10 @@ impl CompletedDataSetsService {
 
 #[cfg(test)]
 pub mod test {
-    use {
-        super::*,
-        solana_sdk::{
-            hash::Hash,
-            signature::{Keypair, Signer},
-            transaction::Transaction,
-        },
-    };
+    use super::*;
+    use solana_sdk::hash::Hash;
+    use solana_sdk::signature::{Keypair, Signer};
+    use solana_sdk::transaction::Transaction;
 
     #[test]
     fn test_zero_signatures() {

core/src/consensus.rs

@@ -1,29 +1,28 @@
-use {
-    crate::{
+use crate::{
     heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice,
     latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
     progress_map::{LockoutIntervals, ProgressMap},
-    },
-    chrono::prelude::*,
-    solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore, blockstore_db},
-    solana_measure::measure::Measure,
-    solana_runtime::{
+};
+use chrono::prelude::*;
+use solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore, blockstore_db};
+use solana_measure::measure::Measure;
+use solana_runtime::{
     bank::Bank, bank_forks::BankForks, commitment::VOTE_THRESHOLD_SIZE,
     vote_account::ArcVoteAccount,
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     clock::{Slot, UnixTimestamp},
     hash::Hash,
     instruction::Instruction,
     pubkey::Pubkey,
     signature::{Keypair, Signature, Signer},
     slot_history::{Check, SlotHistory},
-    },
-    solana_vote_program::{
+};
+use solana_vote_program::{
     vote_instruction,
     vote_state::{BlockTimestamp, Lockout, Vote, VoteState, MAX_LOCKOUT_HISTORY},
-    },
-    std::{
+};
+use std::{
     cmp::Ordering,
     collections::{HashMap, HashSet},
     fs::{self, File},
@@ -34,9 +33,8 @@ use {
     },
     path::{Path, PathBuf},
     sync::Arc,
-    },
-    thiserror::Error,
 };
+use thiserror::Error;
 
 #[derive(PartialEq, Clone, Debug, AbiExample)]
 pub enum SwitchForkDecision {
@@ -1357,9 +1355,8 @@ pub fn reconcile_blockstore_roots_with_tower(
 
 #[cfg(test)]
 pub mod test {
-    use {
-        super::*,
-        crate::{
+    use super::*;
+    use crate::{
         cluster_info_vote_listener::VoteTracker,
         cluster_slot_state_verifier::{DuplicateSlotsTracker, GossipDuplicateConfirmedSlots},
         cluster_slots::ClusterSlots,
@@ -1368,37 +1365,36 @@ pub mod test {
         progress_map::ForkProgress,
         replay_stage::{HeaviestForkFailures, ReplayStage},
         unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes,
-        },
-        solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path},
-        solana_runtime::{
+    };
+    use solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path};
+    use solana_runtime::{
         accounts_background_service::AbsRequestSender,
         bank::Bank,
         bank_forks::BankForks,
         genesis_utils::{
             create_genesis_config_with_vote_accounts, GenesisConfigInfo, ValidatorVoteKeypairs,
         },
-        },
-        solana_sdk::{
+    };
+    use solana_sdk::{
         account::{Account, AccountSharedData, ReadableAccount, WritableAccount},
         clock::Slot,
         hash::Hash,
         pubkey::Pubkey,
         signature::Signer,
         slot_history::SlotHistory,
-        },
-        solana_vote_program::{
+    };
+    use solana_vote_program::{
         vote_state::{Vote, VoteStateVersions, MAX_LOCKOUT_HISTORY},
         vote_transaction,
-        },
-        std::{
+    };
+    use std::{
         collections::HashMap,
         fs::{remove_file, OpenOptions},
         io::{Read, Seek, SeekFrom, Write},
         sync::RwLock,
-        },
-        tempfile::TempDir,
-        trees::{tr, Tree, TreeWalk},
     };
+    use tempfile::TempDir;
+    use trees::{tr, Tree, TreeWalk};
 
     pub(crate) struct VoteSimulator {
         pub validator_keypairs: HashMap<Pubkey, ValidatorVoteKeypairs>,

core/src/cost_update_service.rs

@@ -3,15 +3,11 @@
 //! packing transactions into block; it also triggers persisting cost
 //! table to blockstore.
 
-use {
-    solana_ledger::blockstore::Blockstore,
-    solana_measure::measure::Measure,
-    solana_runtime::{
-        bank::{Bank, ExecuteTimings},
-        cost_model::CostModel,
-    },
-    solana_sdk::timing::timestamp,
-    std::{
+use solana_ledger::blockstore::Blockstore;
+use solana_measure::measure::Measure;
+use solana_runtime::{bank::Bank, bank::ExecuteTimings, cost_model::CostModel};
+use solana_sdk::timing::timestamp;
+use std::{
     sync::{
         atomic::{AtomicBool, Ordering},
         mpsc::Receiver,
@@ -19,7 +15,6 @@ use {
     },
     thread::{self, Builder, JoinHandle},
     time::Duration,
-    },
 };
 
 #[derive(Default)]
@@ -208,7 +203,9 @@ impl CostUpdateService {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, solana_runtime::message_processor::ProgramTiming, solana_sdk::pubkey::Pubkey};
+    use super::*;
+    use solana_runtime::message_processor::ProgramTiming;
+    use solana_sdk::pubkey::Pubkey;
 
     #[test]
     fn test_update_cost_model_with_empty_execute_timings() {

core/src/drop_bank_service.rs

@@ -1,10 +1,8 @@
-use {
-    solana_measure::measure::Measure,
-    solana_runtime::bank::Bank,
-    std::{
+use solana_measure::measure::Measure;
+use solana_runtime::bank::Bank;
+use std::{
     sync::{mpsc::Receiver, Arc},
     thread::{self, Builder, JoinHandle},
-    },
 };
 
 pub struct DropBankService {

core/src/fetch_stage.rs

@@ -1,25 +1,18 @@
 //! The `fetch_stage` batches input from a UDP socket and sends it to a channel.
 
-use {
-    crate::{
-        banking_stage::HOLD_TRANSACTIONS_SLOT_OFFSET,
-        result::{Error, Result},
-    },
-    solana_metrics::{inc_new_counter_debug, inc_new_counter_info},
-    solana_perf::{packet::PacketsRecycler, recycler::Recycler},
-    solana_poh::poh_recorder::PohRecorder,
-    solana_sdk::clock::DEFAULT_TICKS_PER_SLOT,
-    solana_streamer::streamer::{self, PacketReceiver, PacketSender},
-    std::{
-        net::UdpSocket,
-        sync::{
-            atomic::AtomicBool,
-            mpsc::{channel, RecvTimeoutError},
-            Arc, Mutex,
-        },
-        thread::{self, Builder, JoinHandle},
-    },
-};
+use crate::banking_stage::HOLD_TRANSACTIONS_SLOT_OFFSET;
+use crate::result::{Error, Result};
+use solana_metrics::{inc_new_counter_debug, inc_new_counter_info};
+use solana_perf::packet::PacketsRecycler;
+use solana_perf::recycler::Recycler;
+use solana_poh::poh_recorder::PohRecorder;
+use solana_sdk::clock::DEFAULT_TICKS_PER_SLOT;
+use solana_streamer::streamer::{self, PacketReceiver, PacketSender};
+use std::net::UdpSocket;
+use std::sync::atomic::AtomicBool;
+use std::sync::mpsc::{channel, RecvTimeoutError};
+use std::sync::{Arc, Mutex};
+use std::thread::{self, Builder, JoinHandle};
 
 pub struct FetchStage {
     thread_hdls: Vec<JoinHandle<()>>,

core/src/fork_choice.rs

@@ -1,15 +1,13 @@
-use {
-    crate::{
+use crate::{
     consensus::{SwitchForkDecision, Tower},
     latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
     progress_map::ProgressMap,
     replay_stage::HeaviestForkFailures,
-    },
-    solana_runtime::{bank::Bank, bank_forks::BankForks},
-    std::{
+};
+use solana_runtime::{bank::Bank, bank_forks::BankForks};
+use std::{
     collections::{HashMap, HashSet},
     sync::{Arc, RwLock},
-    },
 };
 
 pub(crate) struct SelectVoteAndResetForkResult {

core/src/gen_keys.rs

@@ -1,11 +1,9 @@
 //! The `gen_keys` module makes lots of keypairs
 
-use {
-    rand::{Rng, SeedableRng},
-    rand_chacha::ChaChaRng,
-    rayon::prelude::*,
-    solana_sdk::signature::Keypair,
-};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaChaRng;
+use rayon::prelude::*;
+use solana_sdk::signature::Keypair;
 
 pub struct GenKeys {
     generator: ChaChaRng,
@@ -41,8 +39,10 @@ impl GenKeys {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     pub use solana_sdk::pubkey::Pubkey;
-    use {super::*, solana_sdk::signature::Signer, std::collections::HashSet};
+    use solana_sdk::signature::Signer;
+    use std::collections::HashSet;
 
     #[test]
     fn test_new_key_is_deterministic() {

core/src/heaviest_subtree_fork_choice.rs

@@ -1,26 +1,24 @@
-#[cfg(test)]
-use trees::{Tree, TreeWalk};
-use {
-    crate::{
+use crate::{
     consensus::Tower, fork_choice::ForkChoice,
     latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
     progress_map::ProgressMap, tree_diff::TreeDiff,
-    },
-    solana_measure::measure::Measure,
-    solana_runtime::{bank::Bank, bank_forks::BankForks, epoch_stakes::EpochStakes},
-    solana_sdk::{
+};
+use solana_measure::measure::Measure;
+use solana_runtime::{bank::Bank, bank_forks::BankForks, epoch_stakes::EpochStakes};
+use solana_sdk::{
     clock::{Epoch, Slot},
     epoch_schedule::EpochSchedule,
     hash::Hash,
     pubkey::Pubkey,
-    },
-    std::{
+};
+use std::{
     borrow::Borrow,
     collections::{hash_map::Entry, BTreeMap, HashMap, HashSet, VecDeque},
     sync::{Arc, RwLock},
     time::Instant,
-    },
 };
+#[cfg(test)]
+use trees::{Tree, TreeWalk};
 
 pub type ForkWeight = u64;
 pub type SlotHashKey = (Slot, Hash);
@@ -1046,14 +1044,12 @@ impl<'a> Iterator for AncestorIterator<'a> {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        crate::consensus::test::VoteSimulator,
-        solana_runtime::{bank::Bank, bank_utils},
-        solana_sdk::{hash::Hash, slot_history::SlotHistory},
-        std::{collections::HashSet, ops::Range},
-        trees::tr,
-    };
+    use super::*;
+    use crate::consensus::test::VoteSimulator;
+    use solana_runtime::{bank::Bank, bank_utils};
+    use solana_sdk::{hash::Hash, slot_history::SlotHistory};
+    use std::{collections::HashSet, ops::Range};
+    use trees::tr;
 
     #[test]
     fn test_max_by_weight() {

core/src/latest_validator_votes_for_frozen_banks.rs

@@ -1,8 +1,6 @@
-use {
-    crate::heaviest_subtree_fork_choice::SlotHashKey,
-    solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey},
-    std::collections::{hash_map::Entry, HashMap},
-};
+use crate::heaviest_subtree_fork_choice::SlotHashKey;
+use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey};
+use std::collections::{hash_map::Entry, HashMap};
 
 #[derive(Default)]
 pub(crate) struct LatestValidatorVotesForFrozenBanks {

core/src/ledger_cleanup_service.rs

@@ -1,24 +1,17 @@
 //! The `ledger_cleanup_service` drops older ledger data to limit disk space usage
 
-use {
-    rand::{thread_rng, Rng},
-    solana_ledger::{
-        blockstore::{Blockstore, PurgeType},
-        blockstore_db::Result as BlockstoreResult,
-    },
-    solana_measure::measure::Measure,
-    solana_sdk::clock::{Slot, DEFAULT_TICKS_PER_SLOT, TICKS_PER_DAY},
-    std::{
-        string::ToString,
-        sync::{
-            atomic::{AtomicBool, AtomicU64, Ordering},
-            mpsc::{Receiver, RecvTimeoutError},
-            Arc,
-        },
-        thread::{self, sleep, Builder, JoinHandle},
-        time::Duration,
-    },
-};
+use rand::{thread_rng, Rng};
+use solana_ledger::blockstore::{Blockstore, PurgeType};
+use solana_ledger::blockstore_db::Result as BlockstoreResult;
+use solana_measure::measure::Measure;
+use solana_sdk::clock::{Slot, DEFAULT_TICKS_PER_SLOT, TICKS_PER_DAY};
+use std::string::ToString;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::mpsc::{Receiver, RecvTimeoutError};
+use std::sync::Arc;
+use std::thread;
+use std::thread::{sleep, Builder, JoinHandle};
+use std::time::Duration;
 
 // - To try and keep the RocksDB size under 400GB:
 //   Seeing about 1600b/shred, using 2000b/shred for margin, so 200m shreds can be stored in 400gb.
@@ -313,11 +306,10 @@ impl LedgerCleanupService {
 }
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        solana_ledger::{blockstore::make_many_slot_entries, get_tmp_ledger_path},
-        std::sync::mpsc::channel,
-    };
+    use super::*;
+    use solana_ledger::blockstore::make_many_slot_entries;
+    use solana_ledger::get_tmp_ledger_path;
+    use std::sync::mpsc::channel;
 
     #[test]
     fn test_cleanup1() {

core/src/optimistic_confirmation_verifier.rs

@@ -1,10 +1,8 @@
-use {
-    crate::cluster_info_vote_listener::VoteTracker,
-    solana_ledger::blockstore::Blockstore,
-    solana_runtime::bank::Bank,
-    solana_sdk::{clock::Slot, hash::Hash},
-    std::{collections::BTreeSet, time::Instant},
-};
+use crate::cluster_info_vote_listener::VoteTracker;
+use solana_ledger::blockstore::Blockstore;
+use solana_runtime::bank::Bank;
+use solana_sdk::{clock::Slot, hash::Hash};
+use std::{collections::BTreeSet, time::Instant};
 
 pub struct OptimisticConfirmationVerifier {
     snapshot_start_slot: Slot,
@@ -141,11 +139,13 @@ impl OptimisticConfirmationVerifier {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*, crate::consensus::test::VoteSimulator, solana_ledger::get_tmp_ledger_path,
-        solana_runtime::bank::Bank, solana_sdk::pubkey::Pubkey, std::collections::HashMap,
-        trees::tr,
-    };
+    use super::*;
+    use crate::consensus::test::VoteSimulator;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_runtime::bank::Bank;
+    use solana_sdk::pubkey::Pubkey;
+    use std::collections::HashMap;
+    use trees::tr;
 
     #[test]
     fn test_add_new_optimistic_confirmed_slots() {

core/src/outstanding_requests.rs

@@ -1,9 +1,7 @@
-use {
-    crate::request_response::RequestResponse,
-    lru::LruCache,
-    rand::{thread_rng, Rng},
-    solana_ledger::shred::Nonce,
-};
+use crate::request_response::RequestResponse;
+use lru::LruCache;
+use rand::{thread_rng, Rng};
+use solana_ledger::shred::Nonce;
 
 pub const DEFAULT_REQUEST_EXPIRATION_MS: u64 = 60_000;
 
@@ -74,10 +72,10 @@ pub struct RequestStatus<T> {
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use {
-        super::*, crate::serve_repair::RepairType, solana_ledger::shred::Shred,
-        solana_sdk::timing::timestamp,
-    };
+    use super::*;
+    use crate::serve_repair::RepairType;
+    use solana_ledger::shred::Shred;
+    use solana_sdk::timing::timestamp;
 
     #[test]
     fn test_add_request() {

core/src/progress_map.rs

@@ -1,17 +1,15 @@
-use {
-    crate::{
+use crate::{
     cluster_info_vote_listener::SlotVoteTracker,
     cluster_slots::SlotPubkeys,
-        consensus::{Stake, VotedStakes},
     replay_stage::SUPERMINORITY_THRESHOLD,
-    },
-    solana_ledger::blockstore_processor::{ConfirmationProgress, ConfirmationTiming},
-    solana_runtime::{bank::Bank, bank_forks::BankForks, vote_account::ArcVoteAccount},
-    solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey},
-    std::{
+    {consensus::Stake, consensus::VotedStakes},
+};
+use solana_ledger::blockstore_processor::{ConfirmationProgress, ConfirmationTiming};
+use solana_runtime::{bank::Bank, bank_forks::BankForks, vote_account::ArcVoteAccount};
+use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey};
+use std::{
     collections::{BTreeMap, HashMap, HashSet},
     sync::{Arc, RwLock},
-    },
 };
 
 type VotedSlot = Slot;

core/src/repair_response.rs

@@ -1,12 +1,10 @@
-use {
-    solana_ledger::{
+use solana_ledger::{
     blockstore::Blockstore,
     shred::{Nonce, SIZE_OF_NONCE},
-    },
-    solana_perf::packet::limited_deserialize,
-    solana_sdk::{clock::Slot, packet::Packet},
-    std::{io, net::SocketAddr},
 };
+use solana_perf::packet::limited_deserialize;
+use solana_sdk::{clock::Slot, packet::Packet};
+use std::{io, net::SocketAddr};
 
 pub fn repair_response_packet(
     blockstore: &Blockstore,
@@ -50,17 +48,15 @@ pub fn nonce(buf: &[u8]) -> Option<Nonce> {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_ledger::{
+    use super::*;
+    use solana_ledger::{
         shred::{Shred, Shredder},
         sigverify_shreds::verify_shred_cpu,
-        },
-        solana_sdk::signature::{Keypair, Signer},
-        std::{
+    };
+    use solana_sdk::signature::{Keypair, Signer};
+    use std::{
         collections::HashMap,
         net::{IpAddr, Ipv4Addr},
-        },
     };
 
     fn run_test_sigverify_shred_cpu_repair(slot: Slot) {

core/src/repair_service.rs

@@ -1,7 +1,6 @@
 //! The `repair_service` module implements the tools necessary to generate a thread which
 //! regularly finds missing shreds in the ledger and sends repair requests for those shreds
-use {
-    crate::{
+use crate::{
     cluster_info_vote_listener::VerifiedVoteReceiver,
     cluster_slots::ClusterSlots,
     outstanding_requests::OutstandingRequests,
@@ -9,34 +8,33 @@ use {
     replay_stage::DUPLICATE_THRESHOLD,
     result::Result,
     serve_repair::{RepairType, ServeRepair, REPAIR_PEERS_CACHE_CAPACITY},
-    },
-    crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender},
-    lru::LruCache,
-    solana_gossip::cluster_info::ClusterInfo,
-    solana_ledger::{
+};
+use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender};
+use lru::LruCache;
+use solana_gossip::cluster_info::ClusterInfo;
+use solana_ledger::{
     blockstore::{Blockstore, SlotMeta},
     shred::Nonce,
-    },
-    solana_measure::measure::Measure,
-    solana_runtime::{bank::Bank, bank_forks::BankForks, contains::Contains},
-    solana_sdk::{
+};
+use solana_measure::measure::Measure;
+use solana_runtime::{bank::Bank, bank_forks::BankForks, contains::Contains};
+use solana_sdk::{
     clock::{BankId, Slot},
     epoch_schedule::EpochSchedule,
     pubkey::Pubkey,
     timing::timestamp,
-    },
-    solana_streamer::sendmmsg::{batch_send, SendPktsError},
-    std::{
+};
+use solana_streamer::sendmmsg::{batch_send, SendPktsError};
+use std::{
     collections::{HashMap, HashSet},
     iter::Iterator,
-        net::{SocketAddr, UdpSocket},
-        sync::{
-            atomic::{AtomicBool, Ordering},
-            Arc, RwLock,
-        },
-        thread::{self, sleep, Builder, JoinHandle},
+    net::SocketAddr,
+    net::UdpSocket,
+    sync::atomic::{AtomicBool, Ordering},
+    sync::{Arc, RwLock},
+    thread::sleep,
+    thread::{self, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 pub type DuplicateSlotsResetSender = CrossbeamSender<Slot>;
@@ -713,23 +711,20 @@ impl RepairService {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        crossbeam_channel::unbounded,
-        solana_gossip::{cluster_info::Node, contact_info::ContactInfo},
-        solana_ledger::{
-            blockstore::{
-                make_chaining_slot_entries, make_many_slot_entries, make_slot_entries, Blockstore,
-            },
-            get_tmp_ledger_path,
-            shred::max_ticks_per_n_shreds,
-        },
-        solana_runtime::genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
-        solana_sdk::signature::{Keypair, Signer},
-        solana_streamer::socket::SocketAddrSpace,
-        solana_vote_program::vote_transaction,
-        std::collections::HashSet,
+    use super::*;
+    use crossbeam_channel::unbounded;
+    use solana_gossip::{cluster_info::Node, contact_info::ContactInfo};
+    use solana_ledger::blockstore::{
+        make_chaining_slot_entries, make_many_slot_entries, make_slot_entries,
     };
+    use solana_ledger::shred::max_ticks_per_n_shreds;
+    use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
+    use solana_runtime::genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs};
+    use solana_sdk::signature::Keypair;
+    use solana_sdk::signature::Signer;
+    use solana_streamer::socket::SocketAddrSpace;
+    use solana_vote_program::vote_transaction;
+    use std::collections::HashSet;
 
     fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo {
         ClusterInfo::new(

core/src/repair_weight.rs

@@ -1,19 +1,17 @@
-use {
-    crate::{
+use crate::{
     heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, repair_service::RepairTiming,
     repair_weighted_traversal, serve_repair::RepairType, tree_diff::TreeDiff,
-    },
-    solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore},
-    solana_measure::measure::Measure,
-    solana_runtime::{contains::Contains, epoch_stakes::EpochStakes},
-    solana_sdk::{
+};
+use solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore};
+use solana_measure::measure::Measure;
+use solana_runtime::{contains::Contains, epoch_stakes::EpochStakes};
+use solana_sdk::{
     clock::Slot,
     epoch_schedule::{Epoch, EpochSchedule},
     hash::Hash,
     pubkey::Pubkey,
-    },
-    std::collections::{BTreeSet, HashMap, HashSet, VecDeque},
 };
+use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
 
 pub struct RepairWeight {
     // Map from root -> a subtree rooted at that `root`
@@ -533,13 +531,11 @@ impl RepairWeight {
 
 #[cfg(test)]
 mod test {
-    use {
-        super::*,
-        solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path},
-        solana_runtime::{bank::Bank, bank_utils},
-        solana_sdk::hash::Hash,
-        trees::tr,
-    };
+    use super::*;
+    use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
+    use solana_runtime::{bank::Bank, bank_utils};
+    use solana_sdk::hash::Hash;
+    use trees::tr;
 
     #[test]
     fn test_sort_by_stake_weight_slot() {

core/src/repair_weighted_traversal.rs

@@ -1,13 +1,11 @@
-use {
-    crate::{
+use crate::{
     heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, repair_service::RepairService,
     serve_repair::RepairType, tree_diff::TreeDiff,
-    },
-    solana_ledger::blockstore::Blockstore,
-    solana_runtime::contains::Contains,
-    solana_sdk::{clock::Slot, hash::Hash},
-    std::collections::{HashMap, HashSet},
 };
+use solana_ledger::blockstore::Blockstore;
+use solana_runtime::contains::Contains;
+use solana_sdk::{clock::Slot, hash::Hash};
+use std::collections::{HashMap, HashSet};
 
 #[derive(Debug, PartialEq)]
 enum Visit {
@@ -138,13 +136,11 @@ pub fn get_best_repair_shreds<'a>(
 
 #[cfg(test)]
 pub mod test {
-    use {
-        super::*,
-        solana_ledger::{get_tmp_ledger_path, shred::Shred},
-        solana_runtime::bank_utils,
-        solana_sdk::hash::Hash,
-        trees::tr,
-    };
+    use super::*;
+    use solana_ledger::{get_tmp_ledger_path, shred::Shred};
+    use solana_runtime::bank_utils;
+    use solana_sdk::hash::Hash;
+    use trees::tr;
 
     #[test]
     fn test_weighted_repair_traversal_single() {

core/src/replay_stage.rs

@@ -1,7 +1,6 @@
 //! The `replay_stage` replays transactions broadcast by the leader.
 
-use {
-    crate::{
+use crate::{
     broadcast_stage::RetransmitSlotsSender,
     cache_block_meta_service::CacheBlockMetaSender,
     cluster_info_vote_listener::{
@@ -24,41 +23,42 @@ use {
     unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes,
     voting_service::VoteOp,
     window_service::DuplicateSlotReceiver,
-    },
-    solana_client::rpc_response::SlotUpdate,
-    solana_gossip::cluster_info::ClusterInfo,
-    solana_ledger::{
+};
+use solana_client::rpc_response::SlotUpdate;
+use solana_gossip::cluster_info::ClusterInfo;
+use solana_ledger::{
     block_error::BlockError,
     blockstore::Blockstore,
     blockstore_processor::{self, BlockstoreProcessorError, TransactionStatusSender},
     entry::VerifyRecyclers,
     leader_schedule_cache::LeaderScheduleCache,
-    },
-    solana_measure::measure::Measure,
-    solana_metrics::inc_new_counter_info,
-    solana_poh::poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS},
-    solana_rpc::{
+};
+use solana_measure::measure::Measure;
+use solana_metrics::inc_new_counter_info;
+use solana_poh::poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS};
+use solana_rpc::{
     optimistically_confirmed_bank_tracker::{BankNotification, BankNotificationSender},
     rpc_subscriptions::RpcSubscriptions,
-    },
-    solana_runtime::{
+};
+use solana_runtime::{
     accounts_background_service::AbsRequestSender,
     bank::{Bank, ExecuteTimings, NewBankOptions},
     bank_forks::BankForks,
     commitment::BlockCommitmentCache,
     vote_sender_types::ReplayVoteSender,
-    },
-    solana_sdk::{
+};
+use solana_sdk::{
     clock::{Slot, MAX_PROCESSING_AGE, NUM_CONSECUTIVE_LEADER_SLOTS},
     genesis_config::ClusterType,
     hash::Hash,
     pubkey::Pubkey,
-        signature::{Keypair, Signature, Signer},
+    signature::Signature,
+    signature::{Keypair, Signer},
     timing::timestamp,
     transaction::Transaction,
-    },
-    solana_vote_program::vote_state::Vote,
-    std::{
+};
+use solana_vote_program::vote_state::Vote;
+use std::{
     collections::{BTreeMap, HashMap, HashSet},
     result,
     sync::{
@@ -68,7 +68,6 @@ use {
     },
     thread::{self, Builder, JoinHandle},
     time::{Duration, Instant},
-    },
 };
 
 pub const MAX_ENTRY_RECV_PER_ITER: usize = 512;
@@ -2562,20 +2561,18 @@ impl ReplayStage {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{
-            consensus::{
-                test::{initialize_state, VoteSimulator},
-                Tower,
-            },
+    use super::*;
+    use crate::{
+        consensus::test::{initialize_state, VoteSimulator},
+        consensus::Tower,
         progress_map::ValidatorStakeInfo,
         replay_stage::ReplayStage,
-        },
-        crossbeam_channel::unbounded,
-        solana_gossip::{cluster_info::Node, crds::Cursor},
-        solana_ledger::{
-            blockstore::{entries_to_test_shreds, make_slot_entries, BlockstoreError},
+    };
+    use crossbeam_channel::unbounded;
+    use solana_gossip::{cluster_info::Node, crds::Cursor};
+    use solana_ledger::{
+        blockstore::make_slot_entries,
+        blockstore::{entries_to_test_shreds, BlockstoreError},
         create_new_tmp_ledger,
         entry::{self, Entry},
         genesis_utils::{create_genesis_config, create_genesis_config_with_leader},
@@ -2584,17 +2581,17 @@ mod tests {
             CodingShredHeader, DataShredHeader, Shred, ShredCommonHeader, DATA_COMPLETE_SHRED,
             SIZE_OF_COMMON_SHRED_HEADER, SIZE_OF_DATA_SHRED_HEADER, SIZE_OF_DATA_SHRED_PAYLOAD,
         },
-        },
-        solana_rpc::{
+    };
+    use solana_rpc::{
         optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank,
         rpc::create_test_transactions_and_populate_blockstore,
-        },
-        solana_runtime::{
+    };
+    use solana_runtime::{
         accounts_background_service::AbsRequestSender,
         commitment::BlockCommitment,
         genesis_utils::{GenesisConfigInfo, ValidatorVoteKeypairs},
-        },
-        solana_sdk::{
+    };
+    use solana_sdk::{
         clock::NUM_CONSECUTIVE_LEADER_SLOTS,
         genesis_config,
         hash::{hash, Hash},
@@ -2604,20 +2601,20 @@ mod tests {
         signature::{Keypair, Signer},
         system_transaction,
         transaction::TransactionError,
-        },
-        solana_streamer::socket::SocketAddrSpace,
-        solana_transaction_status::TransactionWithStatusMeta,
-        solana_vote_program::{
+    };
+    use solana_streamer::socket::SocketAddrSpace;
+    use solana_transaction_status::TransactionWithStatusMeta;
+    use solana_vote_program::{
         vote_state::{VoteState, VoteStateVersions},
         vote_transaction,
-        },
-        std::{
+    };
+    use std::sync::mpsc::channel;
+    use std::{
         fs::remove_dir_all,
         iter,
-            sync::{atomic::AtomicU64, mpsc::channel, Arc, RwLock},
-        },
-        trees::{tr, Tree},
+        sync::{atomic::AtomicU64, Arc, RwLock},
     };
+    use trees::{tr, Tree};
 
     #[test]
     fn test_is_partition_detected() {

core/src/result.rs

@@ -1,9 +1,7 @@
 //! The `result` module exposes a Result type that propagates one of many different Error types.
 
-use {
-    solana_gossip::{cluster_info, gossip_error::GossipError},
-    solana_ledger::blockstore,
-};
+use solana_gossip::{cluster_info, gossip_error::GossipError};
+use solana_ledger::blockstore;
 
 #[derive(Debug)]
 pub enum Error {
@@ -100,15 +98,14 @@ impl std::convert::From<GossipError> for Error {
 
 #[cfg(test)]
 mod tests {
-    use {
-        crate::result::{Error, Result},
-        std::{
-            io,
-            io::Write,
-            panic,
-            sync::mpsc::{channel, RecvError, RecvTimeoutError},
-        },
-    };
+    use crate::result::Error;
+    use crate::result::Result;
+    use std::io;
+    use std::io::Write;
+    use std::panic;
+    use std::sync::mpsc::channel;
+    use std::sync::mpsc::RecvError;
+    use std::sync::mpsc::RecvTimeoutError;
 
     fn send_error() -> Result<()> {
         let (s, r) = channel();