Reformat imports to a consistent style for imports

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

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

@@ -1,17 +1,19 @@
 #![cfg(feature = "full")]
 
-use crate::{
-    entrypoint::HEAP_LENGTH as MIN_HEAP_FRAME_BYTES,
-    feature_set::{requestable_heap_size, FeatureSet},
-    process_instruction::BpfComputeBudget,
-    transaction::{Transaction, TransactionError},
+use {
+    crate::{
+        entrypoint::HEAP_LENGTH as MIN_HEAP_FRAME_BYTES,
+        feature_set::{requestable_heap_size, FeatureSet},
+        process_instruction::BpfComputeBudget,
+        transaction::{Transaction, TransactionError},
+    },
+    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
+    solana_sdk::{
+        borsh::try_from_slice_unchecked,
+        instruction::{Instruction, InstructionError},
+    },
+    std::sync::Arc,
 };
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use solana_sdk::{
-    borsh::try_from_slice_unchecked,
-    instruction::{Instruction, InstructionError},
-};
-use std::sync::Arc;
 
 crate::declare_id!("ComputeBudget111111111111111111111111111111");
 
@@ -91,8 +93,10 @@ pub fn process_request(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{hash::Hash, message::Message, pubkey::Pubkey, signature::Keypair, signer::Signer};
+    use {
+        super::*,
+        crate::{hash::Hash, message::Message, pubkey::Pubkey, signature::Keypair, signer::Signer},
+    };
 
     macro_rules! test {
         ( $instructions: expr, $expected_error: expr, $expected_budget: expr ) => {

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::{decode_error::DecodeError, instruction::Instruction};
-use bytemuck::{bytes_of, Pod, Zeroable};
-use ed25519_dalek::{ed25519::signature::Signature, Signer, Verifier};
-use thiserror::Error;
+use {
+    crate::{decode_error::DecodeError, instruction::Instruction},
+    bytemuck::{bytes_of, Pod, Zeroable},
+    ed25519_dalek::{ed25519::signature::Signature, Signer, Verifier},
+    thiserror::Error,
+};
 
 #[derive(Error, Debug, Clone, PartialEq)]
 pub enum Ed25519Error {

sdk/src/feature_set.rs

@@ -1,10 +1,12 @@
-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 instructions_sysvar_enabled {
     solana_sdk::declare_id!("EnvhHCLvg55P7PDtbvR1NwuTuAeodqpusV3MR5QEK8gs");

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";
@@ -293,9 +294,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)]
@@ -256,12 +258,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,11 +1,13 @@
-use crate::{
-    account::{AccountSharedData, ReadableAccount},
-    account_utils::StateMut,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    nonce::{state::Versions, State},
+use {
+    crate::{
+        account::{AccountSharedData, ReadableAccount},
+        account_utils::StateMut,
+        fee_calculator::FeeCalculator,
+        hash::Hash,
+        nonce::{state::Versions, State},
+    },
+    std::cell::RefCell,
 };
-use std::cell::RefCell;
 
 pub fn create_account(lamports: u64) -> RefCell<AccountSharedData> {
     RefCell::new(
@@ -41,8 +43,7 @@ pub fn fee_calculator_of(account: &AccountSharedData) -> Option<FeeCalculator> {
 
 #[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/nonce_keyed_account.rs

@@ -1,19 +1,21 @@
-use crate::{
-    account::{ReadableAccount, WritableAccount},
-    account_utils::State as AccountUtilsState,
-    feature_set, ic_msg,
-    keyed_account::KeyedAccount,
-    nonce_account::create_account,
-    process_instruction::InvokeContext,
+use {
+    crate::{
+        account::{ReadableAccount, WritableAccount},
+        account_utils::State as AccountUtilsState,
+        feature_set, ic_msg,
+        keyed_account::KeyedAccount,
+        nonce_account::create_account,
+        process_instruction::InvokeContext,
+    },
+    solana_program::{
+        instruction::{checked_add, InstructionError},
+        nonce::{self, state::Versions, State},
+        pubkey::Pubkey,
+        system_instruction::{nonce_to_instruction_error, NonceError},
+        sysvar::{recent_blockhashes::RecentBlockhashes, rent::Rent},
+    },
+    std::collections::HashSet,
 };
-use solana_program::{
-    instruction::{checked_add, InstructionError},
-    nonce::{self, state::Versions, State},
-    pubkey::Pubkey,
-    system_instruction::{nonce_to_instruction_error, NonceError},
-    sysvar::{recent_blockhashes::RecentBlockhashes, rent::Rent},
-};
-use std::collections::HashSet;
 
 pub trait NonceKeyedAccount {
     fn advance_nonce_account(
@@ -294,18 +296,20 @@ where
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use crate::{
-        account::ReadableAccount,
-        account_utils::State as AccountUtilsState,
-        keyed_account::KeyedAccount,
-        nonce::{self, State},
-        nonce_account::verify_nonce_account,
-        process_instruction::MockInvokeContext,
-        system_instruction::SystemError,
-        sysvar::recent_blockhashes::create_test_recent_blockhashes,
+    use {
+        super::*,
+        crate::{
+            account::ReadableAccount,
+            account_utils::State as AccountUtilsState,
+            keyed_account::KeyedAccount,
+            nonce::{self, State},
+            nonce_account::verify_nonce_account,
+            process_instruction::MockInvokeContext,
+            system_instruction::SystemError,
+            sysvar::recent_blockhashes::create_test_recent_blockhashes,
+        },
+        solana_program::hash::Hash,
     };
-    use solana_program::hash::Hash;
 
     #[test]
     fn default_is_uninitialized() {

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/process_instruction.rs

@@ -1,12 +1,14 @@
-use itertools::Itertools;
-use solana_sdk::{
-    account::AccountSharedData,
-    instruction::{CompiledInstruction, Instruction, InstructionError},
-    keyed_account::{create_keyed_accounts_unified, KeyedAccount},
-    pubkey::Pubkey,
-    sysvar::Sysvar,
+use {
+    itertools::Itertools,
+    solana_sdk::{
+        account::AccountSharedData,
+        instruction::{CompiledInstruction, Instruction, InstructionError},
+        keyed_account::{create_keyed_accounts_unified, KeyedAccount},
+        pubkey::Pubkey,
+        sysvar::Sysvar,
+    },
+    std::{cell::RefCell, collections::HashSet, fmt::Debug, rc::Rc, sync::Arc},
 };
-use std::{cell::RefCell, collections::HashSet, fmt::Debug, rc::Rc, sync::Arc};
 
 /// Prototype of a native loader entry point
 ///

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,12 +1,16 @@
-use crate::account::{
-    create_account_shared_data_with_fields, to_account, AccountSharedData,
-    InheritableAccountFields, DUMMY_INHERITABLE_ACCOUNT_FIELDS,
+use {
+    crate::{
+        account::{
+            create_account_shared_data_with_fields, to_account, AccountSharedData,
+            InheritableAccountFields, DUMMY_INHERITABLE_ACCOUNT_FIELDS,
+        },
+        clock::INITIAL_RENT_EPOCH,
+    },
+    solana_program::sysvar::recent_blockhashes::{
+        IntoIterSorted, IterItem, RecentBlockhashes, MAX_ENTRIES,
+    },
+    std::{collections::BinaryHeap, iter::FromIterator},
 };
-use crate::clock::INITIAL_RENT_EPOCH;
-use solana_program::sysvar::recent_blockhashes::{
-    IntoIterSorted, IterItem, RecentBlockhashes, MAX_ENTRIES,
-};
-use std::{collections::BinaryHeap, iter::FromIterator};
 
 pub fn update_account<'a, I>(
     account: &mut AccountSharedData,
@@ -57,13 +61,15 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::account::from_account;
-    use rand::{seq::SliceRandom, thread_rng};
-    use solana_program::{
-        fee_calculator::FeeCalculator,
-        hash::{Hash, HASH_BYTES},
-        sysvar::recent_blockhashes::Entry,
+    use {
+        super::*,
+        crate::account::from_account,
+        rand::{seq::SliceRandom, thread_rng},
+        solana_program::{
+            fee_calculator::FeeCalculator,
+            hash::{Hash, HASH_BYTES},
+            sysvar::recent_blockhashes::Entry,
+        },
     };
 
     #[test]

sdk/src/secp256k1_instruction.rs

@@ -1,8 +1,10 @@
 #![cfg(feature = "full")]
 
-use crate::instruction::Instruction;
-use digest::Digest;
-use serde_derive::{Deserialize, Serialize};
+use {
+    crate::instruction::Instruction,
+    digest::Digest,
+    serde_derive::{Deserialize, Serialize},
+};
 
 #[derive(Debug, PartialEq)]
 pub enum Secp256k1Error {

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.rs

@@ -2,26 +2,27 @@
 
 #![cfg(feature = "full")]
 
-use crate::sanitize::{Sanitize, SanitizeError};
-use crate::secp256k1_instruction::verify_eth_addresses;
-use crate::{
-    ed25519_instruction::verify_signatures,
-    feature_set,
-    hash::Hash,
-    instruction::{CompiledInstruction, Instruction, InstructionError},
-    message::Message,
-    nonce::NONCED_TX_MARKER_IX_INDEX,
-    program_utils::limited_deserialize,
-    pubkey::Pubkey,
-    short_vec,
-    signature::{Signature, SignerError},
-    signers::Signers,
-    system_instruction::SystemInstruction,
-    system_program,
+use {
+    crate::{
+        ed25519_instruction::verify_signatures,
+        feature_set,
+        hash::Hash,
+        instruction::{CompiledInstruction, Instruction, InstructionError},
+        message::Message,
+        nonce::NONCED_TX_MARKER_IX_INDEX,
+        program_utils::limited_deserialize,
+        pubkey::Pubkey,
+        sanitize::{Sanitize, SanitizeError},
+        secp256k1_instruction::verify_eth_addresses,
+        short_vec,
+        signature::{Signature, SignerError},
+        signers::Signers,
+        system_instruction::SystemInstruction,
+        system_program,
+    },
+    std::{result, sync::Arc},
+    thiserror::Error,
 };
-use std::result;
-use std::sync::Arc;
-use thiserror::Error;
 
 /// Reasons a transaction might be rejected.
 #[derive(
@@ -519,15 +520,17 @@ pub fn get_nonce_pubkey_from_instruction<'a>(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{
-        hash::hash,
-        instruction::AccountMeta,
-        signature::{Keypair, Presigner, Signer},
-        system_instruction,
+    use {
+        super::*,
+        crate::{
+            hash::hash,
+            instruction::AccountMeta,
+            signature::{Keypair, Presigner, Signer},
+            system_instruction,
+        },
+        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 {