Cleanup SDK use syntax (#8004)

sdk/src/account.rs

@@ -1,6 +1,8 @@
-use crate::hash::Hash;
+use crate::{
-use crate::instruction::InstructionError;
+    hash::Hash,
-use crate::{clock::Epoch, pubkey::Pubkey};
+    instruction::InstructionError,
+    {clock::Epoch, pubkey::Pubkey},
+};
 use std::{
     cell::{Ref, RefCell, RefMut},
     cmp, fmt,

sdk/src/account_utils.rs

@@ -46,8 +46,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::account::Account;
+    use crate::{account::Account, pubkey::Pubkey};
-    use crate::pubkey::Pubkey;
 
     #[test]
     fn test_account_state() {

sdk/src/bank_hash.rs

@@ -3,8 +3,7 @@ use bincode::deserialize_from;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
 use serde::{Deserialize, Serialize, Serializer};
-use std::fmt;
+use std::{fmt, io::Cursor};
-use std::io::Cursor;
 
 // Type for representing a bank accounts state.
 // Taken by xor of a sha256 of accounts state for lower 32-bytes, and

sdk/src/fee_calculator.rs

@@ -133,8 +133,7 @@ impl FeeCalculator {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pubkey::Pubkey;
+    use crate::{pubkey::Pubkey, system_instruction};
-    use crate::system_instruction;
 
     #[test]
     fn test_fee_calculator_burn() {

sdk/src/hash.rs

@@ -2,10 +2,7 @@
 
 use bs58;
 use sha2::{Digest, Sha256};
-use std::convert::TryFrom;
+use std::{convert::TryFrom, fmt, mem, str::FromStr};
-use std::fmt;
-use std::mem;
-use std::str::FromStr;
 
 pub const HASH_BYTES: usize = 32;
 #[derive(Serialize, Deserialize, Clone, Copy, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]

sdk/src/instruction.rs

@@ -1,8 +1,6 @@
 //! Defines a composable Instruction type and a memory-efficient CompiledInstruction.
 
-use crate::pubkey::Pubkey;
+use crate::{pubkey::Pubkey, short_vec, system_instruction::SystemError};
-use crate::short_vec;
-use crate::system_instruction::SystemError;
 use bincode::serialize;
 use serde::Serialize;
 

sdk/src/loader_instruction.rs

@@ -1,6 +1,8 @@
-use crate::instruction::{AccountMeta, Instruction};
+use crate::{
-use crate::pubkey::Pubkey;
+    instruction::{AccountMeta, Instruction},
-use crate::sysvar::rent;
+    pubkey::Pubkey,
+    sysvar::rent,
+};
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
 pub enum LoaderInstruction {

sdk/src/message.rs

@@ -1,9 +1,11 @@
 //! A library for generating a message from a sequence of instructions
 
-use crate::hash::Hash;
+use crate::{
-use crate::instruction::{AccountMeta, CompiledInstruction, Instruction};
+    hash::Hash,
-use crate::pubkey::Pubkey;
+    instruction::{AccountMeta, CompiledInstruction, Instruction},
-use crate::short_vec;
+    pubkey::Pubkey,
+    short_vec,
+};
 use itertools::Itertools;
 
 fn position(keys: &[Pubkey], key: &Pubkey) -> u8 {
@@ -245,8 +247,10 @@ impl Message {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::instruction::AccountMeta;
+    use crate::{
-    use crate::signature::{Keypair, KeypairUtil};
+        instruction::AccountMeta,
+        signature::{Keypair, KeypairUtil},
+    };
 
     #[test]
     fn test_message_unique_program_ids() {

sdk/src/native_loader.rs

@@ -1,5 +1,4 @@
-use crate::account::Account;
+use crate::{account::Account, hash::Hash};
-use crate::hash::Hash;
 
 crate::declare_id!("NativeLoader1111111111111111111111111111111");
 

sdk/src/nonce_state.rs

@@ -6,8 +6,7 @@ use crate::{
     pubkey::Pubkey,
     system_instruction::NonceError,
     system_program,
-    sysvar::recent_blockhashes::RecentBlockhashes,
+    sysvar::{recent_blockhashes::RecentBlockhashes, rent::Rent},
-    sysvar::rent::Rent,
 };
 use serde_derive::{Deserialize, Serialize};
 use std::{cell::RefCell, collections::HashSet};

sdk/src/packet.rs

@@ -1,8 +1,10 @@
 use crate::clock::Slot;
 use bincode::Result;
 use serde::Serialize;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::{
-use std::{fmt, io};
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    {fmt, io},
+};
 
 /// Maximum over-the-wire size of a Transaction
 ///   1280 is IPv6 minimum MTU

sdk/src/pubkey.rs

@@ -1,8 +1,4 @@
-use std::convert::TryFrom;
+use std::{convert::TryFrom, error, fmt, mem, str::FromStr};
-use std::error;
-use std::fmt;
-use std::mem;
-use std::str::FromStr;
 
 pub use bs58;
 

sdk/src/short_vec.rs

@@ -1,9 +1,9 @@
-use serde::de::{self, Deserializer, SeqAccess, Visitor};
+use serde::{
-use serde::ser::{self, SerializeTuple, Serializer};
+    de::{self, Deserializer, SeqAccess, Visitor},
-use serde::{Deserialize, Serialize};
+    ser::{self, SerializeTuple, Serializer},
-use std::fmt;
+    {Deserialize, Serialize},
-use std::marker::PhantomData;
+};
-use std::mem::size_of;
+use std::{fmt, marker::PhantomData, mem::size_of};
 
 /// 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

sdk/src/system_instruction.rs

@@ -1,10 +1,12 @@
-use crate::hash::hashv;
+use crate::{
-use crate::instruction::{AccountMeta, Instruction, WithSigner};
+    hash::hashv,
-use crate::instruction_processor_utils::DecodeError;
+    instruction::{AccountMeta, Instruction, WithSigner},
-use crate::nonce_state::NonceState;
+    instruction_processor_utils::DecodeError,
-use crate::pubkey::Pubkey;
+    nonce_state::NonceState,
-use crate::system_program;
+    pubkey::Pubkey,
-use crate::sysvar::{recent_blockhashes, rent};
+    system_program,
+    sysvar::{recent_blockhashes, rent},
+};
 use num_derive::{FromPrimitive, ToPrimitive};
 use thiserror::Error;
 

sdk/src/sysvar/recent_blockhashes.rs

@@ -4,9 +4,7 @@ use crate::{
     sysvar::Sysvar,
 };
 use bincode::serialize;
-use std::collections::BinaryHeap;
+use std::{collections::BinaryHeap, iter::FromIterator, ops::Deref};
-use std::iter::FromIterator;
-use std::ops::Deref;
 
 const MAX_ENTRIES: usize = 32;
 

sdk/src/transaction.rs

@@ -1,12 +1,14 @@
 //! Defines a Transaction type to package an atomic sequence of instructions.
 
-use crate::hash::Hash;
+use crate::{
-use crate::instruction::{CompiledInstruction, Instruction, InstructionError};
+    hash::Hash,
-use crate::message::Message;
+    instruction::{CompiledInstruction, Instruction, InstructionError},
-use crate::pubkey::Pubkey;
+    message::Message,
-use crate::short_vec;
+    pubkey::Pubkey,
-use crate::signature::{KeypairUtil, Signature};
+    short_vec,
-use crate::system_instruction;
+    signature::{KeypairUtil, Signature},
+    system_instruction,
+};
 use bincode::serialize;
 use std::result;
 use thiserror::Error;
@@ -337,10 +339,7 @@ impl Transaction {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::hash::hash;
+    use crate::{hash::hash, instruction::AccountMeta, signature::Keypair, system_instruction};
-    use crate::instruction::AccountMeta;
-    use crate::signature::Keypair;
-    use crate::system_instruction;
     use bincode::{deserialize, serialize, serialized_size};
     use std::mem::size_of;
 

sdk/src/transport.rs

@@ -1,7 +1,5 @@
 use crate::transaction::TransactionError;
-use std::error;
+use std::{error, fmt, io};
-use std::fmt;
-use std::io;
 
 #[derive(Debug)]
 pub enum TransportError {