Switch to a single `use`

client/src/blockhash_query.rs

@@ -1,12 +1,15 @@
-use crate::{nonce_utils, rpc_client::RpcClient};
+use {
-use clap::ArgMatches;
+    crate::{nonce_utils, rpc_client::RpcClient},
-use solana_clap_utils::{
+    clap::ArgMatches,
+    solana_clap_utils::{
         input_parsers::{pubkey_of, value_of},
         nonce::*,
         offline::*,
-};
+    },
-use solana_sdk::{
+    solana_sdk::{
-    commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey,
+        commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, hash::Hash,
+        pubkey::Pubkey,
+    },
 };
 
 #[derive(Debug, PartialEq)]

client/src/client_error.rs

@@ -1,9 +1,11 @@
-use crate::rpc_request;
+use {
-use solana_sdk::{
+    crate::rpc_request,
+    solana_sdk::{
         signature::SignerError, transaction::TransactionError, transport::TransportError,
+    },
+    std::io,
+    thiserror::Error,
 };
-use std::io;
-use thiserror::Error;
 
 pub use reqwest; // export `reqwest` for clients
 

client/src/http_sender.rs

@@ -1,13 +1,15 @@
-use crate::{
+use {
+    crate::{
         client_error::Result,
         rpc_custom_error,
         rpc_request::{RpcError, RpcRequest, RpcResponseErrorData},
         rpc_response::RpcSimulateTransactionResult,
         rpc_sender::RpcSender,
+    },
+    log::*,
+    reqwest::{self, header::CONTENT_TYPE, StatusCode},
+    std::{thread::sleep, time::Duration},
 };
-use log::*;
-use reqwest::{self, header::CONTENT_TYPE, StatusCode};
-use std::{thread::sleep, time::Duration};
 
 pub struct HttpSender {
     client: reqwest::blocking::Client,

client/src/mock_sender.rs

@@ -1,20 +1,22 @@
-use crate::{
+use {
+    crate::{
         client_error::Result,
         rpc_request::RpcRequest,
         rpc_response::{Response, RpcResponseContext, RpcVersionInfo},
         rpc_sender::RpcSender,
-};
+    },
-use serde_json::{json, Number, Value};
+    serde_json::{json, Number, Value},
-use solana_sdk::{
+    solana_sdk::{
         epoch_info::EpochInfo,
         fee_calculator::{FeeCalculator, FeeRateGovernor},
         instruction::InstructionError,
         signature::Signature,
         transaction::{self, Transaction, TransactionError},
+    },
+    solana_transaction_status::{TransactionConfirmationStatus, TransactionStatus},
+    solana_version::Version,
+    std::{collections::HashMap, sync::RwLock},
 };
-use solana_transaction_status::{TransactionConfirmationStatus, TransactionStatus};
-use solana_version::Version;
-use std::{collections::HashMap, sync::RwLock};
 
 pub const PUBKEY: &str = "7RoSF9fUmdphVCpabEoefH81WwrW7orsWonXWqTXkKV8";
 pub const SIGNATURE: &str =

client/src/nonce_utils.rs

@@ -1,5 +1,6 @@
-use crate::rpc_client::RpcClient;
+use {
-use solana_sdk::{
+    crate::rpc_client::RpcClient,
+    solana_sdk::{
         account::{Account, ReadableAccount},
         account_utils::StateMut,
         commitment_config::CommitmentConfig,
@@ -9,6 +10,7 @@ use solana_sdk::{
         },
         pubkey::Pubkey,
         system_program,
+    },
 };
 
 #[derive(Debug, thiserror::Error, PartialEq)]

client/src/perf_utils.rs

@@ -1,12 +1,14 @@
-use log::*;
+use {
-use solana_sdk::{client::Client, commitment_config::CommitmentConfig, timing::duration_as_s};
+    log::*,
-use std::{
+    solana_sdk::{client::Client, commitment_config::CommitmentConfig, timing::duration_as_s},
+    std::{
         sync::{
             atomic::{AtomicBool, Ordering},
             Arc, RwLock,
         },
         thread::sleep,
         time::{Duration, Instant},
+    },
 };
 
 #[derive(Default)]

client/src/pubsub_client.rs

@@ -1,16 +1,19 @@
-use crate::{
+use {
-    rpc_config::{RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter},
+    crate::{
+        rpc_config::{
+            RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
+        },
         rpc_response::{Response as RpcResponse, RpcLogsResponse, RpcSignatureResult, SlotInfo},
-};
+    },
-use log::*;
+    log::*,
-use serde::de::DeserializeOwned;
+    serde::de::DeserializeOwned,
-use serde_json::{
+    serde_json::{
         json,
         value::Value::{Number, Object},
         Map, Value,
-};
+    },
-use solana_sdk::signature::Signature;
+    solana_sdk::signature::Signature,
-use std::{
+    std::{
         marker::PhantomData,
         sync::{
             atomic::{AtomicBool, Ordering},
@@ -18,10 +21,11 @@ use std::{
             Arc, RwLock,
         },
         thread::JoinHandle,
+    },
+    thiserror::Error,
+    tungstenite::{client::AutoStream, connect, Message, WebSocket},
+    url::{ParseError, Url},
 };
-use thiserror::Error;
-use tungstenite::{client::AutoStream, connect, Message, WebSocket};
-use url::{ParseError, Url};
 
 #[derive(Debug, Error)]
 pub enum PubsubClientError {

client/src/rpc_cache.rs

@@ -1,7 +1,9 @@
-use crate::{rpc_config::RpcLargestAccountsFilter, rpc_response::RpcAccountBalance};
+use {
-use std::{
+    crate::{rpc_config::RpcLargestAccountsFilter, rpc_response::RpcAccountBalance},
+    std::{
         collections::HashMap,
         time::{Duration, SystemTime},
+    },
 };
 
 #[derive(Debug, Clone)]

client/src/rpc_client.rs

@@ -1,4 +1,5 @@
-use crate::{
+use {
+    crate::{
         client_error::{ClientError, ClientErrorKind, Result as ClientResult},
         http_sender::HttpSender,
         mock_sender::{MockSender, Mocks},
@@ -12,16 +13,16 @@ use crate::{
         rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
         rpc_response::*,
         rpc_sender::RpcSender,
-};
+    },
-use bincode::serialize;
+    bincode::serialize,
-use indicatif::{ProgressBar, ProgressStyle};
+    indicatif::{ProgressBar, ProgressStyle},
-use log::*;
+    log::*,
-use serde_json::{json, Value};
+    serde_json::{json, Value},
-use solana_account_decoder::{
+    solana_account_decoder::{
         parse_token::{TokenAccountType, UiTokenAccount, UiTokenAmount},
         UiAccount, UiAccountData, UiAccountEncoding,
-};
+    },
-use solana_sdk::{
+    solana_sdk::{
         account::Account,
         clock::{Epoch, Slot, UnixTimestamp, DEFAULT_MS_PER_SLOT, MAX_HASH_AGE_IN_SECONDS},
         commitment_config::{CommitmentConfig, CommitmentLevel},
@@ -32,19 +33,20 @@ use solana_sdk::{
         pubkey::Pubkey,
         signature::Signature,
         transaction::{self, uses_durable_nonce, Transaction},
-};
+    },
-use solana_transaction_status::{
+    solana_transaction_status::{
         EncodedConfirmedBlock, EncodedConfirmedTransaction, TransactionStatus, UiConfirmedBlock,
         UiTransactionEncoding,
-};
+    },
-use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
+    solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY,
-use std::{
+    std::{
         cmp::min,
         net::SocketAddr,
         str::FromStr,
         sync::RwLock,
         thread::sleep,
         time::{Duration, Instant},
+    },
 };
 
 pub struct RpcClient {

client/src/rpc_config.rs

@@ -1,10 +1,12 @@
-use crate::rpc_filter::RpcFilterType;
+use {
-use solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig};
+    crate::rpc_filter::RpcFilterType,
-use solana_sdk::{
+    solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig},
+    solana_sdk::{
         clock::Epoch,
         commitment_config::{CommitmentConfig, CommitmentLevel},
+    },
+    solana_transaction_status::{TransactionDetails, UiTransactionEncoding},
 };
-use solana_transaction_status::{TransactionDetails, UiTransactionEncoding};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]

client/src/rpc_custom_error.rs

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

client/src/rpc_request.rs

@@ -1,8 +1,10 @@
-use crate::rpc_response::RpcSimulateTransactionResult;
+use {
-use serde_json::{json, Value};
+    crate::rpc_response::RpcSimulateTransactionResult,
-use solana_sdk::{clock::Slot, pubkey::Pubkey};
+    serde_json::{json, Value},
-use std::fmt;
+    solana_sdk::{clock::Slot, pubkey::Pubkey},
-use thiserror::Error;
+    std::fmt,
+    thiserror::Error,
+};
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
 pub enum RpcRequest {

client/src/rpc_response.rs

@@ -1,13 +1,15 @@
-use crate::client_error;
+use {
-use solana_account_decoder::{parse_token::UiTokenAmount, UiAccount};
+    crate::client_error,
-use solana_sdk::{
+    solana_account_decoder::{parse_token::UiTokenAmount, UiAccount},
+    solana_sdk::{
         clock::{Epoch, Slot, UnixTimestamp},
         fee_calculator::{FeeCalculator, FeeRateGovernor},
         inflation::Inflation,
         transaction::{Result, TransactionError},
+    },
+    solana_transaction_status::ConfirmedTransactionStatusWithSignature,
+    std::{collections::HashMap, fmt, net::SocketAddr},
 };
-use solana_transaction_status::ConfirmedTransactionStatusWithSignature;
-use std::{collections::HashMap, fmt, net::SocketAddr};
 
 pub type RpcResult<T> = client_error::Result<Response<T>>;
 

client/src/thin_client.rs

@@ -3,10 +3,11 @@
 //! messages to the network directly. The binary encoding of its messages are
 //! unstable and may change in future releases.
 
-use crate::{rpc_client::RpcClient, rpc_config::RpcProgramAccountsConfig, rpc_response::Response};
+use {
-use bincode::{serialize_into, serialized_size};
+    crate::{rpc_client::RpcClient, rpc_config::RpcProgramAccountsConfig, rpc_response::Response},
-use log::*;
+    bincode::{serialize_into, serialized_size},
-use solana_sdk::{
+    log::*,
+    solana_sdk::{
         account::Account,
         client::{AsyncClient, Client, SyncClient},
         clock::{Slot, MAX_PROCESSING_AGE},
@@ -24,8 +25,8 @@ use solana_sdk::{
         timing::duration_as_ms,
         transaction::{self, Transaction},
         transport::Result as TransportResult,
-};
+    },
-use std::{
+    std::{
         io,
         net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
         sync::{
@@ -33,6 +34,7 @@ use std::{
             RwLock,
         },
         time::{Duration, Instant},
+    },
 };
 
 struct ClientOptimizer {