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,
-    input_parsers::{pubkey_of, value_of},
+    solana_clap_utils::{
-    nonce::*,
+        input_parsers::{pubkey_of, value_of},
-    offline::*,
+        nonce::*,
-};
+        offline::*,
-use solana_sdk::{
+    },
-    commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey,
+    solana_sdk::{
+        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,
-    signature::SignerError, transaction::TransactionError, transport::TransportError,
+    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 {
-    client_error::Result,
+    crate::{
-    rpc_custom_error,
+        client_error::Result,
-    rpc_request::{RpcError, RpcRequest, RpcResponseErrorData},
+        rpc_custom_error,
-    rpc_response::RpcSimulateTransactionResult,
+        rpc_request::{RpcError, RpcRequest, RpcResponseErrorData},
-    rpc_sender::RpcSender,
+        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 {
-    client_error::Result,
+    crate::{
-    rpc_request::RpcRequest,
+        client_error::Result,
-    rpc_response::{Response, RpcResponseContext, RpcVersionInfo},
+        rpc_request::RpcRequest,
-    rpc_sender::RpcSender,
+        rpc_response::{Response, RpcResponseContext, RpcVersionInfo},
+        rpc_sender::RpcSender,
+    },
+    serde_json::{json, Number, Value},
+    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 serde_json::{json, Number, Value};
-use solana_sdk::{
-    epoch_info::EpochInfo,
-    fee_calculator::{FeeCalculator, FeeRateGovernor},
-    instruction::InstructionError,
-    signature::Signature,
-    transaction::{self, Transaction, TransactionError},
-};
-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,14 +1,16 @@
-use crate::rpc_client::RpcClient;
+use {
-use solana_sdk::{
+    crate::rpc_client::RpcClient,
-    account::{Account, ReadableAccount},
+    solana_sdk::{
-    account_utils::StateMut,
+        account::{Account, ReadableAccount},
-    commitment_config::CommitmentConfig,
+        account_utils::StateMut,
-    nonce::{
+        commitment_config::CommitmentConfig,
-        state::{Data, Versions},
+        nonce::{
-        State,
+            state::{Data, Versions},
+            State,
+        },
+        pubkey::Pubkey,
+        system_program,
     },
-    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},
-    sync::{
+    std::{
-        atomic::{AtomicBool, Ordering},
+        sync::{
-        Arc, RwLock,
+            atomic::{AtomicBool, Ordering},
+            Arc, RwLock,
+        },
+        thread::sleep,
+        time::{Duration, Instant},
     },
-    thread::sleep,
-    time::{Duration, Instant},
 };
 
 #[derive(Default)]

client/src/pubsub_client.rs

@@ -1,27 +1,31 @@
-use crate::{
+use {
-    rpc_config::{RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter},
+    crate::{
-    rpc_response::{Response as RpcResponse, RpcLogsResponse, RpcSignatureResult, SlotInfo},
+        rpc_config::{
-};
+            RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
-use log::*;
+        },
-use serde::de::DeserializeOwned;
+        rpc_response::{Response as RpcResponse, RpcLogsResponse, RpcSignatureResult, SlotInfo},
-use serde_json::{
-    json,
-    value::Value::{Number, Object},
-    Map, Value,
-};
-use solana_sdk::signature::Signature;
-use std::{
-    marker::PhantomData,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc::{channel, Receiver},
-        Arc, RwLock,
     },
-    thread::JoinHandle,
+    log::*,
+    serde::de::DeserializeOwned,
+    serde_json::{
+        json,
+        value::Value::{Number, Object},
+        Map, Value,
+    },
+    solana_sdk::signature::Signature,
+    std::{
+        marker::PhantomData,
+        sync::{
+            atomic::{AtomicBool, Ordering},
+            mpsc::{channel, Receiver},
+            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},
-    collections::HashMap,
+    std::{
-    time::{Duration, SystemTime},
+        collections::HashMap,
+        time::{Duration, SystemTime},
+    },
 };
 
 #[derive(Debug, Clone)]

client/src/rpc_client.rs

@@ -1,50 +1,52 @@
-use crate::{
+use {
-    client_error::{ClientError, ClientErrorKind, Result as ClientResult},
+    crate::{
-    http_sender::HttpSender,
+        client_error::{ClientError, ClientErrorKind, Result as ClientResult},
-    mock_sender::{MockSender, Mocks},
+        http_sender::HttpSender,
-    rpc_config::RpcAccountInfoConfig,
+        mock_sender::{MockSender, Mocks},
-    rpc_config::{
+        rpc_config::RpcAccountInfoConfig,
-        RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig,
+        rpc_config::{
-        RpcGetConfirmedSignaturesForAddress2Config, RpcLargestAccountsConfig,
+            RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig,
-        RpcProgramAccountsConfig, RpcSendTransactionConfig, RpcSimulateTransactionConfig,
+            RpcGetConfirmedSignaturesForAddress2Config, RpcLargestAccountsConfig,
-        RpcStakeConfig, RpcTokenAccountsFilter,
+            RpcProgramAccountsConfig, RpcSendTransactionConfig, RpcSimulateTransactionConfig,
+            RpcStakeConfig, RpcTokenAccountsFilter,
+        },
+        rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
+        rpc_response::*,
+        rpc_sender::RpcSender,
+    },
+    bincode::serialize,
+    indicatif::{ProgressBar, ProgressStyle},
+    log::*,
+    serde_json::{json, Value},
+    solana_account_decoder::{
+        parse_token::{TokenAccountType, UiTokenAccount, UiTokenAmount},
+        UiAccount, UiAccountData, UiAccountEncoding,
+    },
+    solana_sdk::{
+        account::Account,
+        clock::{Epoch, Slot, UnixTimestamp, DEFAULT_MS_PER_SLOT, MAX_HASH_AGE_IN_SECONDS},
+        commitment_config::{CommitmentConfig, CommitmentLevel},
+        epoch_info::EpochInfo,
+        epoch_schedule::EpochSchedule,
+        fee_calculator::{FeeCalculator, FeeRateGovernor},
+        hash::Hash,
+        pubkey::Pubkey,
+        signature::Signature,
+        transaction::{self, uses_durable_nonce, Transaction},
+    },
+    solana_transaction_status::{
+        EncodedConfirmedBlock, EncodedConfirmedTransaction, TransactionStatus, UiConfirmedBlock,
+        UiTransactionEncoding,
+    },
+    solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY,
+    std::{
+        cmp::min,
+        net::SocketAddr,
+        str::FromStr,
+        sync::RwLock,
+        thread::sleep,
+        time::{Duration, Instant},
     },
-    rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
-    rpc_response::*,
-    rpc_sender::RpcSender,
-};
-use bincode::serialize;
-use indicatif::{ProgressBar, ProgressStyle};
-use log::*;
-use serde_json::{json, Value};
-use solana_account_decoder::{
-    parse_token::{TokenAccountType, UiTokenAccount, UiTokenAmount},
-    UiAccount, UiAccountData, UiAccountEncoding,
-};
-use solana_sdk::{
-    account::Account,
-    clock::{Epoch, Slot, UnixTimestamp, DEFAULT_MS_PER_SLOT, MAX_HASH_AGE_IN_SECONDS},
-    commitment_config::{CommitmentConfig, CommitmentLevel},
-    epoch_info::EpochInfo,
-    epoch_schedule::EpochSchedule,
-    fee_calculator::{FeeCalculator, FeeRateGovernor},
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Signature,
-    transaction::{self, uses_durable_nonce, Transaction},
-};
-use solana_transaction_status::{
-    EncodedConfirmedBlock, EncodedConfirmedTransaction, TransactionStatus, UiConfirmedBlock,
-    UiTransactionEncoding,
-};
-use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
-use 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},
-    clock::Epoch,
+    solana_sdk::{
-    commitment_config::{CommitmentConfig, CommitmentLevel},
+        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},
-    clock::{Epoch, Slot, UnixTimestamp},
+    solana_sdk::{
-    fee_calculator::{FeeCalculator, FeeRateGovernor},
+        clock::{Epoch, Slot, UnixTimestamp},
-    inflation::Inflation,
+        fee_calculator::{FeeCalculator, FeeRateGovernor},
-    transaction::{Result, TransactionError},
+        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,36 +3,38 @@
 //! 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::*,
-    account::Account,
+    solana_sdk::{
-    client::{AsyncClient, Client, SyncClient},
+        account::Account,
-    clock::{Slot, MAX_PROCESSING_AGE},
+        client::{AsyncClient, Client, SyncClient},
-    commitment_config::CommitmentConfig,
+        clock::{Slot, MAX_PROCESSING_AGE},
-    epoch_info::EpochInfo,
+        commitment_config::CommitmentConfig,
-    fee_calculator::{FeeCalculator, FeeRateGovernor},
+        epoch_info::EpochInfo,
-    hash::Hash,
+        fee_calculator::{FeeCalculator, FeeRateGovernor},
-    instruction::Instruction,
+        hash::Hash,
-    message::Message,
+        instruction::Instruction,
-    packet::PACKET_DATA_SIZE,
+        message::Message,
-    pubkey::Pubkey,
+        packet::PACKET_DATA_SIZE,
-    signature::{Keypair, Signature, Signer},
+        pubkey::Pubkey,
-    signers::Signers,
+        signature::{Keypair, Signature, Signer},
-    system_instruction,
+        signers::Signers,
-    timing::duration_as_ms,
+        system_instruction,
-    transaction::{self, Transaction},
+        timing::duration_as_ms,
-    transport::Result as TransportResult,
+        transaction::{self, Transaction},
-};
+        transport::Result as TransportResult,
-use std::{
+    },
-    io,
+    std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
+        io,
-    sync::{
+        net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
-        atomic::{AtomicBool, AtomicUsize, Ordering},
+        sync::{
-        RwLock,
+            atomic::{AtomicBool, AtomicUsize, Ordering},
+            RwLock,
+        },
+        time::{Duration, Instant},
     },
-    time::{Duration, Instant},
 };
 
 struct ClientOptimizer {