align cluster and sim logging as hex (#13484) (#13486)

(cherry picked from commit c280d40b40)

Co-authored-by: Jack May <jack@solana.com>

.gitignore

@@ -1,3 +1,7 @@
+/docs/html/
+/docs/src/tests.ok
+/docs/src/cli/usage.md
+/docs/src/.gitbook/assets/*.svg
 /farf/
 /solana-release/
 /solana-release.tar.bz2
@@ -10,8 +14,6 @@
 
 /config/
 
-.cache
-
 # log files
 *.log
 log-*.txt

.mergify.yml

@@ -50,6 +50,14 @@ pull_request_rules:
       label:
         add:
           - automerge
+  - name: v1.2 backport
+    conditions:
+      - label=v1.2
+    actions:
+      backport:
+        ignore_conflicts: true
+        branches:
+          - v1.2
   - name: v1.3 backport
     conditions:
       - label=v1.3
@@ -66,19 +74,3 @@ pull_request_rules:
         ignore_conflicts: true
         branches:
           - v1.4
-  - name: v1.5 backport
-    conditions:
-      - label=v1.5
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.5
-  - name: v1.6 backport
-    conditions:
-      - label=v1.6
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.6

Cargo.toml

@@ -28,7 +28,6 @@ members = [
     "local-cluster",
     "logger",
     "log-analyzer",
-    "merkle-root-bench",
     "merkle-tree",
     "stake-o-matic",
     "storage-bigtable",
@@ -54,7 +53,6 @@ members = [
     "remote-wallet",
     "ramp-tps",
     "runtime",
-    "runtime/store-tool",
     "sdk",
     "sdk/cargo-build-bpf",
     "sdk/cargo-test-bpf",
@@ -68,6 +66,7 @@ members = [
     "upload-perf",
     "net-utils",
     "version",
+    "vote-signer",
     "cli",
     "rayon-threadlimit",
     "watchtower",

README.md

@@ -29,7 +29,7 @@ On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, etc
 
 ```bash
 $ sudo apt-get update
-$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make
+$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```
 
 ## **2. Download the source code.**
@@ -61,9 +61,8 @@ $ cargo test
 ### Starting a local testnet
 Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/cluster/bench-tps).
 
-### Accessing the remote development cluster
-* `devnet` - stable public cluster for development accessible via
-devnet.solana.com. Runs 24/7. Learn more about the [public clusters](https://docs.solana.com/clusters)
+### Accessing the remote testnet
+* `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7
 
 # Benchmarking
 
@@ -108,5 +107,3 @@ send us that patch!
 # Disclaimer
 
 All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
-
-Any content produced by Solana, or developer resources that Solana provides, are for educational and inspiration purposes only.  Solana does not encourage, induce or sanction the deployment of any such applications in violation of applicable laws or regulations.

account-decoder/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-account-decoder"
-version = "1.5.6"
+version = "1.4.6"
 description = "Solana account decoder"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -18,13 +18,12 @@ lazy_static = "1.4.0"
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-config-program = { path = "../programs/config", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.0.1", features = ["no-entrypoint"] }
+solana-config-program = { path = "../programs/config", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-stake-program = { path = "../programs/stake", version = "1.4.6" }
+solana-vote-program = { path = "../programs/vote", version = "1.4.6" }
+spl-token-v2-0 = { package = "spl-token", version = "=3.0.0", features = ["no-entrypoint"] }
 thiserror = "1.0"
-zstd = "0.5.1"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

account-decoder/src/lib.rs

@@ -4,7 +4,6 @@ extern crate lazy_static;
 extern crate serde_derive;
 
 pub mod parse_account_data;
-pub mod parse_bpf_loader;
 pub mod parse_config;
 pub mod parse_nonce;
 pub mod parse_stake;
@@ -13,14 +12,9 @@ pub mod parse_token;
 pub mod parse_vote;
 pub mod validator_info;
 
-use {
-    crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount},
-    solana_sdk::{account::Account, clock::Epoch, fee_calculator::FeeCalculator, pubkey::Pubkey},
-    std::{
-        io::{Read, Write},
-        str::FromStr,
-    },
-};
+use crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount};
+use solana_sdk::{account::Account, clock::Epoch, fee_calculator::FeeCalculator, pubkey::Pubkey};
+use std::str::FromStr;
 
 pub type StringAmount = String;
 
@@ -50,8 +44,6 @@ pub enum UiAccountEncoding {
     Base58,
     Base64,
     JsonParsed,
-    #[serde(rename = "base64+zstd")]
-    Base64Zstd,
 }
 
 impl UiAccount {
@@ -74,19 +66,6 @@ impl UiAccount {
                 base64::encode(slice_data(&account.data, data_slice_config)),
                 encoding,
             ),
-            UiAccountEncoding::Base64Zstd => {
-                let mut encoder = zstd::stream::write::Encoder::new(Vec::new(), 0).unwrap();
-                match encoder
-                    .write_all(slice_data(&account.data, data_slice_config))
-                    .and_then(|()| encoder.finish())
-                {
-                    Ok(zstd_data) => UiAccountData::Binary(base64::encode(zstd_data), encoding),
-                    Err(_) => UiAccountData::Binary(
-                        base64::encode(slice_data(&account.data, data_slice_config)),
-                        UiAccountEncoding::Base64,
-                    ),
-                }
-            }
             UiAccountEncoding::JsonParsed => {
                 if let Ok(parsed_data) =
                     parse_account_data(pubkey, &account.owner, &account.data, additional_data)
@@ -113,16 +92,6 @@ impl UiAccount {
             UiAccountData::Binary(blob, encoding) => match encoding {
                 UiAccountEncoding::Base58 => bs58::decode(blob).into_vec().ok(),
                 UiAccountEncoding::Base64 => base64::decode(blob).ok(),
-                UiAccountEncoding::Base64Zstd => base64::decode(blob)
-                    .ok()
-                    .map(|zstd_data| {
-                        let mut data = vec![];
-                        zstd::stream::read::Decoder::new(zstd_data.as_slice())
-                            .and_then(|mut reader| reader.read_to_end(&mut data))
-                            .map(|_| data)
-                            .ok()
-                    })
-                    .flatten(),
                 UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
             },
         }?;
@@ -210,25 +179,4 @@ mod test {
         });
         assert_eq!(slice_data(&data, slice_config), &[] as &[u8]);
     }
-
-    #[test]
-    fn test_base64_zstd() {
-        let encoded_account = UiAccount::encode(
-            &Pubkey::default(),
-            Account {
-                data: vec![0; 1024],
-                ..Account::default()
-            },
-            UiAccountEncoding::Base64Zstd,
-            None,
-            None,
-        );
-        assert!(matches!(
-            encoded_account.data,
-            UiAccountData::Binary(_, UiAccountEncoding::Base64Zstd)
-        ));
-
-        let decoded_account = encoded_account.decode().unwrap();
-        assert_eq!(decoded_account.data, vec![0; 1024]);
-    }
 }

account-decoder/src/parse_account_data.rs

@@ -1,5 +1,4 @@
 use crate::{
-    parse_bpf_loader::parse_bpf_upgradeable_loader,
     parse_config::parse_config,
     parse_nonce::parse_nonce,
     parse_stake::parse_stake,
@@ -14,7 +13,6 @@ use std::collections::HashMap;
 use thiserror::Error;
 
 lazy_static! {
-    static ref BPF_UPGRADEABLE_LOADER_PROGRAM_ID: Pubkey = solana_sdk::bpf_loader_upgradeable::id();
     static ref CONFIG_PROGRAM_ID: Pubkey = solana_config_program::id();
     static ref STAKE_PROGRAM_ID: Pubkey = solana_stake_program::id();
     static ref SYSTEM_PROGRAM_ID: Pubkey = system_program::id();
@@ -23,10 +21,6 @@ lazy_static! {
     static ref VOTE_PROGRAM_ID: Pubkey = solana_vote_program::id();
     pub static ref PARSABLE_PROGRAM_IDS: HashMap<Pubkey, ParsableAccount> = {
         let mut m = HashMap::new();
-        m.insert(
-            *BPF_UPGRADEABLE_LOADER_PROGRAM_ID,
-            ParsableAccount::BpfUpgradeableLoader,
-        );
         m.insert(*CONFIG_PROGRAM_ID, ParsableAccount::Config);
         m.insert(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
         m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::SplToken);
@@ -66,7 +60,6 @@ pub struct ParsedAccount {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum ParsableAccount {
-    BpfUpgradeableLoader,
     Config,
     Nonce,
     SplToken,
@@ -88,12 +81,9 @@ pub fn parse_account_data(
 ) -> Result<ParsedAccount, ParseAccountError> {
     let program_name = PARSABLE_PROGRAM_IDS
         .get(program_id)
-        .ok_or(ParseAccountError::ProgramNotParsable)?;
+        .ok_or_else(|| ParseAccountError::ProgramNotParsable)?;
     let additional_data = additional_data.unwrap_or_default();
     let parsed_json = match program_name {
-        ParsableAccount::BpfUpgradeableLoader => {
-            serde_json::to_value(parse_bpf_upgradeable_loader(data)?)?
-        }
         ParsableAccount::Config => serde_json::to_value(parse_config(data, pubkey)?)?,
         ParsableAccount::Nonce => serde_json::to_value(parse_nonce(data)?)?,
         ParsableAccount::SplToken => {
@@ -128,7 +118,7 @@ mod test {
 
         let vote_state = VoteState::default();
         let mut vote_account_data: Vec<u8> = vec![0; VoteState::size_of()];
-        let versioned = VoteStateVersions::new_current(vote_state);
+        let versioned = VoteStateVersions::Current(Box::new(vote_state));
         VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
         let parsed = parse_account_data(
             &account_pubkey,

account-decoder/src/parse_bpf_loader.rs

@@ -1,181 +0,0 @@
-use crate::{
-    parse_account_data::{ParsableAccount, ParseAccountError},
-    UiAccountData, UiAccountEncoding,
-};
-use bincode::{deserialize, serialized_size};
-use solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey};
-
-pub fn parse_bpf_upgradeable_loader(
-    data: &[u8],
-) -> Result<BpfUpgradeableLoaderAccountType, ParseAccountError> {
-    let account_state: UpgradeableLoaderState = deserialize(data).map_err(|_| {
-        ParseAccountError::AccountNotParsable(ParsableAccount::BpfUpgradeableLoader)
-    })?;
-    let parsed_account = match account_state {
-        UpgradeableLoaderState::Uninitialized => BpfUpgradeableLoaderAccountType::Uninitialized,
-        UpgradeableLoaderState::Buffer { authority_address } => {
-            let offset = if authority_address.is_some() {
-                UpgradeableLoaderState::buffer_data_offset().unwrap()
-            } else {
-                // This case included for code completeness; in practice, a Buffer account will
-                // always have authority_address.is_some()
-                UpgradeableLoaderState::buffer_data_offset().unwrap()
-                    - serialized_size(&Pubkey::default()).unwrap() as usize
-            };
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: authority_address.map(|pubkey| pubkey.to_string()),
-                data: UiAccountData::Binary(
-                    base64::encode(&data[offset as usize..]),
-                    UiAccountEncoding::Base64,
-                ),
-            })
-        }
-        UpgradeableLoaderState::Program {
-            programdata_address,
-        } => BpfUpgradeableLoaderAccountType::Program(UiProgram {
-            program_data: programdata_address.to_string(),
-        }),
-        UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address,
-        } => {
-            let offset = if upgrade_authority_address.is_some() {
-                UpgradeableLoaderState::programdata_data_offset().unwrap()
-            } else {
-                UpgradeableLoaderState::programdata_data_offset().unwrap()
-                    - serialized_size(&Pubkey::default()).unwrap() as usize
-            };
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: upgrade_authority_address.map(|pubkey| pubkey.to_string()),
-                data: UiAccountData::Binary(
-                    base64::encode(&data[offset as usize..]),
-                    UiAccountEncoding::Base64,
-                ),
-            })
-        }
-    };
-    Ok(parsed_account)
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase", tag = "type", content = "info")]
-pub enum BpfUpgradeableLoaderAccountType {
-    Uninitialized,
-    Buffer(UiBuffer),
-    Program(UiProgram),
-    ProgramData(UiProgramData),
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiBuffer {
-    pub authority: Option<String>,
-    pub data: UiAccountData,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiProgram {
-    pub program_data: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiProgramData {
-    pub slot: u64,
-    pub authority: Option<String>,
-    pub data: UiAccountData,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use bincode::serialize;
-    use solana_sdk::pubkey::Pubkey;
-
-    #[test]
-    fn test_parse_bpf_upgradeable_loader_accounts() {
-        let bpf_loader_state = UpgradeableLoaderState::Uninitialized;
-        let account_data = serialize(&bpf_loader_state).unwrap();
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Uninitialized
-        );
-
-        let program = vec![7u8; 64]; // Arbitrary program data
-
-        let authority = Pubkey::new_unique();
-        let bpf_loader_state = UpgradeableLoaderState::Buffer {
-            authority_address: Some(authority),
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: Some(authority.to_string()),
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        // This case included for code completeness; in practice, a Buffer account will always have
-        // authority_address.is_some()
-        let bpf_loader_state = UpgradeableLoaderState::Buffer {
-            authority_address: None,
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: None,
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        let programdata_address = Pubkey::new_unique();
-        let bpf_loader_state = UpgradeableLoaderState::Program {
-            programdata_address,
-        };
-        let account_data = serialize(&bpf_loader_state).unwrap();
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Program(UiProgram {
-                program_data: programdata_address.to_string(),
-            })
-        );
-
-        let authority = Pubkey::new_unique();
-        let slot = 42;
-        let bpf_loader_state = UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address: Some(authority),
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: Some(authority.to_string()),
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        let bpf_loader_state = UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address: None,
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: None,
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-    }
-}

account-decoder/src/parse_sysvar.rs

@@ -105,7 +105,6 @@ pub enum SysvarAccountType {
 pub struct UiClock {
     pub slot: Slot,
     pub epoch: Epoch,
-    pub epoch_start_timestamp: UnixTimestamp,
     pub leader_schedule_epoch: Epoch,
     pub unix_timestamp: UnixTimestamp,
 }
@@ -115,7 +114,6 @@ impl From<Clock> for UiClock {
         Self {
             slot: clock.slot,
             epoch: clock.epoch,
-            epoch_start_timestamp: clock.epoch_start_timestamp,
             leader_schedule_epoch: clock.leader_schedule_epoch,
             unix_timestamp: clock.unix_timestamp,
         }
@@ -217,6 +215,7 @@ mod test {
         account::create_account, fee_calculator::FeeCalculator, hash::Hash,
         sysvar::recent_blockhashes::IterItem,
     };
+    use std::iter::FromIterator;
 
     #[test]
     fn test_parse_sysvars() {
@@ -249,9 +248,8 @@ mod test {
         let fee_calculator = FeeCalculator {
             lamports_per_signature: 10,
         };
-        let recent_blockhashes: RecentBlockhashes = vec![IterItem(0, &hash, &fee_calculator)]
-            .into_iter()
-            .collect();
+        let recent_blockhashes =
+            RecentBlockhashes::from_iter(vec![IterItem(0, &hash, &fee_calculator)].into_iter());
         let recent_blockhashes_sysvar = create_account(&recent_blockhashes, 1);
         assert_eq!(
             parse_sysvar(

account-decoder/src/parse_token.rs

@@ -23,16 +23,6 @@ pub fn spl_token_v2_0_native_mint() -> Pubkey {
     Pubkey::from_str(&spl_token_v2_0::native_mint::id().to_string()).unwrap()
 }
 
-// A helper function to convert a solana_sdk::pubkey::Pubkey to spl_sdk::pubkey::Pubkey
-pub fn spl_token_v2_0_pubkey(pubkey: &Pubkey) -> SplTokenPubkey {
-    SplTokenPubkey::from_str(&pubkey.to_string()).unwrap()
-}
-
-// A helper function to convert a spl_sdk::pubkey::Pubkey to solana_sdk::pubkey::Pubkey
-pub fn pubkey_from_spl_token_v2_0(pubkey: &SplTokenPubkey) -> Pubkey {
-    Pubkey::from_str(&pubkey.to_string()).unwrap()
-}
-
 pub fn parse_token(
     data: &[u8],
     mint_decimals: Option<u8>,

account-decoder/src/parse_vote.rs

@@ -128,13 +128,11 @@ mod test {
     fn test_parse_vote() {
         let vote_state = VoteState::default();
         let mut vote_account_data: Vec<u8> = vec![0; VoteState::size_of()];
-        let versioned = VoteStateVersions::new_current(vote_state);
+        let versioned = VoteStateVersions::Current(Box::new(vote_state));
         VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
-        let expected_vote_state = UiVoteState {
-            node_pubkey: Pubkey::default().to_string(),
-            authorized_withdrawer: Pubkey::default().to_string(),
-            ..UiVoteState::default()
-        };
+        let mut expected_vote_state = UiVoteState::default();
+        expected_vote_state.node_pubkey = Pubkey::default().to_string();
+        expected_vote_state.authorized_withdrawer = Pubkey::default().to_string();
         assert_eq!(
             parse_vote(&vote_account_data).unwrap(),
             VoteAccountType::Vote(expected_vote_state)

accounts-bench/Cargo.toml

@@ -2,20 +2,20 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-accounts-bench"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 publish = false
 
 [dependencies]
-log = "0.4.11"
+log = "0.4.6"
 rayon = "1.4.0"
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-measure = { path = "../measure", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
 rand = "0.7.0"
 clap = "2.33.1"
 crossbeam-channel = "0.4"

accounts-bench/src/main.rs

@@ -1,14 +1,14 @@
-#[macro_use]
-extern crate log;
 use clap::{crate_description, crate_name, value_t, App, Arg};
 use rayon::prelude::*;
 use solana_measure::measure::Measure;
 use solana_runtime::{
-    accounts::{create_test_accounts, update_accounts_bench, Accounts},
+    accounts::{create_test_accounts, update_accounts, Accounts},
     accounts_index::Ancestors,
 };
 use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
-use std::{collections::HashSet, env, fs, path::PathBuf};
+use std::env;
+use std::fs;
+use std::path::PathBuf;
 
 fn main() {
     solana_logger::setup();
@@ -53,12 +53,10 @@ fn main() {
 
     let path = PathBuf::from(env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_owned()))
         .join("accounts-bench");
-    println!("cleaning file system: {:?}", path);
     if fs::remove_dir_all(path.clone()).is_err() {
         println!("Warning: Couldn't remove {:?}", path);
     }
-    let accounts =
-        Accounts::new_with_config(vec![path], &ClusterType::Testnet, HashSet::new(), false);
+    let accounts = Accounts::new(vec![path], &ClusterType::Testnet);
     println!("Creating {} accounts", num_accounts);
     let mut create_time = Measure::start("create accounts");
     let pubkeys: Vec<_> = (0..num_slots)
@@ -87,8 +85,6 @@ fn main() {
         ancestors.insert(i as u64, i - 1);
         accounts.add_root(i as u64);
     }
-    let mut elapsed = vec![0; iterations];
-    let mut elapsed_store = vec![0; iterations];
     for x in 0..iterations {
         if clean {
             let mut time = Measure::start("clean");
@@ -96,45 +92,16 @@ fn main() {
             time.stop();
             println!("{}", time);
             for slot in 0..num_slots {
-                update_accounts_bench(&accounts, &pubkeys, ((x + 1) * num_slots + slot) as u64);
+                update_accounts(&accounts, &pubkeys, ((x + 1) * num_slots + slot) as u64);
                 accounts.add_root((x * num_slots + slot) as u64);
             }
         } else {
             let mut pubkeys: Vec<Pubkey> = vec![];
             let mut time = Measure::start("hash");
-            let results = accounts
-                .accounts_db
-                .update_accounts_hash(0, &ancestors, true);
+            let hash = accounts.accounts_db.update_accounts_hash(0, &ancestors).0;
             time.stop();
-            let mut time_store = Measure::start("hash using store");
-            let results_store = accounts.accounts_db.update_accounts_hash_with_index_option(
-                true,
-                false,
-                solana_sdk::clock::Slot::default(),
-                &ancestors,
-                true,
-            );
-            time_store.stop();
-            if results != results_store {
-                error!("results different: \n{:?}\n{:?}", results, results_store);
-            }
-            println!(
-                "hash,{},{},{},{}%",
-                results.0,
-                time,
-                time_store,
-                (time_store.as_us() as f64 / time.as_us() as f64 * 100.0f64) as u32
-            );
+            println!("hash: {} {}", hash, time);
             create_test_accounts(&accounts, &mut pubkeys, 1, 0);
-            elapsed[x] = time.as_us();
-            elapsed_store[x] = time_store.as_us();
         }
     }
-
-    for x in elapsed {
-        info!("update_accounts_hash(us),{}", x);
-    }
-    for x in elapsed_store {
-        info!("calculate_accounts_hash_without_index(us),{}", x);
-    }
 }

banking-bench/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,19 +11,19 @@ publish = false
 [dependencies]
 clap = "2.33.1"
 crossbeam-channel = "0.4"
-log = "0.4.11"
+log = "0.4.6"
 rand = "0.7.0"
 rayon = "1.4.0"
-solana-core = { path = "../core", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-streamer = { path = "../streamer", version = "1.5.6" }
-solana-perf = { path = "../perf", version = "1.5.6" }
-solana-ledger = { path = "../ledger", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-core = { path = "../core", version = "1.4.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-streamer = { path = "../streamer", version = "1.4.6" }
+solana-perf = { path = "../perf", version = "1.4.6" }
+solana-ledger = { path = "../ledger", version = "1.4.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-measure = { path = "../measure", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

banking-bench/src/main.rs

@@ -17,9 +17,7 @@ use solana_ledger::{
 };
 use solana_measure::measure::Measure;
 use solana_perf::packet::to_packets_chunked;
-use solana_runtime::{
-    accounts_background_service::ABSRequestSender, bank::Bank, bank_forks::BankForks,
-};
+use solana_runtime::{bank::Bank, bank_forks::BankForks};
 use solana_sdk::{
     hash::Hash,
     signature::Keypair,
@@ -325,7 +323,7 @@ fn main() {
                 poh_recorder.lock().unwrap().set_bank(&bank);
                 assert!(poh_recorder.lock().unwrap().bank().is_some());
                 if bank.slot() > 32 {
-                    bank_forks.set_root(root, &ABSRequestSender::default(), None);
+                    bank_forks.set_root(root, &None, None);
                     root += 1;
                 }
                 debug!(

banks-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-banks-client"
-version = "1.5.6"
+version = "1.4.6"
 description = "Solana banks client"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -9,18 +9,18 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
+async-trait = "0.1.36"
 bincode = "1.3.1"
 futures = "0.3"
-mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
+solana-banks-interface = { path = "../banks-interface", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
 tarpc = { version = "0.23.0", features = ["full"] }
-tokio = { version = "0.3.5", features = ["full"] }
+tokio = { version = "0.3", features = ["full"] }
 tokio-serde = { version = "0.6", features = ["bincode"] }
 
 [dev-dependencies]
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-banks-server = { path = "../banks-server", version = "1.5.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-banks-server = { path = "../banks-server", version = "1.4.6" }
 
 [lib]
 crate-type = ["lib"]

banks-client/src/lib.rs

@@ -5,8 +5,9 @@
 //! but they are undocumented, may change over time, and are generally more
 //! cumbersome to use.
 
-use futures::{future::join_all, Future, FutureExt};
-pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
+use async_trait::async_trait;
+use futures::future::join_all;
+pub use solana_banks_interface::{BanksClient, TransactionStatus};
 use solana_banks_interface::{BanksRequest, BanksResponse};
 use solana_sdk::{
     account::{from_account, Account},
@@ -18,237 +19,186 @@ use solana_sdk::{
     rent::Rent,
     signature::Signature,
     sysvar,
-    transaction::{self, Transaction},
+    transaction::Transaction,
     transport,
 };
 use std::io::{self, Error, ErrorKind};
 use tarpc::{
-    client::{self, channel::RequestDispatch, NewClient},
-    context::{self, Context},
-    rpc::{ClientMessage, Response},
+    client, context,
+    rpc::{transport::channel::UnboundedChannel, ClientMessage, Response},
     serde_transport::tcp,
-    Transport,
 };
 use tokio::{net::ToSocketAddrs, time::Duration};
 use tokio_serde::formats::Bincode;
 
-// This exists only for backward compatibility
-pub trait BanksClientExt {}
-
-#[derive(Clone)]
-pub struct BanksClient {
-    inner: TarpcClient,
-}
-
-impl BanksClient {
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new<C>(
-        config: client::Config,
-        transport: C,
-    ) -> NewClient<TarpcClient, RequestDispatch<BanksRequest, BanksResponse, C>>
-    where
-        C: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>>,
-    {
-        TarpcClient::new(config, transport)
-    }
-
-    pub fn send_transaction_with_context(
-        &mut self,
-        ctx: Context,
-        transaction: Transaction,
-    ) -> impl Future<Output = io::Result<()>> + '_ {
-        self.inner.send_transaction_with_context(ctx, transaction)
-    }
-
-    pub fn get_fees_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
-        self.inner
-            .get_fees_with_commitment_and_context(ctx, commitment)
-    }
-
-    pub fn get_transaction_status_with_context(
-        &mut self,
-        ctx: Context,
-        signature: Signature,
-    ) -> impl Future<Output = io::Result<Option<TransactionStatus>>> + '_ {
-        self.inner
-            .get_transaction_status_with_context(ctx, signature)
-    }
-
-    pub fn get_slot_with_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.inner.get_slot_with_context(ctx, commitment)
-    }
-
-    pub fn process_transaction_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<transaction::Result<()>>>> + '_ {
-        self.inner
-            .process_transaction_with_commitment_and_context(ctx, transaction, commitment)
-    }
-
-    pub fn get_account_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.inner
-            .get_account_with_commitment_and_context(ctx, address, commitment)
-    }
-
+#[async_trait]
+pub trait BanksClientExt {
     /// Send a transaction and return immediately. The server will resend the
     /// transaction until either it is accepted by the cluster or the transaction's
     /// blockhash expires.
-    pub fn send_transaction(
-        &mut self,
-        transaction: Transaction,
-    ) -> impl Future<Output = io::Result<()>> + '_ {
-        self.send_transaction_with_context(context::current(), transaction)
-    }
-
-    /// Return the fee parameters associated with a recent, rooted blockhash. The cluster
-    /// will use the transaction's blockhash to look up these same fee parameters and
-    /// use them to calculate the transaction fee.
-    pub fn get_fees(
-        &mut self,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
-        self.get_fees_with_commitment_and_context(context::current(), CommitmentLevel::default())
-    }
-
-    /// Return the cluster rent
-    pub fn get_rent(&mut self) -> impl Future<Output = io::Result<Rent>> + '_ {
-        self.get_account(sysvar::rent::id()).map(|result| {
-            let rent_sysvar = result?
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Rent sysvar not present"))?;
-            from_account::<Rent>(&rent_sysvar).ok_or_else(|| {
-                io::Error::new(io::ErrorKind::Other, "Failed to deserialize Rent sysvar")
-            })
-        })
-    }
+    async fn send_transaction(&mut self, transaction: Transaction) -> io::Result<()>;
 
     /// Return a recent, rooted blockhash from the server. The cluster will only accept
     /// transactions with a blockhash that has not yet expired. Use the `get_fees`
     /// method to get both a blockhash and the blockhash's last valid slot.
-    pub fn get_recent_blockhash(&mut self) -> impl Future<Output = io::Result<Hash>> + '_ {
-        self.get_fees().map(|result| Ok(result?.1))
-    }
+    async fn get_recent_blockhash(&mut self) -> io::Result<Hash>;
+
+    /// Return the fee parameters associated with a recent, rooted blockhash. The cluster
+    /// will use the transaction's blockhash to look up these same fee parameters and
+    /// use them to calculate the transaction fee.
+    async fn get_fees(&mut self) -> io::Result<(FeeCalculator, Hash, Slot)>;
+
+    /// Return the cluster rent
+    async fn get_rent(&mut self) -> io::Result<Rent>;
 
     /// Send a transaction and return after the transaction has been rejected or
     /// reached the given level of commitment.
-    pub fn process_transaction_with_commitment(
+    async fn process_transaction_with_commitment(
         &mut self,
         transaction: Transaction,
         commitment: CommitmentLevel,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        let mut ctx = context::current();
-        ctx.deadline += Duration::from_secs(50);
-        self.process_transaction_with_commitment_and_context(ctx, transaction, commitment)
-            .map(|result| match result? {
-                None => {
-                    Err(Error::new(ErrorKind::TimedOut, "invalid blockhash or fee-payer").into())
-                }
-                Some(transaction_result) => Ok(transaction_result?),
-            })
-    }
+    ) -> transport::Result<()>;
 
-    /// Send a transaction and return until the transaction has been finalized or rejected.
-    pub fn process_transaction(
-        &mut self,
-        transaction: Transaction,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        self.process_transaction_with_commitment(transaction, CommitmentLevel::default())
-    }
-
-    pub async fn process_transactions_with_commitment(
-        &mut self,
-        transactions: Vec<Transaction>,
-        commitment: CommitmentLevel,
-    ) -> transport::Result<()> {
-        let mut clients: Vec<_> = transactions.iter().map(|_| self.clone()).collect();
-        let futures = clients
-            .iter_mut()
-            .zip(transactions)
-            .map(|(client, transaction)| {
-                client.process_transaction_with_commitment(transaction, commitment)
-            });
-        let statuses = join_all(futures).await;
-        statuses.into_iter().collect() // Convert Vec<Result<_, _>> to Result<Vec<_>>
-    }
-
-    /// Send transactions and return until the transaction has been finalized or rejected.
-    pub fn process_transactions(
-        &mut self,
-        transactions: Vec<Transaction>,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        self.process_transactions_with_commitment(transactions, CommitmentLevel::default())
-    }
-
-    /// Return the most recent rooted slot height. All transactions at or below this height
-    /// are said to be finalized. The cluster will not fork to a higher slot height.
-    pub fn get_root_slot(&mut self) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.get_slot_with_context(context::current(), CommitmentLevel::default())
-    }
-
-    /// Return the account at the given address at the slot corresponding to the given
-    /// commitment level. If the account is not found, None is returned.
-    pub fn get_account_with_commitment(
-        &mut self,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.get_account_with_commitment_and_context(context::current(), address, commitment)
-    }
-
-    /// Return the account at the given address at the time of the most recent root slot.
-    /// If the account is not found, None is returned.
-    pub fn get_account(
-        &mut self,
-        address: Pubkey,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.get_account_with_commitment(address, CommitmentLevel::default())
-    }
-
-    /// Return the balance in lamports of an account at the given address at the slot
-    /// corresponding to the given commitment level.
-    pub fn get_balance_with_commitment(
-        &mut self,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<u64>> + '_ {
-        self.get_account_with_commitment_and_context(context::current(), address, commitment)
-            .map(|result| Ok(result?.map(|x| x.lamports).unwrap_or(0)))
-    }
-
-    /// Return the balance in lamports of an account at the given address at the time
-    /// of the most recent root slot.
-    pub fn get_balance(&mut self, address: Pubkey) -> impl Future<Output = io::Result<u64>> + '_ {
-        self.get_balance_with_commitment(address, CommitmentLevel::default())
-    }
+    /// Send a transaction and return after the transaction has been finalized or rejected.
+    async fn process_transaction(&mut self, transaction: Transaction) -> transport::Result<()>;
 
     /// Return the status of a transaction with a signature matching the transaction's first
     /// signature. Return None if the transaction is not found, which may be because the
     /// blockhash was expired or the fee-paying account had insufficient funds to pay the
     /// transaction fee. Note that servers rarely store the full transaction history. This
     /// method may return None if the transaction status has been discarded.
-    pub fn get_transaction_status(
+    async fn get_transaction_status(
         &mut self,
         signature: Signature,
-    ) -> impl Future<Output = io::Result<Option<TransactionStatus>>> + '_ {
-        self.get_transaction_status_with_context(context::current(), signature)
-    }
+    ) -> io::Result<Option<TransactionStatus>>;
 
     /// Same as get_transaction_status, but for multiple transactions.
-    pub async fn get_transaction_statuses(
+    async fn get_transaction_statuses(
+        &mut self,
+        signatures: Vec<Signature>,
+    ) -> io::Result<Vec<Option<TransactionStatus>>>;
+
+    /// Return the most recent rooted slot height. All transactions at or below this height
+    /// are said to be finalized. The cluster will not fork to a higher slot height.
+    async fn get_root_slot(&mut self) -> io::Result<Slot>;
+
+    /// Return the account at the given address at the slot corresponding to the given
+    /// commitment level. If the account is not found, None is returned.
+    async fn get_account_with_commitment(
+        &mut self,
+        address: Pubkey,
+        commitment: CommitmentLevel,
+    ) -> io::Result<Option<Account>>;
+
+    /// Return the account at the given address at the time of the most recent root slot.
+    /// If the account is not found, None is returned.
+    async fn get_account(&mut self, address: Pubkey) -> io::Result<Option<Account>>;
+
+    /// Return the balance in lamports of an account at the given address at the slot
+    /// corresponding to the given commitment level.
+    async fn get_balance_with_commitment(
+        &mut self,
+        address: Pubkey,
+        commitment: CommitmentLevel,
+    ) -> io::Result<u64>;
+
+    /// Return the balance in lamports of an account at the given address at the time
+    /// of the most recent root slot.
+    async fn get_balance(&mut self, address: Pubkey) -> io::Result<u64>;
+}
+
+#[async_trait]
+impl BanksClientExt for BanksClient {
+    async fn send_transaction(&mut self, transaction: Transaction) -> io::Result<()> {
+        self.send_transaction_with_context(context::current(), transaction)
+            .await
+    }
+
+    async fn get_fees(&mut self) -> io::Result<(FeeCalculator, Hash, Slot)> {
+        self.get_fees_with_commitment_and_context(context::current(), CommitmentLevel::Root)
+            .await
+    }
+
+    async fn get_rent(&mut self) -> io::Result<Rent> {
+        let rent_sysvar = self
+            .get_account(sysvar::rent::id())
+            .await?
+            .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Rent sysvar not present"))?;
+
+        from_account::<Rent>(&rent_sysvar).ok_or_else(|| {
+            io::Error::new(io::ErrorKind::Other, "Failed to deserialize Rent sysvar")
+        })
+    }
+
+    async fn get_recent_blockhash(&mut self) -> io::Result<Hash> {
+        Ok(self.get_fees().await?.1)
+    }
+
+    async fn process_transaction_with_commitment(
+        &mut self,
+        transaction: Transaction,
+        commitment: CommitmentLevel,
+    ) -> transport::Result<()> {
+        let mut ctx = context::current();
+        ctx.deadline += Duration::from_secs(50);
+        let result = self
+            .process_transaction_with_commitment_and_context(ctx, transaction, commitment)
+            .await?;
+        match result {
+            None => Err(Error::new(ErrorKind::TimedOut, "invalid blockhash or fee-payer").into()),
+            Some(transaction_result) => Ok(transaction_result?),
+        }
+    }
+
+    async fn process_transaction(&mut self, transaction: Transaction) -> transport::Result<()> {
+        self.process_transaction_with_commitment(transaction, CommitmentLevel::default())
+            .await
+    }
+
+    async fn get_root_slot(&mut self) -> io::Result<Slot> {
+        self.get_slot_with_context(context::current(), CommitmentLevel::Root)
+            .await
+    }
+
+    async fn get_account_with_commitment(
+        &mut self,
+        address: Pubkey,
+        commitment: CommitmentLevel,
+    ) -> io::Result<Option<Account>> {
+        self.get_account_with_commitment_and_context(context::current(), address, commitment)
+            .await
+    }
+
+    async fn get_account(&mut self, address: Pubkey) -> io::Result<Option<Account>> {
+        self.get_account_with_commitment(address, CommitmentLevel::default())
+            .await
+    }
+
+    async fn get_balance_with_commitment(
+        &mut self,
+        address: Pubkey,
+        commitment: CommitmentLevel,
+    ) -> io::Result<u64> {
+        let account = self
+            .get_account_with_commitment_and_context(context::current(), address, commitment)
+            .await?;
+        Ok(account.map(|x| x.lamports).unwrap_or(0))
+    }
+
+    async fn get_balance(&mut self, address: Pubkey) -> io::Result<u64> {
+        self.get_balance_with_commitment(address, CommitmentLevel::default())
+            .await
+    }
+
+    async fn get_transaction_status(
+        &mut self,
+        signature: Signature,
+    ) -> io::Result<Option<TransactionStatus>> {
+        self.get_transaction_status_with_context(context::current(), signature)
+            .await
+    }
+
+    async fn get_transaction_statuses(
         &mut self,
         signatures: Vec<Signature>,
     ) -> io::Result<Vec<Option<TransactionStatus>>> {
@@ -269,30 +219,22 @@ impl BanksClient {
     }
 }
 
-pub async fn start_client<C>(transport: C) -> io::Result<BanksClient>
-where
-    C: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>> + Send + 'static,
-{
-    Ok(BanksClient {
-        inner: TarpcClient::new(client::Config::default(), transport).spawn()?,
-    })
+pub async fn start_client(
+    transport: UnboundedChannel<Response<BanksResponse>, ClientMessage<BanksRequest>>,
+) -> io::Result<BanksClient> {
+    BanksClient::new(client::Config::default(), transport).spawn()
 }
 
 pub async fn start_tcp_client<T: ToSocketAddrs>(addr: T) -> io::Result<BanksClient> {
     let transport = tcp::connect(addr, Bincode::default).await?;
-    Ok(BanksClient {
-        inner: TarpcClient::new(client::Config::default(), transport).spawn()?,
-    })
+    BanksClient::new(client::Config::default(), transport).spawn()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use solana_banks_server::banks_server::start_local_server;
-    use solana_runtime::{
-        bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache,
-        genesis_utils::create_genesis_config,
-    };
+    use solana_runtime::{bank::Bank, bank_forks::BankForks, genesis_utils::create_genesis_config};
     use solana_sdk::{message::Message, signature::Signer, system_instruction};
     use std::sync::{Arc, RwLock};
     use tarpc::transport;
@@ -311,12 +253,9 @@ mod tests {
         // `runtime.block_on()` just once, to run all the async code.
 
         let genesis = create_genesis_config(10);
-        let bank = Bank::new(&genesis.genesis_config);
-        let slot = bank.slot();
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
-        ));
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
+        let bank_forks = Arc::new(RwLock::new(BankForks::new(Bank::new(
+            &genesis.genesis_config,
+        ))));
 
         let bob_pubkey = solana_sdk::pubkey::new_rand();
         let mint_pubkey = genesis.mint_keypair.pubkey();
@@ -324,8 +263,9 @@ mod tests {
         let message = Message::new(&[instruction], Some(&mint_pubkey));
 
         Runtime::new()?.block_on(async {
-            let client_transport = start_local_server(bank_forks, block_commitment_cache).await;
-            let mut banks_client = start_client(client_transport).await?;
+            let client_transport = start_local_server(&bank_forks).await;
+            let mut banks_client =
+                BanksClient::new(client::Config::default(), client_transport).spawn()?;
 
             let recent_blockhash = banks_client.get_recent_blockhash().await?;
             let transaction = Transaction::new(&[&genesis.mint_keypair], message, recent_blockhash);
@@ -342,12 +282,9 @@ mod tests {
         // server-side functionality is available to the client.
 
         let genesis = create_genesis_config(10);
-        let bank = Bank::new(&genesis.genesis_config);
-        let slot = bank.slot();
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
-        ));
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
+        let bank_forks = Arc::new(RwLock::new(BankForks::new(Bank::new(
+            &genesis.genesis_config,
+        ))));
 
         let mint_pubkey = &genesis.mint_keypair.pubkey();
         let bob_pubkey = solana_sdk::pubkey::new_rand();
@@ -355,8 +292,9 @@ mod tests {
         let message = Message::new(&[instruction], Some(&mint_pubkey));
 
         Runtime::new()?.block_on(async {
-            let client_transport = start_local_server(bank_forks, block_commitment_cache).await;
-            let mut banks_client = start_client(client_transport).await?;
+            let client_transport = start_local_server(&bank_forks).await;
+            let mut banks_client =
+                BanksClient::new(client::Config::default(), client_transport).spawn()?;
             let (_, recent_blockhash, last_valid_slot) = banks_client.get_fees().await?;
             let transaction = Transaction::new(&[&genesis.mint_keypair], message, recent_blockhash);
             let signature = transaction.signatures[0];

banks-interface/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-banks-interface"
-version = "1.5.6"
+version = "1.4.6"
 description = "Solana banks RPC interface"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -9,14 +9,10 @@ homepage = "https://solana.com/"
 edition = "2018"
 
 [dependencies]
-mio = "0.7.6"
 serde = { version = "1.0.112", features = ["derive"] }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
 tarpc = { version = "0.23.0", features = ["full"] }
 
-[dev-dependencies]
-tokio = { version = "0.3.5", features = ["full"] }
-
 [lib]
 crate-type = ["lib"]
 name = "solana_banks_interface"

banks-interface/src/lib.rs

@@ -10,19 +10,11 @@ use solana_sdk::{
     transaction::{self, Transaction, TransactionError},
 };
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TransactionConfirmationStatus {
-    Processed,
-    Confirmed,
-    Finalized,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct TransactionStatus {
     pub slot: Slot,
     pub confirmations: Option<usize>, // None = rooted
     pub err: Option<TransactionError>,
-    pub confirmation_status: Option<TransactionConfirmationStatus>,
 }
 
 #[tarpc::service]

banks-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-banks-server"
-version = "1.5.6"
+version = "1.4.6"
 description = "Solana banks server"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,12 +11,11 @@ edition = "2018"
 [dependencies]
 bincode = "1.3.1"
 futures = "0.3"
-log = "0.4.11"
-mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
+log = "0.4.8"
+solana-banks-interface = { path = "../banks-interface", version = "1.4.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-metrics = { path = "../metrics", version = "1.4.6" }
 tarpc = { version = "0.23.0", features = ["full"] }
 tokio = { version = "0.3", features = ["full"] }
 tokio-serde = { version = "0.6", features = ["bincode"] }

banks-server/src/banks_server.rs

@@ -4,9 +4,7 @@ use futures::{
     future,
     prelude::stream::{self, StreamExt},
 };
-use solana_banks_interface::{
-    Banks, BanksRequest, BanksResponse, TransactionConfirmationStatus, TransactionStatus,
-};
+use solana_banks_interface::{Banks, BanksRequest, BanksResponse, TransactionStatus};
 use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache};
 use solana_sdk::{
     account::Account,
@@ -62,7 +60,7 @@ impl BanksServer {
         }
     }
 
-    fn run(bank_forks: Arc<RwLock<BankForks>>, transaction_receiver: Receiver<TransactionInfo>) {
+    fn run(bank: &Bank, transaction_receiver: Receiver<TransactionInfo>) {
         while let Ok(info) = transaction_receiver.recv() {
             let mut transaction_infos = vec![info];
             while let Ok(info) = transaction_receiver.try_recv() {
@@ -72,28 +70,21 @@ impl BanksServer {
                 .into_iter()
                 .map(|info| deserialize(&info.wire_transaction).unwrap())
                 .collect();
-            let bank = bank_forks.read().unwrap().working_bank();
             let _ = bank.process_transactions(&transactions);
         }
     }
 
     /// Useful for unit-testing
-    fn new_loopback(
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    ) -> Self {
+    fn new_loopback(bank_forks: Arc<RwLock<BankForks>>) -> Self {
         let (transaction_sender, transaction_receiver) = channel();
         let bank = bank_forks.read().unwrap().working_bank();
         let slot = bank.slot();
-        {
-            // ensure that the commitment cache and bank are synced
-            let mut w_block_commitment_cache = block_commitment_cache.write().unwrap();
-            w_block_commitment_cache.set_all_slots(slot, slot);
-        }
-        let server_bank_forks = bank_forks.clone();
+        let block_commitment_cache = Arc::new(RwLock::new(
+            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
+        ));
         Builder::new()
             .name("solana-bank-forks-client".to_string())
-            .spawn(move || Self::run(server_bank_forks, transaction_receiver))
+            .spawn(move || Self::run(&bank, transaction_receiver))
             .unwrap();
         Self::new(bank_forks, block_commitment_cache, transaction_sender)
     }
@@ -131,16 +122,6 @@ impl BanksServer {
     }
 }
 
-fn verify_transaction(transaction: &Transaction) -> transaction::Result<()> {
-    if let Err(err) = transaction.verify() {
-        Err(err)
-    } else if let Err(err) = transaction.verify_precompiles() {
-        Err(err)
-    } else {
-        Ok(())
-    }
-}
-
 #[tarpc::server]
 impl Banks for BanksServer {
     async fn send_transaction_with_context(self, _: Context, transaction: Transaction) {
@@ -174,17 +155,11 @@ impl Banks for BanksServer {
         _: Context,
         signature: Signature,
     ) -> Option<TransactionStatus> {
-        let bank = self.bank(CommitmentLevel::Processed);
+        let bank = self.bank(CommitmentLevel::Recent);
         let (slot, status) = bank.get_signature_status_slot(&signature)?;
         let r_block_commitment_cache = self.block_commitment_cache.read().unwrap();
 
-        let optimistically_confirmed_bank = self.bank(CommitmentLevel::Confirmed);
-        let optimistically_confirmed =
-            optimistically_confirmed_bank.get_signature_status_slot(&signature);
-
-        let confirmations = if r_block_commitment_cache.root() >= slot
-            && r_block_commitment_cache.highest_confirmed_root() >= slot
-        {
+        let confirmations = if r_block_commitment_cache.root() >= slot {
             None
         } else {
             r_block_commitment_cache
@@ -195,13 +170,6 @@ impl Banks for BanksServer {
             slot,
             confirmations,
             err: status.err(),
-            confirmation_status: if confirmations.is_none() {
-                Some(TransactionConfirmationStatus::Finalized)
-            } else if optimistically_confirmed.is_some() {
-                Some(TransactionConfirmationStatus::Confirmed)
-            } else {
-                Some(TransactionConfirmationStatus::Processed)
-            },
         })
     }
 
@@ -215,10 +183,6 @@ impl Banks for BanksServer {
         transaction: Transaction,
         commitment: CommitmentLevel,
     ) -> Option<transaction::Result<()>> {
-        if let Err(err) = verify_transaction(&transaction) {
-            return Some(Err(err));
-        }
-
         let blockhash = &transaction.message.recent_blockhash;
         let last_valid_slot = self
             .bank_forks
@@ -247,10 +211,9 @@ impl Banks for BanksServer {
 }
 
 pub async fn start_local_server(
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
+    bank_forks: &Arc<RwLock<BankForks>>,
 ) -> UnboundedChannel<Response<BanksResponse>, ClientMessage<BanksRequest>> {
-    let banks_server = BanksServer::new_loopback(bank_forks, block_commitment_cache);
+    let banks_server = BanksServer::new_loopback(bank_forks.clone());
     let (client_transport, server_transport) = transport::channel::unbounded();
     let server = server::new(server::Config::default())
         .incoming(stream::once(future::ready(server_transport)))

bench-exchange/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,28 +11,28 @@ publish = false
 [dependencies]
 clap = "2.33.1"
 itertools = "0.9.0"
-log = "0.4.11"
+log = "0.4.8"
 num-derive = "0.3"
 num-traits = "0.2"
 rand = "0.7.0"
 rayon = "1.4.0"
 serde_json = "1.0.56"
 serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-core = { path = "../core", version = "1.5.6" }
-solana-genesis = { path = "../genesis", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-core = { path = "../core", version = "1.4.6" }
+solana-genesis = { path = "../genesis", version = "1.4.6" }
+solana-client = { path = "../client", version = "1.4.6" }
+solana-faucet = { path = "../faucet", version = "1.4.6" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.4.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-metrics = { path = "../metrics", version = "1.4.6" }
+solana-net-utils = { path = "../net-utils", version = "1.4.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
 
 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.5.6" }
+solana-local-cluster = { path = "../local-cluster", version = "1.4.6" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-exchange/src/bench.rs

@@ -390,7 +390,7 @@ fn swapper<T>(
             while client
                 .get_balance_with_commitment(
                     &trade_infos[trade_index].trade_account,
-                    CommitmentConfig::processed(),
+                    CommitmentConfig::recent(),
                 )
                 .unwrap_or(0)
                 == 0
@@ -445,7 +445,7 @@ fn swapper<T>(
             account_group = (account_group + 1) % account_groups as usize;
 
             let (blockhash, _fee_calculator, _last_valid_slot) = client
-                .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                 .expect("Failed to get blockhash");
             let to_swap_txs: Vec<_> = to_swap
                 .par_iter()
@@ -571,7 +571,7 @@ fn trader<T>(
         account_group = (account_group + 1) % account_groups as usize;
 
         let (blockhash, _fee_calculator, _last_valid_slot) = client
-            .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+            .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
 
         trades.chunks(chunk_size).for_each(|chunk| {
@@ -658,7 +658,7 @@ where
 {
     for s in &tx.signatures {
         if let Ok(Some(r)) =
-            sync_client.get_signature_status_with_commitment(s, CommitmentConfig::processed())
+            sync_client.get_signature_status_with_commitment(s, CommitmentConfig::recent())
         {
             match r {
                 Ok(_) => {
@@ -681,7 +681,7 @@ fn verify_funding_transfer<T: SyncClient + ?Sized>(
     if verify_transaction(client, tx) {
         for a in &tx.message().account_keys[1..] {
             if client
-                .get_balance_with_commitment(a, CommitmentConfig::processed())
+                .get_balance_with_commitment(a, CommitmentConfig::recent())
                 .unwrap_or(0)
                 >= amount
             {
@@ -764,7 +764,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                 );
 
                 let (blockhash, _fee_calculator, _last_valid_slot) = client
-                    .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("blockhash");
                 to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
                     tx.sign(&[*k], blockhash);
@@ -803,7 +803,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
         funded.append(&mut new_funded);
         funded.retain(|(k, b)| {
             client
-                .get_balance_with_commitment(&k.pubkey(), CommitmentConfig::processed())
+                .get_balance_with_commitment(&k.pubkey(), CommitmentConfig::recent())
                 .unwrap_or(0)
                 > lamports
                 && *b > lamports
@@ -857,7 +857,7 @@ pub fn create_token_accounts<T: Client>(
             let mut retries = 0;
             while !to_create_txs.is_empty() {
                 let (blockhash, _fee_calculator, _last_valid_slot) = client
-                    .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("Failed to get blockhash");
                 to_create_txs
                     .par_iter_mut()
@@ -903,7 +903,7 @@ pub fn create_token_accounts<T: Client>(
         let mut new_notfunded: Vec<(&Arc<Keypair>, &Keypair)> = vec![];
         for f in &notfunded {
             if client
-                .get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::processed())
+                .get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::recent())
                 .unwrap_or(0)
                 == 0
             {
@@ -968,7 +968,7 @@ pub fn airdrop_lamports<T: Client>(
     id: &Keypair,
     amount: u64,
 ) {
-    let balance = client.get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed());
+    let balance = client.get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent());
     let balance = balance.unwrap_or(0);
     if balance >= amount {
         return;
@@ -986,7 +986,7 @@ pub fn airdrop_lamports<T: Client>(
     let mut tries = 0;
     loop {
         let (blockhash, _fee_calculator, _last_valid_slot) = client
-            .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+            .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
         match request_airdrop_transaction(&faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {
             Ok(transaction) => {
@@ -995,14 +995,14 @@ pub fn airdrop_lamports<T: Client>(
                 for _ in 0..30 {
                     if let Ok(Some(_)) = client.get_signature_status_with_commitment(
                         &signature,
-                        CommitmentConfig::processed(),
+                        CommitmentConfig::recent(),
                     ) {
                         break;
                     }
                     sleep(Duration::from_millis(100));
                 }
                 if client
-                    .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed())
+                    .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent())
                     .unwrap_or(0)
                     >= amount
                 {

bench-exchange/src/cli.rs

@@ -163,8 +163,7 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
         )
 }
 
-#[allow(clippy::field_reassign_with_default)]
-pub fn extract_args(matches: &ArgMatches) -> Config {
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
     let mut args = Config::default();
 
     args.entrypoint_addr = solana_net_utils::parse_host_port(

bench-exchange/tests/bench_exchange.rs

@@ -5,7 +5,7 @@ use solana_core::validator::ValidatorConfig;
 use solana_exchange_program::exchange_processor::process_instruction;
 use solana_exchange_program::id;
 use solana_exchange_program::solana_exchange_program;
-use solana_faucet::faucet::run_local_faucet_with_port;
+use solana_faucet::faucet::run_local_faucet;
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_runtime::bank::Bank;
 use solana_runtime::bank_client::BankClient;
@@ -22,17 +22,15 @@ fn test_exchange_local_cluster() {
 
     const NUM_NODES: usize = 1;
 
-    let config = Config {
-        identity: Keypair::new(),
-        duration: Duration::from_secs(1),
-        fund_amount: 100_000,
-        threads: 1,
-        transfer_delay: 20, // 15
-        batch_size: 100,    // 1000
-        chunk_size: 10,     // 200
-        account_groups: 1,  // 10
-        ..Config::default()
-    };
+    let mut config = Config::default();
+    config.identity = Keypair::new();
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 15
+    config.batch_size = 100; // 1000;
+    config.chunk_size = 10; // 200;
+    config.account_groups = 1; // 10;
     let Config {
         fund_amount,
         batch_size,
@@ -41,7 +39,7 @@ fn test_exchange_local_cluster() {
     } = config;
     let accounts_in_groups = batch_size * account_groups;
 
-    let cluster = LocalCluster::new(&mut ClusterConfig {
+    let cluster = LocalCluster::new(&ClusterConfig {
         node_stakes: vec![100_000; NUM_NODES],
         cluster_lamports: 100_000_000_000_000,
         validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
@@ -57,11 +55,8 @@ fn test_exchange_local_cluster() {
     );
 
     let (addr_sender, addr_receiver) = channel();
-    run_local_faucet_with_port(faucet_keypair, addr_sender, Some(1_000_000_000_000), 0);
-    let faucet_addr = addr_receiver
-        .recv_timeout(Duration::from_secs(2))
-        .expect("run_local_faucet")
-        .expect("faucet_addr");
+    run_local_faucet(faucet_keypair, addr_sender, Some(1_000_000_000_000));
+    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();
 
     info!("Connecting to the cluster");
     let nodes =
@@ -94,18 +89,15 @@ fn test_exchange_bank_client() {
     bank.add_builtin("exchange_program", id(), process_instruction);
     let clients = vec![BankClient::new(bank)];
 
-    do_bench_exchange(
-        clients,
-        Config {
-            identity,
-            duration: Duration::from_secs(1),
-            fund_amount: 100_000,
-            threads: 1,
-            transfer_delay: 20, // 0;
-            batch_size: 100,    // 1500;
-            chunk_size: 10,     // 1500;
-            account_groups: 1,  // 50;
-            ..Config::default()
-        },
-    );
+    let mut config = Config::default();
+    config.identity = identity;
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 0;
+    config.batch_size = 100; // 1500;
+    config.chunk_size = 10; // 1500;
+    config.account_groups = 1; // 50;
+
+    do_bench_exchange(clients, config);
 }

bench-streamer/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -10,11 +10,11 @@ publish = false
 
 [dependencies]
 clap = "2.33.1"
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-streamer = { path = "../streamer", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-streamer = { path = "../streamer", version = "1.4.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-net-utils = { path = "../net-utils", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-tps/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,27 +11,27 @@ publish = false
 [dependencies]
 bincode = "1.3.1"
 clap = "2.33.1"
-log = "0.4.11"
+log = "0.4.8"
 rayon = "1.4.0"
 serde_json = "1.0.56"
 serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-core = { path = "../core", version = "1.5.6" }
-solana-genesis = { path = "../genesis", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-core = { path = "../core", version = "1.4.6" }
+solana-genesis = { path = "../genesis", version = "1.4.6" }
+solana-client = { path = "../client", version = "1.4.6" }
+solana-faucet = { path = "../faucet", version = "1.4.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-metrics = { path = "../metrics", version = "1.4.6" }
+solana-measure = { path = "../measure", version = "1.4.6" }
+solana-net-utils = { path = "../net-utils", version = "1.4.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
 
 [dev-dependencies]
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "1.5.6" }
+solana-local-cluster = { path = "../local-cluster", version = "1.4.6" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-tps/src/bench.rs

@@ -48,7 +48,7 @@ pub type SharedTransactions = Arc<RwLock<VecDeque<Vec<(Transaction, u64)>>>>;
 
 fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
     loop {
-        match client.get_recent_blockhash_with_commitment(CommitmentConfig::processed()) {
+        match client.get_recent_blockhash_with_commitment(CommitmentConfig::recent()) {
             Ok((blockhash, fee_calculator, _last_valid_slot)) => {
                 return (blockhash, fee_calculator)
             }
@@ -497,7 +497,7 @@ fn do_tx_transfers<T: Client>(
 
 fn verify_funding_transfer<T: Client>(client: &Arc<T>, tx: &Transaction, amount: u64) -> bool {
     for a in &tx.message().account_keys[1..] {
-        match client.get_balance_with_commitment(a, CommitmentConfig::processed()) {
+        match client.get_balance_with_commitment(a, CommitmentConfig::recent()) {
             Ok(balance) => return balance >= amount,
             Err(err) => error!("failed to get balance {:?}", err),
         }
@@ -762,7 +762,7 @@ pub fn airdrop_lamports<T: Client>(
         };
 
         let current_balance = client
-            .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed())
+            .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent())
             .unwrap_or_else(|e| {
                 info!("airdrop error {}", e);
                 starting_balance
@@ -938,12 +938,10 @@ mod tests {
         let bank = Bank::new(&genesis_config);
         let client = Arc::new(BankClient::new(bank));
 
-        let config = Config {
-            id,
-            tx_count: 10,
-            duration: Duration::from_secs(5),
-            ..Config::default()
-        };
+        let mut config = Config::default();
+        config.id = id;
+        config.tx_count = 10;
+        config.duration = Duration::from_secs(5);
 
         let keypair_count = config.tx_count * config.keypair_multiplier;
         let keypairs =
@@ -967,7 +965,7 @@ mod tests {
         for kp in &keypairs {
             assert_eq!(
                 client
-                    .get_balance_with_commitment(&kp.pubkey(), CommitmentConfig::processed())
+                    .get_balance_with_commitment(&kp.pubkey(), CommitmentConfig::recent())
                     .unwrap(),
                 lamports
             );

bench-tps/src/cli.rs

@@ -196,7 +196,7 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
 /// * `matches` - command line arguments parsed by clap
 /// # Panics
 /// Panics if there is trouble parsing any of the arguments
-pub fn extract_args(matches: &ArgMatches) -> Config {
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
     let mut args = Config::default();
 
     if let Some(addr) = matches.value_of("entrypoint") {

bench-tps/tests/bench_tps.rs

@@ -4,7 +4,7 @@ use solana_bench_tps::cli::Config;
 use solana_client::thin_client::create_client;
 use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
 use solana_core::validator::ValidatorConfig;
-use solana_faucet::faucet::run_local_faucet_with_port;
+use solana_faucet::faucet::run_local_faucet;
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_sdk::signature::{Keypair, Signer};
 use std::sync::{mpsc::channel, Arc};
@@ -15,7 +15,7 @@ fn test_bench_tps_local_cluster(config: Config) {
 
     solana_logger::setup();
     const NUM_NODES: usize = 1;
-    let cluster = LocalCluster::new(&mut ClusterConfig {
+    let cluster = LocalCluster::new(&ClusterConfig {
         node_stakes: vec![999_990; NUM_NODES],
         cluster_lamports: 200_000_000,
         validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
@@ -36,11 +36,8 @@ fn test_bench_tps_local_cluster(config: Config) {
     ));
 
     let (addr_sender, addr_receiver) = channel();
-    run_local_faucet_with_port(faucet_keypair, addr_sender, None, 0);
-    let faucet_addr = addr_receiver
-        .recv_timeout(Duration::from_secs(2))
-        .expect("run_local_faucet")
-        .expect("faucet_addr");
+    run_local_faucet(faucet_keypair, addr_sender, None);
+    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();
 
     let lamports_per_account = 100;
 
@@ -63,9 +60,9 @@ fn test_bench_tps_local_cluster(config: Config) {
 #[test]
 #[serial]
 fn test_bench_tps_local_cluster_solana() {
-    test_bench_tps_local_cluster(Config {
-        tx_count: 100,
-        duration: Duration::from_secs(10),
-        ..Config::default()
-    });
+    let mut config = Config::default();
+    config.tx_count = 100;
+    config.duration = Duration::from_secs(10);
+
+    test_bench_tps_local_cluster(config);
 }

ci/README.md

@@ -47,8 +47,6 @@ sudo ./setup-new-buildkite-agent/setup-buildkite.sh
 ```
 - Copy the pubkey contents from `~buildkite-agent/.ssh/id_ecdsa.pub` and
 add the pubkey as an authorized SSH key on github.
-  - In net/scripts/solana-user-authorized_keys.sh
-  - Bug mvines to add it to the "solana-grimes" github user
 - Edit `/etc/buildkite-agent/buildkite-agent.cfg` and/or `/etc/systemd/system/buildkite-agent@*` to the desired configuration of the agent(s)
 - Copy `ejson` keys from another CI node at `/opt/ejson/keys/`
 to the same location on the new node.

ci/buildkite-pipeline.sh

@@ -263,7 +263,7 @@ if [[ $BUILDKITE_BRANCH =~ ^pull ]]; then
   annotate --style info --context pr-backlink \
     "Github Pull Request: https://github.com/solana-labs/solana/$BUILDKITE_BRANCH"
 
-  if [[ $GITHUB_USER = "dependabot[bot]" ]]; then
+  if [[ $GITHUB_USER = "dependabot-preview[bot]" ]]; then
     command_step dependabot "ci/dependabot-pr.sh" 5
     wait_step
   fi

ci/dependabot-updater.sh

@@ -6,13 +6,13 @@ source ci/_
 
 commit_range="$(git merge-base HEAD origin/master)..HEAD"
 parsed_update_args="$(
-  git log "$commit_range" --author "dependabot\[bot\]" --oneline -n1 |
+  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
     grep -o '[Bb]ump.*$' |
     sed -r 's/[Bb]ump ([^ ]+) from ([^ ]+) to ([^ ]+)/-p \1:\2 --precise \3/'
 )"
 # relaxed_parsed_update_args is temporal measure...
 relaxed_parsed_update_args="$(
-  git log "$commit_range" --author "dependabot\[bot\]" --oneline -n1 |
+  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
     grep -o '[Bb]ump.*$' |
     sed -r 's/[Bb]ump ([^ ]+) from [^ ]+ to ([^ ]+)/-p \1 --precise \2/'
 )"

ci/docker-rust-nightly/Dockerfile

@@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.49.0
+FROM solanalabs/rust:1.46.0
 ARG date
 
 RUN set -x \

ci/docker-rust/Dockerfile

@@ -1,6 +1,6 @@
 # Note: when the rust version is changed also modify
 # ci/rust-version.sh to pick up the new image tag
-FROM rust:1.49.0
+FROM rust:1.46.0
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0

ci/localnet-sanity.sh

@@ -80,7 +80,7 @@ nodes=(
   "multinode-demo/validator.sh \
     --enable-rpc-exit \
     --no-restart \
-    --dynamic-port-range 8050-8100 \
+    --dynamic-port-range 8050-8100
     --init-complete-file init-complete-node1.log \
     --rpc-port 18899"
 )

ci/nits.sh

@@ -19,7 +19,6 @@ declare prints=(
 # Parts of the tree that are expected to be print free
 declare print_free_tree=(
   ':core/src/**.rs'
-  ':^core/src/validator.rs'
   ':faucet/src/**.rs'
   ':ledger/src/**.rs'
   ':metrics/src/**.rs'

ci/publish-bpf-sdk.sh

@@ -16,12 +16,21 @@ fi
   [[ -f bpf-sdk.tar.bz2 ]]
 )
 
-source ci/upload-ci-artifact.sh
 echo --- AWS S3 Store
 if [[ -z $CHANNEL_OR_TAG ]]; then
   echo Skipped
 else
-  upload-s3-artifact "/solana/bpf-sdk.tar.bz2" "s3://solana-sdk/$CHANNEL_OR_TAG/bpf-sdk.tar.bz2"
+  (
+    set -x
+    docker run \
+      --rm \
+      --env AWS_ACCESS_KEY_ID \
+      --env AWS_SECRET_ACCESS_KEY \
+      --volume "$PWD:/solana" \
+      eremite/aws-cli:2018.12.18 \
+      /usr/bin/s3cmd --acl-public put /solana/bpf-sdk.tar.bz2 \
+      s3://solana-sdk/"$CHANNEL_OR_TAG"/bpf-sdk.tar.bz2
+  )
 fi
 
 exit 0

ci/publish-tarball.sh

@@ -113,10 +113,19 @@ for file in "${TARBALL_BASENAME}"-$TARGET.tar.bz2 "${TARBALL_BASENAME}"-$TARGET.
 
   if [[ -n $BUILDKITE ]]; then
     echo --- AWS S3 Store: "$file"
-    upload-s3-artifact "/solana/$file" s3://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
+    (
+      set -x
+      $DRYRUN docker run \
+        --rm \
+        --env AWS_ACCESS_KEY_ID \
+        --env AWS_SECRET_ACCESS_KEY \
+        --volume "$PWD:/solana" \
+        eremite/aws-cli:2018.12.18 \
+        /usr/bin/s3cmd --acl-public put /solana/"$file" s3://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
 
-    echo Published to:
-    $DRYRUN ci/format-url.sh https://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
+      echo Published to:
+      $DRYRUN ci/format-url.sh https://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
+    )
 
     if [[ -n $TAG ]]; then
       ci/upload-github-release-asset.sh "$file"
@@ -140,9 +149,7 @@ done
 
 
 # Create install wrapper for release.solana.com
-if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
-  echo "Skipping publishing install wrapper"
-elif [[ -n $BUILDKITE ]]; then
+if [[ -n $BUILDKITE ]]; then
   cat > release.solana.com-install <<EOF
 SOLANA_RELEASE=$CHANNEL_OR_TAG
 SOLANA_INSTALL_INIT_ARGS=$CHANNEL_OR_TAG
@@ -151,9 +158,19 @@ EOF
   cat install/solana-install-init.sh >> release.solana.com-install
 
   echo --- AWS S3 Store: "install"
-  $DRYRUN upload-s3-artifact "/solana/release.solana.com-install" "s3://release.solana.com/$CHANNEL_OR_TAG/install"
-  echo Published to:
-  $DRYRUN ci/format-url.sh https://release.solana.com/"$CHANNEL_OR_TAG"/install
+  (
+    set -x
+    $DRYRUN docker run \
+      --rm \
+      --env AWS_ACCESS_KEY_ID \
+      --env AWS_SECRET_ACCESS_KEY \
+      --volume "$PWD:/solana" \
+      eremite/aws-cli:2018.12.18 \
+      /usr/bin/s3cmd --acl-public put /solana/release.solana.com-install s3://release.solana.com/"$CHANNEL_OR_TAG"/install
+
+    echo Published to:
+    $DRYRUN ci/format-url.sh https://release.solana.com/"$CHANNEL_OR_TAG"/install
+  )
 fi
 
 echo --- ok

ci/rust-version.sh

@@ -18,13 +18,13 @@
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.49.0
+  stable_version=1.46.0
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2021-01-23
+  nightly_version=2020-08-17
 fi
 
 

ci/setup-new-buildkite-agent/setup-buildkite.sh

@@ -76,7 +76,7 @@ RestartForceExitStatus=SIGPIPE
 TimeoutStartSec=10
 TimeoutStopSec=0
 KillMode=process
-LimitNOFILE=700000
+LimitNOFILE=500000
 
 [Install]
 WantedBy=multi-user.target

ci/setup-new-buildkite-agent/setup-limits.sh

@@ -8,5 +8,5 @@ source "$HERE"/utils.sh
 ensure_env || exit 1
 
 # Allow more files to be opened by a user
-echo "* - nofile 700000" > /etc/security/limits.d/90-solana-nofiles.conf
+echo "* - nofile 500000" > /etc/security/limits.d/90-solana-nofiles.conf
 

ci/setup-new-buildkite-agent/setup-new-machine.sh

@@ -7,7 +7,6 @@ SOLANA_ROOT="$HERE"/../..
 source "$HERE"/utils.sh
 
 ensure_env || exit 1
-check_ssh_authorized_keys || exit 1
 
 set -ex
 

ci/setup-new-buildkite-agent/setup-ssh.sh

@@ -6,11 +6,6 @@ HERE="$(dirname "$0")"
 source "$HERE"/utils.sh
 
 ensure_env || exit 1
-# This is a last ditch effort to prevent the caller from locking themselves
-# out of the machine. Exiting here will likely leave the system in some
-# half-configured state. To prevent this, duplicate the next line at the top
-# of the entrypoint script.
-check_ssh_authorized_keys || exit 1
 
 set -xe
 # Setup sshd

ci/setup-new-buildkite-agent/utils.sh

@@ -14,33 +14,3 @@ ensure_env() {
   $RC
 }
 
-# Some scripts disable SSH password logins. If no one hash setup authorized_keys
-# this will result in the machine being remotely inaccessible. Check that the
-# user running this script has setup their keys
-check_ssh_authorized_keys() {
-  declare rc=false
-  declare user_home=
-  if [[ -n "$SUDO_USER" ]]; then
-    declare user uid gid home
-    declare passwd_entry
-    passwd_entry="$(grep "$SUDO_USER:[^:]*:$SUDO_UID:$SUDO_GID" /etc/passwd)"
-    IFS=: read -r user _ uid gid _ home _ <<<"$passwd_entry"
-    if [[ "$user" == "$SUDO_USER" && "$uid" == "$SUDO_UID" && "$gid" == "$SUDO_GID" ]]; then
-      user_home="$home"
-    fi
-  else
-    user_home="$HOME"
-  fi
-  declare authorized_keys="${user_home}/.ssh/authorized_keys"
-  if [[ -n "$user_home" ]]; then
-    [[ -s "$authorized_keys" ]] && rc=true
-  fi
-  if ! $rc; then
-    echo "ERROR! This script will disable SSH password logins and you don't"
-    echo "appear to have set up any authorized keys.  Please add you SSH"
-    echo "public key to ${authorized_keys} before continuing!"
-  fi
-  $rc
-}
-
-check_ssh_authorized_keys

ci/test-bench.sh

@@ -23,10 +23,6 @@ fi
 BENCH_FILE=bench_output.log
 BENCH_ARTIFACT=current_bench_results.log
 
-# solana-keygen required when building C programs
-_ "$cargo" build --manifest-path=keygen/Cargo.toml
-export PATH="$PWD/target/debug":$PATH
-
 # Clear the C dependency files, if dependeny moves these files are not regenerated
 test -d target/debug/bpf && find target/debug/bpf -name '*.d' -delete
 test -d target/release/bpf && find target/release/bpf -name '*.d' -delete

ci/test-checks.sh

@@ -56,7 +56,9 @@ _ "$cargo" stable fmt --all -- --check
 
 # -Z... is needed because of clippy bug: https://github.com/rust-lang/rust-clippy/issues/4612
 # run nightly clippy for `sdk/` as there's a moderate amount of nightly-only code there
-_ "$cargo" nightly clippy -Zunstable-options --workspace --all-targets -- --deny=warnings
+_ "$cargo" nightly clippy \
+  -Zunstable-options --workspace --all-targets \
+  -- --deny=warnings --allow=clippy::stable_sort_primitive
 
 cargo_audit_ignores=(
   # failure is officially deprecated/unmaintained
@@ -73,20 +75,6 @@ cargo_audit_ignores=(
   #
   # Blocked on multiple upstream crates removing their `stdweb` dependency.
   --ignore RUSTSEC-2020-0056
-
-  # Potential segfault in the time crate
-  #
-  # Blocked on multiple crates updating `time` to >= 0.2.23
-  --ignore RUSTSEC-2020-0071
-
-  # difference is unmaintained
-  #
-  # Blocked on predicates v1.0.6 removing its dependency on `difference`
-  --ignore RUSTSEC-2020-0095
-
-  # hyper is upgraded on master/v1.6 but not for v1.5
-  --ignore RUSTSEC-2021-0020
-
 )
 _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit "${cargo_audit_ignores[@]}"
 
@@ -99,7 +87,9 @@ _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit "${cargo_audit_ignor
       cd "$project"
       _ "$cargo" stable fmt -- --check
       _ "$cargo" nightly test
-      _ "$cargo" nightly clippy -- --deny=warnings --allow=clippy::missing_safety_doc
+      _ "$cargo" nightly clippy -- --deny=warnings \
+        --allow=clippy::missing_safety_doc \
+        --allow=clippy::stable_sort_primitive
     )
   done
 }

ci/test-sanity.sh

@@ -8,16 +8,10 @@ source ci/_
 (
   echo --- git diff --check
   set -x
-
-  if [[ -n $CI_BASE_BRANCH ]]
-  then branch="$CI_BASE_BRANCH"
-  else branch="master"
-  fi
-
   # Look for failed mergify.io backports by searching leftover conflict markers
   # Also check for any trailing whitespaces!
-  git fetch origin "$branch"
-  git diff "$(git merge-base HEAD "origin/$branch")" --check --oneline
+  git fetch origin "$CI_BASE_BRANCH"
+  git diff "$(git merge-base HEAD "origin/$CI_BASE_BRANCH")..HEAD" --check --oneline
 )
 
 echo

ci/test-stable.sh

@@ -21,6 +21,9 @@ export RUST_BACKTRACE=1
 export RUSTFLAGS="-D warnings"
 source scripts/ulimit-n.sh
 
+# Clear cached json keypair files
+rm -rf "$HOME/.config/solana"
+
 # Clear the C dependency files, if dependency moves these files are not regenerated
 test -d target/debug/bpf && find target/debug/bpf -name '*.d' -delete
 test -d target/release/bpf && find target/release/bpf -name '*.d' -delete
@@ -39,10 +42,6 @@ test-stable)
   _ "$cargo" stable test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
   ;;
 test-stable-perf)
-  # solana-keygen required when building C programs
-  _ "$cargo" build --manifest-path=keygen/Cargo.toml
-  export PATH="$PWD/target/debug":$PATH
-
   # BPF solana-sdk legacy compile test
   ./cargo-build-bpf --manifest-path sdk/Cargo.toml
 

ci/upload-ci-artifact.sh

@@ -16,16 +16,3 @@ upload-ci-artifact() {
   fi
 }
 
-upload-s3-artifact() {
-  echo "--- artifact: $1 to $2"
-  (
-    set -x
-    docker run \
-      --rm \
-      --env AWS_ACCESS_KEY_ID \
-      --env AWS_SECRET_ACCESS_KEY \
-      --volume "$PWD:/solana" \
-      eremite/aws-cli:2018.12.18 \
-      /usr/bin/s3cmd --acl-public put "$1" "$2"
-  )
-}

clap-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-clap-utils"
-version = "1.5.6"
+version = "1.4.6"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,9 +11,9 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-thiserror = "1.0.21"
+solana-remote-wallet = { path = "../remote-wallet", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+thiserror = "1.0.20"
 tiny-bip39 = "0.7.0"
 url = "2.1.0"
 chrono = "0.4"

clap-utils/src/commitment.rs

@@ -0,0 +1,22 @@
+use crate::ArgConstant;
+use clap::Arg;
+
+pub const COMMITMENT_ARG: ArgConstant<'static> = ArgConstant {
+    name: "commitment",
+    long: "commitment",
+    help: "Return information at the selected commitment level",
+};
+
+pub fn commitment_arg<'a, 'b>() -> Arg<'a, 'b> {
+    commitment_arg_with_default("recent")
+}
+
+pub fn commitment_arg_with_default<'a, 'b>(default_value: &'static str) -> Arg<'a, 'b> {
+    Arg::with_name(COMMITMENT_ARG.name)
+        .long(COMMITMENT_ARG.long)
+        .takes_value(true)
+        .possible_values(&["recent", "single", "singleGossip", "root", "max"])
+        .default_value(default_value)
+        .value_name("COMMITMENT_LEVEL")
+        .help(COMMITMENT_ARG.help)
+}

clap-utils/src/input_parsers.rs

@@ -167,12 +167,12 @@ pub fn resolve_signer(
     name: &str,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<Option<String>, Box<dyn std::error::Error>> {
-    resolve_signer_from_path(
+    Ok(resolve_signer_from_path(
         matches,
         matches.value_of(name).unwrap(),
         name,
         wallet_manager,
-    )
+    )?)
 }
 
 pub fn lamports_of_sol(matches: &ArgMatches<'_>, name: &str) -> Option<u64> {
@@ -184,9 +184,13 @@ pub fn cluster_type_of(matches: &ArgMatches<'_>, name: &str) -> Option<ClusterTy
 }
 
 pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentConfig> {
-    matches
-        .value_of(name)
-        .map(|value| CommitmentConfig::from_str(value).unwrap_or_default())
+    matches.value_of(name).map(|value| match value {
+        "max" => CommitmentConfig::max(),
+        "recent" => CommitmentConfig::recent(),
+        "root" => CommitmentConfig::root(),
+        "single" => CommitmentConfig::single(),
+        _ => CommitmentConfig::default(),
+    })
 }
 
 #[cfg(test)]

clap-utils/src/input_validators.rs

@@ -1,7 +1,7 @@
 use crate::keypair::{parse_keypair_path, KeypairUrl, ASK_KEYWORD};
 use chrono::DateTime;
 use solana_sdk::{
-    clock::{Epoch, Slot},
+    clock::Slot,
     hash::Hash,
     pubkey::Pubkey,
     signature::{read_keypair_file, Signature},
@@ -148,40 +148,6 @@ where
     }
 }
 
-pub fn is_url_or_moniker<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + Display,
-{
-    match url::Url::parse(&normalize_to_url_if_moniker(string.as_ref())) {
-        Ok(url) => {
-            if url.has_host() {
-                Ok(())
-            } else {
-                Err("no host provided".to_string())
-            }
-        }
-        Err(err) => Err(format!("{}", err)),
-    }
-}
-
-pub fn normalize_to_url_if_moniker<T: AsRef<str>>(url_or_moniker: T) -> String {
-    match url_or_moniker.as_ref() {
-        "m" | "mainnet-beta" => "https://api.mainnet-beta.solana.com",
-        "t" | "testnet" => "https://testnet.solana.com",
-        "d" | "devnet" => "https://devnet.solana.com",
-        "l" | "localhost" => "http://localhost:8899",
-        url => url,
-    }
-    .to_string()
-}
-
-pub fn is_epoch<T>(epoch: T) -> Result<(), String>
-where
-    T: AsRef<str> + Display,
-{
-    is_parsable_generic::<Epoch, _>(epoch)
-}
-
 pub fn is_slot<T>(slot: T) -> Result<(), String>
 where
     T: AsRef<str> + Display,

clap-utils/src/keypair.rs

@@ -58,15 +58,6 @@ impl CliSignerInfo {
             Some(0)
         }
     }
-    pub fn index_of_or_none(&self, pubkey: Option<Pubkey>) -> Option<usize> {
-        if let Some(pubkey) = pubkey {
-            self.signers
-                .iter()
-                .position(|signer| signer.pubkey() == pubkey)
-        } else {
-            None
-        }
-    }
 }
 
 pub struct DefaultSigner {

clap-utils/src/lib.rs

@@ -23,6 +23,7 @@ impl std::fmt::Debug for DisplayError {
     }
 }
 
+pub mod commitment;
 pub mod fee_payer;
 pub mod input_parsers;
 pub mod input_validators;

cli-config/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-config"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"

cli-config/src/config.rs

@@ -17,10 +17,9 @@ pub struct Config {
     pub json_rpc_url: String,
     pub websocket_url: String,
     pub keypair_path: String,
+
     #[serde(default)]
     pub address_labels: HashMap<String, String>,
-    #[serde(default)]
-    pub commitment: String,
 }
 
 impl Default for Config {
@@ -42,14 +41,11 @@ impl Default for Config {
             "System Program".to_string(),
         );
 
-        let commitment = "confirmed".to_string();
-
         Self {
             json_rpc_url,
             websocket_url,
             keypair_path,
             address_labels,
-            commitment,
         }
     }
 }
@@ -80,6 +76,17 @@ impl Config {
         ws_url.to_string()
     }
 
+    pub fn compute_rpc_banks_url(json_rpc_url: &str) -> String {
+        let json_rpc_url: Option<Url> = json_rpc_url.parse().ok();
+        if json_rpc_url.is_none() {
+            return "".to_string();
+        }
+        let mut url = json_rpc_url.unwrap();
+        let port = url.port().unwrap_or(8899);
+        url.set_port(Some(port + 3)).expect("unable to set port");
+        url.to_string()
+    }
+
     pub fn import_address_labels<P>(&mut self, filename: P) -> Result<(), io::Error>
     where
         P: AsRef<Path>,
@@ -126,4 +133,28 @@ mod test {
 
         assert_eq!(Config::compute_websocket_url(&"garbage"), String::new());
     }
+
+    #[test]
+    fn compute_rpc_banks_url() {
+        assert_eq!(
+            Config::compute_rpc_banks_url(&"http://devnet.solana.com"),
+            "http://devnet.solana.com:8902/".to_string()
+        );
+
+        assert_eq!(
+            Config::compute_rpc_banks_url(&"https://devnet.solana.com"),
+            "https://devnet.solana.com:8902/".to_string()
+        );
+
+        assert_eq!(
+            Config::compute_rpc_banks_url(&"http://example.com:8899"),
+            "http://example.com:8902/".to_string()
+        );
+        assert_eq!(
+            Config::compute_rpc_banks_url(&"https://example.com:1234"),
+            "https://example.com:1237/".to_string()
+        );
+
+        assert_eq!(Config::compute_rpc_banks_url(&"garbage"), String::new());
+    }
 }

cli-output/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-output"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -17,13 +17,13 @@ indicatif = "0.15.0"
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-transaction-status = { path = "../transaction-status", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
+solana-account-decoder = { path = "../account-decoder", version = "1.4.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-client = { path = "../client", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-stake-program = { path = "../programs/stake", version = "1.4.6" }
+solana-transaction-status = { path = "../transaction-status", version = "1.4.6" }
+solana-vote-program = { path = "../programs/vote", version = "1.4.6" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

cli-output/src/cli_output.rs

@@ -1,42 +1,37 @@
-use {
-    crate::{
-        display::{
-            build_balance_message, build_balance_message_with_config, format_labeled_address,
-            unix_timestamp_to_string, writeln_name_value, BuildBalanceMessageConfig,
-        },
-        QuietDisplay, VerboseDisplay,
-    },
-    console::{style, Emoji},
-    inflector::cases::titlecase::to_title_case,
-    serde::{Deserialize, Serialize},
-    serde_json::{Map, Value},
-    solana_account_decoder::parse_token::UiTokenAccount,
-    solana_clap_utils::keypair::SignOnly,
-    solana_client::rpc_response::{
-        RpcAccountBalance, RpcInflationGovernor, RpcInflationRate, RpcKeyedAccount, RpcSupply,
-        RpcVoteAccountInfo,
-    },
-    solana_sdk::{
-        clock::{self, Epoch, Slot, UnixTimestamp},
-        epoch_info::EpochInfo,
-        hash::Hash,
-        native_token::lamports_to_sol,
-        pubkey::Pubkey,
-        signature::Signature,
-        stake_history::StakeHistoryEntry,
-        transaction::Transaction,
-    },
-    solana_stake_program::stake_state::{Authorized, Lockup},
-    solana_vote_program::{
-        authorized_voters::AuthorizedVoters,
-        vote_state::{BlockTimestamp, Lockout},
-    },
-    std::{
-        collections::{BTreeMap, HashMap},
-        fmt,
-        str::FromStr,
-        time::Duration,
-    },
+use crate::{
+    display::{build_balance_message, format_labeled_address, writeln_name_value},
+    QuietDisplay, VerboseDisplay,
+};
+use chrono::{DateTime, NaiveDateTime, SecondsFormat, Utc};
+use console::{style, Emoji};
+use inflector::cases::titlecase::to_title_case;
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+use solana_account_decoder::parse_token::UiTokenAccount;
+use solana_clap_utils::keypair::SignOnly;
+use solana_client::rpc_response::{
+    RpcAccountBalance, RpcKeyedAccount, RpcSupply, RpcVoteAccountInfo,
+};
+use solana_sdk::{
+    clock::{self, Epoch, Slot, UnixTimestamp},
+    epoch_info::EpochInfo,
+    hash::Hash,
+    native_token::lamports_to_sol,
+    pubkey::Pubkey,
+    signature::Signature,
+    stake_history::StakeHistoryEntry,
+    transaction::Transaction,
+};
+use solana_stake_program::stake_state::{Authorized, Lockup};
+use solana_vote_program::{
+    authorized_voters::AuthorizedVoters,
+    vote_state::{BlockTimestamp, Lockout},
+};
+use std::{
+    collections::{BTreeMap, HashMap},
+    fmt,
+    str::FromStr,
+    time::Duration,
 };
 
 static WARNING: Emoji = Emoji("⚠️", "!");
@@ -246,9 +241,6 @@ impl fmt::Display for CliEpochInfo {
         )?;
         writeln_name_value(f, "Slot:", &self.epoch_info.absolute_slot.to_string())?;
         writeln_name_value(f, "Epoch:", &self.epoch_info.epoch.to_string())?;
-        if let Some(transaction_count) = &self.epoch_info.transaction_count {
-            writeln_name_value(f, "Transaction Count:", &transaction_count.to_string())?;
-        }
         let start_slot = self.epoch_info.absolute_slot - self.epoch_info.slot_index;
         let end_slot = start_slot + self.epoch_info.slots_in_epoch;
         writeln_name_value(
@@ -363,42 +355,6 @@ impl fmt::Display for CliValidators {
                 },
             )
         }
-        writeln!(
-            f,
-            "{}",
-            style(format!(
-                "  {:<44}  {:<38}  {}  {}  {}  {:>10}  {:^8}  {}",
-                "Identity",
-                "Vote Account",
-                "Commission",
-                "Last Vote",
-                "Root Block",
-                "Credits",
-                "Version",
-                "Active Stake",
-            ))
-            .bold()
-        )?;
-        for validator in &self.current_validators {
-            write_vote_account(
-                f,
-                validator,
-                self.total_active_stake,
-                self.use_lamports_unit,
-                false,
-            )?;
-        }
-        for validator in &self.delinquent_validators {
-            write_vote_account(
-                f,
-                validator,
-                self.total_active_stake,
-                self.use_lamports_unit,
-                true,
-            )?;
-        }
-
-        writeln!(f)?;
         writeln_name_value(
             f,
             "Active Stake:",
@@ -450,6 +406,41 @@ impl fmt::Display for CliValidators {
             )?;
         }
 
+        writeln!(f)?;
+        writeln!(
+            f,
+            "{}",
+            style(format!(
+                "  {:<44}  {:<38}  {}  {}  {}  {:>10}  {:^8}  {}",
+                "Identity",
+                "Vote Account",
+                "Commission",
+                "Last Vote",
+                "Root Block",
+                "Credits",
+                "Version",
+                "Active Stake",
+            ))
+            .bold()
+        )?;
+        for validator in &self.current_validators {
+            write_vote_account(
+                f,
+                validator,
+                self.total_active_stake,
+                self.use_lamports_unit,
+                false,
+            )?;
+        }
+        for validator in &self.delinquent_validators {
+            write_vote_account(
+                f,
+                validator,
+                self.total_active_stake,
+                self.use_lamports_unit,
+                true,
+            )?;
+        }
         Ok(())
     }
 }
@@ -550,15 +541,7 @@ impl CliStakeVec {
 }
 
 impl QuietDisplay for CliStakeVec {}
-impl VerboseDisplay for CliStakeVec {
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        for state in &self.0 {
-            writeln!(w)?;
-            VerboseDisplay::write_str(state, w)?;
-        }
-        Ok(())
-    }
-}
+impl VerboseDisplay for CliStakeVec {}
 
 impl fmt::Display for CliStakeVec {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -579,12 +562,7 @@ pub struct CliKeyedStakeState {
 }
 
 impl QuietDisplay for CliKeyedStakeState {}
-impl VerboseDisplay for CliKeyedStakeState {
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        writeln!(w, "Stake Pubkey: {}", self.stake_pubkey)?;
-        VerboseDisplay::write_str(&self.stake_state, w)
-    }
-}
+impl VerboseDisplay for CliKeyedStakeState {}
 
 impl fmt::Display for CliKeyedStakeState {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -601,46 +579,7 @@ pub struct CliEpochReward {
     pub amount: u64,       // lamports
     pub post_balance: u64, // lamports
     pub percent_change: f64,
-    pub apr: Option<f64>,
-}
-
-fn show_votes_and_credits(
-    f: &mut fmt::Formatter,
-    votes: &[CliLockout],
-    epoch_voting_history: &[CliEpochVotingHistory],
-) -> fmt::Result {
-    if votes.is_empty() {
-        return Ok(());
-    }
-
-    writeln!(f, "Recent Votes:")?;
-    for vote in votes {
-        writeln!(f, "- slot: {}", vote.slot)?;
-        writeln!(f, "  confirmation count: {}", vote.confirmation_count)?;
-    }
-    writeln!(f, "Epoch Voting History:")?;
-    writeln!(
-        f,
-        "* missed credits include slots unavailable to vote on due to delinquent leaders",
-    )?;
-    for entry in epoch_voting_history {
-        writeln!(
-            f, // tame fmt so that this will be folded like following
-            "- epoch: {}",
-            entry.epoch
-        )?;
-        writeln!(
-            f,
-            "  credits range: [{}..{})",
-            entry.prev_credits, entry.credits
-        )?;
-        writeln!(
-            f,
-            "  credits/slots: {}/{}",
-            entry.credits_earned, entry.slots_in_epoch
-        )?;
-    }
-    Ok(())
+    pub apr: f64,
 }
 
 fn show_epoch_rewards(
@@ -655,22 +594,19 @@ fn show_epoch_rewards(
         writeln!(f, "Epoch Rewards:")?;
         writeln!(
             f,
-            "  {:<6}  {:<11}  {:<16}  {:<16}  {:>14}  {:>14}",
+            "  {:<8}  {:<11}  {:<15}  {:<15}  {:>14}  {:>14}",
             "Epoch", "Reward Slot", "Amount", "New Balance", "Percent Change", "APR"
         )?;
         for reward in epoch_rewards {
             writeln!(
                 f,
-                "  {:<6}  {:<11}  ◎{:<16.9}  ◎{:<14.9}  {:>13.2}%  {}",
+                "  {:<8}  {:<11}  ◎{:<14.9}  ◎{:<14.9}  {:>13.9}%  {:>13.9}%",
                 reward.epoch,
                 reward.effective_slot,
                 lamports_to_sol(reward.amount),
                 lamports_to_sol(reward.post_balance),
                 reward.percent_change,
-                reward
-                    .apr
-                    .map(|apr| format!("{:>13.2}%", apr))
-                    .unwrap_or_default(),
+                reward.apr,
             )?;
         }
     }
@@ -683,8 +619,6 @@ pub struct CliStakeState {
     pub stake_type: CliStakeType,
     pub account_balance: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub credits_observed: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub delegated_stake: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub delegated_vote_account_address: Option<String>,
@@ -713,15 +647,7 @@ pub struct CliStakeState {
 }
 
 impl QuietDisplay for CliStakeState {}
-impl VerboseDisplay for CliStakeState {
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        write!(w, "{}", self)?;
-        if let Some(credits) = self.credits_observed {
-            writeln!(w, "Credits Observed: {}", credits)?;
-        }
-        Ok(())
-    }
-}
+impl VerboseDisplay for CliStakeState {}
 
 impl fmt::Display for CliStakeState {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -910,19 +836,14 @@ impl fmt::Display for CliStakeHistory {
             ))
             .bold()
         )?;
-        let config = BuildBalanceMessageConfig {
-            use_lamports_unit: self.use_lamports_unit,
-            show_unit: false,
-            trim_trailing_zeros: false,
-        };
         for entry in &self.entries {
             writeln!(
                 f,
                 "  {:>5}  {:>20}  {:>20}  {:>20} {}",
                 entry.epoch,
-                build_balance_message_with_config(entry.effective_stake, &config),
-                build_balance_message_with_config(entry.activating_stake, &config),
-                build_balance_message_with_config(entry.deactivating_stake, &config),
+                build_balance_message(entry.effective_stake, self.use_lamports_unit, false),
+                build_balance_message(entry.activating_stake, self.use_lamports_unit, false),
+                build_balance_message(entry.deactivating_stake, self.use_lamports_unit, false),
                 if self.use_lamports_unit {
                     "lamports"
                 } else {
@@ -1088,7 +1009,24 @@ impl fmt::Display for CliVoteAccount {
             unix_timestamp_to_string(self.recent_timestamp.timestamp),
             self.recent_timestamp.slot
         )?;
-        show_votes_and_credits(f, &self.votes, &self.epoch_voting_history)?;
+        if !self.votes.is_empty() {
+            writeln!(f, "Recent Votes:")?;
+            for vote in &self.votes {
+                writeln!(
+                    f,
+                    "- slot: {}\n  confirmation count: {}",
+                    vote.slot, vote.confirmation_count
+                )?;
+            }
+            writeln!(f, "Epoch Voting History:")?;
+            for epoch_info in &self.epoch_voting_history {
+                writeln!(
+                    f,
+                    "- epoch: {}\n  slots in epoch: {}\n  credits earned: {}",
+                    epoch_info.epoch, epoch_info.slots_in_epoch, epoch_info.credits_earned,
+                )?;
+            }
+        }
         show_epoch_rewards(f, &self.epoch_rewards)?;
         Ok(())
     }
@@ -1127,8 +1065,6 @@ pub struct CliEpochVotingHistory {
     pub epoch: Epoch,
     pub slots_in_epoch: u64,
     pub credits_earned: u64,
-    pub credits: u64,
-    pub prev_credits: u64,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -1157,6 +1093,18 @@ pub struct CliBlockTime {
 impl QuietDisplay for CliBlockTime {}
 impl VerboseDisplay for CliBlockTime {}
 
+fn unix_timestamp_to_string(unix_timestamp: UnixTimestamp) -> String {
+    format!(
+        "{} (UnixTimestamp: {})",
+        match NaiveDateTime::from_timestamp_opt(unix_timestamp, 0) {
+            Some(ndt) =>
+                DateTime::<Utc>::from_utc(ndt, Utc).to_rfc3339_opts(SecondsFormat::Secs, true),
+            None => "unknown".to_string(),
+        },
+        unix_timestamp,
+    )
+}
+
 impl fmt::Display for CliBlockTime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln_name_value(f, "Block:", &self.slot.to_string())?;
@@ -1164,104 +1112,6 @@ impl fmt::Display for CliBlockTime {
     }
 }
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliLeaderSchedule {
-    pub epoch: Epoch,
-    pub leader_schedule_entries: Vec<CliLeaderScheduleEntry>,
-}
-
-impl QuietDisplay for CliLeaderSchedule {}
-impl VerboseDisplay for CliLeaderSchedule {}
-
-impl fmt::Display for CliLeaderSchedule {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for entry in &self.leader_schedule_entries {
-            writeln!(f, "  {:<15} {:<44}", entry.slot, entry.leader)?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliLeaderScheduleEntry {
-    pub slot: Slot,
-    pub leader: String,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliInflation {
-    pub governor: RpcInflationGovernor,
-    pub current_rate: RpcInflationRate,
-}
-
-impl QuietDisplay for CliInflation {}
-impl VerboseDisplay for CliInflation {}
-
-impl fmt::Display for CliInflation {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "{}", style("Inflation Governor:").bold())?;
-        if (self.governor.initial - self.governor.terminal).abs() < f64::EPSILON {
-            writeln!(
-                f,
-                "Fixed APR:               {:>5.2}%",
-                self.governor.terminal * 100.
-            )?;
-        } else {
-            writeln!(
-                f,
-                "Initial APR:             {:>5.2}%",
-                self.governor.initial * 100.
-            )?;
-            writeln!(
-                f,
-                "Terminal APR:            {:>5.2}%",
-                self.governor.terminal * 100.
-            )?;
-            writeln!(
-                f,
-                "Rate reduction per year: {:>5.2}%",
-                self.governor.taper * 100.
-            )?;
-        }
-        if self.governor.foundation_term > 0. {
-            writeln!(
-                f,
-                "Foundation percentage:   {:>5.2}%",
-                self.governor.foundation
-            )?;
-            writeln!(
-                f,
-                "Foundation term:         {:.1} years",
-                self.governor.foundation_term
-            )?;
-        }
-
-        writeln!(
-            f,
-            "\n{}",
-            style(format!("Inflation for Epoch {}:", self.current_rate.epoch)).bold()
-        )?;
-        writeln!(
-            f,
-            "Total APR:               {:>5.2}%",
-            self.current_rate.total * 100.
-        )?;
-        writeln!(
-            f,
-            "Staking APR:             {:>5.2}%",
-            self.current_rate.validator * 100.
-        )?;
-        writeln!(
-            f,
-            "Foundation APR:          {:>5.2}%",
-            self.current_rate.foundation * 100.
-        )
-    }
-}
-
 #[derive(Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct CliSignOnlyData {
@@ -1467,114 +1317,6 @@ impl fmt::Display for CliTokenAccount {
     }
 }
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliProgramId {
-    pub program_id: String,
-}
-
-impl QuietDisplay for CliProgramId {}
-impl VerboseDisplay for CliProgramId {}
-
-impl fmt::Display for CliProgramId {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln_name_value(f, "Program Id:", &self.program_id)
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliProgramBuffer {
-    pub buffer: String,
-}
-
-impl QuietDisplay for CliProgramBuffer {}
-impl VerboseDisplay for CliProgramBuffer {}
-
-impl fmt::Display for CliProgramBuffer {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln_name_value(f, "Buffer:", &self.buffer)
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum CliProgramAccountType {
-    Buffer,
-    Program,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliProgramAuthority {
-    pub authority: String,
-    pub account_type: CliProgramAccountType,
-}
-
-impl QuietDisplay for CliProgramAuthority {}
-impl VerboseDisplay for CliProgramAuthority {}
-
-impl fmt::Display for CliProgramAuthority {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln_name_value(f, "Account Type:", &format!("{:?}", self.account_type))?;
-        writeln_name_value(f, "Authority:", &self.authority)
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliUpgradeableProgram {
-    pub program_id: String,
-    pub programdata_address: String,
-    pub authority: String,
-    pub last_deploy_slot: u64,
-    pub data_len: usize,
-}
-impl QuietDisplay for CliUpgradeableProgram {}
-impl VerboseDisplay for CliUpgradeableProgram {}
-impl fmt::Display for CliUpgradeableProgram {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Program Id:", &self.program_id)?;
-        writeln_name_value(f, "ProgramData Address:", &self.programdata_address)?;
-        writeln_name_value(f, "Authority:", &self.authority)?;
-        writeln_name_value(
-            f,
-            "Last Deployed In Slot:",
-            &self.last_deploy_slot.to_string(),
-        )?;
-        writeln_name_value(
-            f,
-            "Data Length:",
-            &format!("{:?} ({:#x?}) bytes", self.data_len, self.data_len),
-        )?;
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliUpgradeableBuffer {
-    pub address: String,
-    pub authority: String,
-    pub data_len: usize,
-}
-impl QuietDisplay for CliUpgradeableBuffer {}
-impl VerboseDisplay for CliUpgradeableBuffer {}
-impl fmt::Display for CliUpgradeableBuffer {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Buffer Address:", &self.address)?;
-        writeln_name_value(f, "Authority:", &self.authority)?;
-        writeln_name_value(
-            f,
-            "Data Length:",
-            &format!("{:?} ({:#x?}) bytes", self.data_len, self.data_len),
-        )?;
-        Ok(())
-    }
-}
-
 pub fn return_signers(
     tx: &Transaction,
     output_format: &OutputFormat,
@@ -1661,37 +1403,6 @@ pub fn parse_sign_only_reply_string(reply: &str) -> SignOnly {
     }
 }
 
-#[derive(Debug)]
-pub enum CliSignatureVerificationStatus {
-    None,
-    Pass,
-    Fail,
-}
-
-impl CliSignatureVerificationStatus {
-    pub fn verify_transaction(tx: &Transaction) -> Vec<Self> {
-        tx.verify_with_results()
-            .iter()
-            .zip(&tx.signatures)
-            .map(|(stat, sig)| match stat {
-                true => CliSignatureVerificationStatus::Pass,
-                false if sig == &Signature::default() => CliSignatureVerificationStatus::None,
-                false => CliSignatureVerificationStatus::Fail,
-            })
-            .collect()
-    }
-}
-
-impl fmt::Display for CliSignatureVerificationStatus {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::None => write!(f, "none"),
-            Self::Pass => write!(f, "pass"),
-            Self::Fail => write!(f, "fail"),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

cli-output/src/display.rs

@@ -1,78 +1,33 @@
-use {
-    crate::cli_output::CliSignatureVerificationStatus,
-    chrono::{DateTime, NaiveDateTime, SecondsFormat, Utc},
-    console::style,
-    indicatif::{ProgressBar, ProgressStyle},
-    solana_sdk::{
-        clock::UnixTimestamp, hash::Hash, native_token::lamports_to_sol,
-        program_utils::limited_deserialize, transaction::Transaction,
-    },
-    solana_transaction_status::UiTransactionStatusMeta,
-    std::{collections::HashMap, fmt, io},
+use console::style;
+use indicatif::{ProgressBar, ProgressStyle};
+use solana_sdk::{
+    hash::Hash, native_token::lamports_to_sol, program_utils::limited_deserialize,
+    transaction::Transaction,
 };
+use solana_transaction_status::UiTransactionStatusMeta;
+use std::{collections::HashMap, fmt, io};
 
-#[derive(Clone, Debug)]
-pub struct BuildBalanceMessageConfig {
-    pub use_lamports_unit: bool,
-    pub show_unit: bool,
-    pub trim_trailing_zeros: bool,
-}
-
-impl Default for BuildBalanceMessageConfig {
-    fn default() -> Self {
-        Self {
-            use_lamports_unit: false,
-            show_unit: true,
-            trim_trailing_zeros: true,
-        }
-    }
-}
-
-pub fn build_balance_message_with_config(
-    lamports: u64,
-    config: &BuildBalanceMessageConfig,
-) -> String {
-    let value = if config.use_lamports_unit {
-        lamports.to_string()
+pub fn build_balance_message(lamports: u64, use_lamports_unit: bool, show_unit: bool) -> String {
+    if use_lamports_unit {
+        let ess = if lamports == 1 { "" } else { "s" };
+        let unit = if show_unit {
+            format!(" lamport{}", ess)
+        } else {
+            "".to_string()
+        };
+        format!("{:?}{}", lamports, unit)
     } else {
         let sol = lamports_to_sol(lamports);
         let sol_str = format!("{:.9}", sol);
-        if config.trim_trailing_zeros {
-            sol_str
-                .trim_end_matches('0')
-                .trim_end_matches('.')
-                .to_string()
-        } else {
-            sol_str
-        }
-    };
-    let unit = if config.show_unit {
-        if config.use_lamports_unit {
-            let ess = if lamports == 1 { "" } else { "s" };
-            format!(" lamport{}", ess)
-        } else {
-            " SOL".to_string()
-        }
-    } else {
-        "".to_string()
-    };
-    format!("{}{}", value, unit)
-}
-
-pub fn build_balance_message(lamports: u64, use_lamports_unit: bool, show_unit: bool) -> String {
-    build_balance_message_with_config(
-        lamports,
-        &BuildBalanceMessageConfig {
-            use_lamports_unit,
-            show_unit,
-            ..BuildBalanceMessageConfig::default()
-        },
-    )
+        let pretty_sol = sol_str.trim_end_matches('0').trim_end_matches('.');
+        let unit = if show_unit { " SOL" } else { "" };
+        format!("{}{}", pretty_sol, unit)
+    }
 }
 
 // Pretty print a "name value"
 pub fn println_name_value(name: &str, value: &str) {
-    let styled_value = if value.is_empty() {
+    let styled_value = if value == "" {
         style("(not set)").italic()
     } else {
         style(value)
@@ -80,8 +35,8 @@ pub fn println_name_value(name: &str, value: &str) {
     println!("{} {}", style(name).bold(), styled_value);
 }
 
-pub fn writeln_name_value(f: &mut dyn fmt::Write, name: &str, value: &str) -> fmt::Result {
-    let styled_value = if value.is_empty() {
+pub fn writeln_name_value(f: &mut fmt::Formatter, name: &str, value: &str) -> fmt::Result {
+    let styled_value = if value == "" {
         style("(not set)").italic()
     } else {
         style(value)
@@ -130,7 +85,6 @@ pub fn write_transaction<W: io::Write>(
     transaction: &Transaction,
     transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
-    sigverify_status: Option<&[CliSignatureVerificationStatus]>,
 ) -> io::Result<()> {
     let message = &transaction.message;
     writeln!(
@@ -138,24 +92,11 @@ pub fn write_transaction<W: io::Write>(
         "{}Recent Blockhash: {:?}",
         prefix, message.recent_blockhash
     )?;
-    let sigverify_statuses = if let Some(sigverify_status) = sigverify_status {
-        sigverify_status
-            .iter()
-            .map(|s| format!(" ({})", s))
-            .collect()
-    } else {
-        vec!["".to_string(); transaction.signatures.len()]
-    };
-    for (signature_index, (signature, sigverify_status)) in transaction
-        .signatures
-        .iter()
-        .zip(&sigverify_statuses)
-        .enumerate()
-    {
+    for (signature_index, signature) in transaction.signatures.iter().enumerate() {
         writeln!(
             w,
-            "{}Signature {}: {:?}{}",
-            prefix, signature_index, signature, sigverify_status,
+            "{}Signature {}: {:?}",
+            prefix, signature_index, signature
         )?;
     }
     writeln!(w, "{}{:?}", prefix, message.header)?;
@@ -276,18 +217,9 @@ pub fn println_transaction(
     transaction: &Transaction,
     transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
-    sigverify_status: Option<&[CliSignatureVerificationStatus]>,
 ) {
     let mut w = Vec::new();
-    if write_transaction(
-        &mut w,
-        transaction,
-        transaction_status,
-        prefix,
-        sigverify_status,
-    )
-    .is_ok()
-    {
+    if write_transaction(&mut w, transaction, transaction_status, prefix).is_ok() {
         if let Ok(s) = String::from_utf8(w) {
             print!("{}", s);
         }
@@ -303,13 +235,6 @@ pub fn new_spinner_progress_bar() -> ProgressBar {
     progress_bar
 }
 
-pub fn unix_timestamp_to_string(unix_timestamp: UnixTimestamp) -> String {
-    match NaiveDateTime::from_timestamp_opt(unix_timestamp, 0) {
-        Some(ndt) => DateTime::<Utc>::from_utc(ndt, Utc).to_rfc3339_opts(SecondsFormat::Secs, true),
-        None => format!("UnixTimestamp {}", unix_timestamp),
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

cli/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
+version = "1.4.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -17,39 +17,40 @@ criterion-stats = "0.3.0"
 ctrlc = { version = "3.1.5", features = ["termination"] }
 console = "0.11.3"
 dirs-next = "2.0.0"
-log = "0.4.11"
+log = "0.4.8"
 Inflector = "0.11.4"
 indicatif = "0.15.0"
 humantime = "2.0.1"
 num-traits = "0.2"
-pretty-hex = "0.2.1"
+pretty-hex = "0.1.1"
 reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "1.5.6" }
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-cli-config = { path = "../cli-config", version = "1.5.6" }
-solana-cli-output = { path = "../cli-output", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-config-program = { path = "../programs/config", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana_rbpf = "=0.2.4"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-transaction-status = { path = "../transaction-status", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
-thiserror = "1.0.21"
+solana-account-decoder = { path = "../account-decoder", version = "1.4.6" }
+solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.4.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-cli-config = { path = "../cli-config", version = "1.4.6" }
+solana-cli-output = { path = "../cli-output", version = "1.4.6" }
+solana-client = { path = "../client", version = "1.4.6" }
+solana-config-program = { path = "../programs/config", version = "1.4.6" }
+solana-faucet = { path = "../faucet", version = "1.4.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-net-utils = { path = "../net-utils", version = "1.4.6" }
+solana_rbpf = "=0.1.32"
+solana-remote-wallet = { path = "../remote-wallet", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-stake-program = { path = "../programs/stake", version = "1.4.6" }
+solana-transaction-status = { path = "../transaction-status", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
+solana-vote-program = { path = "../programs/vote", version = "1.4.6" }
+solana-vote-signer = { path = "../vote-signer", version = "1.4.6" }
+thiserror = "1.0.20"
 tiny-bip39 = "0.7.0"
 url = "2.1.1"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "1.5.6" }
+solana-core = { path = "../core", version = "1.4.6" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/feature.rs

@@ -19,22 +19,10 @@ use solana_sdk::{
 };
 use std::{collections::HashMap, fmt, sync::Arc};
 
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum ForceActivation {
-    No,
-    Almost,
-    Yes,
-}
-
 #[derive(Debug, PartialEq)]
 pub enum FeatureCliCommand {
-    Status {
-        features: Vec<Pubkey>,
-    },
-    Activate {
-        feature: Pubkey,
-        force: ForceActivation,
-    },
+    Status { features: Vec<Pubkey> },
+    Activate { feature: Pubkey },
 }
 
 #[derive(Serialize, Deserialize)]
@@ -70,8 +58,8 @@ impl fmt::Display for CliFeatures {
                 f,
                 "{}",
                 style(format!(
-                    "{:<44} {:<28} {}",
-                    "Feature", "Status", "Description"
+                    "{:<44} {:<40} {}",
+                    "Feature", "Description", "Status"
                 ))
                 .bold()
             )?;
@@ -79,15 +67,15 @@ impl fmt::Display for CliFeatures {
         for feature in &self.features {
             writeln!(
                 f,
-                "{:<44} {:<28} {}",
+                "{:<44} {:<40} {}",
                 feature.id,
+                feature.description,
                 match feature.status {
                     CliFeatureStatus::Inactive => style("inactive".to_string()).red(),
                     CliFeatureStatus::Pending => style("activation pending".to_string()).yellow(),
                     CliFeatureStatus::Active(activation_slot) =>
                         style(format!("active since slot {}", activation_slot)).green(),
-                },
-                feature.description,
+                }
             )?;
         }
         if self.inactive && !self.feature_activation_allowed {
@@ -138,13 +126,6 @@ impl FeatureSubCommands for App<'_, '_> {
                                 .index(1)
                                 .required(true)
                                 .help("The signer for the feature to activate"),
-                        )
-                        .arg(
-                            Arg::with_name("force")
-                                .long("yolo")
-                                .hidden(true)
-                                .multiple(true)
-                                .help("Override activation sanity checks. Don't use this flag"),
                         ),
                 ),
         )
@@ -171,20 +152,13 @@ pub fn parse_feature_subcommand(
         ("activate", Some(matches)) => {
             let (feature_signer, feature) = signer_of(matches, "feature", wallet_manager)?;
             let mut signers = vec![default_signer.signer_from_path(matches, wallet_manager)?];
-
-            let force = match matches.occurrences_of("force") {
-                2 => ForceActivation::Yes,
-                1 => ForceActivation::Almost,
-                _ => ForceActivation::No,
-            };
-
             signers.push(feature_signer.unwrap());
             let feature = feature.unwrap();
 
             known_feature(&feature)?;
 
             CliCommandInfo {
-                command: CliCommand::Feature(FeatureCliCommand::Activate { feature, force }),
+                command: CliCommand::Feature(FeatureCliCommand::Activate { feature }),
                 signers,
             }
         }
@@ -215,9 +189,7 @@ pub fn process_feature_subcommand(
 ) -> ProcessResult {
     match feature_subcommand {
         FeatureCliCommand::Status { features } => process_status(rpc_client, config, features),
-        FeatureCliCommand::Activate { feature, force } => {
-            process_activate(rpc_client, config, *feature, *force)
-        }
+        FeatureCliCommand::Activate { feature } => process_activate(rpc_client, config, *feature),
     }
 }
 
@@ -357,14 +329,12 @@ fn process_activate(
     rpc_client: &RpcClient,
     config: &CliConfig,
     feature_id: Pubkey,
-    force: ForceActivation,
 ) -> ProcessResult {
     let account = rpc_client
         .get_multiple_accounts(&[feature_id])?
         .into_iter()
         .next()
         .unwrap();
-
     if let Some(account) = account {
         if feature::from_account(&account).is_some() {
             return Err(format!("{} has already been activated", feature_id).into());
@@ -372,13 +342,7 @@ fn process_activate(
     }
 
     if !feature_activation_allowed(rpc_client, false)? {
-        match force {
-        ForceActivation::Almost =>
-            return Err("Add force argument once more to override the sanity check to force feature activation ".into()),
-        ForceActivation::Yes => println!("FEATURE ACTIVATION FORCED"),
-        ForceActivation::No =>
-            return Err("Feature activation is not allowed at this time".into()),
-        }
+        return Err("Feature activation is not allowed at this time".into());
     }
 
     let rent = rpc_client.get_minimum_balance_for_rent_exemption(Feature::size_of())?;

cli/src/inflation.rs

@@ -1,7 +1,7 @@
 use crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult};
 use clap::{App, ArgMatches, SubCommand};
+use console::style;
 use solana_clap_utils::keypair::*;
-use solana_cli_output::CliInflation;
 use solana_client::rpc_client::RpcClient;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use std::sync::Arc;
@@ -34,18 +34,56 @@ pub fn parse_inflation_subcommand(
 
 pub fn process_inflation_subcommand(
     rpc_client: &RpcClient,
-    config: &CliConfig,
+    _config: &CliConfig,
     inflation_subcommand: &InflationCliCommand,
 ) -> ProcessResult {
     assert_eq!(*inflation_subcommand, InflationCliCommand::Show);
 
     let governor = rpc_client.get_inflation_governor()?;
-    let current_rate = rpc_client.get_inflation_rate()?;
+    let current_inflation_rate = rpc_client.get_inflation_rate()?;
 
-    let inflation = CliInflation {
-        governor,
-        current_rate,
-    };
+    println!("{}", style("Inflation Governor:").bold());
+    if (governor.initial - governor.terminal).abs() < f64::EPSILON {
+        println!(
+            "Fixed APR:               {:>5.2}%",
+            governor.terminal * 100.
+        );
+    } else {
+        println!("Initial APR:             {:>5.2}%", governor.initial * 100.);
+        println!(
+            "Terminal APR:            {:>5.2}%",
+            governor.terminal * 100.
+        );
+        println!("Rate reduction per year: {:>5.2}%", governor.taper * 100.);
+    }
+    if governor.foundation_term > 0. {
+        println!("Foundation percentage:   {:>5.2}%", governor.foundation);
+        println!(
+            "Foundation term:         {:.1} years",
+            governor.foundation_term
+        );
+    }
 
-    Ok(config.output_format.formatted_string(&inflation))
+    println!(
+        "\n{}",
+        style(format!(
+            "Inflation for Epoch {}:",
+            current_inflation_rate.epoch
+        ))
+        .bold()
+    );
+    println!(
+        "Total APR:               {:>5.2}%",
+        current_inflation_rate.total * 100.
+    );
+    println!(
+        "Staking APR:             {:>5.2}%",
+        current_inflation_rate.validator * 100.
+    );
+    println!(
+        "Foundation APR:          {:>5.2}%",
+        current_inflation_rate.foundation * 100.
+    );
+
+    Ok("".to_string())
 }

cli/src/lib.rs

@@ -26,7 +26,6 @@ pub mod cluster_query;
 pub mod feature;
 pub mod inflation;
 pub mod nonce;
-pub mod program;
 pub mod send_tpu;
 pub mod spend_utils;
 pub mod stake;

cli/src/main.rs

@@ -3,8 +3,11 @@ use clap::{
     SubCommand,
 };
 use console::style;
+
 use solana_clap_utils::{
-    input_validators::{is_url, is_url_or_moniker, normalize_to_url_if_moniker},
+    commitment::COMMITMENT_ARG,
+    input_parsers::commitment_of,
+    input_validators::is_url,
     keypair::{CliSigners, DefaultSigner, SKIP_SEED_PHRASE_VALIDATION_ARG},
     DisplayError,
 };
@@ -60,19 +63,12 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                     );
                     let (keypair_setting_type, keypair_path) =
                         CliConfig::compute_keypair_path_setting("", &config.keypair_path);
-                    let (commitment_setting_type, commitment) =
-                        CliConfig::compute_commitment_config("", &config.commitment);
 
                     if let Some(field) = subcommand_matches.value_of("specific_setting") {
                         let (field_name, value, setting_type) = match field {
                             "json_rpc_url" => ("RPC URL", json_rpc_url, url_setting_type),
                             "websocket_url" => ("WebSocket URL", websocket_url, ws_setting_type),
                             "keypair" => ("Key Path", keypair_path, keypair_setting_type),
-                            "commitment" => (
-                                "Commitment",
-                                commitment.commitment.to_string(),
-                                commitment_setting_type,
-                            ),
                             _ => unreachable!(),
                         };
                         println_name_value_or(&format!("{}:", field_name), &value, setting_type);
@@ -81,16 +77,11 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                         println_name_value_or("RPC URL:", &json_rpc_url, url_setting_type);
                         println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
                         println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
-                        println_name_value_or(
-                            "Commitment:",
-                            &commitment.commitment.to_string(),
-                            commitment_setting_type,
-                        );
                     }
                 }
                 ("set", Some(subcommand_matches)) => {
                     if let Some(url) = subcommand_matches.value_of("json_rpc_url") {
-                        config.json_rpc_url = normalize_to_url_if_moniker(url);
+                        config.json_rpc_url = url.to_string();
                         // Revert to a computed `websocket_url` value when `json_rpc_url` is
                         // changed
                         config.websocket_url = "".to_string();
@@ -101,9 +92,6 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                     if let Some(keypair) = subcommand_matches.value_of("keypair") {
                         config.keypair_path = keypair.to_string();
                     }
-                    if let Some(commitment) = subcommand_matches.value_of("commitment") {
-                        config.commitment = commitment.to_string();
-                    }
 
                     config.save(config_file)?;
 
@@ -117,18 +105,11 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                     );
                     let (keypair_setting_type, keypair_path) =
                         CliConfig::compute_keypair_path_setting("", &config.keypair_path);
-                    let (commitment_setting_type, commitment) =
-                        CliConfig::compute_commitment_config("", &config.commitment);
 
                     println_name_value("Config File:", config_file);
                     println_name_value_or("RPC URL:", &json_rpc_url, url_setting_type);
                     println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
                     println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
-                    println_name_value_or(
-                        "Commitment:",
-                        &commitment.commitment.to_string(),
-                        commitment_setting_type,
-                    );
                 }
                 ("import-address-labels", Some(subcommand_matches)) => {
                     let filename = value_t_or_exit!(subcommand_matches, "filename", PathBuf);
@@ -184,20 +165,9 @@ pub fn parse_args<'a>(
         path: default_signer_path.clone(),
     };
 
-    let CliCommandInfo {
-        command,
-        mut signers,
-    } = parse_command(&matches, &default_signer, &mut wallet_manager)?;
+    let CliCommandInfo { command, signers } =
+        parse_command(&matches, &default_signer, &mut wallet_manager)?;
 
-    if signers.is_empty() {
-        if let Ok(signer_info) =
-            default_signer.generate_unique_signers(vec![None], matches, &mut wallet_manager)
-        {
-            signers.extend(signer_info.signers);
-        }
-    }
-
-    let verbose = matches.is_present("verbose");
     let output_format = matches
         .value_of("output_format")
         .map(|value| match value {
@@ -205,16 +175,13 @@ pub fn parse_args<'a>(
             "json-compact" => OutputFormat::JsonCompact,
             _ => unreachable!(),
         })
-        .unwrap_or(if verbose {
-            OutputFormat::DisplayVerbose
-        } else {
-            OutputFormat::Display
-        });
+        .unwrap_or(OutputFormat::Display);
 
-    let (_, commitment) = CliConfig::compute_commitment_config(
-        matches.value_of("commitment").unwrap_or(""),
-        &config.commitment,
-    );
+    let commitment = matches
+        .subcommand_name()
+        .and_then(|name| matches.subcommand_matches(name))
+        .and_then(|sub_matches| commitment_of(sub_matches, COMMITMENT_ARG.long))
+        .unwrap_or_default();
 
     let address_labels = if matches.is_present("no_address_labels") {
         HashMap::new()
@@ -231,13 +198,10 @@ pub fn parse_args<'a>(
             keypair_path: default_signer_path,
             rpc_client: None,
             rpc_timeout,
-            verbose,
+            verbose: matches.is_present("verbose"),
             output_format,
             commitment,
-            send_transaction_config: RpcSendTransactionConfig {
-                preflight_commitment: Some(commitment.commitment),
-                ..RpcSendTransactionConfig::default()
-            },
+            send_transaction_config: RpcSendTransactionConfig::default(),
             address_labels,
         },
         signers,
@@ -245,7 +209,7 @@ pub fn parse_args<'a>(
 }
 
 fn main() -> Result<(), Box<dyn error::Error>> {
-    solana_logger::setup_with_default("off");
+    solana_logger::setup();
     let matches = app(
         crate_name!(),
         crate_description!(),
@@ -269,14 +233,11 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         Arg::with_name("json_rpc_url")
             .short("u")
             .long("url")
-            .value_name("URL_OR_MONIKER")
+            .value_name("URL")
             .takes_value(true)
             .global(true)
-            .validator(is_url_or_moniker)
-            .help(
-                "URL for Solana's JSON RPC or moniker (or their first letter): \
-                   [mainnet-beta, testnet, devnet, localhost]",
-            ),
+            .validator(is_url)
+            .help("JSON RPC URL for the solana cluster"),
     )
     .arg(
         Arg::with_name("websocket_url")
@@ -296,25 +257,6 @@ fn main() -> Result<(), Box<dyn error::Error>> {
             .takes_value(true)
             .help("Filepath or URL to a keypair"),
     )
-    .arg(
-        Arg::with_name("commitment")
-            .long("commitment")
-            .takes_value(true)
-            .possible_values(&[
-                "processed",
-                "confirmed",
-                "finalized",
-                "recent", // Deprecated as of v1.5.5
-                "single", // Deprecated as of v1.5.5
-                "singleGossip", // Deprecated as of v1.5.5
-                "root", // Deprecated as of v1.5.5
-                "max", // Deprecated as of v1.5.5
-            ])
-            .value_name("COMMITMENT_LEVEL")
-            .hide_possible_values(true)
-            .global(true)
-            .help("Return information at the selected commitment level [possible values: processed, confirmed, finalized]"),
-    )
     .arg(
         Arg::with_name("verbose")
             .long("verbose")
@@ -366,12 +308,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                             .index(1)
                             .value_name("CONFIG_FIELD")
                             .takes_value(true)
-                            .possible_values(&[
-                                "json_rpc_url",
-                                "websocket_url",
-                                "keypair",
-                                "commitment",
-                            ])
+                            .possible_values(&["json_rpc_url", "websocket_url", "keypair"])
                             .help("Return a specific config setting"),
                     ),
             )
@@ -380,7 +317,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                     .about("Set a config setting")
                     .group(
                         ArgGroup::with_name("config_settings")
-                            .args(&["json_rpc_url", "websocket_url", "keypair", "commitment"])
+                            .args(&["json_rpc_url", "websocket_url", "keypair"])
                             .multiple(true)
                             .required(true),
                     ),

cli/src/nonce.rs

@@ -332,7 +332,9 @@ pub fn process_authorize_nonce_account(
     nonce_authority: SignerIndex,
     new_authority: &Pubkey,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
 
     let nonce_authority = config.signers[nonce_authority];
     let ix = authorize_nonce_account(nonce_account, &nonce_authority.pubkey(), new_authority);
@@ -347,7 +349,11 @@ pub fn process_authorize_nonce_account(
         &tx.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<NonceError>(result, &config)
 }
 
@@ -394,7 +400,9 @@ pub fn process_create_nonce_account(
         Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
 
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
 
     let (message, lamports) = resolve_spend_tx_and_check_account_balance(
         rpc_client,
@@ -406,7 +414,9 @@ pub fn process_create_nonce_account(
         config.commitment,
     )?;
 
-    if let Ok(nonce_account) = get_account(rpc_client, &nonce_account_address) {
+    if let Ok(nonce_account) =
+        get_account_with_commitment(rpc_client, &nonce_account_address, config.commitment)
+    {
         let err_msg = if state_from_account(&nonce_account).is_ok() {
             format!("Nonce account {} already exists", nonce_account_address)
         } else {
@@ -429,7 +439,11 @@ pub fn process_create_nonce_account(
 
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<SystemError>(result, &config)
 }
 
@@ -457,17 +471,20 @@ pub fn process_new_nonce(
         (&nonce_account, "nonce_account_pubkey".to_string()),
     )?;
 
-    if let Err(err) = rpc_client.get_account(&nonce_account) {
-        return Err(CliError::BadParameter(format!(
-            "Unable to advance nonce account {}. error: {}",
-            nonce_account, err
-        ))
+    let nonce_account_check =
+        rpc_client.get_account_with_commitment(&nonce_account, config.commitment);
+    if nonce_account_check.is_err() || nonce_account_check.unwrap().value.is_none() {
+        return Err(CliError::BadParameter(
+            "Unable to create new nonce, no nonce account found".to_string(),
+        )
         .into());
     }
 
     let nonce_authority = config.signers[nonce_authority];
     let ix = advance_nonce_account(&nonce_account, &nonce_authority.pubkey());
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
@@ -478,7 +495,11 @@ pub fn process_new_nonce(
         &tx.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<SystemError>(result, &config)
 }
 
@@ -520,7 +541,9 @@ pub fn process_withdraw_from_nonce_account(
     destination_account_pubkey: &Pubkey,
     lamports: u64,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
 
     let nonce_authority = config.signers[nonce_authority];
     let ix = withdraw_nonce_account(
@@ -539,7 +562,11 @@ pub fn process_withdraw_from_nonce_account(
         &tx.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<NonceError>(result, &config)
 }
 

cli/src/stake.rs

@@ -35,7 +35,6 @@ use solana_sdk::{
     account::from_account,
     account_utils::StateMut,
     clock::{Clock, Epoch, Slot, UnixTimestamp, SECONDS_PER_DAY},
-    feature, feature_set,
     message::Message,
     pubkey::Pubkey,
     system_instruction::SystemError,
@@ -64,12 +63,6 @@ pub const WITHDRAW_AUTHORITY_ARG: ArgConstant<'static> = ArgConstant {
     help: "Authorized withdrawer [default: cli config keypair]",
 };
 
-pub const CUSTODIAN_ARG: ArgConstant<'static> = ArgConstant {
-    name: "custodian",
-    long: "custodian",
-    help: "Authority to override account lockup",
-};
-
 fn stake_authority_arg<'a, 'b>() -> Arg<'a, 'b> {
     Arg::with_name(STAKE_AUTHORITY_ARG.name)
         .long(STAKE_AUTHORITY_ARG.long)
@@ -88,15 +81,6 @@ fn withdraw_authority_arg<'a, 'b>() -> Arg<'a, 'b> {
         .help(WITHDRAW_AUTHORITY_ARG.help)
 }
 
-fn custodian_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(CUSTODIAN_ARG.name)
-        .long(CUSTODIAN_ARG.long)
-        .takes_value(true)
-        .value_name("KEYPAIR")
-        .validator(is_valid_signer)
-        .help(CUSTODIAN_ARG.help)
-}
-
 pub trait StakeSubCommands {
     fn stake_subcommands(self) -> Self;
 }
@@ -238,7 +222,6 @@ impl StakeSubCommands for App<'_, '_> {
                 .offline_args()
                 .nonce_args(false)
                 .arg(fee_payer_arg())
-                .arg(custodian_arg())
         )
         .subcommand(
             SubCommand::with_name("deactivate-stake")
@@ -347,7 +330,14 @@ impl StakeSubCommands for App<'_, '_> {
                 .offline_args()
                 .nonce_args(false)
                 .arg(fee_payer_arg())
-                .arg(custodian_arg())
+                .arg(
+                    Arg::with_name("custodian")
+                        .long("custodian")
+                        .takes_value(true)
+                        .value_name("KEYPAIR")
+                        .validator(is_valid_signer)
+                        .help("Authority to override account lockup")
+                )
         )
         .subcommand(
             SubCommand::with_name("stake-set-lockup")
@@ -412,7 +402,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .long("lamports")
                         .takes_value(false)
                         .help("Display balance in lamports instead of SOL")
-                ),
+                )
         )
         .subcommand(
             SubCommand::with_name("stake-history")
@@ -570,15 +560,11 @@ pub fn parse_stake_authorize(
     let (nonce_authority, nonce_authority_pubkey) =
         signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
     let (fee_payer, fee_payer_pubkey) = signer_of(matches, FEE_PAYER_ARG.name, wallet_manager)?;
-    let (custodian, custodian_pubkey) = signer_of(matches, "custodian", wallet_manager)?;
 
     bulk_signers.push(fee_payer);
     if nonce_account.is_some() {
         bulk_signers.push(nonce_authority);
     }
-    if custodian.is_some() {
-        bulk_signers.push(custodian);
-    }
     let signer_info =
         default_signer.generate_unique_signers(bulk_signers, matches, wallet_manager)?;
 
@@ -604,7 +590,6 @@ pub fn parse_stake_authorize(
             nonce_account,
             nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
             fee_payer: signer_info.index_of(fee_payer_pubkey).unwrap(),
-            custodian: custodian_pubkey.and_then(|_| signer_info.index_of(custodian_pubkey)),
         },
         signers: signer_info.signers,
     })
@@ -973,7 +958,11 @@ pub fn process_create_stake_account(
         return_signers(&tx, &config.output_format)
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<SystemError>(result, &config)
     }
 }
@@ -984,7 +973,6 @@ pub fn process_stake_authorize(
     config: &CliConfig,
     stake_account_pubkey: &Pubkey,
     new_authorizations: &[(StakeAuthorize, Pubkey, SignerIndex)],
-    custodian: Option<SignerIndex>,
     sign_only: bool,
     blockhash_query: &BlockhashQuery,
     nonce_account: Option<Pubkey>,
@@ -992,7 +980,6 @@ pub fn process_stake_authorize(
     fee_payer: SignerIndex,
 ) -> ProcessResult {
     let mut ixs = Vec::new();
-    let custodian = custodian.map(|index| config.signers[index]);
     for (stake_authorize, authorized_pubkey, authority) in new_authorizations.iter() {
         check_unique_pubkeys(
             (stake_account_pubkey, "stake_account_pubkey".to_string()),
@@ -1004,7 +991,6 @@ pub fn process_stake_authorize(
             &authority.pubkey(),  // currently authorized
             authorized_pubkey,    // new stake signer
             *stake_authorize,     // stake or withdraw
-            custodian.map(|signer| signer.pubkey()).as_ref(),
         ));
     }
 
@@ -1046,7 +1032,11 @@ pub fn process_stake_authorize(
             &tx.message,
             config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -1105,7 +1095,11 @@ pub fn process_deactivate_stake_account(
             &tx.message,
             config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -1173,7 +1167,11 @@ pub fn process_withdraw_stake(
             &tx.message,
             config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<SystemError>(result, &config)
     }
 }
@@ -1312,7 +1310,11 @@ pub fn process_split_stake(
             &tx.message,
             config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -1476,7 +1478,11 @@ pub fn process_stake_set_lockup(
             &tx.message,
             config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -1495,7 +1501,6 @@ pub fn build_stake_state(
     use_lamports_unit: bool,
     stake_history: &StakeHistory,
     clock: &Clock,
-    stake_program_v2_enabled: bool,
 ) -> CliStakeState {
     match stake_state {
         StakeState::Stake(
@@ -1507,12 +1512,9 @@ pub fn build_stake_state(
             stake,
         ) => {
             let current_epoch = clock.epoch;
-            let (active_stake, activating_stake, deactivating_stake) =
-                stake.delegation.stake_activating_and_deactivating(
-                    current_epoch,
-                    Some(stake_history),
-                    stake_program_v2_enabled,
-                );
+            let (active_stake, activating_stake, deactivating_stake) = stake
+                .delegation
+                .stake_activating_and_deactivating(current_epoch, Some(stake_history));
             let lockup = if lockup.is_in_force(clock, None) {
                 Some(lockup.into())
             } else {
@@ -1521,7 +1523,6 @@ pub fn build_stake_state(
             CliStakeState {
                 stake_type: CliStakeType::Stake,
                 account_balance,
-                credits_observed: Some(stake.credits_observed),
                 delegated_stake: Some(stake.delegation.stake),
                 delegated_vote_account_address: if stake.delegation.voter_pubkey
                     != Pubkey::default()
@@ -1573,7 +1574,6 @@ pub fn build_stake_state(
             CliStakeState {
                 stake_type: CliStakeType::Initialized,
                 account_balance,
-                credits_observed: Some(0),
                 authorized: Some(authorized.into()),
                 lockup,
                 use_lamports_unit,
@@ -1640,37 +1640,29 @@ pub(crate) fn fetch_epoch_rewards(
         let previous_epoch_rewards = first_confirmed_block.rewards;
 
         if let Some((effective_slot, epoch_end_time, epoch_rewards)) = epoch_info {
-            let wallclock_epoch_duration = if epoch_end_time > epoch_start_time {
-                Some(
-                    { Local.timestamp(epoch_end_time, 0) - Local.timestamp(epoch_start_time, 0) }
-                        .to_std()?
-                        .as_secs_f64(),
-                )
-            } else {
-                None
-            };
+            let wallclock_epoch_duration =
+                { Local.timestamp(epoch_end_time, 0) - Local.timestamp(epoch_start_time, 0) }
+                    .to_std()?
+                    .as_secs_f64();
+
+            let wallclock_epochs_per_year =
+                (SECONDS_PER_DAY * 356) as f64 / wallclock_epoch_duration;
 
             if let Some(reward) = epoch_rewards
                 .into_iter()
                 .find(|reward| reward.pubkey == address.to_string())
             {
                 if reward.post_balance > reward.lamports.try_into().unwrap_or(0) {
-                    let rate_change = reward.lamports.abs() as f64
+                    let balance_increase_percent = reward.lamports.abs() as f64
                         / (reward.post_balance as f64 - reward.lamports as f64);
 
-                    let apr = wallclock_epoch_duration.map(|wallclock_epoch_duration| {
-                        let wallclock_epochs_per_year =
-                            (SECONDS_PER_DAY * 356) as f64 / wallclock_epoch_duration;
-                        rate_change * wallclock_epochs_per_year
-                    });
-
                     all_epoch_rewards.push(CliEpochReward {
                         epoch,
                         effective_slot,
                         amount: reward.lamports.abs() as u64,
                         post_balance: reward.post_balance,
-                        percent_change: rate_change * 100.0,
-                        apr: apr.map(|r| r * 100.0),
+                        percent_change: balance_increase_percent,
+                        apr: balance_increase_percent * wallclock_epochs_per_year,
                     });
                 }
             }
@@ -1718,17 +1710,15 @@ pub fn process_show_stake_account(
                 use_lamports_unit,
                 &stake_history,
                 &clock,
-                is_stake_program_v2_enabled(rpc_client)?, // At v1.6, this check can be removed and simply passed as `true`
             );
 
             if state.stake_type == CliStakeType::Stake {
                 if let Some(activation_epoch) = state.activation_epoch {
-                    let rewards =
-                        fetch_epoch_rewards(rpc_client, stake_account_address, activation_epoch);
-                    match rewards {
-                        Ok(rewards) => state.epoch_rewards = Some(rewards),
-                        Err(error) => eprintln!("Failed to fetch epoch rewards: {:?}", error),
-                    };
+                    state.epoch_rewards = Some(fetch_epoch_rewards(
+                        rpc_client,
+                        stake_account_address,
+                        activation_epoch,
+                    )?);
                 }
             }
             Ok(config.output_format.formatted_string(&state))
@@ -1785,15 +1775,23 @@ pub fn process_delegate_stake(
     if !sign_only {
         // Sanity check the vote account to ensure it is attached to a validator that has recently
         // voted at the tip of the ledger
-        let vote_account_data = rpc_client
-            .get_account(vote_account_pubkey)
-            .map_err(|err| {
+        let vote_account = rpc_client
+            .get_account_with_commitment(vote_account_pubkey, config.commitment)
+            .map_err(|_| {
                 CliError::RpcRequestError(format!(
-                    "Vote account not found: {}. error: {}",
-                    vote_account_pubkey, err,
+                    "Vote account not found: {}",
+                    vote_account_pubkey
                 ))
-            })?
-            .data;
+            })?;
+        let vote_account_data = if let Some(account) = vote_account.value {
+            account.data
+        } else {
+            return Err(CliError::RpcRequestError(format!(
+                "Vote account not found: {}",
+                vote_account_pubkey
+            ))
+            .into());
+        };
 
         let vote_state = VoteState::deserialize(&vote_account_data).map_err(|_| {
             CliError::RpcRequestError(
@@ -1873,20 +1871,15 @@ pub fn process_delegate_stake(
             &tx.message,
             config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
 
-pub fn is_stake_program_v2_enabled(
-    rpc_client: &RpcClient,
-) -> Result<bool, Box<dyn std::error::Error>> {
-    let feature_account = rpc_client.get_account(&feature_set::stake_program_v2::id())?;
-    Ok(feature::from_account(&feature_account)
-        .and_then(|feature| feature.activated_at)
-        .is_some())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1956,7 +1949,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into(),],
             },
@@ -1991,7 +1983,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2030,7 +2021,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2058,7 +2048,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into(),],
             },
@@ -2083,7 +2072,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2114,7 +2102,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2146,7 +2133,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into(),],
             },
@@ -2175,7 +2161,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2210,7 +2195,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -2247,7 +2231,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 1,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2294,7 +2277,6 @@ mod tests {
                     nonce_account: Some(nonce_account),
                     nonce_authority: 2,
                     fee_payer: 1,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2327,7 +2309,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -2365,7 +2346,6 @@ mod tests {
                     nonce_account: Some(nonce_account_pubkey),
                     nonce_authority: 1,
                     fee_payer: 0,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2399,7 +2379,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 1,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -2437,7 +2416,6 @@ mod tests {
                     nonce_account: None,
                     nonce_authority: 0,
                     fee_payer: 1,
-                    custodian: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),

cli/src/test_utils.rs

@@ -5,7 +5,7 @@ use std::{thread::sleep, time::Duration};
 pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
     (0..5).for_each(|tries| {
         let balance = client
-            .get_balance_with_commitment(pubkey, CommitmentConfig::processed())
+            .get_balance_with_commitment(pubkey, CommitmentConfig::recent())
             .unwrap()
             .value;
         if balance == expected_balance {
@@ -20,7 +20,7 @@ pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &
 
 pub fn check_ready(rpc_client: &RpcClient) {
     while rpc_client
-        .get_slot_with_commitment(CommitmentConfig::processed())
+        .get_slot_with_commitment(CommitmentConfig::recent())
         .unwrap()
         < 5
     {

cli/src/validator_info.rs

@@ -20,6 +20,7 @@ use solana_config_program::{config_instruction, get_config_data, ConfigKeys, Con
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     account::Account,
+    commitment_config::CommitmentConfig,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
@@ -287,7 +288,9 @@ pub fn process_set_validator_info(
     };
 
     // Check existence of validator-info account
-    let balance = rpc_client.get_balance(&info_pubkey).unwrap_or(0);
+    let balance = rpc_client
+        .poll_get_balance_with_commitment(&info_pubkey, CommitmentConfig::default())
+        .unwrap_or(0);
 
     let lamports =
         rpc_client.get_minimum_balance_for_rent_exemption(ValidatorInfo::max_space() as usize)?;

cli/src/vote.rs

@@ -8,6 +8,7 @@ use crate::{
 };
 use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{
+    commitment::commitment_arg,
     input_parsers::*,
     input_validators::*,
     keypair::{DefaultSigner, SignerIndex},
@@ -207,7 +208,8 @@ impl VoteSubCommands for App<'_, '_> {
                         .long("lamports")
                         .takes_value(false)
                         .help("Display balance in lamports instead of SOL"),
-                ),
+                )
+                .arg(commitment_arg()),
         )
         .subcommand(
             SubCommand::with_name("withdraw-from-vote-account")
@@ -492,7 +494,9 @@ pub fn process_create_vote_account(
         }
     }
 
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
 
     let (message, _) = resolve_spend_tx_and_check_account_balance(
         rpc_client,
@@ -505,7 +509,11 @@ pub fn process_create_vote_account(
     )?;
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<SystemError>(result, &config)
 }
 
@@ -528,7 +536,9 @@ pub fn process_vote_authorize(
         (&authorized.pubkey(), "authorized_account".to_string()),
         (new_authorized_pubkey, "new_authorized_pubkey".to_string()),
     )?;
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let ixs = vec![vote_instruction::authorize(
         vote_account_pubkey,   // vote account to update
         &authorized.pubkey(),  // current authorized
@@ -546,7 +556,11 @@ pub fn process_vote_authorize(
         &tx.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 
@@ -564,7 +578,9 @@ pub fn process_vote_update_validator(
         (vote_account_pubkey, "vote_account_pubkey".to_string()),
         (&new_identity_pubkey, "new_identity_account".to_string()),
     )?;
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let ixs = vec![vote_instruction::update_validator_identity(
         vote_account_pubkey,
         &authorized_withdrawer.pubkey(),
@@ -581,7 +597,11 @@ pub fn process_vote_update_validator(
         &tx.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 
@@ -593,7 +613,9 @@ pub fn process_vote_update_commission(
     withdraw_authority: SignerIndex,
 ) -> ProcessResult {
     let authorized_withdrawer = config.signers[withdraw_authority];
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let ixs = vec![vote_instruction::update_commission(
         vote_account_pubkey,
         &authorized_withdrawer.pubkey(),
@@ -610,7 +632,11 @@ pub fn process_vote_update_commission(
         &tx.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 
@@ -659,27 +685,22 @@ pub fn process_show_vote_account(
         for vote in &vote_state.votes {
             votes.push(vote.into());
         }
-        for (epoch, credits, prev_credits) in vote_state.epoch_credits().iter().copied() {
+        for (epoch, credits, prev_credits) in vote_state.epoch_credits() {
             let credits_earned = credits - prev_credits;
-            let slots_in_epoch = epoch_schedule.get_slots_in_epoch(epoch);
+            let slots_in_epoch = epoch_schedule.get_slots_in_epoch(*epoch);
             epoch_voting_history.push(CliEpochVotingHistory {
-                epoch,
+                epoch: *epoch,
                 slots_in_epoch,
                 credits_earned,
-                credits,
-                prev_credits,
             });
         }
     }
 
-    let epoch_rewards = match crate::stake::fetch_epoch_rewards(rpc_client, vote_account_address, 1)
-    {
-        Ok(rewards) => Some(rewards),
-        Err(error) => {
-            eprintln!("Failed to fetch epoch rewards: {:?}", error);
-            None
-        }
-    };
+    let epoch_rewards = Some(crate::stake::fetch_epoch_rewards(
+        rpc_client,
+        vote_account_address,
+        1,
+    )?);
 
     let vote_account_data = CliVoteAccount {
         account_balance: vote_account.lamports,
@@ -707,10 +728,14 @@ pub fn process_withdraw_from_vote_account(
     withdraw_amount: SpendAmount,
     destination_account_pubkey: &Pubkey,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let withdraw_authority = config.signers[withdraw_authority];
 
-    let current_balance = rpc_client.get_balance(&vote_account_pubkey)?;
+    let current_balance = rpc_client
+        .get_balance_with_commitment(&vote_account_pubkey, config.commitment)?
+        .value;
     let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(VoteState::size_of())?;
 
     let lamports = match withdraw_amount {
@@ -743,7 +768,11 @@ pub fn process_withdraw_from_vote_account(
         &transaction.message,
         config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&transaction);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &transaction,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 

cli/tests/deploy.rs

@@ -0,0 +1,158 @@
+use serde_json::Value;
+use solana_cli::cli::{process_command, CliCommand, CliConfig};
+use solana_client::rpc_client::RpcClient;
+use solana_core::test_validator::TestValidator;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
+    bpf_loader,
+    commitment_config::CommitmentConfig,
+    pubkey::Pubkey,
+    signature::{Keypair, Signer},
+};
+use std::{
+    fs::{remove_dir_all, File},
+    io::Read,
+    path::PathBuf,
+    str::FromStr,
+    sync::mpsc::channel,
+};
+
+#[test]
+fn test_cli_deploy_program() {
+    solana_logger::setup();
+
+    let mut pathbuf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    pathbuf.push("tests");
+    pathbuf.push("fixtures");
+    pathbuf.push("noop");
+    pathbuf.set_extension("so");
+
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
+
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
+
+    let mut file = File::open(pathbuf.to_str().unwrap()).unwrap();
+    let mut program_data = Vec::new();
+    file.read_to_end(&mut program_data).unwrap();
+    let minimum_balance_for_rent_exemption = rpc_client
+        .get_minimum_balance_for_rent_exemption(program_data.len())
+        .unwrap();
+
+    let mut config = CliConfig::recent_for_tests();
+    let keypair = Keypair::new();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
+    config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
+        pubkey: None,
+        lamports: 4 * minimum_balance_for_rent_exemption, // min balance for rent exemption for three programs + leftover for tx processing
+    };
+    config.signers = vec![&keypair];
+    process_command(&config).unwrap();
+
+    config.command = CliCommand::Deploy {
+        program_location: pathbuf.to_str().unwrap().to_string(),
+        address: None,
+        use_deprecated_loader: false,
+        allow_excessive_balance: false,
+    };
+
+    let response = process_command(&config);
+    let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
+    let program_id_str = json
+        .as_object()
+        .unwrap()
+        .get("programId")
+        .unwrap()
+        .as_str()
+        .unwrap();
+    let program_id = Pubkey::from_str(&program_id_str).unwrap();
+    let account0 = rpc_client
+        .get_account_with_commitment(&program_id, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
+    assert_eq!(account0.lamports, minimum_balance_for_rent_exemption);
+    assert_eq!(account0.owner, bpf_loader::id());
+    assert_eq!(account0.executable, true);
+
+    let mut file = File::open(pathbuf.to_str().unwrap().to_string()).unwrap();
+    let mut elf = Vec::new();
+    file.read_to_end(&mut elf).unwrap();
+
+    assert_eq!(account0.data, elf);
+
+    // Test custom address
+    let custom_address_keypair = Keypair::new();
+    config.signers = vec![&keypair, &custom_address_keypair];
+    config.command = CliCommand::Deploy {
+        program_location: pathbuf.to_str().unwrap().to_string(),
+        address: Some(1),
+        use_deprecated_loader: false,
+        allow_excessive_balance: false,
+    };
+    process_command(&config).unwrap();
+    let account1 = rpc_client
+        .get_account_with_commitment(&custom_address_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
+    assert_eq!(account1.lamports, minimum_balance_for_rent_exemption);
+    assert_eq!(account1.owner, bpf_loader::id());
+    assert_eq!(account1.executable, true);
+    assert_eq!(account0.data, account1.data);
+
+    // Attempt to redeploy to the same address
+    process_command(&config).unwrap_err();
+
+    // Attempt to deploy to account with excess balance
+    let custom_address_keypair = Keypair::new();
+    config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
+        pubkey: None,
+        lamports: 2 * minimum_balance_for_rent_exemption, // Anything over minimum_balance_for_rent_exemption should trigger err
+    };
+    config.signers = vec![&custom_address_keypair];
+    process_command(&config).unwrap();
+
+    config.signers = vec![&keypair, &custom_address_keypair];
+    config.command = CliCommand::Deploy {
+        program_location: pathbuf.to_str().unwrap().to_string(),
+        address: Some(1),
+        use_deprecated_loader: false,
+        allow_excessive_balance: false,
+    };
+    process_command(&config).unwrap_err();
+
+    // Use forcing parameter to deploy to account with excess balance
+    config.command = CliCommand::Deploy {
+        program_location: pathbuf.to_str().unwrap().to_string(),
+        address: Some(1),
+        use_deprecated_loader: false,
+        allow_excessive_balance: true,
+    };
+    process_command(&config).unwrap();
+    let account2 = rpc_client
+        .get_account_with_commitment(&custom_address_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
+    assert_eq!(account2.lamports, 2 * minimum_balance_for_rent_exemption);
+    assert_eq!(account2.owner, bpf_loader::id());
+    assert_eq!(account2.executable, true);
+    assert_eq!(account0.data, account2.data);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
+}

cli/tests/nonce.rs

@@ -9,7 +9,8 @@ use solana_client::{
     nonce_utils,
     rpc_client::RpcClient,
 };
-use solana_core::test_validator::TestValidator;
+use solana_core::contact_info::ContactInfo;
+use solana_core::test_validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
     commitment_config::CommitmentConfig,
@@ -18,51 +19,69 @@ use solana_sdk::{
     signature::{keypair_from_seed, Keypair, Signer},
     system_program,
 };
+use std::{fs::remove_dir_all, sync::mpsc::channel};
 
 #[test]
 fn test_nonce() {
-    let mint_keypair = Keypair::new();
-    full_battery_tests(
-        TestValidator::with_no_fees(mint_keypair.pubkey()),
-        mint_keypair,
-        None,
-        false,
-    );
+    solana_logger::setup();
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+
+    full_battery_tests(leader_data, alice, None, false);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_nonce_with_seed() {
-    let mint_keypair = Keypair::new();
-    full_battery_tests(
-        TestValidator::with_no_fees(mint_keypair.pubkey()),
-        mint_keypair,
-        Some(String::from("seed")),
-        false,
-    );
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+
+    full_battery_tests(leader_data, alice, Some(String::from("seed")), false);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_nonce_with_authority() {
-    let mint_keypair = Keypair::new();
-    full_battery_tests(
-        TestValidator::with_no_fees(mint_keypair.pubkey()),
-        mint_keypair,
-        None,
-        true,
-    );
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+
+    full_battery_tests(leader_data, alice, None, true);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 fn full_battery_tests(
-    test_validator: TestValidator,
-    mint_keypair: Keypair,
+    leader_data: ContactInfo,
+    alice: Keypair,
     seed: Option<String>,
     use_nonce_authority: bool,
 ) {
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
-    let json_rpc_url = test_validator.rpc_url();
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
+    let json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
     let mut config_payer = CliConfig::recent_for_tests();
     config_payer.json_rpc_url = json_rpc_url.clone();
@@ -212,11 +231,21 @@ fn full_battery_tests(
 
 #[test]
 fn test_create_account_with_seed() {
-    solana_logger::setup();
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
+    let TestValidator {
+        server,
+        leader_data,
+        alice: mint_keypair,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: 1,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
 
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let (sender, receiver) = channel();
+    run_local_faucet(mint_keypair, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
     let offline_nonce_authority_signer = keypair_from_seed(&[1u8; 32]).unwrap();
     let online_nonce_creator_signer = keypair_from_seed(&[2u8; 32]).unwrap();
@@ -224,8 +253,7 @@ fn test_create_account_with_seed() {
     let config = CliConfig::recent_for_tests();
 
     // Setup accounts
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     request_and_confirm_airdrop(
         &rpc_client,
         &faucet_addr,
@@ -257,7 +285,8 @@ fn test_create_account_with_seed() {
     check_recent_balance(0, &rpc_client, &nonce_address);
 
     let mut creator_config = CliConfig::recent_for_tests();
-    creator_config.json_rpc_url = test_validator.rpc_url();
+    creator_config.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     creator_config.signers = vec![&online_nonce_creator_signer];
     creator_config.command = CliCommand::CreateNonceAccount {
         nonce_account: 0,
@@ -275,7 +304,7 @@ fn test_create_account_with_seed() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_address,
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -307,7 +336,8 @@ fn test_create_account_with_seed() {
 
     // And submit it
     let mut submit_config = CliConfig::recent_for_tests();
-    submit_config.json_rpc_url = test_validator.rpc_url();
+    submit_config.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     submit_config.signers = vec![&authority_presigner];
     submit_config.command = CliCommand::Transfer {
         amount: SpendAmount::Some(10),
@@ -328,4 +358,7 @@ fn test_create_account_with_seed() {
     check_recent_balance(31, &rpc_client, &offline_nonce_authority_signer.pubkey());
     check_recent_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
     check_recent_balance(10, &rpc_client, &to_address);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }

cli/tests/request_airdrop.rs

@@ -2,20 +2,24 @@ use solana_cli::cli::{process_command, CliCommand, CliConfig};
 use solana_client::rpc_client::RpcClient;
 use solana_core::test_validator::TestValidator;
 use solana_faucet::faucet::run_local_faucet;
-use solana_sdk::{
-    commitment_config::CommitmentConfig,
-    signature::{Keypair, Signer},
-};
+use solana_sdk::{commitment_config::CommitmentConfig, signature::Keypair};
+use std::{fs::remove_dir_all, sync::mpsc::channel};
 
 #[test]
 fn test_cli_request_airdrop() {
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
     let mut bob_config = CliConfig::recent_for_tests();
-    bob_config.json_rpc_url = test_validator.rpc_url();
+    bob_config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     bob_config.command = CliCommand::Airdrop {
         faucet_host: None,
         faucet_port: faucet_addr.port(),
@@ -28,11 +32,14 @@ fn test_cli_request_airdrop() {
     let sig_response = process_command(&bob_config);
     sig_response.unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let balance = rpc_client
-        .get_balance(&bob_config.signers[0].pubkey())
-        .unwrap();
+        .get_balance_with_commitment(&bob_config.signers[0].pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value;
     assert_eq!(balance, 50);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }

cli/tests/stake.rs

@@ -9,7 +9,7 @@ use solana_client::{
     nonce_utils,
     rpc_client::RpcClient,
 };
-use solana_core::test_validator::TestValidator;
+use solana_core::test_validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
     account_utils::StateMut,
@@ -22,19 +22,26 @@ use solana_stake_program::{
     stake_instruction::LockupArgs,
     stake_state::{Lockup, StakeAuthorize, StakeState},
 };
+use std::{fs::remove_dir_all, sync::mpsc::channel};
 
 #[test]
 fn test_stake_delegation_force() {
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     request_and_confirm_airdrop(
@@ -106,22 +113,33 @@ fn test_stake_delegation_force() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_seed_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        vote_pubkey,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let validator_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
     let mut config_validator = CliConfig::recent_for_tests();
-    config_validator.json_rpc_url = test_validator.rpc_url();
+    config_validator.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_validator.signers = vec![&validator_keypair];
 
     request_and_confirm_airdrop(
@@ -162,7 +180,7 @@ fn test_seed_stake_delegation_and_deactivation() {
     // Delegate stake
     config_validator.command = CliCommand::DelegateStake {
         stake_account_pubkey: stake_address,
-        vote_account_pubkey: test_validator.vote_account_address(),
+        vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
         force: true,
         sign_only: false,
@@ -184,22 +202,33 @@ fn test_seed_stake_delegation_and_deactivation() {
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        vote_pubkey,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let validator_keypair = Keypair::new();
 
     let mut config_validator = CliConfig::recent_for_tests();
-    config_validator.json_rpc_url = test_validator.rpc_url();
+    config_validator.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_validator.signers = vec![&validator_keypair];
 
     let stake_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
@@ -236,7 +265,7 @@ fn test_stake_delegation_and_deactivation() {
     config_validator.signers.pop();
     config_validator.command = CliCommand::DelegateStake {
         stake_account_pubkey: stake_keypair.pubkey(),
-        vote_account_pubkey: test_validator.vote_account_address(),
+        vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
         force: true,
         sign_only: false,
@@ -258,26 +287,38 @@ fn test_stake_delegation_and_deactivation() {
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_offline_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        vote_pubkey,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let mut config_validator = CliConfig::recent_for_tests();
-    config_validator.json_rpc_url = test_validator.rpc_url();
+    config_validator.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     let validator_keypair = Keypair::new();
     config_validator.signers = vec![&validator_keypair];
 
     let mut config_payer = CliConfig::recent_for_tests();
-    config_payer.json_rpc_url = test_validator.rpc_url();
+    config_payer.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
     let stake_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
 
@@ -331,7 +372,7 @@ fn test_offline_stake_delegation_and_deactivation() {
     let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
     config_offline.command = CliCommand::DelegateStake {
         stake_account_pubkey: stake_keypair.pubkey(),
-        vote_account_pubkey: test_validator.vote_account_address(),
+        vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
         force: true,
         sign_only: true,
@@ -350,7 +391,7 @@ fn test_offline_stake_delegation_and_deactivation() {
     config_payer.signers = vec![&offline_presigner];
     config_payer.command = CliCommand::DelegateStake {
         stake_account_pubkey: stake_keypair.pubkey(),
-        vote_account_pubkey: test_validator.vote_account_address(),
+        vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
         force: true,
         sign_only: false,
@@ -389,23 +430,33 @@ fn test_offline_stake_delegation_and_deactivation() {
         fee_payer: 0,
     };
     process_command(&config_payer).unwrap();
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_nonced_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        vote_pubkey,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let config_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
     let mut config = CliConfig::recent_for_tests();
     config.signers = vec![&config_keypair];
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
     let minimum_nonce_balance = rpc_client
         .get_minimum_balance_for_rent_exemption(NonceState::size())
@@ -454,7 +505,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -464,7 +515,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
     config.signers = vec![&config_keypair];
     config.command = CliCommand::DelegateStake {
         stake_account_pubkey: stake_keypair.pubkey(),
-        vote_account_pubkey: test_validator.vote_account_address(),
+        vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
         force: true,
         sign_only: false,
@@ -482,7 +533,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -502,22 +553,31 @@ fn test_nonced_stake_delegation_and_deactivation() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_stake_authorize() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     request_and_confirm_airdrop(
@@ -579,10 +639,13 @@ fn test_stake_authorize() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -607,10 +670,13 @@ fn test_stake_authorize() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let (current_staker, current_withdrawer) = match stake_state {
         StakeState::Initialized(meta) => (meta.authorized.staker, meta.authorized.withdrawer),
@@ -630,10 +696,13 @@ fn test_stake_authorize() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -644,7 +713,10 @@ fn test_stake_authorize() {
     // Offline assignment of new nonced stake authority
     let nonced_authority = Keypair::new();
     let nonced_authority_pubkey = nonced_authority.pubkey();
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
         new_authorizations: vec![(StakeAuthorize::Staker, nonced_authority_pubkey, 0)],
@@ -653,7 +725,6 @@ fn test_stake_authorize() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
     let sign_reply = process_command(&config_offline).unwrap();
@@ -669,10 +740,13 @@ fn test_stake_authorize() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -698,7 +772,7 @@ fn test_stake_authorize() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -716,7 +790,6 @@ fn test_stake_authorize() {
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     let sign_reply = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_reply);
@@ -736,10 +809,13 @@ fn test_stake_authorize() {
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -750,12 +826,15 @@ fn test_stake_authorize() {
     let new_nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
     .blockhash;
     assert_ne!(nonce_hash, new_nonce_hash);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
@@ -763,23 +842,34 @@ fn test_stake_authorize_with_fee_payer() {
     solana_logger::setup();
     const SIG_FEE: u64 = 42;
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), SIG_FEE);
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: SIG_FEE,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
     let default_pubkey = default_signer.pubkey();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     let payer_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
     let mut config_payer = CliConfig::recent_for_tests();
     config_payer.signers = vec![&payer_keypair];
-    config_payer.json_rpc_url = test_validator.rpc_url();
+    config_payer.json_rpc_url =
+        format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     let payer_pubkey = config_payer.signers[0].pubkey();
 
     let mut config_offline = CliConfig::recent_for_tests();
@@ -837,7 +927,6 @@ fn test_stake_authorize_with_fee_payer() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 1,
-        custodian: None,
     };
     process_command(&config).unwrap();
     // `config` balance has not changed, despite submitting the TX
@@ -847,7 +936,10 @@ fn test_stake_authorize_with_fee_payer() {
     check_recent_balance(100_000 - SIG_FEE - SIG_FEE, &rpc_client, &payer_pubkey);
 
     // Assign authority with offline fee payer
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
         new_authorizations: vec![(StakeAuthorize::Staker, payer_pubkey, 0)],
@@ -856,7 +948,6 @@ fn test_stake_authorize_with_fee_payer() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
     let sign_reply = process_command(&config_offline).unwrap();
@@ -872,7 +963,6 @@ fn test_stake_authorize_with_fee_payer() {
         nonce_account: None,
         nonce_authority: 0,
         fee_payer: 0,
-        custodian: None,
     };
     process_command(&config).unwrap();
     // `config`'s balance again has not changed
@@ -880,23 +970,36 @@ fn test_stake_authorize_with_fee_payer() {
     // `config_offline` however has paid 1 sig due to being both authority
     // and fee payer
     check_recent_balance(100_000 - SIG_FEE, &rpc_client, &offline_pubkey);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_stake_split() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: 1,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
     let offline_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     let mut config_offline = CliConfig::recent_for_tests();
@@ -968,7 +1071,7 @@ fn test_stake_split() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -1022,23 +1125,36 @@ fn test_stake_split() {
         &rpc_client,
         &split_account.pubkey(),
     );
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_stake_set_lockup() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: 1,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
     let offline_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     let mut config_offline = CliConfig::recent_for_tests();
@@ -1071,10 +1187,8 @@ fn test_stake_set_lockup() {
     let stake_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
     let stake_account_pubkey = stake_keypair.pubkey();
 
-    let lockup = Lockup {
-        custodian: config.signers[0].pubkey(),
-        ..Lockup::default()
-    };
+    let mut lockup = Lockup::default();
+    lockup.custodian = config.signers[0].pubkey();
 
     config.signers.push(&stake_keypair);
     config.command = CliCommand::CreateStakeAccount {
@@ -1116,7 +1230,11 @@ fn test_stake_set_lockup() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_lockup = match stake_state {
         StakeState::Initialized(meta) => meta.lockup,
@@ -1167,7 +1285,11 @@ fn test_stake_set_lockup() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_lockup = match stake_state {
         StakeState::Initialized(meta) => meta.lockup,
@@ -1218,7 +1340,7 @@ fn test_stake_set_lockup() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -1260,7 +1382,11 @@ fn test_stake_set_lockup() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_lockup = match stake_state {
         StakeState::Initialized(meta) => meta.lockup,
@@ -1272,22 +1398,32 @@ fn test_stake_set_lockup() {
     );
     assert_eq!(current_lockup.epoch, lockup.epoch.unwrap());
     assert_eq!(current_lockup.custodian, offline_pubkey);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_offline_nonced_create_stake_account_and_withdraw() {
     solana_logger::setup();
 
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
+
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
     let mut config = CliConfig::recent_for_tests();
     let default_signer = keypair_from_seed(&[1u8; 32]).unwrap();
     config.signers = vec![&default_signer];
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
     let mut config_offline = CliConfig::recent_for_tests();
     let offline_signer = keypair_from_seed(&[2u8; 32]).unwrap();
@@ -1331,7 +1467,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -1386,7 +1522,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -1434,7 +1570,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -1483,4 +1619,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     let seed_address =
         Pubkey::create_with_seed(&stake_pubkey, seed, &solana_stake_program::id()).unwrap();
     check_recent_balance(50_000, &rpc_client, &seed_address);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }

cli/tests/transfer.rs

@@ -9,7 +9,7 @@ use solana_client::{
     nonce_utils,
     rpc_client::RpcClient,
 };
-use solana_core::test_validator::TestValidator;
+use solana_core::test_validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
     commitment_config::CommitmentConfig,
@@ -17,22 +17,33 @@ use solana_sdk::{
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, NullSigner, Signer},
 };
+use std::{fs::remove_dir_all, sync::mpsc::channel};
 
 #[test]
 fn test_transfer() {
-    solana_logger::setup();
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice: mint_keypair,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: 1,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let (sender, receiver) = channel();
+    run_local_faucet(mint_keypair, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
+
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let default_signer = Keypair::new();
     let default_offline_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     let sender_pubkey = config.signers[0].pubkey();
@@ -89,7 +100,10 @@ fn test_transfer() {
     check_recent_balance(50, &rpc_client, &offline_pubkey);
 
     // Offline transfer
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
     offline.command = CliCommand::Transfer {
         amount: SpendAmount::Some(10),
         to: recipient_pubkey,
@@ -141,7 +155,7 @@ fn test_transfer() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -169,7 +183,7 @@ fn test_transfer() {
     let new_nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -190,7 +204,7 @@ fn test_transfer() {
     let nonce_hash = nonce_utils::get_account_with_commitment(
         &rpc_client,
         &nonce_account.pubkey(),
-        CommitmentConfig::processed(),
+        CommitmentConfig::recent(),
     )
     .and_then(|ref a| nonce_utils::data_from_account(a))
     .unwrap()
@@ -231,14 +245,28 @@ fn test_transfer() {
     process_command(&config).unwrap();
     check_recent_balance(28, &rpc_client, &offline_pubkey);
     check_recent_balance(40, &rpc_client, &recipient_pubkey);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_transfer_multisession_signing() {
-    solana_logger::setup();
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice: mint_keypair,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: 1,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
+
+    let (sender, receiver) = channel();
+    run_local_faucet(mint_keypair, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
     let to_pubkey = Pubkey::new(&[1u8; 32]);
     let offline_from_signer = keypair_from_seed(&[2u8; 32]).unwrap();
@@ -247,8 +275,7 @@ fn test_transfer_multisession_signing() {
     let config = CliConfig::recent_for_tests();
 
     // Setup accounts
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     request_and_confirm_airdrop(
         &rpc_client,
         &faucet_addr,
@@ -271,7 +298,10 @@ fn test_transfer_multisession_signing() {
 
     check_ready(&rpc_client);
 
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
 
     // Offline fee-payer signs first
     let mut fee_payer_config = CliConfig::recent_for_tests();
@@ -327,7 +357,7 @@ fn test_transfer_multisession_signing() {
 
     // Finally submit to the cluster
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&fee_payer_presigner, &from_presigner];
     config.command = CliCommand::Transfer {
         amount: SpendAmount::Some(42),
@@ -345,22 +375,35 @@ fn test_transfer_multisession_signing() {
     check_recent_balance(1, &rpc_client, &offline_from_signer.pubkey());
     check_recent_balance(1, &rpc_client, &offline_fee_payer_signer.pubkey());
     check_recent_balance(42, &rpc_client, &to_pubkey);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }
 
 #[test]
 fn test_transfer_all() {
-    solana_logger::setup();
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice: mint_keypair,
+        ledger_path,
+        ..
+    } = TestValidator::run_with_options(TestValidatorOptions {
+        fees: 1,
+        bootstrap_validator_lamports: 42_000,
+        ..TestValidatorOptions::default()
+    });
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let (sender, receiver) = channel();
+    run_local_faucet(mint_keypair, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
+
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let default_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     let sender_pubkey = config.signers[0].pubkey();
@@ -388,4 +431,7 @@ fn test_transfer_all() {
     process_command(&config).unwrap();
     check_recent_balance(0, &rpc_client, &sender_pubkey);
     check_recent_balance(49_999, &rpc_client, &recipient_pubkey);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }

cli/tests/vote.rs

@@ -15,19 +15,26 @@ use solana_sdk::{
     signature::{Keypair, Signer},
 };
 use solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersions};
+use std::{fs::remove_dir_all, sync::mpsc::channel};
 
 #[test]
 fn test_vote_authorize_and_withdraw() {
-    let mint_keypair = Keypair::new();
-    let test_validator = TestValidator::with_no_fees(mint_keypair.pubkey());
-    let faucet_addr = run_local_faucet(mint_keypair, None);
+    let TestValidator {
+        server,
+        leader_data,
+        alice,
+        ledger_path,
+        ..
+    } = TestValidator::run();
+    let (sender, receiver) = channel();
+    run_local_faucet(alice, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
 
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
     let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     request_and_confirm_airdrop(
@@ -53,7 +60,9 @@ fn test_vote_authorize_and_withdraw() {
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
-        .get_account(&vote_account_keypair.pubkey())
+        .get_account_with_commitment(&vote_account_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
         .unwrap();
     let vote_state: VoteStateVersions = vote_account.state().unwrap();
     let authorized_withdrawer = vote_state.convert_to_current().authorized_withdrawer;
@@ -91,7 +100,9 @@ fn test_vote_authorize_and_withdraw() {
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
-        .get_account(&vote_account_keypair.pubkey())
+        .get_account_with_commitment(&vote_account_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
         .unwrap();
     let vote_state: VoteStateVersions = vote_account.state().unwrap();
     let authorized_withdrawer = vote_state.convert_to_current().authorized_withdrawer;
@@ -119,4 +130,7 @@ fn test_vote_authorize_and_withdraw() {
         withdraw_authority: 1,
     };
     process_command(&config).unwrap();
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
 }

client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-client"
-version = "1.5.6"
+version = "1.4.6"
 description = "Solana Client"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -15,21 +15,20 @@ bs58 = "0.3.1"
 clap = "2.33.0"
 indicatif = "0.15.0"
 jsonrpc-core = "15.0.0"
-log = "0.4.11"
-net2 = "0.2.37"
+log = "0.4.8"
 rayon = "1.4.0"
 reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
 semver = "0.11.0"
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-transaction-status = { path = "../transaction-status", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
+solana-account-decoder = { path = "../account-decoder", version = "1.4.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-net-utils = { path = "../net-utils", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-transaction-status = { path = "../transaction-status", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
+solana-vote-program = { path = "../programs/vote", version = "1.4.6" }
 thiserror = "1.0"
 tungstenite = "0.10.1"
 url = "2.1.1"
@@ -38,7 +37,7 @@ url = "2.1.1"
 assert_matches = "1.3.0"
 jsonrpc-core = "15.0.0"
 jsonrpc-http-server = "15.0.0"
-solana-logger = { path = "../logger", version = "1.5.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

client/src/client_error.rs

@@ -5,8 +5,6 @@ use solana_sdk::{
 use std::io;
 use thiserror::Error;
 
-pub use reqwest; // export `reqwest` for clients
-
 #[derive(Error, Debug)]
 pub enum ClientErrorKind {
     #[error(transparent)]
@@ -35,16 +33,16 @@ impl From<TransportError> for ClientErrorKind {
     }
 }
 
-impl From<ClientErrorKind> for TransportError {
-    fn from(client_error_kind: ClientErrorKind) -> Self {
-        match client_error_kind {
-            ClientErrorKind::Io(err) => Self::IoError(err),
-            ClientErrorKind::TransactionError(err) => Self::TransactionError(err),
-            ClientErrorKind::Reqwest(err) => Self::Custom(format!("{:?}", err)),
-            ClientErrorKind::RpcError(err) => Self::Custom(format!("{:?}", err)),
-            ClientErrorKind::SerdeJson(err) => Self::Custom(format!("{:?}", err)),
-            ClientErrorKind::SigningError(err) => Self::Custom(format!("{:?}", err)),
-            ClientErrorKind::Custom(err) => Self::Custom(format!("{:?}", err)),
+impl Into<TransportError> for ClientErrorKind {
+    fn into(self) -> TransportError {
+        match self {
+            Self::Io(err) => TransportError::IoError(err),
+            Self::TransactionError(err) => TransportError::TransactionError(err),
+            Self::Reqwest(err) => TransportError::Custom(format!("{:?}", err)),
+            Self::RpcError(err) => TransportError::Custom(format!("{:?}", err)),
+            Self::SerdeJson(err) => TransportError::Custom(format!("{:?}", err)),
+            Self::SigningError(err) => TransportError::Custom(format!("{:?}", err)),
+            Self::Custom(err) => TransportError::Custom(format!("{:?}", err)),
         }
     }
 }
@@ -100,9 +98,9 @@ impl From<TransportError> for ClientError {
     }
 }
 
-impl From<ClientError> for TransportError {
-    fn from(client_error: ClientError) -> Self {
-        client_error.kind.into()
+impl Into<TransportError> for ClientError {
+    fn into(self) -> TransportError {
+        self.kind.into()
     }
 }
 

client/src/http_sender.rs

@@ -85,14 +85,6 @@ impl RpcSender for HttpSender {
                                             }
                                         }
                                     },
-                                    rpc_custom_error::JSON_RPC_SERVER_ERROR_NODE_UNHEALTHLY => {
-                                        match serde_json::from_value::<rpc_custom_error::NodeUnhealthyErrorData>(json["error"]["data"].clone()) {
-                                            Ok(rpc_custom_error::NodeUnhealthyErrorData {num_slots_behind}) => RpcResponseErrorData::NodeUnhealthy {num_slots_behind},
-                                            Err(_err) => {
-                                                RpcResponseErrorData::Empty
-                                            }
-                                        }
-                                    },
                                     _ => RpcResponseErrorData::Empty
                                 };
 

client/src/mock_sender.rs

@@ -12,7 +12,7 @@ use solana_sdk::{
     signature::Signature,
     transaction::{self, Transaction, TransactionError},
 };
-use solana_transaction_status::{TransactionConfirmationStatus, TransactionStatus};
+use solana_transaction_status::TransactionStatus;
 use solana_version::Version;
 use std::{collections::HashMap, sync::RwLock};
 
@@ -48,10 +48,6 @@ impl RpcSender for MockSender {
             return Ok(Value::Null);
         }
         let val = match request {
-            RpcRequest::GetAccountInfo => serde_json::to_value(Response {
-                context: RpcResponseContext { slot: 1 },
-                value: Value::Null,
-            })?,
             RpcRequest::GetBalance => serde_json::to_value(Response {
                 context: RpcResponseContext { slot: 1 },
                 value: Value::Number(Number::from(50)),
@@ -69,7 +65,6 @@ impl RpcSender for MockSender {
                 slots_in_epoch: 32,
                 absolute_slot: 34,
                 block_height: 34,
-                transaction_count: Some(123),
             })?,
             RpcRequest::GetFeeCalculatorForBlockhash => {
                 let value = if self.url == "blockhash_expired" {
@@ -106,7 +101,6 @@ impl RpcSender for MockSender {
                         slot: 1,
                         confirmations: None,
                         err,
-                        confirmation_status: Some(TransactionConfirmationStatus::Finalized),
                     })
                 };
                 let statuses: Vec<Option<TransactionStatus>> = params.as_array().unwrap()[0]

client/src/perf_utils.rs

@@ -33,7 +33,7 @@ pub fn sample_txs<T>(
     let mut now = Instant::now();
     let start_time = now;
     let initial_txs = client
-        .get_transaction_count_with_commitment(CommitmentConfig::processed())
+        .get_transaction_count_with_commitment(CommitmentConfig::recent())
         .expect("transaction count");
     let mut last_txs = initial_txs;
 
@@ -42,7 +42,7 @@ pub fn sample_txs<T>(
         let elapsed = now.elapsed();
         now = Instant::now();
         let mut txs;
-        match client.get_transaction_count_with_commitment(CommitmentConfig::processed()) {
+        match client.get_transaction_count_with_commitment(CommitmentConfig::recent()) {
             Err(e) => {
                 // ThinClient with multiple options should pick a better one now.
                 info!("Couldn't get transaction count {:?}", e);

client/src/pubsub_client.rs

@@ -1,7 +1,4 @@
-use crate::{
-    rpc_config::{RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter},
-    rpc_response::{Response as RpcResponse, RpcLogsResponse, RpcSignatureResult, SlotInfo},
-};
+use crate::rpc_response::{Response as RpcResponse, RpcSignatureResult, SlotInfo};
 use log::*;
 use serde::de::DeserializeOwned;
 use serde_json::{
@@ -23,6 +20,8 @@ use thiserror::Error;
 use tungstenite::{client::AutoStream, connect, Message, WebSocket};
 use url::{ParseError, Url};
 
+type PubsubSignatureResponse = PubsubClientSubscription<RpcResponse<RpcSignatureResult>>;
+
 #[derive(Debug, Error)]
 pub enum PubsubClientError {
     #[error("url parse error")]
@@ -34,8 +33,8 @@ pub enum PubsubClientError {
     #[error("json parse error")]
     JsonParseError(#[from] serde_json::error::Error),
 
-    #[error("unexpected message format: {0}")]
-    UnexpectedMessageError(String),
+    #[error("unexpected message format")]
+    UnexpectedMessageError,
 }
 
 pub struct PubsubClientSubscription<T>
@@ -90,11 +89,8 @@ where
                 return Ok(x);
             }
         }
-        // TODO: Add proper JSON RPC response/error handling...
-        Err(PubsubClientError::UnexpectedMessageError(format!(
-            "{:?}",
-            json_msg
-        )))
+
+        Err(PubsubClientError::UnexpectedMessageError)
     }
 
     pub fn send_unsubscribe(&self) -> Result<(), PubsubClientError> {
@@ -118,18 +114,14 @@ where
         let message_text = &message.into_text().unwrap();
         let json_msg: Map<String, Value> = serde_json::from_str(message_text)?;
 
-        if let Some(Object(params)) = json_msg.get("params") {
-            if let Some(result) = params.get("result") {
-                let x: T = serde_json::from_value::<T>(result.clone()).unwrap();
+        if let Some(Object(value_1)) = json_msg.get("params") {
+            if let Some(value_2) = value_1.get("result") {
+                let x: T = serde_json::from_value::<T>(value_2.clone()).unwrap();
                 return Ok(x);
             }
         }
 
-        // TODO: Add proper JSON RPC response/error handling...
-        Err(PubsubClientError::UnexpectedMessageError(format!(
-            "{:?}",
-            json_msg
-        )))
+        Err(PubsubClientError::UnexpectedMessageError)
     }
 
     pub fn shutdown(&mut self) -> std::thread::Result<()> {
@@ -146,79 +138,15 @@ where
     }
 }
 
-pub type LogsSubscription = (
-    PubsubClientSubscription<RpcResponse<RpcLogsResponse>>,
-    Receiver<RpcResponse<RpcLogsResponse>>,
-);
-pub type SlotsSubscription = (PubsubClientSubscription<SlotInfo>, Receiver<SlotInfo>);
-pub type SignatureSubscription = (
-    PubsubClientSubscription<RpcResponse<RpcSignatureResult>>,
-    Receiver<RpcResponse<RpcSignatureResult>>,
-);
+const SLOT_OPERATION: &str = "slot";
+const SIGNATURE_OPERATION: &str = "signature";
 
 pub struct PubsubClient {}
 
 impl PubsubClient {
-    pub fn logs_subscribe(
+    pub fn slot_subscribe(
         url: &str,
-        filter: RpcTransactionLogsFilter,
-        config: RpcTransactionLogsConfig,
-    ) -> Result<LogsSubscription, PubsubClientError> {
-        let url = Url::parse(url)?;
-        let (socket, _response) = connect(url)?;
-        let (sender, receiver) = channel();
-
-        let socket = Arc::new(RwLock::new(socket));
-        let socket_clone = socket.clone();
-        let exit = Arc::new(AtomicBool::new(false));
-        let exit_clone = exit.clone();
-
-        let subscription_id =
-            PubsubClientSubscription::<RpcResponse<RpcLogsResponse>>::send_subscribe(
-                &socket_clone,
-                json!({
-                    "jsonrpc":"2.0","id":1,"method":"logsSubscribe","params":[filter, config]
-                })
-                .to_string(),
-            )?;
-
-        let t_cleanup = std::thread::spawn(move || {
-            loop {
-                if exit_clone.load(Ordering::Relaxed) {
-                    break;
-                }
-
-                match PubsubClientSubscription::read_message(&socket_clone) {
-                    Ok(message) => match sender.send(message) {
-                        Ok(_) => (),
-                        Err(err) => {
-                            info!("receive error: {:?}", err);
-                            break;
-                        }
-                    },
-                    Err(err) => {
-                        info!("receive error: {:?}", err);
-                        break;
-                    }
-                }
-            }
-
-            info!("websocket - exited receive loop");
-        });
-
-        let result = PubsubClientSubscription {
-            message_type: PhantomData,
-            operation: "logs",
-            socket,
-            subscription_id,
-            t_cleanup: Some(t_cleanup),
-            exit,
-        };
-
-        Ok((result, receiver))
-    }
-
-    pub fn slot_subscribe(url: &str) -> Result<SlotsSubscription, PubsubClientError> {
+    ) -> Result<(PubsubClientSubscription<SlotInfo>, Receiver<SlotInfo>), PubsubClientError> {
         let url = Url::parse(url)?;
         let (socket, _response) = connect(url)?;
         let (sender, receiver) = channel::<SlotInfo>();
@@ -230,37 +158,41 @@ impl PubsubClient {
         let subscription_id = PubsubClientSubscription::<SlotInfo>::send_subscribe(
             &socket_clone,
             json!({
-                "jsonrpc":"2.0","id":1,"method":"slotSubscribe","params":[]
+                "jsonrpc":"2.0","id":1,"method":format!("{}Subscribe", SLOT_OPERATION),"params":[]
             })
             .to_string(),
-        )?;
+        )
+        .unwrap();
 
         let t_cleanup = std::thread::spawn(move || {
             loop {
                 if exit_clone.load(Ordering::Relaxed) {
                     break;
                 }
-                match PubsubClientSubscription::read_message(&socket_clone) {
-                    Ok(message) => match sender.send(message) {
+
+                let message: Result<SlotInfo, PubsubClientError> =
+                    PubsubClientSubscription::read_message(&socket_clone);
+
+                if let Ok(msg) = message {
+                    match sender.send(msg) {
                         Ok(_) => (),
                         Err(err) => {
                             info!("receive error: {:?}", err);
                             break;
                         }
-                    },
-                    Err(err) => {
-                        info!("receive error: {:?}", err);
-                        break;
                     }
+                } else {
+                    info!("receive error: {:?}", message);
+                    break;
                 }
             }
 
             info!("websocket - exited receive loop");
         });
 
-        let result = PubsubClientSubscription {
+        let result: PubsubClientSubscription<SlotInfo> = PubsubClientSubscription {
             message_type: PhantomData,
-            operation: "slot",
+            operation: SLOT_OPERATION,
             socket,
             subscription_id,
             t_cleanup: Some(t_cleanup),
@@ -273,11 +205,16 @@ impl PubsubClient {
     pub fn signature_subscribe(
         url: &str,
         signature: &Signature,
-        config: Option<RpcSignatureSubscribeConfig>,
-    ) -> Result<SignatureSubscription, PubsubClientError> {
+    ) -> Result<
+        (
+            PubsubSignatureResponse,
+            Receiver<RpcResponse<RpcSignatureResult>>,
+        ),
+        PubsubClientError,
+    > {
         let url = Url::parse(url)?;
         let (socket, _response) = connect(url)?;
-        let (sender, receiver) = channel();
+        let (sender, receiver) = channel::<RpcResponse<RpcSignatureResult>>();
 
         let socket = Arc::new(RwLock::new(socket));
         let socket_clone = socket.clone();
@@ -286,10 +223,10 @@ impl PubsubClient {
         let body = json!({
             "jsonrpc":"2.0",
             "id":1,
-            "method":"signatureSubscribe",
+            "method":format!("{}Subscribe", SIGNATURE_OPERATION),
             "params":[
                 signature.to_string(),
-                config
+                {"enableReceivedNotification": true }
             ]
         })
         .to_string();
@@ -297,7 +234,8 @@ impl PubsubClient {
             PubsubClientSubscription::<RpcResponse<RpcSignatureResult>>::send_subscribe(
                 &socket_clone,
                 body,
-            )?;
+            )
+            .unwrap();
 
         let t_cleanup = std::thread::spawn(move || {
             loop {
@@ -325,14 +263,15 @@ impl PubsubClient {
             info!("websocket - exited receive loop");
         });
 
-        let result = PubsubClientSubscription {
-            message_type: PhantomData,
-            operation: "signature",
-            socket,
-            subscription_id,
-            t_cleanup: Some(t_cleanup),
-            exit,
-        };
+        let result: PubsubClientSubscription<RpcResponse<RpcSignatureResult>> =
+            PubsubClientSubscription {
+                message_type: PhantomData,
+                operation: SIGNATURE_OPERATION,
+                socket,
+                subscription_id,
+                t_cleanup: Some(t_cleanup),
+                exit,
+            };
 
         Ok((result, receiver))
     }

client/src/rpc_client.rs

@@ -40,7 +40,6 @@ use solana_transaction_status::{
 };
 use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
 use std::{
-    cmp::min,
     net::SocketAddr,
     sync::RwLock,
     thread::sleep,
@@ -49,8 +48,7 @@ use std::{
 
 pub struct RpcClient {
     sender: Box<dyn RpcSender + Send + Sync + 'static>,
-    commitment_config: CommitmentConfig,
-    node_version: RwLock<Option<semver::Version>>,
+    default_cluster_transaction_encoding: RwLock<Option<UiTransactionEncoding>>,
 }
 
 fn serialize_encode_transaction(
@@ -74,52 +72,27 @@ fn serialize_encode_transaction(
 }
 
 impl RpcClient {
-    fn new_sender<T: RpcSender + Send + Sync + 'static>(
-        sender: T,
-        commitment_config: CommitmentConfig,
-    ) -> Self {
+    pub fn new_sender<T: RpcSender + Send + Sync + 'static>(sender: T) -> Self {
         Self {
             sender: Box::new(sender),
-            node_version: RwLock::new(None),
-            commitment_config,
+            default_cluster_transaction_encoding: RwLock::new(None),
         }
     }
 
     pub fn new(url: String) -> Self {
-        Self::new_with_commitment(url, CommitmentConfig::default())
-    }
-
-    pub fn new_with_commitment(url: String, commitment_config: CommitmentConfig) -> Self {
-        Self::new_sender(HttpSender::new(url), commitment_config)
+        Self::new_sender(HttpSender::new(url))
     }
 
     pub fn new_with_timeout(url: String, timeout: Duration) -> Self {
-        Self::new_sender(
-            HttpSender::new_with_timeout(url, timeout),
-            CommitmentConfig::default(),
-        )
-    }
-
-    pub fn new_with_timeout_and_commitment(
-        url: String,
-        timeout: Duration,
-        commitment_config: CommitmentConfig,
-    ) -> Self {
-        Self::new_sender(
-            HttpSender::new_with_timeout(url, timeout),
-            commitment_config,
-        )
+        Self::new_sender(HttpSender::new_with_timeout(url, timeout))
     }
 
     pub fn new_mock(url: String) -> Self {
-        Self::new_sender(MockSender::new(url), CommitmentConfig::default())
+        Self::new_sender(MockSender::new(url))
     }
 
     pub fn new_mock_with_mocks(url: String, mocks: Mocks) -> Self {
-        Self::new_sender(
-            MockSender::new_with_mocks(url, mocks),
-            CommitmentConfig::default(),
-        )
+        Self::new_sender(MockSender::new_with_mocks(url, mocks))
     }
 
     pub fn new_socket(addr: SocketAddr) -> Self {
@@ -131,51 +104,9 @@ impl RpcClient {
         Self::new_with_timeout(url, timeout)
     }
 
-    fn get_node_version(&self) -> Result<semver::Version, RpcError> {
-        let r_node_version = self.node_version.read().unwrap();
-        if let Some(version) = &*r_node_version {
-            Ok(version.clone())
-        } else {
-            drop(r_node_version);
-            let mut w_node_version = self.node_version.write().unwrap();
-            let node_version = self.get_version().map_err(|e| {
-                RpcError::RpcRequestError(format!("cluster version query failed: {}", e))
-            })?;
-            let node_version = semver::Version::parse(&node_version.solana_core).map_err(|e| {
-                RpcError::RpcRequestError(format!("failed to parse cluster version: {}", e))
-            })?;
-            *w_node_version = Some(node_version.clone());
-            Ok(node_version)
-        }
-    }
-
-    pub fn commitment(&self) -> CommitmentConfig {
-        self.commitment_config
-    }
-
-    fn use_deprecated_commitment(&self) -> Result<bool, RpcError> {
-        Ok(self.get_node_version()? < semver::Version::new(1, 5, 5))
-    }
-
-    fn maybe_map_commitment(
-        &self,
-        requested_commitment: CommitmentConfig,
-    ) -> Result<CommitmentConfig, RpcError> {
-        if matches!(
-            requested_commitment.commitment,
-            CommitmentLevel::Finalized | CommitmentLevel::Confirmed | CommitmentLevel::Processed
-        ) && self.use_deprecated_commitment()?
-        {
-            return Ok(CommitmentConfig::use_deprecated_commitment(
-                requested_commitment,
-            ));
-        }
-        Ok(requested_commitment)
-    }
-
     pub fn confirm_transaction(&self, signature: &Signature) -> ClientResult<bool> {
         Ok(self
-            .confirm_transaction_with_commitment(signature, self.commitment_config)?
+            .confirm_transaction_with_commitment(signature, CommitmentConfig::default())?
             .value)
     }
 
@@ -197,23 +128,31 @@ impl RpcClient {
     }
 
     pub fn send_transaction(&self, transaction: &Transaction) -> ClientResult<Signature> {
-        self.send_transaction_with_config(
-            transaction,
-            RpcSendTransactionConfig {
-                preflight_commitment: Some(
-                    self.maybe_map_commitment(self.commitment_config)?
-                        .commitment,
-                ),
-                ..RpcSendTransactionConfig::default()
-            },
-        )
+        self.send_transaction_with_config(transaction, RpcSendTransactionConfig::default())
     }
 
     fn default_cluster_transaction_encoding(&self) -> Result<UiTransactionEncoding, RpcError> {
-        if self.get_node_version()? < semver::Version::new(1, 3, 16) {
-            Ok(UiTransactionEncoding::Base58)
+        let default_cluster_transaction_encoding =
+            self.default_cluster_transaction_encoding.read().unwrap();
+        if let Some(encoding) = *default_cluster_transaction_encoding {
+            Ok(encoding)
         } else {
-            Ok(UiTransactionEncoding::Base64)
+            drop(default_cluster_transaction_encoding);
+            let cluster_version = self.get_version().map_err(|e| {
+                RpcError::RpcRequestError(format!("cluster version query failed: {}", e))
+            })?;
+            let cluster_version =
+                semver::Version::parse(&cluster_version.solana_core).map_err(|e| {
+                    RpcError::RpcRequestError(format!("failed to parse cluster version: {}", e))
+                })?;
+            // Prefer base64 since 1.3.16
+            let encoding = if cluster_version < semver::Version::new(1, 3, 16) {
+                UiTransactionEncoding::Base58
+            } else {
+                UiTransactionEncoding::Base64
+            };
+            *self.default_cluster_transaction_encoding.write().unwrap() = Some(encoding);
+            Ok(encoding)
         }
     }
 
@@ -227,13 +166,8 @@ impl RpcClient {
         } else {
             self.default_cluster_transaction_encoding()?
         };
-        let preflight_commitment = CommitmentConfig {
-            commitment: config.preflight_commitment.unwrap_or_default(),
-        };
-        let preflight_commitment = self.maybe_map_commitment(preflight_commitment)?;
         let config = RpcSendTransactionConfig {
             encoding: Some(encoding),
-            preflight_commitment: Some(preflight_commitment.commitment),
             ..config
         };
         let serialized_encoded = serialize_encode_transaction(transaction, encoding)?;
@@ -259,7 +193,6 @@ impl RpcClient {
                         for (i, log) in logs.iter().enumerate() {
                             debug!("{:>3}: {}", i + 1, log);
                         }
-                        debug!("");
                     }
                 }
                 return Err(err);
@@ -288,13 +221,7 @@ impl RpcClient {
         &self,
         transaction: &Transaction,
     ) -> RpcResult<RpcSimulateTransactionResult> {
-        self.simulate_transaction_with_config(
-            transaction,
-            RpcSimulateTransactionConfig {
-                commitment: Some(self.commitment_config),
-                ..RpcSimulateTransactionConfig::default()
-            },
-        )
+        self.simulate_transaction_with_config(transaction, RpcSimulateTransactionConfig::default())
     }
 
     pub fn simulate_transaction_with_config(
@@ -307,11 +234,8 @@ impl RpcClient {
         } else {
             self.default_cluster_transaction_encoding()?
         };
-        let commitment = config.commitment.unwrap_or_default();
-        let commitment = self.maybe_map_commitment(commitment)?;
         let config = RpcSimulateTransactionConfig {
             encoding: Some(encoding),
-            commitment: Some(commitment),
             ..config
         };
         let serialized_encoded = serialize_encode_transaction(transaction, encoding)?;
@@ -321,15 +245,11 @@ impl RpcClient {
         )
     }
 
-    pub fn get_snapshot_slot(&self) -> ClientResult<Slot> {
-        self.send(RpcRequest::GetSnapshotSlot, Value::Null)
-    }
-
     pub fn get_signature_status(
         &self,
         signature: &Signature,
     ) -> ClientResult<Option<transaction::Result<()>>> {
-        self.get_signature_status_with_commitment(signature, self.commitment_config)
+        self.get_signature_status_with_commitment(signature, CommitmentConfig::default())
     }
 
     pub fn get_signature_statuses(
@@ -387,104 +307,50 @@ impl RpcClient {
     }
 
     pub fn get_slot(&self) -> ClientResult<Slot> {
-        self.get_slot_with_commitment(self.commitment_config)
+        self.get_slot_with_commitment(CommitmentConfig::default())
     }
 
     pub fn get_slot_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<Slot> {
-        self.send(
-            RpcRequest::GetSlot,
-            json!([self.maybe_map_commitment(commitment_config)?]),
-        )
-    }
-
-    pub fn supply(&self) -> RpcResult<RpcSupply> {
-        self.supply_with_commitment(self.commitment_config)
+        self.send(RpcRequest::GetSlot, json!([commitment_config]))
     }
 
     pub fn supply_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> RpcResult<RpcSupply> {
-        self.send(
-            RpcRequest::GetSupply,
-            json!([self.maybe_map_commitment(commitment_config)?]),
-        )
+        self.send(RpcRequest::GetSupply, json!([commitment_config]))
     }
 
     pub fn total_supply(&self) -> ClientResult<u64> {
-        self.total_supply_with_commitment(self.commitment_config)
+        self.total_supply_with_commitment(CommitmentConfig::default())
     }
 
     pub fn total_supply_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<u64> {
-        self.send(
-            RpcRequest::GetTotalSupply,
-            json!([self.maybe_map_commitment(commitment_config)?]),
-        )
+        self.send(RpcRequest::GetTotalSupply, json!([commitment_config]))
     }
 
     pub fn get_largest_accounts_with_config(
         &self,
         config: RpcLargestAccountsConfig,
     ) -> RpcResult<Vec<RpcAccountBalance>> {
-        let commitment = config.commitment.unwrap_or_default();
-        let commitment = self.maybe_map_commitment(commitment)?;
-        let config = RpcLargestAccountsConfig {
-            commitment: Some(commitment),
-            ..config
-        };
         self.send(RpcRequest::GetLargestAccounts, json!([config]))
     }
 
     pub fn get_vote_accounts(&self) -> ClientResult<RpcVoteAccountStatus> {
-        self.get_vote_accounts_with_commitment(self.commitment_config)
+        self.get_vote_accounts_with_commitment(CommitmentConfig::default())
     }
 
     pub fn get_vote_accounts_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<RpcVoteAccountStatus> {
-        self.send(
-            RpcRequest::GetVoteAccounts,
-            json!([self.maybe_map_commitment(commitment_config)?]),
-        )
-    }
-
-    pub fn wait_for_max_stake(
-        &self,
-        commitment: CommitmentConfig,
-        max_stake_percent: f32,
-    ) -> ClientResult<()> {
-        let mut current_percent;
-        loop {
-            let vote_accounts = self.get_vote_accounts_with_commitment(commitment)?;
-
-            let mut max = 0;
-            let total_active_stake = vote_accounts
-                .current
-                .iter()
-                .chain(vote_accounts.delinquent.iter())
-                .map(|vote_account| {
-                    max = std::cmp::max(max, vote_account.activated_stake);
-                    vote_account.activated_stake
-                })
-                .sum::<u64>();
-            current_percent = 100f32 * max as f32 / total_active_stake as f32;
-            if current_percent < max_stake_percent {
-                break;
-            }
-            info!(
-                "Waiting for stake to drop below {} current: {:.1}",
-                max_stake_percent, current_percent
-            );
-            sleep(Duration::from_secs(10));
-        }
-        Ok(())
+        self.send(RpcRequest::GetVoteAccounts, json!([commitment_config]))
     }
 
     pub fn get_cluster_nodes(&self) -> ClientResult<Vec<RpcContactInfo>> {
@@ -605,24 +471,21 @@ impl RpcClient {
     }
 
     pub fn get_epoch_info(&self) -> ClientResult<EpochInfo> {
-        self.get_epoch_info_with_commitment(self.commitment_config)
+        self.get_epoch_info_with_commitment(CommitmentConfig::default())
     }
 
     pub fn get_epoch_info_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<EpochInfo> {
-        self.send(
-            RpcRequest::GetEpochInfo,
-            json!([self.maybe_map_commitment(commitment_config)?]),
-        )
+        self.send(RpcRequest::GetEpochInfo, json!([commitment_config]))
     }
 
     pub fn get_leader_schedule(
         &self,
         slot: Option<Slot>,
     ) -> ClientResult<Option<RpcLeaderSchedule>> {
-        self.get_leader_schedule_with_commitment(slot, self.commitment_config)
+        self.get_leader_schedule_with_commitment(slot, CommitmentConfig::default())
     }
 
     pub fn get_leader_schedule_with_commitment(
@@ -632,7 +495,7 @@ impl RpcClient {
     ) -> ClientResult<Option<RpcLeaderSchedule>> {
         self.send(
             RpcRequest::GetLeaderSchedule,
-            json!([slot, self.maybe_map_commitment(commitment_config)?]),
+            json!([slot, commitment_config]),
         )
     }
 
@@ -673,7 +536,7 @@ impl RpcClient {
     ) -> ClientResult<Signature> {
         let signature = self.send_transaction(transaction)?;
         let recent_blockhash = if uses_durable_nonce(transaction).is_some() {
-            self.get_recent_blockhash_with_commitment(CommitmentConfig::processed())?
+            self.get_recent_blockhash_with_commitment(CommitmentConfig::recent())?
                 .value
                 .0
         } else {
@@ -685,7 +548,7 @@ impl RpcClient {
                 if self
                     .get_fee_calculator_for_blockhash_with_commitment(
                         &recent_blockhash,
-                        CommitmentConfig::processed(),
+                        CommitmentConfig::recent(),
                     )?
                     .value
                     .is_none()
@@ -716,10 +579,8 @@ impl RpcClient {
         }
     }
 
-    /// Note that `get_account` returns `Err(..)` if the account does not exist whereas
-    /// `get_account_with_commitment` returns `Ok(None)` if the account does not exist.
     pub fn get_account(&self, pubkey: &Pubkey) -> ClientResult<Account> {
-        self.get_account_with_commitment(pubkey, self.commitment_config)?
+        self.get_account_with_commitment(pubkey, CommitmentConfig::default())?
             .value
             .ok_or_else(|| RpcError::ForUser(format!("AccountNotFound: pubkey={}", pubkey)).into())
     }
@@ -731,7 +592,7 @@ impl RpcClient {
     ) -> RpcResult<Option<Account>> {
         let config = RpcAccountInfoConfig {
             encoding: Some(UiAccountEncoding::Base64),
-            commitment: Some(self.maybe_map_commitment(commitment_config)?),
+            commitment: Some(commitment_config),
             data_slice: None,
         };
         let response = self.sender.send(
@@ -767,7 +628,7 @@ impl RpcClient {
 
     pub fn get_multiple_accounts(&self, pubkeys: &[Pubkey]) -> ClientResult<Vec<Option<Account>>> {
         Ok(self
-            .get_multiple_accounts_with_commitment(pubkeys, self.commitment_config)?
+            .get_multiple_accounts_with_commitment(pubkeys, CommitmentConfig::default())?
             .value)
     }
 
@@ -778,7 +639,7 @@ impl RpcClient {
     ) -> RpcResult<Vec<Option<Account>>> {
         let config = RpcAccountInfoConfig {
             encoding: Some(UiAccountEncoding::Base64),
-            commitment: Some(self.maybe_map_commitment(commitment_config)?),
+            commitment: Some(commitment_config),
             data_slice: None,
         };
         let pubkeys: Vec<_> = pubkeys.iter().map(|pubkey| pubkey.to_string()).collect();
@@ -821,7 +682,7 @@ impl RpcClient {
     /// Request the balance of the account `pubkey`.
     pub fn get_balance(&self, pubkey: &Pubkey) -> ClientResult<u64> {
         Ok(self
-            .get_balance_with_commitment(pubkey, self.commitment_config)?
+            .get_balance_with_commitment(pubkey, CommitmentConfig::default())?
             .value)
     }
 
@@ -832,10 +693,7 @@ impl RpcClient {
     ) -> RpcResult<u64> {
         self.send(
             RpcRequest::GetBalance,
-            json!([
-                pubkey.to_string(),
-                self.maybe_map_commitment(commitment_config)?
-            ]),
+            json!([pubkey.to_string(), commitment_config]),
         )
     }
 
@@ -846,7 +704,6 @@ impl RpcClient {
                 filters: None,
                 account_config: RpcAccountInfoConfig {
                     encoding: Some(UiAccountEncoding::Base64),
-                    commitment: Some(self.commitment_config),
                     ..RpcAccountInfoConfig::default()
                 },
             },
@@ -858,16 +715,6 @@ impl RpcClient {
         pubkey: &Pubkey,
         config: RpcProgramAccountsConfig,
     ) -> ClientResult<Vec<(Pubkey, Account)>> {
-        let commitment = config.account_config.commitment.unwrap_or_default();
-        let commitment = self.maybe_map_commitment(commitment)?;
-        let account_config = RpcAccountInfoConfig {
-            commitment: Some(commitment),
-            ..config.account_config
-        };
-        let config = RpcProgramAccountsConfig {
-            account_config,
-            ..config
-        };
         let accounts: Vec<RpcKeyedAccount> = self.send(
             RpcRequest::GetProgramAccounts,
             json!([pubkey.to_string(), config]),
@@ -877,22 +724,19 @@ impl RpcClient {
 
     /// Request the transaction count.
     pub fn get_transaction_count(&self) -> ClientResult<u64> {
-        self.get_transaction_count_with_commitment(self.commitment_config)
+        self.get_transaction_count_with_commitment(CommitmentConfig::default())
     }
 
     pub fn get_transaction_count_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<u64> {
-        self.send(
-            RpcRequest::GetTransactionCount,
-            json!([self.maybe_map_commitment(commitment_config)?]),
-        )
+        self.send(RpcRequest::GetTransactionCount, json!([commitment_config]))
     }
 
     pub fn get_recent_blockhash(&self) -> ClientResult<(Hash, FeeCalculator)> {
         let (blockhash, fee_calculator, _last_valid_slot) = self
-            .get_recent_blockhash_with_commitment(self.commitment_config)?
+            .get_recent_blockhash_with_commitment(CommitmentConfig::default())?
             .value;
         Ok((blockhash, fee_calculator))
     }
@@ -909,11 +753,9 @@ impl RpcClient {
                     fee_calculator,
                     last_valid_slot,
                 },
-        }) = self
-            .send::<Response<RpcFees>>(
-                RpcRequest::GetFees,
-                json!([self.maybe_map_commitment(commitment_config)?]),
-            ) {
+        }) =
+            self.send::<Response<RpcFees>>(RpcRequest::GetFees, json!([commitment_config]))
+        {
             (context, blockhash, fee_calculator, last_valid_slot)
         } else if let Ok(Response {
             context,
@@ -924,7 +766,7 @@ impl RpcClient {
                 },
         }) = self.send::<Response<RpcBlockhashFeeCalculator>>(
             RpcRequest::GetRecentBlockhash,
-            json!([self.maybe_map_commitment(commitment_config)?]),
+            json!([commitment_config]),
         ) {
             (context, blockhash, fee_calculator, 0)
         } else {
@@ -951,7 +793,10 @@ impl RpcClient {
         blockhash: &Hash,
     ) -> ClientResult<Option<FeeCalculator>> {
         Ok(self
-            .get_fee_calculator_for_blockhash_with_commitment(blockhash, self.commitment_config)?
+            .get_fee_calculator_for_blockhash_with_commitment(
+                blockhash,
+                CommitmentConfig::default(),
+            )?
             .value)
     }
 
@@ -962,10 +807,7 @@ impl RpcClient {
     ) -> RpcResult<Option<FeeCalculator>> {
         let Response { context, value } = self.send::<Response<Option<RpcFeeCalculator>>>(
             RpcRequest::GetFeeCalculatorForBlockhash,
-            json!([
-                blockhash.to_string(),
-                self.maybe_map_commitment(commitment_config)?
-            ]),
+            json!([blockhash.to_string(), commitment_config]),
         )?;
 
         Ok(Response {
@@ -1028,14 +870,9 @@ impl RpcClient {
         Ok(hash)
     }
 
-    pub fn get_health(&self) -> ClientResult<()> {
-        self.send::<String>(RpcRequest::GetHealth, Value::Null)
-            .map(|_| ())
-    }
-
     pub fn get_token_account(&self, pubkey: &Pubkey) -> ClientResult<Option<UiTokenAccount>> {
         Ok(self
-            .get_token_account_with_commitment(pubkey, self.commitment_config)?
+            .get_token_account_with_commitment(pubkey, CommitmentConfig::default())?
             .value)
     }
 
@@ -1046,7 +883,7 @@ impl RpcClient {
     ) -> RpcResult<Option<UiTokenAccount>> {
         let config = RpcAccountInfoConfig {
             encoding: Some(UiAccountEncoding::JsonParsed),
-            commitment: Some(self.maybe_map_commitment(commitment_config)?),
+            commitment: Some(commitment_config),
             data_slice: None,
         };
         let response = self.sender.send(
@@ -1096,7 +933,7 @@ impl RpcClient {
 
     pub fn get_token_account_balance(&self, pubkey: &Pubkey) -> ClientResult<UiTokenAmount> {
         Ok(self
-            .get_token_account_balance_with_commitment(pubkey, self.commitment_config)?
+            .get_token_account_balance_with_commitment(pubkey, CommitmentConfig::default())?
             .value)
     }
 
@@ -1107,10 +944,7 @@ impl RpcClient {
     ) -> RpcResult<UiTokenAmount> {
         self.send(
             RpcRequest::GetTokenAccountBalance,
-            json!([
-                pubkey.to_string(),
-                self.maybe_map_commitment(commitment_config)?
-            ]),
+            json!([pubkey.to_string(), commitment_config]),
         )
     }
 
@@ -1123,7 +957,7 @@ impl RpcClient {
             .get_token_accounts_by_delegate_with_commitment(
                 delegate,
                 token_account_filter,
-                self.commitment_config,
+                CommitmentConfig::default(),
             )?
             .value)
     }
@@ -1143,7 +977,7 @@ impl RpcClient {
 
         let config = RpcAccountInfoConfig {
             encoding: Some(UiAccountEncoding::JsonParsed),
-            commitment: Some(self.maybe_map_commitment(commitment_config)?),
+            commitment: Some(commitment_config),
             data_slice: None,
         };
 
@@ -1162,7 +996,7 @@ impl RpcClient {
             .get_token_accounts_by_owner_with_commitment(
                 owner,
                 token_account_filter,
-                self.commitment_config,
+                CommitmentConfig::default(),
             )?
             .value)
     }
@@ -1182,7 +1016,7 @@ impl RpcClient {
 
         let config = RpcAccountInfoConfig {
             encoding: Some(UiAccountEncoding::JsonParsed),
-            commitment: Some(self.maybe_map_commitment(commitment_config)?),
+            commitment: Some(commitment_config),
             data_slice: None,
         };
 
@@ -1194,7 +1028,7 @@ impl RpcClient {
 
     pub fn get_token_supply(&self, mint: &Pubkey) -> ClientResult<UiTokenAmount> {
         Ok(self
-            .get_token_supply_with_commitment(mint, self.commitment_config)?
+            .get_token_supply_with_commitment(mint, CommitmentConfig::default())?
             .value)
     }
 
@@ -1205,10 +1039,7 @@ impl RpcClient {
     ) -> RpcResult<UiTokenAmount> {
         self.send(
             RpcRequest::GetTokenSupply,
-            json!([
-                mint.to_string(),
-                self.maybe_map_commitment(commitment_config)?
-            ]),
+            json!([mint.to_string(), commitment_config]),
         )
     }
 
@@ -1278,7 +1109,7 @@ impl RpcClient {
 
     /// Poll the server to confirm a transaction.
     pub fn poll_for_signature(&self, signature: &Signature) -> ClientResult<()> {
-        self.poll_for_signature_with_commitment(signature, self.commitment_config)
+        self.poll_for_signature_with_commitment(signature, CommitmentConfig::default())
     }
 
     /// Poll the server to confirm a transaction.
@@ -1386,9 +1217,10 @@ impl RpcClient {
         &self,
         transaction: &Transaction,
     ) -> ClientResult<Signature> {
-        self.send_and_confirm_transaction_with_spinner_and_commitment(
+        self.send_and_confirm_transaction_with_spinner_and_config(
             transaction,
-            self.commitment_config,
+            CommitmentConfig::default(),
+            RpcSendTransactionConfig::default(),
         )
     }
 
@@ -1400,10 +1232,7 @@ impl RpcClient {
         self.send_and_confirm_transaction_with_spinner_and_config(
             transaction,
             commitment,
-            RpcSendTransactionConfig {
-                preflight_commitment: Some(commitment.commitment),
-                ..RpcSendTransactionConfig::default()
-            },
+            RpcSendTransactionConfig::default(),
         )
     }
 
@@ -1413,10 +1242,9 @@ impl RpcClient {
         commitment: CommitmentConfig,
         config: RpcSendTransactionConfig,
     ) -> ClientResult<Signature> {
-        let desired_confirmations = if commitment.is_finalized() {
-            MAX_LOCKOUT_HISTORY + 1
-        } else {
-            1
+        let desired_confirmations = match commitment.commitment {
+            CommitmentLevel::Max | CommitmentLevel::Root => MAX_LOCKOUT_HISTORY + 1,
+            _ => 1,
         };
         let mut confirmations = 0;
 
@@ -1427,7 +1255,7 @@ impl RpcClient {
             confirmations, desired_confirmations, transaction.signatures[0],
         ));
         let recent_blockhash = if uses_durable_nonce(transaction).is_some() {
-            self.get_recent_blockhash_with_commitment(CommitmentConfig::processed())?
+            self.get_recent_blockhash_with_commitment(CommitmentConfig::recent())?
                 .value
                 .0
         } else {
@@ -1436,13 +1264,13 @@ impl RpcClient {
         let signature = self.send_transaction_with_config(transaction, config)?;
         let (signature, status) = loop {
             // Get recent commitment in order to count confirmations for successful transactions
-            let status = self
-                .get_signature_status_with_commitment(&signature, CommitmentConfig::processed())?;
+            let status =
+                self.get_signature_status_with_commitment(&signature, CommitmentConfig::recent())?;
             if status.is_none() {
                 if self
                     .get_fee_calculator_for_blockhash_with_commitment(
                         &recent_blockhash,
-                        CommitmentConfig::processed(),
+                        CommitmentConfig::recent(),
                     )?
                     .value
                     .is_none()
@@ -1472,20 +1300,29 @@ impl RpcClient {
         }
         let now = Instant::now();
         loop {
-            // Return when specified commitment is reached
-            // Failed transactions have already been eliminated, `is_some` check is sufficient
-            if self
-                .get_signature_status_with_commitment(&signature, commitment)?
-                .is_some()
-            {
-                progress_bar.set_message("Transaction confirmed");
-                progress_bar.finish_and_clear();
-                return Ok(signature);
+            match commitment.commitment {
+                CommitmentLevel::Max | CommitmentLevel::Root =>
+                // Return when default (max) commitment is reached
+                // Failed transactions have already been eliminated, `is_some` check is sufficient
+                {
+                    if self.get_signature_status(&signature)?.is_some() {
+                        progress_bar.set_message("Transaction confirmed");
+                        progress_bar.finish_and_clear();
+                        return Ok(signature);
+                    }
+                }
+                _ => {
+                    // Return when one confirmation has been reached
+                    if confirmations >= desired_confirmations {
+                        progress_bar.set_message("Transaction reached commitment");
+                        progress_bar.finish_and_clear();
+                        return Ok(signature);
+                    }
+                }
             }
-
             progress_bar.set_message(&format!(
                 "[{}/{}] Finalizing transaction {}",
-                min(confirmations + 1, desired_confirmations),
+                confirmations + 1,
                 desired_confirmations,
                 signature,
             ));
@@ -1536,7 +1373,7 @@ fn new_spinner_progress_bar() -> ProgressBar {
     progress_bar
 }
 
-fn get_rpc_request_str(rpc_addr: SocketAddr, tls: bool) -> String {
+pub fn get_rpc_request_str(rpc_addr: SocketAddr, tls: bool) -> String {
     if tls {
         format!("https://{}", rpc_addr)
     } else {

client/src/rpc_config.rs

@@ -71,21 +71,6 @@ pub struct RpcProgramAccountsConfig {
     pub account_config: RpcAccountInfoConfig,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum RpcTransactionLogsFilter {
-    All,
-    AllWithVotes,
-    Mentions(Vec<String>), // base58-encoded list of addresses
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcTransactionLogsConfig {
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-}
-
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum RpcTokenAccountsFilter {

client/src/rpc_custom_error.rs

@@ -10,9 +10,6 @@ pub const JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: i64
 pub const JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: i64 = -32004;
 pub const JSON_RPC_SERVER_ERROR_NODE_UNHEALTHLY: i64 = -32005;
 pub const JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: i64 = -32006;
-pub const JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: i64 = -32007;
-pub const JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: i64 = -32008;
-pub const JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: i64 = -32009;
 
 pub enum RpcCustomError {
     BlockCleanedUp {
@@ -27,23 +24,8 @@ pub enum RpcCustomError {
     BlockNotAvailable {
         slot: Slot,
     },
-    NodeUnhealthy {
-        num_slots_behind: Option<Slot>,
-    },
+    RpcNodeUnhealthy,
     TransactionPrecompileVerificationFailure(solana_sdk::transaction::TransactionError),
-    SlotSkipped {
-        slot: Slot,
-    },
-    NoSnapshot,
-    LongTermStorageSlotSkipped {
-        slot: Slot,
-    },
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct NodeUnhealthyErrorData {
-    pub num_slots_behind: Option<Slot>,
 }
 
 impl From<RpcCustomError> for Error {
@@ -79,16 +61,10 @@ impl From<RpcCustomError> for Error {
                 message: format!("Block not available for slot {}", slot),
                 data: None,
             },
-            RpcCustomError::NodeUnhealthy { num_slots_behind } => Self {
+            RpcCustomError::RpcNodeUnhealthy => Self {
                 code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_NODE_UNHEALTHLY),
-                message: if let Some(num_slots_behind) = num_slots_behind {
-                    format!("Node is behind by {} slots", num_slots_behind)
-                } else {
-                    "Node is unhealthy".to_string()
-                },
-                data: Some(serde_json::json!(NodeUnhealthyErrorData {
-                    num_slots_behind
-                })),
+                message: "RPC node is unhealthy".to_string(),
+                data: None,
             },
             RpcCustomError::TransactionPrecompileVerificationFailure(e) => Self {
                 code: ErrorCode::ServerError(
@@ -97,24 +73,6 @@ impl From<RpcCustomError> for Error {
                 message: format!("Transaction precompile verification failure {:?}", e),
                 data: None,
             },
-            RpcCustomError::SlotSkipped { slot } => Self {
-                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_SLOT_SKIPPED),
-                message: format!(
-                    "Slot {} was skipped, or missing due to ledger jump to recent snapshot",
-                    slot
-                ),
-                data: None,
-            },
-            RpcCustomError::NoSnapshot => Self {
-                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_NO_SNAPSHOT),
-                message: "No snapshot".to_string(),
-                data: None,
-            },
-            RpcCustomError::LongTermStorageSlotSkipped { slot } => Self {
-                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED),
-                message: format!("Slot {} was skipped, or missing in long-term storage", slot),
-                data: None,
-            },
         }
     }
 }

client/src/rpc_request.rs

@@ -1,6 +1,6 @@
 use crate::rpc_response::RpcSimulateTransactionResult;
 use serde_json::{json, Value};
-use solana_sdk::{clock::Slot, pubkey::Pubkey};
+use solana_sdk::pubkey::Pubkey;
 use std::fmt;
 use thiserror::Error;
 
@@ -25,7 +25,6 @@ pub enum RpcRequest {
     GetFees,
     GetFirstAvailableBlock,
     GetGenesisHash,
-    GetHealth,
     GetIdentity,
     GetInflationGovernor,
     GetInflationRate,
@@ -35,7 +34,6 @@ pub enum RpcRequest {
     GetMultipleAccounts,
     GetProgramAccounts,
     GetRecentBlockhash,
-    GetSnapshotSlot,
     GetSignatureStatuses,
     GetSlot,
     GetSlotLeader,
@@ -82,7 +80,6 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetFees => "getFees",
             RpcRequest::GetFirstAvailableBlock => "getFirstAvailableBlock",
             RpcRequest::GetGenesisHash => "getGenesisHash",
-            RpcRequest::GetHealth => "getHealth",
             RpcRequest::GetIdentity => "getIdentity",
             RpcRequest::GetInflationGovernor => "getInflationGovernor",
             RpcRequest::GetInflationRate => "getInflationRate",
@@ -92,7 +89,6 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetMultipleAccounts => "getMultipleAccounts",
             RpcRequest::GetProgramAccounts => "getProgramAccounts",
             RpcRequest::GetRecentBlockhash => "getRecentBlockhash",
-            RpcRequest::GetSnapshotSlot => "getSnapshotSlot",
             RpcRequest::GetSignatureStatuses => "getSignatureStatuses",
             RpcRequest::GetSlot => "getSlot",
             RpcRequest::GetSlotLeader => "getSlotLeader",
@@ -147,7 +143,6 @@ impl RpcRequest {
 pub enum RpcResponseErrorData {
     Empty,
     SendTransactionPreflightFailure(RpcSimulateTransactionResult),
-    NodeUnhealthy { num_slots_behind: Option<Slot> },
 }
 
 impl fmt::Display for RpcResponseErrorData {
@@ -248,7 +243,7 @@ mod tests {
     #[test]
     fn test_build_request_json_config_options() {
         let commitment_config = CommitmentConfig {
-            commitment: CommitmentLevel::Finalized,
+            commitment: CommitmentLevel::Max,
         };
         let addr = json!("deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx");
 

client/src/rpc_response.rs

@@ -1,7 +1,7 @@
 use crate::client_error;
 use solana_account_decoder::{parse_token::UiTokenAmount, UiAccount};
 use solana_sdk::{
-    clock::{Epoch, Slot, UnixTimestamp},
+    clock::{Epoch, Slot},
     fee_calculator::{FeeCalculator, FeeRateGovernor},
     inflation::Inflation,
     transaction::{Result, TransactionError},
@@ -108,14 +108,6 @@ pub enum RpcSignatureResult {
     ReceivedSignature(ReceivedSignatureResult),
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcLogsResponse {
-    pub signature: String, // Signature as base58 string
-    pub err: Option<TransactionError>,
-    pub logs: Vec<String>,
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct ProcessedSignatureResult {
@@ -286,7 +278,6 @@ pub struct RpcConfirmedTransactionStatusWithSignature {
     pub slot: Slot,
     pub err: Option<TransactionError>,
     pub memo: Option<String>,
-    pub block_time: Option<UnixTimestamp>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -305,14 +296,12 @@ impl From<ConfirmedTransactionStatusWithSignature> for RpcConfirmedTransactionSt
             slot,
             err,
             memo,
-            block_time,
         } = value;
         Self {
             signature: signature.to_string(),
             slot,
             err,
             memo,
-            block_time,
         }
     }
 }

client/src/thin_client.rs

@@ -3,7 +3,7 @@
 //! 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 crate::{rpc_client::RpcClient, rpc_response::Response};
 use bincode::{serialize_into, serialized_size};
 use log::*;
 use solana_sdk::{
@@ -276,16 +276,6 @@ impl ThinClient {
         )
     }
 
-    pub fn get_program_accounts_with_config(
-        &self,
-        pubkey: &Pubkey,
-        config: RpcProgramAccountsConfig,
-    ) -> TransportResult<Vec<(Pubkey, Account)>> {
-        self.rpc_client()
-            .get_program_accounts_with_config(pubkey, config)
-            .map_err(|e| e.into())
-    }
-
     pub fn wait_for_balance_with_commitment(
         &self,
         pubkey: &Pubkey,
@@ -399,12 +389,6 @@ impl SyncClient for ThinClient {
             .map(|r| r.value)
     }
 
-    fn get_minimum_balance_for_rent_exemption(&self, data_len: usize) -> TransportResult<u64> {
-        self.rpc_client()
-            .get_minimum_balance_for_rent_exemption(data_len)
-            .map_err(|e| e.into())
-    }
-
     fn get_recent_blockhash(&self) -> TransportResult<(Hash, FeeCalculator)> {
         let (blockhash, fee_calculator, _last_valid_slot) =
             self.get_recent_blockhash_with_commitment(CommitmentConfig::default())?;

core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "solana-core"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
+version = "1.4.6"
 documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
 readme = "../README.md"
@@ -14,7 +14,6 @@ edition = "2018"
 codecov = { repository = "solana-labs/solana", branch = "master", service = "github" }
 
 [dependencies]
-ahash = "0.6.1"
 base64 = "0.12.3"
 bincode = "1.3.1"
 bv = { version = "0.11.1", features = ["serde"] }
@@ -34,60 +33,54 @@ jsonrpc-derive = "15.0.0"
 jsonrpc-http-server = "15.0.0"
 jsonrpc-pubsub = "15.0.0"
 jsonrpc-ws-server = "15.0.0"
-log = "0.4.11"
-lru = "0.6.1"
-miow = "0.2.2"
-net2 = "0.2.37"
+log = "0.4.8"
+lru = "0.6.0"
+num_cpus = "1.13.0"
 num-traits = "0.2"
 rand = "0.7.0"
 rand_chacha = "0.2.2"
 raptorq = "1.4.2"
 rayon = "1.4.1"
 regex = "1.3.9"
-rustversion = "1.0.4"
 serde = "1.0.112"
-serde_bytes = "0.11"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "1.5.6" }
-solana-banks-server = { path = "../banks-server", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-ledger = { path = "../ledger", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-merkle-tree = { path = "../merkle-tree", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-perf = { path = "../perf", version = "1.5.6" }
-solana-program-test = { path = "../program-test", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-frozen-abi = { path = "../frozen-abi", version = "1.5.6" }
-solana-frozen-abi-macro = { path = "../frozen-abi/macro", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-storage-bigtable = { path = "../storage-bigtable", version = "1.5.6" }
-solana-streamer = { path = "../streamer", version = "1.5.6" }
-solana-sys-tuner = { path = "../sys-tuner", version = "1.5.6" }
-solana-transaction-status = { path = "../transaction-status", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "1.4.6" }
+solana-banks-server = { path = "../banks-server", version = "1.4.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.4.6" }
+solana-client = { path = "../client", version = "1.4.6" }
+solana-faucet = { path = "../faucet", version = "1.4.6" }
+solana-frozen-abi = { path = "../frozen-abi", version = "1.4.6" }
+solana-frozen-abi-macro = { path = "../frozen-abi/macro", version = "1.4.6" }
+solana-ledger = { path = "../ledger", version = "1.4.6" }
+solana-logger = { path = "../logger", version = "1.4.6" }
+solana-merkle-tree = { path = "../merkle-tree", version = "1.4.6" }
+solana-metrics = { path = "../metrics", version = "1.4.6" }
+solana-measure = { path = "../measure", version = "1.4.6" }
+solana-net-utils = { path = "../net-utils", version = "1.4.6" }
+solana-perf = { path = "../perf", version = "1.4.6" }
+solana-runtime = { path = "../runtime", version = "1.4.6" }
+solana-sdk = { path = "../sdk", version = "1.4.6" }
+solana-stake-program = { path = "../programs/stake", version = "1.4.6" }
+solana-storage-bigtable = { path = "../storage-bigtable", version = "1.4.6" }
+solana-streamer = { path = "../streamer", version = "1.4.6" }
+solana-sys-tuner = { path = "../sys-tuner", version = "1.4.6" }
+solana-transaction-status = { path = "../transaction-status", version = "1.4.6" }
+solana-version = { path = "../version", version = "1.4.6" }
+solana-vote-program = { path = "../programs/vote", version = "1.4.6" }
+solana-vote-signer = { path = "../vote-signer", version = "1.4.6" }
+spl-token-v2-0 = { package = "spl-token", version = "=3.0.0", features = ["no-entrypoint"] }
 tempfile = "3.1.0"
 thiserror = "1.0"
 tokio = { version = "0.2", features = ["full"] }
 tokio_01 = { version = "0.1", package = "tokio" }
-tokio_01_bytes = { version = "0.4.7", package = "bytes" }
 tokio_fs_01 = { version = "0.1", package = "tokio-fs" }
 tokio_io_01 = { version = "0.1", package = "tokio-io" }
-tokio_codec_01 = { version = "0.1", package = "tokio-codec" }
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.5.6" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.4.6" }
 trees = "0.2.1"
 
 [dev-dependencies]
 matches = "0.1.6"
-num_cpus = "1.13.0"
 reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"

core/benches/cluster_info.rs

@@ -35,8 +35,9 @@ fn broadcast_shreds_bench(bencher: &mut Bencher) {
         cluster_info.insert_info(contact_info);
         stakes.insert(id, thread_rng().gen_range(1, NUM_PEERS) as u64);
     }
+    let stakes = Arc::new(stakes);
     let cluster_info = Arc::new(cluster_info);
-    let (peers, peers_and_stakes) = get_broadcast_peers(&cluster_info, Some(&stakes));
+    let (peers, peers_and_stakes) = get_broadcast_peers(&cluster_info, Some(stakes));
     let shreds = Arc::new(shreds);
     let last_datapoint = Arc::new(AtomicU64::new(0));
     bencher.iter(move || {

core/benches/crds.rs

@@ -17,7 +17,7 @@ fn bench_find_old_labels(bencher: &mut Bencher) {
     let mut rng = thread_rng();
     let mut crds = Crds::default();
     let now = CRDS_GOSSIP_PULL_CRDS_TIMEOUT_MS + CRDS_GOSSIP_PULL_CRDS_TIMEOUT_MS / 1000;
-    std::iter::repeat_with(|| (CrdsValue::new_rand(&mut rng, None), rng.gen_range(0, now)))
+    std::iter::repeat_with(|| (CrdsValue::new_rand(&mut rng), rng.gen_range(0, now)))
         .take(50_000)
         .for_each(|(v, ts)| assert!(crds.insert(v, ts).is_ok()));
     let mut timeouts = HashMap::new();

core/benches/crds_gossip_pull.rs

@@ -39,7 +39,7 @@ fn bench_build_crds_filters(bencher: &mut Bencher) {
     let mut num_inserts = 0;
     for _ in 0..90_000 {
         if crds
-            .insert(CrdsValue::new_rand(&mut rng, None), rng.gen())
+            .insert(CrdsValue::new_rand(&mut rng), rng.gen())
             .is_ok()
         {
             num_inserts += 1;

core/benches/retransmit_stage.rs

@@ -7,18 +7,14 @@ use log::*;
 use solana_core::cluster_info::{ClusterInfo, Node};
 use solana_core::contact_info::ContactInfo;
 use solana_core::retransmit_stage::retransmitter;
-use solana_ledger::entry::Entry;
 use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
 use solana_ledger::leader_schedule_cache::LeaderScheduleCache;
-use solana_ledger::shred::Shredder;
 use solana_measure::measure::Measure;
-use solana_perf::packet::{Packet, Packets};
+use solana_perf::packet::to_packets_chunked;
+use solana_perf::test_tx::test_tx;
 use solana_runtime::bank::Bank;
 use solana_runtime::bank_forks::BankForks;
-use solana_sdk::hash::Hash;
 use solana_sdk::pubkey;
-use solana_sdk::signature::{Keypair, Signer};
-use solana_sdk::system_transaction;
 use solana_sdk::timing::timestamp;
 use std::net::UdpSocket;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -67,24 +63,14 @@ fn bench_retransmitter(bencher: &mut Bencher) {
     let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
 
     // To work reliably with higher values, this needs larger udp rmem size
-    let entries: Vec<_> = (0..5)
-        .map(|_| {
-            let keypair0 = Keypair::new();
-            let keypair1 = Keypair::new();
-            let tx0 =
-                system_transaction::transfer(&keypair0, &keypair1.pubkey(), 1, Hash::default());
-            Entry::new(&Hash::default(), 1, vec![tx0])
-        })
-        .collect();
-
-    let keypair = Arc::new(Keypair::new());
-    let slot = 0;
-    let parent = 0;
-    let shredder =
-        Shredder::new(slot, parent, 0.0, keypair, 0, 0).expect("Failed to create entry shredder");
-    let mut data_shreds = shredder.entries_to_shreds(&entries, true, 0).0;
-
-    let num_packets = data_shreds.len();
+    let tx = test_tx();
+    const NUM_PACKETS: usize = 50;
+    let chunk_size = NUM_PACKETS / (4 * NUM_THREADS);
+    let batches = to_packets_chunked(
+        &std::iter::repeat(tx).take(NUM_PACKETS).collect::<Vec<_>>(),
+        chunk_size,
+    );
+    info!("batches: {}", batches.len());
 
     let retransmitter_handles = retransmitter(
         Arc::new(sockets),
@@ -94,8 +80,6 @@ fn bench_retransmitter(bencher: &mut Bencher) {
         packet_receiver,
     );
 
-    let mut index = 0;
-    let mut slot = 0;
     let total = Arc::new(AtomicUsize::new(0));
     bencher.iter(move || {
         let peer_sockets1 = peer_sockets.clone();
@@ -112,7 +96,7 @@ fn bench_retransmitter(bencher: &mut Bencher) {
                             while peer_sockets2[p].recv(&mut buf).is_ok() {
                                 total2.fetch_add(1, Ordering::Relaxed);
                             }
-                            if total2.load(Ordering::Relaxed) >= num_packets {
+                            if total2.load(Ordering::Relaxed) >= NUM_PACKETS {
                                 break;
                             }
                             info!("{} recv", total2.load(Ordering::Relaxed));
@@ -123,17 +107,9 @@ fn bench_retransmitter(bencher: &mut Bencher) {
             })
             .collect();
 
-        for shred in data_shreds.iter_mut() {
-            shred.set_slot(slot);
-            shred.set_index(index);
-            index += 1;
-            index %= 200;
-            let mut p = Packet::default();
-            shred.copy_to_packet(&mut p);
-            let _ = packet_sender.send(Packets::new(vec![p]));
+        for packets in batches.clone() {
+            packet_sender.send(packets).unwrap();
         }
-        slot += 1;
-
         info!("sent...");
 
         let mut join_time = Measure::start("join");

core/benches/shredder.rs

@@ -6,7 +6,7 @@ use rand::seq::SliceRandom;
 use raptorq::{Decoder, Encoder};
 use solana_ledger::entry::{create_ticks, Entry};
 use solana_ledger::shred::{
-    max_entries_per_n_shred, max_ticks_per_n_shreds, ProcessShredsStats, Shred, Shredder,
+    max_entries_per_n_shred, max_ticks_per_n_shreds, Shred, Shredder,
     MAX_DATA_SHREDS_PER_FEC_BLOCK, RECOMMENDED_FEC_RATE, SHRED_PAYLOAD_SIZE,
     SIZE_OF_DATA_SHRED_IGNORED_TAIL, SIZE_OF_DATA_SHRED_PAYLOAD,
 };
@@ -40,9 +40,7 @@ fn make_shreds(num_shreds: usize) -> Vec<Shred> {
     let entries = make_large_unchained_entries(txs_per_entry, num_entries);
     let shredder =
         Shredder::new(1, 0, RECOMMENDED_FEC_RATE, Arc::new(Keypair::new()), 0, 0).unwrap();
-    let data_shreds = shredder
-        .entries_to_data_shreds(&entries, true, 0, &mut ProcessShredsStats::default())
-        .0;
+    let data_shreds = shredder.entries_to_data_shreds(&entries, true, 0).0;
     assert!(data_shreds.len() >= num_shreds);
     data_shreds
 }
@@ -125,14 +123,8 @@ fn bench_shredder_coding(bencher: &mut Bencher) {
     let symbol_count = MAX_DATA_SHREDS_PER_FEC_BLOCK as usize;
     let data_shreds = make_shreds(symbol_count);
     bencher.iter(|| {
-        Shredder::generate_coding_shreds(
-            0,
-            RECOMMENDED_FEC_RATE,
-            &data_shreds[..symbol_count],
-            0,
-            symbol_count,
-        )
-        .len();
+        Shredder::generate_coding_shreds(0, RECOMMENDED_FEC_RATE, &data_shreds[..symbol_count], 0)
+            .len();
     })
 }
 
@@ -140,13 +132,8 @@ fn bench_shredder_coding(bencher: &mut Bencher) {
 fn bench_shredder_decoding(bencher: &mut Bencher) {
     let symbol_count = MAX_DATA_SHREDS_PER_FEC_BLOCK as usize;
     let data_shreds = make_shreds(symbol_count);
-    let coding_shreds = Shredder::generate_coding_shreds(
-        0,
-        RECOMMENDED_FEC_RATE,
-        &data_shreds[..symbol_count],
-        0,
-        symbol_count,
-    );
+    let coding_shreds =
+        Shredder::generate_coding_shreds(0, RECOMMENDED_FEC_RATE, &data_shreds[..symbol_count], 0);
     bencher.iter(|| {
         Shredder::try_recovery(
             coding_shreds[..].to_vec(),