Reformat imports to a consistent style for imports

rustfmt.toml configuration:
  imports_granularity = "One"
  group_imports = "One"

sdk/benches/serialize_instructions.rs

@@ -1,13 +1,17 @@
 #![feature(test)]
 
 extern crate test;
-use bincode::{deserialize, serialize};
-use solana_sdk::instruction::{AccountMeta, Instruction};
-use solana_sdk::message::{Message, SanitizedMessage};
-use solana_sdk::pubkey::{self, Pubkey};
-use solana_sdk::sysvar::instructions;
-use std::convert::TryFrom;
-use test::Bencher;
+use {
+    bincode::{deserialize, serialize},
+    solana_sdk::{
+        instruction::{AccountMeta, Instruction},
+        message::{Message, SanitizedMessage},
+        pubkey::{self, Pubkey},
+        sysvar::instructions,
+    },
+    std::convert::TryFrom,
+    test::Bencher,
+};
 
 fn make_instructions() -> Vec<Instruction> {
     let meta = AccountMeta::new(pubkey::new_rand(), false);

sdk/benches/short_vec.rs

@@ -1,9 +1,7 @@
 #![feature(test)]
 
 extern crate test;
-use bincode::deserialize;
-use solana_sdk::short_vec::ShortVec;
-use test::Bencher;
+use {bincode::deserialize, solana_sdk::short_vec::ShortVec, test::Bencher};
 
 // Return a ShortVec with 127 bytes
 fn create_encoded_short_vec() -> Vec<u8> {

sdk/benches/slot_hashes.rs

@@ -1,12 +1,14 @@
 #![feature(test)]
 
 extern crate test;
-use solana_sdk::{
-    account::{create_account_for_test, from_account},
-    hash::Hash,
-    slot_hashes::{Slot, SlotHashes, MAX_ENTRIES},
+use {
+    solana_sdk::{
+        account::{create_account_for_test, from_account},
+        hash::Hash,
+        slot_hashes::{Slot, SlotHashes, MAX_ENTRIES},
+    },
+    test::Bencher,
 };
-use test::Bencher;
 
 #[bench]
 fn bench_to_from_account(b: &mut Bencher) {

sdk/benches/slot_history.rs

@@ -1,11 +1,13 @@
 #![feature(test)]
 
 extern crate test;
-use solana_sdk::{
-    account::{create_account_for_test, from_account},
-    slot_history::SlotHistory,
+use {
+    solana_sdk::{
+        account::{create_account_for_test, from_account},
+        slot_history::SlotHistory,
+    },
+    test::Bencher,
 };
-use test::Bencher;
 
 #[bench]
 fn bench_to_from_account(b: &mut Bencher) {

sdk/cargo-build-bpf/src/main.rs

@@ -13,8 +13,7 @@ use {
         fs::{self, File},
         io::{prelude::*, BufReader, BufWriter},
         path::{Path, PathBuf},
-        process::exit,
-        process::{Command, Stdio},
+        process::{exit, Command, Stdio},
         str::FromStr,
     },
     tar::Archive,

sdk/cargo-test-bpf/src/main.rs

@@ -1,14 +1,15 @@
-use clap::{
-    crate_description, crate_name, crate_version, value_t, values_t, App, AppSettings, Arg,
-};
-use std::{
-    env,
-    ffi::OsStr,
-    fs::File,
-    io::{prelude::*, BufWriter},
-    path::{Path, PathBuf},
-    process::exit,
-    process::Command,
+use {
+    clap::{
+        crate_description, crate_name, crate_version, value_t, values_t, App, AppSettings, Arg,
+    },
+    std::{
+        env,
+        ffi::OsStr,
+        fs::File,
+        io::{prelude::*, BufWriter},
+        path::{Path, PathBuf},
+        process::{exit, Command},
+    },
 };
 
 struct Config {

sdk/macro/src/lib.rs

@@ -4,17 +4,19 @@
 
 extern crate proc_macro;
 
-use proc_macro::TokenStream;
-use proc_macro2::{Delimiter, Span, TokenTree};
-use quote::{quote, ToTokens};
-use std::convert::TryFrom;
-use syn::{
-    bracketed,
-    parse::{Parse, ParseStream, Result},
-    parse_macro_input,
-    punctuated::Punctuated,
-    token::Bracket,
-    Expr, Ident, LitByte, LitStr, Path, Token,
+use {
+    proc_macro::TokenStream,
+    proc_macro2::{Delimiter, Span, TokenTree},
+    quote::{quote, ToTokens},
+    std::convert::TryFrom,
+    syn::{
+        bracketed,
+        parse::{Parse, ParseStream, Result},
+        parse_macro_input,
+        punctuated::Punctuated,
+        token::Bracket,
+        Expr, Ident, LitByte, LitStr, Path, Token,
+    },
 };
 
 fn parse_id(

sdk/program/src/account_info.rs

@@ -1,10 +1,12 @@
-use crate::{
-    clock::Epoch, program_error::ProgramError, program_memory::sol_memset, pubkey::Pubkey,
-};
-use std::{
-    cell::{Ref, RefCell, RefMut},
-    cmp, fmt,
-    rc::Rc,
+use {
+    crate::{
+        clock::Epoch, program_error::ProgramError, program_memory::sol_memset, pubkey::Pubkey,
+    },
+    std::{
+        cell::{Ref, RefCell, RefMut},
+        cmp, fmt,
+        rc::Rc,
+    },
 };
 
 /// Account information

sdk/program/src/blake3.rs

@@ -1,8 +1,10 @@
 //! The `blake3` module provides functions for creating hashes.
-use crate::sanitize::Sanitize;
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use std::{convert::TryFrom, fmt, mem, str::FromStr};
-use thiserror::Error;
+use {
+    crate::sanitize::Sanitize,
+    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
+    std::{convert::TryFrom, fmt, mem, str::FromStr},
+    thiserror::Error,
+};
 
 /// Size of hash
 pub const HASH_BYTES: usize = 32;

sdk/program/src/bpf_loader_upgradeable.rs

@@ -8,13 +8,15 @@
 //! upgradeable programs which still have a functioning authority.  For more
 //! information refer to `loader_upgradeable_instruction.rs`
 
-use crate::{
-    instruction::{AccountMeta, Instruction, InstructionError},
-    loader_upgradeable_instruction::UpgradeableLoaderInstruction,
-    pubkey::Pubkey,
-    system_instruction, sysvar,
+use {
+    crate::{
+        instruction::{AccountMeta, Instruction, InstructionError},
+        loader_upgradeable_instruction::UpgradeableLoaderInstruction,
+        pubkey::Pubkey,
+        system_instruction, sysvar,
+    },
+    bincode::serialized_size,
 };
-use bincode::serialized_size;
 
 crate::declare_id!("BPFLoaderUpgradeab1e11111111111111111111111");
 

sdk/program/src/decode_error.rs

@@ -13,8 +13,7 @@ pub trait DecodeError<E> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use num_derive::FromPrimitive;
+    use {super::*, num_derive::FromPrimitive};
 
     #[test]
     fn test_decode_custom_error_to_enum() {

sdk/program/src/entrypoint.rs

@@ -2,17 +2,18 @@
 //! BPFLoader.  For more information see './bpf_loader.rs'
 
 extern crate alloc;
-use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
-use alloc::vec::Vec;
-use std::{
-    alloc::Layout,
-    cell::RefCell,
-    mem::size_of,
-    ptr::null_mut,
-    rc::Rc,
-    // Hide Result from bindgen gets confused about generics in non-generic type declarations
-    result::Result as ResultGeneric,
-    slice::{from_raw_parts, from_raw_parts_mut},
+use {
+    crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey},
+    alloc::vec::Vec,
+    std::{
+        alloc::Layout,
+        cell::RefCell,
+        mem::size_of,
+        ptr::null_mut,
+        rc::Rc,
+        result::Result as ResultGeneric,
+        slice::{from_raw_parts, from_raw_parts_mut},
+    },
 };
 
 pub type ProgramResult = ResultGeneric<(), ProgramError>;
@@ -354,8 +355,7 @@ pub unsafe fn deserialize<'a>(input: *mut u8) -> (&'a Pubkey, Vec<AccountInfo<'a
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use std::alloc::GlobalAlloc;
+    use {super::*, std::alloc::GlobalAlloc};
 
     #[test]
     fn test_bump_allocator() {

sdk/program/src/entrypoint_deprecated.rs

@@ -4,15 +4,16 @@
 //!  './bpf_loader_deprecated.rs'
 
 extern crate alloc;
-use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
-use alloc::vec::Vec;
-use std::{
-    cell::RefCell,
-    mem::size_of,
-    rc::Rc,
-    // Hide Result from bindgen gets confused about generics in non-generic type declarations
-    result::Result as ResultGeneric,
-    slice::{from_raw_parts, from_raw_parts_mut},
+use {
+    crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey},
+    alloc::vec::Vec,
+    std::{
+        cell::RefCell,
+        mem::size_of,
+        rc::Rc,
+        result::Result as ResultGeneric,
+        slice::{from_raw_parts, from_raw_parts_mut},
+    },
 };
 
 pub type ProgramResult = ResultGeneric<(), ProgramError>;

sdk/program/src/feature.rs

@@ -62,8 +62,7 @@ pub fn activate_with_lamports(
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use solana_program::clock::Slot;
+    use {super::*, solana_program::clock::Slot};
 
     #[test]
     fn feature_sizeof() {

sdk/program/src/fee_calculator.rs

@@ -1,9 +1,8 @@
 #![allow(clippy::integer_arithmetic)]
-use crate::clock::DEFAULT_MS_PER_SLOT;
-use crate::ed25519_program;
-use crate::message::Message;
-use crate::secp256k1_program;
-use log::*;
+use {
+    crate::{clock::DEFAULT_MS_PER_SLOT, ed25519_program, message::Message, secp256k1_program},
+    log::*,
+};
 
 #[derive(Serialize, Deserialize, Default, PartialEq, Eq, Clone, Debug, AbiExample)]
 #[serde(rename_all = "camelCase")]
@@ -176,8 +175,10 @@ impl FeeRateGovernor {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{pubkey::Pubkey, system_instruction};
+    use {
+        super::*,
+        crate::{pubkey::Pubkey, system_instruction},
+    };
 
     #[test]
     fn test_fee_rate_governor_burn() {

sdk/program/src/hash.rs

@@ -1,10 +1,12 @@
 //! The `hash` module provides functions for creating SHA-256 hashes.
 
-use crate::sanitize::Sanitize;
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use sha2::{Digest, Sha256};
-use std::{convert::TryFrom, fmt, mem, str::FromStr};
-use thiserror::Error;
+use {
+    crate::sanitize::Sanitize,
+    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
+    sha2::{Digest, Sha256},
+    std::{convert::TryFrom, fmt, mem, str::FromStr},
+    thiserror::Error,
+};
 
 pub const HASH_BYTES: usize = 32;
 /// Maximum string length of a base58 encoded hash

sdk/program/src/instruction.rs

@@ -1,12 +1,13 @@
 #![allow(clippy::integer_arithmetic)]
 //! Defines a composable Instruction type and a memory-efficient CompiledInstruction.
 
-use crate::sanitize::Sanitize;
-use crate::{pubkey::Pubkey, short_vec};
-use bincode::serialize;
-use borsh::BorshSerialize;
-use serde::Serialize;
-use thiserror::Error;
+use {
+    crate::{pubkey::Pubkey, sanitize::Sanitize, short_vec},
+    bincode::serialize,
+    borsh::BorshSerialize,
+    serde::Serialize,
+    thiserror::Error,
+};
 
 /// Reasons the runtime might have rejected an instruction.
 ///

sdk/program/src/keccak.rs

@@ -1,8 +1,10 @@
-use crate::sanitize::Sanitize;
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use sha3::{Digest, Keccak256};
-use std::{convert::TryFrom, fmt, mem, str::FromStr};
-use thiserror::Error;
+use {
+    crate::sanitize::Sanitize,
+    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
+    sha3::{Digest, Keccak256},
+    std::{convert::TryFrom, fmt, mem, str::FromStr},
+    thiserror::Error,
+};
 
 pub const HASH_BYTES: usize = 32;
 /// Maximum string length of a base58 encoded hash

sdk/program/src/lamports.rs

@@ -1,5 +1,4 @@
-use crate::instruction::InstructionError;
-use thiserror::Error;
+use {crate::instruction::InstructionError, thiserror::Error};
 
 #[derive(Debug, Error)]
 pub enum LamportsError {

sdk/program/src/message/legacy.rs

@@ -1,21 +1,23 @@
 #![allow(clippy::integer_arithmetic)]
 //! A library for generating a message from a sequence of instructions
 
-use crate::sanitize::{Sanitize, SanitizeError};
-use crate::serialize_utils::{
-    append_slice, append_u16, append_u8, read_pubkey, read_slice, read_u16, read_u8,
+use {
+    crate::{
+        bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable,
+        hash::Hash,
+        instruction::{AccountMeta, CompiledInstruction, Instruction},
+        message::MessageHeader,
+        pubkey::Pubkey,
+        sanitize::{Sanitize, SanitizeError},
+        serialize_utils::{
+            append_slice, append_u16, append_u8, read_pubkey, read_slice, read_u16, read_u8,
+        },
+        short_vec, system_instruction, system_program, sysvar,
+    },
+    itertools::Itertools,
+    lazy_static::lazy_static,
+    std::{convert::TryFrom, str::FromStr},
 };
-use crate::{
-    bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable,
-    hash::Hash,
-    instruction::{AccountMeta, CompiledInstruction, Instruction},
-    message::MessageHeader,
-    pubkey::Pubkey,
-    short_vec, system_instruction, system_program, sysvar,
-};
-use itertools::Itertools;
-use lazy_static::lazy_static;
-use std::{convert::TryFrom, str::FromStr};
 
 lazy_static! {
     // Copied keys over since direct references create cyclical dependency.
@@ -526,9 +528,11 @@ impl Message {
 #[cfg(test)]
 mod tests {
     #![allow(deprecated)]
-    use super::*;
-    use crate::{hash, instruction::AccountMeta, message::MESSAGE_HEADER_LENGTH};
-    use std::collections::HashSet;
+    use {
+        super::*,
+        crate::{hash, instruction::AccountMeta, message::MESSAGE_HEADER_LENGTH},
+        std::collections::HashSet,
+    };
 
     #[test]
     fn test_message_unique_program_ids() {

sdk/program/src/message/mapped.rs

@@ -114,7 +114,8 @@ impl MappedMessage {
     /// Returns true if the account at the specified index is called as a program by an instruction
     pub fn is_key_called_as_program(&self, key_index: usize) -> bool {
         if let Ok(key_index) = u8::try_from(key_index) {
-            self.message.instructions
+            self.message
+                .instructions
                 .iter()
                 .any(|ix| ix.program_id_index == key_index)
         } else {
@@ -131,9 +132,11 @@ impl MappedMessage {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{instruction::CompiledInstruction, message::MessageHeader, system_program, sysvar};
-    use itertools::Itertools;
+    use {
+        super::*,
+        crate::{instruction::CompiledInstruction, message::MessageHeader, system_program, sysvar},
+        itertools::Itertools,
+    };
 
     fn create_test_mapped_message() -> (MappedMessage, [Pubkey; 6]) {
         let key0 = Pubkey::new_unique();
@@ -279,13 +282,11 @@ mod tests {
                     num_readonly_unsigned_accounts: 0,
                 },
                 account_keys: vec![key0],
-                instructions: vec![
-                    CompiledInstruction {
-                        program_id_index: 2,
-                        accounts: vec![1],
-                        data: vec![],
-                    }
-                ],
+                instructions: vec![CompiledInstruction {
+                    program_id_index: 2,
+                    accounts: vec![1],
+                    data: vec![],
+                }],
                 ..v0::Message::default()
             },
             mapped_addresses: MappedAddresses {

sdk/program/src/message/mod.rs

@@ -10,13 +10,10 @@ mod non_bpf_modules {
     pub mod v0;
     mod versions;
 
-    pub use mapped::*;
-    pub use sanitized::*;
-    pub use versions::*;
+    pub use {mapped::*, sanitized::*, versions::*};
 }
 
 pub use legacy::Message;
-
 #[cfg(not(target_arch = "bpf"))]
 pub use non_bpf_modules::*;
 

sdk/program/src/message/sanitized.rs

@@ -300,10 +300,12 @@ impl SanitizedMessage {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{
-        instruction::{AccountMeta, Instruction},
-        message::v0,
+    use {
+        super::*,
+        crate::{
+            instruction::{AccountMeta, Instruction},
+            message::v0,
+        },
     };
 
     #[test]

sdk/program/src/message/v0.rs

@@ -127,8 +127,7 @@ impl Message {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::message::VersionedMessage;
+    use {super::*, crate::message::VersionedMessage};
 
     fn simple_message() -> Message {
         Message {

sdk/program/src/message/versions.rs

@@ -10,7 +10,7 @@ use {
     serde::{
         de::{self, Deserializer, SeqAccess, Visitor},
         ser::{SerializeTuple, Serializer},
-        {Deserialize, Serialize},
+        Deserialize, Serialize,
     },
     std::fmt,
 };
@@ -243,10 +243,12 @@ impl<'de> Deserialize<'de> for VersionedMessage {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{
-        instruction::{AccountMeta, Instruction},
-        message::v0::AddressMapIndexes,
+    use {
+        super::*,
+        crate::{
+            instruction::{AccountMeta, Instruction},
+            message::v0::AddressMapIndexes,
+        },
     };
 
     #[test]

sdk/program/src/nonce/state/current.rs

@@ -1,6 +1,8 @@
-use super::Versions;
-use crate::{fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey};
-use serde_derive::{Deserialize, Serialize};
+use {
+    super::Versions,
+    crate::{fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey},
+    serde_derive::{Deserialize, Serialize},
+};
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq, Clone)]
 pub struct Data {

sdk/program/src/nonce/state/mod.rs

@@ -1,6 +1,5 @@
 mod current;
 pub use current::{Data, State};
-
 use serde_derive::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]

sdk/program/src/program_error.rs

@@ -1,9 +1,11 @@
 #![allow(clippy::integer_arithmetic)]
-use crate::{decode_error::DecodeError, instruction::InstructionError, msg, pubkey::PubkeyError};
-use borsh::maybestd::io::Error as BorshIoError;
-use num_traits::{FromPrimitive, ToPrimitive};
-use std::convert::TryFrom;
-use thiserror::Error;
+use {
+    crate::{decode_error::DecodeError, instruction::InstructionError, msg, pubkey::PubkeyError},
+    borsh::maybestd::io::Error as BorshIoError,
+    num_traits::{FromPrimitive, ToPrimitive},
+    std::convert::TryFrom,
+    thiserror::Error,
+};
 
 /// Reasons the program may fail
 #[derive(Clone, Debug, Deserialize, Eq, Error, PartialEq, Serialize)]

sdk/program/src/program_stubs.rs

@@ -2,12 +2,14 @@
 
 #![cfg(not(target_arch = "bpf"))]
 
-use crate::{
-    account_info::AccountInfo, entrypoint::ProgramResult, instruction::Instruction,
-    program_error::UNSUPPORTED_SYSVAR, pubkey::Pubkey,
+use {
+    crate::{
+        account_info::AccountInfo, entrypoint::ProgramResult, instruction::Instruction,
+        program_error::UNSUPPORTED_SYSVAR, pubkey::Pubkey,
+    },
+    itertools::Itertools,
+    std::sync::{Arc, RwLock},
 };
-use itertools::Itertools;
-use std::sync::{Arc, RwLock};
 
 lazy_static::lazy_static! {
     static ref SYSCALL_STUBS: Arc<RwLock<Box<dyn SyscallStubs>>> = Arc::new(RwLock::new(Box::new(DefaultSyscallStubs {})));

sdk/program/src/pubkey.rs

@@ -393,8 +393,7 @@ impl fmt::Display for Pubkey {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use std::str::from_utf8;
+    use {super::*, std::str::from_utf8};
 
     #[test]
     fn test_new_unique() {

sdk/program/src/secp256k1_recover.rs

@@ -1,6 +1,8 @@
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use core::convert::TryFrom;
-use thiserror::Error;
+use {
+    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
+    core::convert::TryFrom,
+    thiserror::Error,
+};
 
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
 pub enum Secp256k1RecoverError {

sdk/program/src/serialize_utils.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::integer_arithmetic)]
-use crate::pubkey::Pubkey;
-use crate::sanitize::SanitizeError;
+use crate::{pubkey::Pubkey, sanitize::SanitizeError};
 
 pub fn append_u16(buf: &mut Vec<u8>, data: u16) {
     let start = buf.len();

sdk/program/src/short_vec.rs

@@ -1,10 +1,12 @@
 #![allow(clippy::integer_arithmetic)]
-use serde::{
-    de::{self, Deserializer, SeqAccess, Visitor},
-    ser::{self, SerializeTuple, Serializer},
-    {Deserialize, Serialize},
+use {
+    serde::{
+        de::{self, Deserializer, SeqAccess, Visitor},
+        ser::{self, SerializeTuple, Serializer},
+        Deserialize, Serialize,
+    },
+    std::{convert::TryFrom, fmt, marker::PhantomData},
 };
-use std::{convert::TryFrom, fmt, marker::PhantomData};
 
 /// Same as u16, but serialized with 1 to 3 bytes. If the value is above
 /// 0x7f, the top bit is set and the remaining value is stored in the next
@@ -265,9 +267,11 @@ pub fn decode_shortu16_len(bytes: &[u8]) -> Result<(usize, usize), ()> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use assert_matches::assert_matches;
-    use bincode::{deserialize, serialize};
+    use {
+        super::*,
+        assert_matches::assert_matches,
+        bincode::{deserialize, serialize},
+    };
 
     /// Return the serialized length.
     fn encode_len(len: u16) -> Vec<u8> {

sdk/program/src/slot_hashes.rs

@@ -2,8 +2,10 @@
 //!
 //! this account carries the Bank's most recent bank hashes for some N parents
 //!
-use crate::hash::Hash;
-use std::{iter::FromIterator, ops::Deref};
+use {
+    crate::hash::Hash,
+    std::{iter::FromIterator, ops::Deref},
+};
 
 pub const MAX_ENTRIES: usize = 512; // about 2.5 minutes to get your vote in
 
@@ -54,8 +56,7 @@ impl Deref for SlotHashes {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::hash::hash;
+    use {super::*, crate::hash::hash};
 
     #[test]
     fn test() {

sdk/program/src/slot_history.rs

@@ -3,8 +3,7 @@
 //! slot history
 //!
 pub use crate::clock::Slot;
-use bv::BitVec;
-use bv::BitsMut;
+use bv::{BitVec, BitsMut};
 
 #[repr(C)]
 #[derive(Clone, Serialize, Deserialize, PartialEq)]
@@ -86,8 +85,7 @@ impl SlotHistory {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use log::*;
+    use {super::*, log::*};
 
     #[test]
     fn slot_history_test1() {

sdk/program/src/stake/instruction.rs

@@ -1,14 +1,14 @@
 use {
-    crate::stake::{
-        config,
-        program::id,
-        state::{Authorized, Lockup, StakeAuthorize, StakeState},
-    },
     crate::{
         clock::{Epoch, UnixTimestamp},
         decode_error::DecodeError,
         instruction::{AccountMeta, Instruction},
         pubkey::Pubkey,
+        stake::{
+            config,
+            program::id,
+            state::{Authorized, Lockup, StakeAuthorize, StakeState},
+        },
         system_instruction, sysvar,
     },
     log::*,
@@ -680,8 +680,7 @@ pub fn set_lockup_checked(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::instruction::InstructionError;
+    use {super::*, crate::instruction::InstructionError};
 
     #[test]
     fn test_custom_error_decode() {

sdk/program/src/stake_history.rs

@@ -3,7 +3,6 @@
 //! this account carries history about stake activations and de-activations
 //!
 pub use crate::clock::Epoch;
-
 use std::ops::Deref;
 
 pub const MAX_ENTRIES: usize = 512; // it should never take as many as 512 epochs to warm up or cool down

sdk/program/src/system_instruction.rs

@@ -1,15 +1,17 @@
 #[allow(deprecated)]
 use crate::sysvar::recent_blockhashes;
-use crate::{
-    decode_error::DecodeError,
-    instruction::{AccountMeta, Instruction, InstructionError},
-    nonce,
-    pubkey::Pubkey,
-    system_program,
-    sysvar::rent,
+use {
+    crate::{
+        decode_error::DecodeError,
+        instruction::{AccountMeta, Instruction, InstructionError},
+        nonce,
+        pubkey::Pubkey,
+        system_program,
+        sysvar::rent,
+    },
+    num_derive::{FromPrimitive, ToPrimitive},
+    thiserror::Error,
 };
-use num_derive::{FromPrimitive, ToPrimitive};
-use thiserror::Error;
 
 #[derive(Error, Debug, Serialize, Clone, PartialEq, FromPrimitive, ToPrimitive)]
 pub enum SystemError {
@@ -573,9 +575,11 @@ pub fn authorize_nonce_account(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::instruction::{Instruction, InstructionError};
-    use num_traits::ToPrimitive;
+    use {
+        super::*,
+        crate::instruction::{Instruction, InstructionError},
+        num_traits::ToPrimitive,
+    };
 
     fn get_keys(instruction: &Instruction) -> Vec<Pubkey> {
         instruction.accounts.iter().map(|x| x.pubkey).collect()

sdk/program/src/sysvar/clock.rs

@@ -1,7 +1,6 @@
 //! This account contains the clock slot, epoch, and leader_schedule_epoch
 //!
 pub use crate::clock::Clock;
-
 use crate::{impl_sysvar_get, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarC1ock11111111111111111111111111111111", Clock);

sdk/program/src/sysvar/epoch_schedule.rs

@@ -1,7 +1,6 @@
 //! This account contains the current cluster rent
 //!
 pub use crate::epoch_schedule::EpochSchedule;
-
 use crate::{impl_sysvar_get, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarEpochSchedu1e111111111111111111111111", EpochSchedule);

sdk/program/src/sysvar/instructions.rs

@@ -118,9 +118,11 @@ pub fn get_instruction_relative(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{instruction::AccountMeta, message::Message, pubkey::Pubkey};
-    use std::convert::TryFrom;
+    use {
+        super::*,
+        crate::{instruction::AccountMeta, message::Message, pubkey::Pubkey},
+        std::convert::TryFrom,
+    };
 
     #[test]
     fn test_load_store_instruction() {

sdk/program/src/sysvar/mod.rs

@@ -1,7 +1,9 @@
 //! named accounts for synthesized data accounts for bank state, etc.
 //!
-use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
-use lazy_static::lazy_static;
+use {
+    crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey},
+    lazy_static::lazy_static,
+};
 
 pub mod clock;
 pub mod epoch_schedule;
@@ -140,9 +142,11 @@ macro_rules! impl_sysvar_get {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{clock::Epoch, program_error::ProgramError, pubkey::Pubkey};
-    use std::{cell::RefCell, rc::Rc};
+    use {
+        super::*,
+        crate::{clock::Epoch, program_error::ProgramError, pubkey::Pubkey},
+        std::{cell::RefCell, rc::Rc},
+    };
 
     #[repr(C)]
     #[derive(Serialize, Deserialize, Debug, Default, PartialEq)]

sdk/program/src/sysvar/recent_blockhashes.rs

@@ -1,12 +1,14 @@
 #![allow(deprecated)]
 #![allow(clippy::integer_arithmetic)]
-use crate::{
-    declare_deprecated_sysvar_id,
-    fee_calculator::FeeCalculator,
-    hash::{hash, Hash},
-    sysvar::Sysvar,
+use {
+    crate::{
+        declare_deprecated_sysvar_id,
+        fee_calculator::FeeCalculator,
+        hash::{hash, Hash},
+        sysvar::Sysvar,
+    },
+    std::{cmp::Ordering, collections::BinaryHeap, iter::FromIterator, ops::Deref},
 };
-use std::{cmp::Ordering, collections::BinaryHeap, iter::FromIterator, ops::Deref};
 
 #[deprecated(
     since = "1.9.0",
@@ -161,8 +163,7 @@ pub fn create_test_recent_blockhashes(start: usize) -> RecentBlockhashes {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::clock::MAX_PROCESSING_AGE;
+    use {super::*, crate::clock::MAX_PROCESSING_AGE};
 
     #[test]
     #[allow(clippy::assertions_on_constants)]

sdk/program/src/sysvar/rent.rs

@@ -1,7 +1,6 @@
 //! This account contains the current cluster rent
 //!
 pub use crate::rent::Rent;
-
 use crate::{impl_sysvar_get, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarRent111111111111111111111111111111111", Rent);

sdk/program/src/sysvar/slot_hashes.rs

@@ -3,7 +3,6 @@
 //! this account carries the Bank's most recent bank hashes for some N parents
 //!
 pub use crate::slot_hashes::SlotHashes;
-
 use crate::{account_info::AccountInfo, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarS1otHashes111111111111111111111111111", SlotHashes);
@@ -22,8 +21,10 @@ impl Sysvar for SlotHashes {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{clock::Slot, hash::Hash, slot_hashes::MAX_ENTRIES};
+    use {
+        super::*,
+        crate::{clock::Slot, hash::Hash, slot_hashes::MAX_ENTRIES},
+    };
 
     #[test]
     fn test_size_of() {

sdk/program/src/sysvar/slot_history.rs

@@ -3,12 +3,11 @@
 //! this account carries a bitvector of slots present over the past
 //! epoch
 //!
+use crate::sysvar::Sysvar;
 pub use crate::{
     account_info::AccountInfo, program_error::ProgramError, slot_history::SlotHistory,
 };
 
-use crate::sysvar::Sysvar;
-
 crate::declare_sysvar_id!("SysvarS1otHistory11111111111111111111111111", SlotHistory);
 
 impl Sysvar for SlotHistory {

sdk/program/src/sysvar/stake_history.rs

@@ -3,7 +3,6 @@
 //! this account carries history about stake activations and de-activations
 //!
 pub use crate::stake_history::StakeHistory;
-
 use crate::sysvar::Sysvar;
 
 crate::declare_sysvar_id!("SysvarStakeHistory1111111111111111111111111", StakeHistory);
@@ -18,8 +17,7 @@ impl Sysvar for StakeHistory {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::stake_history::*;
+    use {super::*, crate::stake_history::*};
 
     #[test]
     fn test_size_of() {

sdk/src/account.rs

@@ -1,10 +1,17 @@
-use crate::{
-    clock::{Epoch, INITIAL_RENT_EPOCH},
-    lamports::LamportsError,
-    pubkey::Pubkey,
+use {
+    crate::{
+        clock::{Epoch, INITIAL_RENT_EPOCH},
+        lamports::LamportsError,
+        pubkey::Pubkey,
+    },
+    solana_program::{account_info::AccountInfo, sysvar::Sysvar},
+    std::{
+        cell::{Ref, RefCell},
+        cmp, fmt,
+        rc::Rc,
+        sync::Arc,
+    },
 };
-use solana_program::{account_info::AccountInfo, sysvar::Sysvar};
-use std::{cell::Ref, cell::RefCell, cmp, fmt, rc::Rc, sync::Arc};
 
 /// An Account with data that is stored on chain
 #[repr(C)]

sdk/src/account_utils.rs

@@ -1,7 +1,12 @@
 //! useful extras for Account state
-use crate::{account::Account, account::AccountSharedData, instruction::InstructionError};
-use bincode::ErrorKind;
-use std::cell::Ref;
+use {
+    crate::{
+        account::{Account, AccountSharedData},
+        instruction::InstructionError,
+    },
+    bincode::ErrorKind,
+    std::cell::Ref,
+};
 
 /// Convenience trait to covert bincode errors to instruction errors.
 pub trait StateMut<T> {
@@ -60,8 +65,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{account::AccountSharedData, pubkey::Pubkey};
+    use {
+        super::*,
+        crate::{account::AccountSharedData, pubkey::Pubkey},
+    };
 
     #[test]
     fn test_account_state() {

sdk/src/commitment_config.rs

@@ -1,8 +1,7 @@
 #![allow(deprecated)]
 #![cfg(feature = "full")]
 
-use std::str::FromStr;
-use thiserror::Error;
+use {std::str::FromStr, thiserror::Error};
 
 #[derive(Serialize, Deserialize, Default, Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[serde(rename_all = "camelCase")]

sdk/src/compute_budget.rs

@@ -158,10 +158,12 @@ impl ComputeBudget {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{
-        hash::Hash, message::Message, pubkey::Pubkey, signature::Keypair, signer::Signer,
-        transaction::Transaction,
+    use {
+        super::*,
+        crate::{
+            hash::Hash, message::Message, pubkey::Pubkey, signature::Keypair, signer::Signer,
+            transaction::Transaction,
+        },
     };
 
     macro_rules! test {

sdk/src/derivation_path.rs

@@ -260,8 +260,7 @@ impl Bip44 for Solana {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use uriparse::URIReferenceBuilder;
+    use {super::*, uriparse::URIReferenceBuilder};
 
     struct TestCoin;
     impl Bip44 for TestCoin {

sdk/src/deserialize_utils.rs

@@ -18,8 +18,7 @@ where
 
 #[cfg(test)]
 pub mod tests {
-    use super::*;
-    use bincode::deserialize;
+    use {super::*, bincode::deserialize};
 
     #[test]
     fn test_default_on_eof() {

sdk/src/ed25519_instruction.rs

@@ -1,9 +1,11 @@
 #![cfg(feature = "full")]
 
-use crate::{feature_set::FeatureSet, instruction::Instruction, precompiles::PrecompileError};
-use bytemuck::{bytes_of, Pod, Zeroable};
-use ed25519_dalek::{ed25519::signature::Signature, Signer, Verifier};
-use std::sync::Arc;
+use {
+    crate::{feature_set::FeatureSet, instruction::Instruction, precompiles::PrecompileError},
+    bytemuck::{bytes_of, Pod, Zeroable},
+    ed25519_dalek::{ed25519::signature::Signature, Signer, Verifier},
+    std::sync::Arc,
+};
 
 pub const PUBKEY_SERIALIZED_SIZE: usize = 32;
 pub const SIGNATURE_SERIALIZED_SIZE: usize = 64;
@@ -173,16 +175,18 @@ fn get_data_slice<'a>(
 
 #[cfg(test)]
 pub mod test {
-    use super::*;
-    use crate::{
-        ed25519_instruction::new_ed25519_instruction,
-        feature_set::FeatureSet,
-        hash::Hash,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
+    use {
+        super::*,
+        crate::{
+            ed25519_instruction::new_ed25519_instruction,
+            feature_set::FeatureSet,
+            hash::Hash,
+            signature::{Keypair, Signer},
+            transaction::Transaction,
+        },
+        rand::{thread_rng, Rng},
+        std::sync::Arc,
     };
-    use rand::{thread_rng, Rng};
-    use std::sync::Arc;
 
     fn test_case(
         num_signatures: u16,

sdk/src/feature_set.rs

@@ -18,13 +18,15 @@
 //!
 //! For more information on how features are picked up, see comments for `Feature`.
 
-use lazy_static::lazy_static;
-use solana_sdk::{
-    clock::Slot,
-    hash::{Hash, Hasher},
-    pubkey::Pubkey,
+use {
+    lazy_static::lazy_static,
+    solana_sdk::{
+        clock::Slot,
+        hash::{Hash, Hasher},
+        pubkey::Pubkey,
+    },
+    std::collections::{HashMap, HashSet},
 };
-use std::collections::{HashMap, HashSet};
 
 pub mod deprecate_rewards_sysvar {
     solana_sdk::declare_id!("GaBtBJvmS4Arjj5W1NmFcyvPjsHN38UGYDq2MDwbs9Qu");

sdk/src/genesis_config.rs

@@ -2,34 +2,35 @@
 
 #![cfg(feature = "full")]
 
-use crate::{
-    account::Account,
-    account::AccountSharedData,
-    clock::{UnixTimestamp, DEFAULT_TICKS_PER_SLOT},
-    epoch_schedule::EpochSchedule,
-    fee_calculator::FeeRateGovernor,
-    hash::{hash, Hash},
-    inflation::Inflation,
-    native_token::lamports_to_sol,
-    poh_config::PohConfig,
-    pubkey::Pubkey,
-    rent::Rent,
-    shred_version::compute_shred_version,
-    signature::{Keypair, Signer},
-    system_program,
-    timing::years_as_slots,
-};
-use bincode::{deserialize, serialize};
-use chrono::{TimeZone, Utc};
-use memmap2::Mmap;
-use std::{
-    collections::BTreeMap,
-    fmt,
-    fs::{File, OpenOptions},
-    io::Write,
-    path::{Path, PathBuf},
-    str::FromStr,
-    time::{SystemTime, UNIX_EPOCH},
+use {
+    crate::{
+        account::{Account, AccountSharedData},
+        clock::{UnixTimestamp, DEFAULT_TICKS_PER_SLOT},
+        epoch_schedule::EpochSchedule,
+        fee_calculator::FeeRateGovernor,
+        hash::{hash, Hash},
+        inflation::Inflation,
+        native_token::lamports_to_sol,
+        poh_config::PohConfig,
+        pubkey::Pubkey,
+        rent::Rent,
+        shred_version::compute_shred_version,
+        signature::{Keypair, Signer},
+        system_program,
+        timing::years_as_slots,
+    },
+    bincode::{deserialize, serialize},
+    chrono::{TimeZone, Utc},
+    memmap2::Mmap,
+    std::{
+        collections::BTreeMap,
+        fmt,
+        fs::{File, OpenOptions},
+        io::Write,
+        path::{Path, PathBuf},
+        str::FromStr,
+        time::{SystemTime, UNIX_EPOCH},
+    },
 };
 
 pub const DEFAULT_GENESIS_FILE: &str = "genesis.bin";
@@ -291,9 +292,11 @@ impl fmt::Display for GenesisConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::signature::{Keypair, Signer};
-    use std::path::PathBuf;
+    use {
+        super::*,
+        crate::signature::{Keypair, Signer},
+        std::path::PathBuf,
+    };
 
     fn make_tmp_path(name: &str) -> PathBuf {
         let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());

sdk/src/hard_forks.rs

@@ -3,8 +3,10 @@
 
 #![cfg(feature = "full")]
 
-use byteorder::{ByteOrder, LittleEndian};
-use solana_sdk::clock::Slot;
+use {
+    byteorder::{ByteOrder, LittleEndian},
+    solana_sdk::clock::Slot,
+};
 
 #[derive(Default, Clone, Debug, Deserialize, Serialize, AbiExample, PartialEq, Eq)]
 pub struct HardForks {

sdk/src/keyed_account.rs

@@ -1,12 +1,14 @@
-use crate::{
-    account::{from_account, AccountSharedData, ReadableAccount},
-    account_utils::{State, StateMut},
-};
-use solana_program::{clock::Epoch, instruction::InstructionError, pubkey::Pubkey, sysvar::Sysvar};
-use std::{
-    cell::{Ref, RefCell, RefMut},
-    iter::FromIterator,
-    rc::Rc,
+use {
+    crate::{
+        account::{from_account, AccountSharedData, ReadableAccount},
+        account_utils::{State, StateMut},
+    },
+    solana_program::{clock::Epoch, instruction::InstructionError, pubkey::Pubkey, sysvar::Sysvar},
+    std::{
+        cell::{Ref, RefCell, RefMut},
+        iter::FromIterator,
+        rc::Rc,
+    },
 };
 
 #[repr(C)]
@@ -258,12 +260,14 @@ pub fn from_keyed_account<S: Sysvar>(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{
-        account::{create_account_for_test, to_account},
-        pubkey::Pubkey,
+    use {
+        super::*,
+        crate::{
+            account::{create_account_for_test, to_account},
+            pubkey::Pubkey,
+        },
+        std::cell::RefCell,
     };
-    use std::cell::RefCell;
 
     #[repr(C)]
     #[derive(Serialize, Deserialize, Debug, Default, PartialEq)]

sdk/src/native_loader.rs

@@ -1,7 +1,9 @@
-use crate::account::{
-    Account, AccountSharedData, InheritableAccountFields, DUMMY_INHERITABLE_ACCOUNT_FIELDS,
+use crate::{
+    account::{
+        Account, AccountSharedData, InheritableAccountFields, DUMMY_INHERITABLE_ACCOUNT_FIELDS,
+    },
+    clock::INITIAL_RENT_EPOCH,
 };
-use crate::clock::INITIAL_RENT_EPOCH;
 
 crate::declare_id!("NativeLoader1111111111111111111111111111111");
 

sdk/src/nonce_account.rs

@@ -1,10 +1,12 @@
-use crate::{
-    account::{AccountSharedData, ReadableAccount},
-    account_utils::StateMut,
-    hash::Hash,
-    nonce::{state::Versions, State},
+use {
+    crate::{
+        account::{AccountSharedData, ReadableAccount},
+        account_utils::StateMut,
+        hash::Hash,
+        nonce::{state::Versions, State},
+    },
+    std::cell::RefCell,
 };
-use std::cell::RefCell;
 
 pub fn create_account(lamports: u64) -> RefCell<AccountSharedData> {
     RefCell::new(
@@ -40,8 +42,7 @@ pub fn lamports_per_signature_of(account: &AccountSharedData) -> Option<u64> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::pubkey::Pubkey;
+    use {super::*, crate::pubkey::Pubkey};
 
     #[test]
     fn test_verify_bad_account_owner_fails() {

sdk/src/packet.rs

@@ -1,9 +1,11 @@
-use crate::clock::Slot;
-use bincode::Result;
-use serde::Serialize;
-use std::{
-    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
-    {fmt, io},
+use {
+    crate::clock::Slot,
+    bincode::Result,
+    serde::Serialize,
+    std::{
+        fmt, io,
+        net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    },
 };
 
 /// Maximum over-the-wire size of a Transaction

sdk/src/poh_config.rs

@@ -1,5 +1,7 @@
-use crate::{clock::DEFAULT_TICKS_PER_SECOND, unchecked_div_by_const};
-use std::time::Duration;
+use {
+    crate::{clock::DEFAULT_TICKS_PER_SECOND, unchecked_div_by_const},
+    std::time::Duration,
+};
 
 #[derive(Serialize, Deserialize, Clone, Debug, AbiExample)]
 pub struct PohConfig {

sdk/src/program_utils.rs

@@ -1,5 +1,4 @@
-use crate::instruction::InstructionError;
-use bincode::config::Options;
+use {crate::instruction::InstructionError, bincode::config::Options};
 
 /// Deserialize with a limit based the maximum amount of data a program can expect to get.
 /// This function should be used in place of direct deserialization to help prevent OOM errors

sdk/src/pubkey.rs

@@ -33,8 +33,7 @@ pub fn read_pubkey_file(infile: &str) -> Result<Pubkey, Box<dyn std::error::Erro
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use std::fs::remove_file;
+    use {super::*, std::fs::remove_file};
 
     #[test]
     fn test_read_write_pubkey() -> Result<(), Box<dyn std::error::Error>> {

sdk/src/recent_blockhashes_account.rs

@@ -1,13 +1,17 @@
-use crate::account::{
-    create_account_shared_data_with_fields, to_account, AccountSharedData,
-    InheritableAccountFields, DUMMY_INHERITABLE_ACCOUNT_FIELDS,
-};
-use crate::clock::INITIAL_RENT_EPOCH;
 #[allow(deprecated)]
 use solana_program::sysvar::recent_blockhashes::{
     IntoIterSorted, IterItem, RecentBlockhashes, MAX_ENTRIES,
 };
-use std::{collections::BinaryHeap, iter::FromIterator};
+use {
+    crate::{
+        account::{
+            create_account_shared_data_with_fields, to_account, AccountSharedData,
+            InheritableAccountFields, DUMMY_INHERITABLE_ACCOUNT_FIELDS,
+        },
+        clock::INITIAL_RENT_EPOCH,
+    },
+    std::{collections::BinaryHeap, iter::FromIterator},
+};
 
 #[deprecated(
     since = "1.9.0",
@@ -79,12 +83,14 @@ where
 #[cfg(test)]
 mod tests {
     #![allow(deprecated)]
-    use super::*;
-    use crate::account::from_account;
-    use rand::{seq::SliceRandom, thread_rng};
-    use solana_program::{
-        hash::{Hash, HASH_BYTES},
-        sysvar::recent_blockhashes::Entry,
+    use {
+        super::*,
+        crate::account::from_account,
+        rand::{seq::SliceRandom, thread_rng},
+        solana_program::{
+            hash::{Hash, HASH_BYTES},
+            sysvar::recent_blockhashes::Entry,
+        },
     };
 
     #[test]

sdk/src/secp256k1_instruction.rs

@@ -1,13 +1,17 @@
 #![cfg(feature = "full")]
 
-use crate::{
-    feature_set::{libsecp256k1_0_5_upgrade_enabled, libsecp256k1_fail_on_bad_count, FeatureSet},
-    instruction::Instruction,
-    precompiles::PrecompileError,
+use {
+    crate::{
+        feature_set::{
+            libsecp256k1_0_5_upgrade_enabled, libsecp256k1_fail_on_bad_count, FeatureSet,
+        },
+        instruction::Instruction,
+        precompiles::PrecompileError,
+    },
+    digest::Digest,
+    serde_derive::{Deserialize, Serialize},
+    std::sync::Arc,
 };
-use digest::Digest;
-use serde_derive::{Deserialize, Serialize};
-use std::sync::Arc;
 
 pub const HASHED_PUBKEY_SERIALIZED_SIZE: usize = 20;
 pub const SIGNATURE_SERIALIZED_SIZE: usize = 64;
@@ -211,18 +215,20 @@ fn get_data_slice<'a>(
 
 #[cfg(test)]
 pub mod test {
-    use super::*;
-    use crate::{
-        feature_set,
-        hash::Hash,
-        secp256k1_instruction::{
-            new_secp256k1_instruction, SecpSignatureOffsets, SIGNATURE_OFFSETS_SERIALIZED_SIZE,
+    use {
+        super::*,
+        crate::{
+            feature_set,
+            hash::Hash,
+            secp256k1_instruction::{
+                new_secp256k1_instruction, SecpSignatureOffsets, SIGNATURE_OFFSETS_SERIALIZED_SIZE,
+            },
+            signature::{Keypair, Signer},
+            transaction::Transaction,
         },
-        signature::{Keypair, Signer},
-        transaction::Transaction,
+        rand::{thread_rng, Rng},
+        std::sync::Arc,
     };
-    use rand::{thread_rng, Rng};
-    use std::sync::Arc;
 
     fn test_case(
         num_signatures: u8,

sdk/src/signature.rs

@@ -1,18 +1,19 @@
 //! The `signature` module provides functionality for public, and private keys.
 #![cfg(feature = "full")]
 
-use crate::pubkey::Pubkey;
-use generic_array::{typenum::U64, GenericArray};
-use std::{
-    borrow::{Borrow, Cow},
-    convert::TryInto,
-    fmt, mem,
-    str::FromStr,
-};
-use thiserror::Error;
-
 // legacy module paths
 pub use crate::signer::{keypair::*, null_signer::*, presigner::*, *};
+use {
+    crate::pubkey::Pubkey,
+    generic_array::{typenum::U64, GenericArray},
+    std::{
+        borrow::{Borrow, Cow},
+        convert::TryInto,
+        fmt, mem,
+        str::FromStr,
+    },
+    thiserror::Error,
+};
 
 /// Number of bytes in a signature
 pub const SIGNATURE_BYTES: usize = 64;

sdk/src/signer/mod.rs

@@ -100,8 +100,7 @@ pub fn unique_signers(signers: Vec<&dyn Signer>) -> Vec<&dyn Signer> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::signer::keypair::Keypair;
+    use {super::*, crate::signer::keypair::Keypair};
 
     fn pubkeys(signers: &[&dyn Signer]) -> Vec<Pubkey> {
         signers.iter().map(|x| x.pubkey()).collect()

sdk/src/signer/presigner.rs

@@ -63,8 +63,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::signer::keypair::keypair_from_seed;
+    use {super::*, crate::signer::keypair::keypair_from_seed};
 
     #[test]
     fn test_presigner() {

sdk/src/timing.rs

@@ -1,7 +1,11 @@
 //! The `timing` module provides std::time utility functions.
-use crate::unchecked_div_by_const;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use {
+    crate::unchecked_div_by_const,
+    std::{
+        sync::atomic::{AtomicU64, Ordering},
+        time::{Duration, SystemTime, UNIX_EPOCH},
+    },
+};
 
 pub fn duration_as_ns(d: &Duration) -> u64 {
     d.as_secs()

sdk/src/transaction/mod.rs

@@ -19,16 +19,14 @@ use {
     serde::Serialize,
     solana_program::{system_instruction::SystemInstruction, system_program},
     solana_sdk::feature_set,
-    std::result,
-    std::sync::Arc,
+    std::{result, sync::Arc},
     thiserror::Error,
 };
 
 mod sanitized;
 mod versioned;
 
-pub use sanitized::*;
-pub use versioned::*;
+pub use {sanitized::*, versioned::*};
 
 /// Reasons a transaction might be rejected.
 #[derive(
@@ -547,15 +545,17 @@ pub fn get_nonce_pubkey_from_instruction<'a>(
 mod tests {
     #![allow(deprecated)]
 
-    use super::*;
-    use crate::{
-        hash::hash,
-        instruction::AccountMeta,
-        signature::{Keypair, Presigner, Signer},
-        system_instruction, sysvar,
+    use {
+        super::*,
+        crate::{
+            hash::hash,
+            instruction::AccountMeta,
+            signature::{Keypair, Presigner, Signer},
+            system_instruction, sysvar,
+        },
+        bincode::{deserialize, serialize, serialized_size},
+        std::mem::size_of,
     };
-    use bincode::{deserialize, serialize, serialized_size};
-    use std::mem::size_of;
 
     fn get_program_id(tx: &Transaction, instruction_index: usize) -> &Pubkey {
         let message = tx.message();

sdk/src/transport.rs

@@ -1,8 +1,6 @@
 #![cfg(feature = "full")]
 
-use crate::transaction::TransactionError;
-use std::io;
-use thiserror::Error;
+use {crate::transaction::TransactionError, std::io, thiserror::Error};
 
 #[derive(Debug, Error)]
 pub enum TransportError {