Correct days/year (#17024) (#17032)

(cherry picked from commit 46d2755205)

Co-authored-by: Tyera Eulberg <teulberg@gmail.com>

.buildkite/hooks/pre-command

@@ -36,7 +36,4 @@ export CARGO_TARGET_CACHE=$HOME/cargo-target-cache/"$CHANNEL"-"$BUILDKITE_LABEL"
   # `std:
   #    "found possibly newer version of crate `std` which `xyz` depends on
   rm -rf target/bpfel-unknown-unknown
-  if [[ $BUILDKITE_LABEL = "stable-perf" ]]; then
-    rm -rf target/release
-  fi
 )

.mergify.yml

@@ -50,6 +50,14 @@ pull_request_rules:
       label:
         add:
           - automerge
+  - name: v1.3 backport
+    conditions:
+      - label=v1.3
+    actions:
+      backport:
+        ignore_conflicts: true
+        branches:
+          - v1.3
   - name: v1.4 backport
     conditions:
       - label=v1.4
@@ -74,11 +82,3 @@ pull_request_rules:
         ignore_conflicts: true
         branches:
           - v1.6
-  - name: v1.7 backport
-    conditions:
-      - label=v1.7
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.7

.travis.yml

@@ -38,7 +38,6 @@ jobs:
         - readlink -f .
       script:
         - source ci/env.sh
-        - rustup set profile default
         - ci/publish-tarball.sh
       deploy:
         - provider: s3
@@ -74,7 +73,7 @@ jobs:
 
       language: node_js
       node_js:
-        - "lts/*"
+        - "node"
 
       cache:
         directories:

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "accounts-cluster-bench",
     "bench-exchange",
     "bench-streamer",
     "bench-tps",
@@ -21,7 +20,6 @@ members = [
     "perf",
     "validator",
     "genesis",
-    "genesis-utils",
     "gossip",
     "install",
     "keygen",
@@ -32,6 +30,7 @@ members = [
     "log-analyzer",
     "merkle-root-bench",
     "merkle-tree",
+    "stake-o-matic",
     "storage-bigtable",
     "storage-proto",
     "streamer",
@@ -39,20 +38,21 @@ members = [
     "metrics",
     "net-shaper",
     "notifier",
-    "poh",
     "poh-bench",
     "program-test",
+    "programs/secp256k1",
     "programs/bpf_loader",
+    "programs/budget",
     "programs/config",
     "programs/exchange",
     "programs/failure",
     "programs/noop",
     "programs/ownable",
-    "programs/secp256k1",
     "programs/stake",
+    "programs/vest",
     "programs/vote",
     "remote-wallet",
-    "rpc",
+    "ramp-tps",
     "runtime",
     "runtime/store-tool",
     "sdk",
@@ -60,6 +60,7 @@ members = [
     "sdk/cargo-test-bpf",
     "scripts",
     "stake-accounts",
+    "stake-monitor",
     "sys-tuner",
     "tokens",
     "transaction-status",
@@ -75,6 +76,3 @@ members = [
 exclude = [
     "programs/bpf",
 ]
-
-[profile.dev]
-split-debuginfo = "unpacked"

README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/uBVzyX3.png" width="250" />
+    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
   </a>
 </p>
 
@@ -19,7 +19,7 @@ $ source $HOME/.cargo/env
 $ rustup component add rustfmt
 ```
 
-Please make sure you are always using the latest stable rust version by running:
+Please sure you are always using the latest stable rust version by running:
 
 ```bash
 $ rustup update
@@ -32,12 +32,6 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make
 ```
 
-On Mac M1s, make sure you set up your terminal & homebrew [to use](https://5balloons.info/correct-way-to-install-and-use-homebrew-on-m1-macs/) Rosetta. You can install it with:
-
-```bash
-$ softwareupdate --install-rosetta
-```
-
 ## **2. Download the source code.**
 
 ```bash
@@ -113,41 +107,6 @@ send us that patch!
 
 # Disclaimer
 
-All claims, content, designs, algorithms, estimates, roadmaps,
-specifications, and performance measurements described in this project
-are done with the Solana Foundation's ("SF") best efforts. It is up to
-the reader to check and validate their accuracy and truthfulness.
-Furthermore nothing in this project constitutes a solicitation for
-investment.
+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 SF or developer resources that SF provides, are
-for educational and inspiration purposes only. SF does not encourage,
-induce or sanction the deployment, integration or use of any such
-applications (including the code comprising the Solana blockchain
-protocol) in violation of applicable laws or regulations and hereby
-prohibits any such deployment, integration or use. This includes use of
-any such applications by the reader (a) in violation of export control
-or sanctions laws of the United States or any other applicable
-jurisdiction, (b) if the reader is located in or ordinarily resident in
-a country or territory subject to comprehensive sanctions administered
-by the U.S. Office of Foreign Assets Control (OFAC), or (c) if the
-reader is or is working on behalf of a Specially Designated National
-(SDN) or a person subject to similar blocking or denied party
-prohibitions.
-
-The reader should be aware that U.S. export control and sanctions laws
-prohibit U.S. persons (and other persons that are subject to such laws)
-from transacting with persons in certain countries and territories or
-that are on the SDN list. As a project based primarily on open-source
-software, it is possible that such sanctioned persons may nevertheless
-bypass prohibitions, obtain the code comprising the Solana blockchain
-protocol (or other project code or applications) and deploy, integrate,
-or otherwise use it. Accordingly, there is a risk to individuals that
-other persons using the Solana blockchain protocol may be sanctioned
-persons and that transactions with such persons would be a violation of
-U.S. export controls and sanctions law. This risk applies to
-individuals, organizations, and other ecosystem participants that
-deploy, integrate, or use the Solana blockchain protocol code directly
-(e.g., as a node operator), and individuals that transact on the Solana
-blockchain through light clients, third party interfaces, and/or wallet
-software.
+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.

SECURITY.md

@@ -51,27 +51,13 @@ The following components are out of scope for the bounty program
 * Attacks that require social engineering
 
 Eligibility:
-* The participant submitting the bug report shall follow the process outlined within this document
+* The participant submitting the bug bounty shall follow the process outlined within this document
 * Valid exploits can be eligible even if they are not successfully executed on the cluster
 * Multiple submissions for the same class of exploit are still eligible for compensation, though may be compensated at a lower rate, however these will be assessed on a case-by-case basis
 * Participants must complete KYC and sign the participation agreement here when the registrations are open https://solana.com/validator-registration. Security exploits will still be assessed and open for submission at all times. This needs only be done prior to distribution of tokens.
 
-Payment of Bug Bounties:
-* Payments for eligible bug reports are distributed monthly.
-* Bounties for all bug reports submitted in a given month are paid out in the middle of the
-following month.
-* The SOL/USD conversion rate used for payments is the market price at the end of
-  the last day of the month for the month in which the bug was submitted.
-* The reference for this price is the Closing Price given by Coingecko.com on
-  that date given here:
-  https://www.coingecko.com/en/coins/solana/historical_data/usd#panel
-* For example, for all bugs submitted in March 2021, the SOL/USD price for bug
-  payouts is the Close price on 2021-03-31 of $19.49.  This applies to all bugs
-  submitted in March 2021, to be paid in mid-April 2021.
-* Bug bounties are paid out in
-[stake accounts](https://solana.com/staking) with a
-[lockup](https://docs.solana.com/staking/stake-accounts#lockups)
-expiring 12 months from the last day of the month in which the bug was submitted.
+Notes:
+* All locked tokens can be staked during the lockup period
 
 <a name="process"></a>
 ## Incident Response Process

account-decoder/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-account-decoder"
-version = "1.7.7"
+version = "1.5.20"
 description = "Solana account decoder"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -16,13 +16,14 @@ bs58 = "0.3.1"
 bv = "0.11.1"
 Inflector = "0.11.4"
 lazy_static = "1.4.0"
-serde = "1.0.122"
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-config-program = { path = "../programs/config", version = "=1.7.7" }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.7.7" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.2.0", features = ["no-entrypoint"] }
+solana-config-program = { path = "../programs/config", version = "=1.5.20" }
+solana-sdk = { path = "../sdk", version = "=1.5.20" }
+solana-stake-program = { path = "../programs/stake", version = "=1.5.20" }
+solana-vote-program = { path = "../programs/vote", version = "=1.5.20" }
+spl-token-v2-0 = { package = "spl-token", version = "=3.1.0", features = ["no-entrypoint"] }
 thiserror = "1.0"
 zstd = "0.5.1"
 

account-decoder/src/lib.rs

@@ -16,10 +16,7 @@ pub mod validator_info;
 
 use {
     crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount},
-    solana_sdk::{
-        account::ReadableAccount, account::WritableAccount, clock::Epoch,
-        fee_calculator::FeeCalculator, pubkey::Pubkey,
-    },
+    solana_sdk::{account::Account, clock::Epoch, fee_calculator::FeeCalculator, pubkey::Pubkey},
     std::{
         io::{Read, Write},
         str::FromStr,
@@ -48,7 +45,7 @@ pub enum UiAccountData {
     Binary(String, UiAccountEncoding),
 }
 
-#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub enum UiAccountEncoding {
     Binary, // Legacy. Retained for RPC backwards compatibility
@@ -60,61 +57,58 @@ pub enum UiAccountEncoding {
 }
 
 impl UiAccount {
-    pub fn encode<T: ReadableAccount>(
+    pub fn encode(
         pubkey: &Pubkey,
-        account: &T,
+        account: Account,
         encoding: UiAccountEncoding,
         additional_data: Option<AccountAdditionalData>,
         data_slice_config: Option<UiDataSliceConfig>,
     ) -> Self {
         let data = match encoding {
             UiAccountEncoding::Binary => UiAccountData::LegacyBinary(
-                bs58::encode(slice_data(account.data(), data_slice_config)).into_string(),
+                bs58::encode(slice_data(&account.data, data_slice_config)).into_string(),
             ),
             UiAccountEncoding::Base58 => UiAccountData::Binary(
-                bs58::encode(slice_data(account.data(), data_slice_config)).into_string(),
+                bs58::encode(slice_data(&account.data, data_slice_config)).into_string(),
                 encoding,
             ),
             UiAccountEncoding::Base64 => UiAccountData::Binary(
-                base64::encode(slice_data(account.data(), data_slice_config)),
+                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))
+                    .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)),
+                        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)
+                    parse_account_data(pubkey, &account.owner, &account.data, additional_data)
                 {
                     UiAccountData::Json(parsed_data)
                 } else {
-                    UiAccountData::Binary(
-                        base64::encode(&account.data()),
-                        UiAccountEncoding::Base64,
-                    )
+                    UiAccountData::Binary(base64::encode(&account.data), UiAccountEncoding::Base64)
                 }
             }
         };
         UiAccount {
-            lamports: account.lamports(),
+            lamports: account.lamports,
             data,
-            owner: account.owner().to_string(),
-            executable: account.executable(),
-            rent_epoch: account.rent_epoch(),
+            owner: account.owner.to_string(),
+            executable: account.executable,
+            rent_epoch: account.rent_epoch,
         }
     }
 
-    pub fn decode<T: WritableAccount>(&self) -> Option<T> {
+    pub fn decode(&self) -> Option<Account> {
         let data = match &self.data {
             UiAccountData::Json(_) => None,
             UiAccountData::LegacyBinary(blob) => bs58::decode(blob).into_vec().ok(),
@@ -134,13 +128,13 @@ impl UiAccount {
                 UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
             },
         }?;
-        Some(T::create(
-            self.lamports,
+        Some(Account {
+            lamports: self.lamports,
             data,
-            Pubkey::from_str(&self.owner).ok()?,
-            self.executable,
-            self.rent_epoch,
-        ))
+            owner: Pubkey::from_str(&self.owner).ok()?,
+            executable: self.executable,
+            rent_epoch: self.rent_epoch,
+        })
     }
 }
 
@@ -190,7 +184,6 @@ fn slice_data(data: &[u8], data_slice_config: Option<UiDataSliceConfig>) -> &[u8
 #[cfg(test)]
 mod test {
     use super::*;
-    use solana_sdk::account::{Account, AccountSharedData};
 
     #[test]
     fn test_slice_data() {
@@ -224,10 +217,10 @@ mod test {
     fn test_base64_zstd() {
         let encoded_account = UiAccount::encode(
             &Pubkey::default(),
-            &AccountSharedData::from(Account {
+            Account {
                 data: vec![0; 1024],
                 ..Account::default()
-            }),
+            },
             UiAccountEncoding::Base64Zstd,
             None,
             None,
@@ -237,9 +230,7 @@ mod test {
             UiAccountData::Binary(_, UiAccountEncoding::Base64Zstd)
         ));
 
-        let decoded_account = encoded_account.decode::<Account>().unwrap();
-        assert_eq!(decoded_account.data(), &vec![0; 1024]);
-        let decoded_account = encoded_account.decode::<AccountSharedData>().unwrap();
-        assert_eq!(decoded_account.data(), &vec![0; 1024]);
+        let decoded_account = encoded_account.decode().unwrap();
+        assert_eq!(decoded_account.data, vec![0; 1024]);
     }
 }

account-decoder/src/parse_account_data.rs

@@ -9,14 +9,14 @@ use crate::{
 };
 use inflector::Inflector;
 use serde_json::Value;
-use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, stake, system_program, sysvar};
+use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, system_program, sysvar};
 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 = stake::program::id();
+    static ref STAKE_PROGRAM_ID: Pubkey = solana_stake_program::id();
     static ref SYSTEM_PROGRAM_ID: Pubkey = system_program::id();
     static ref SYSVAR_PROGRAM_ID: Pubkey = sysvar::id();
     static ref TOKEN_PROGRAM_ID: Pubkey = spl_token_id_v2_0();

account-decoder/src/parse_config.rs

@@ -6,10 +6,10 @@ use bincode::deserialize;
 use serde_json::Value;
 use solana_config_program::{get_config_data, ConfigKeys};
 use solana_sdk::pubkey::Pubkey;
-use solana_sdk::stake::config::{self as stake_config, Config as StakeConfig};
+use solana_stake_program::config::Config as StakeConfig;
 
 pub fn parse_config(data: &[u8], pubkey: &Pubkey) -> Result<ConfigAccountType, ParseAccountError> {
-    let parsed_account = if pubkey == &stake_config::id() {
+    let parsed_account = if pubkey == &solana_stake_program::config::id() {
         get_config_data(data)
             .ok()
             .and_then(|data| deserialize::<StakeConfig>(data).ok())
@@ -37,7 +37,7 @@ fn parse_config_data<T>(data: &[u8], keys: Vec<(Pubkey, bool)>) -> Option<UiConf
 where
     T: serde::de::DeserializeOwned,
 {
-    let config_data: T = deserialize(get_config_data(data).ok()?).ok()?;
+    let config_data: T = deserialize(&get_config_data(data).ok()?).ok()?;
     let keys = keys
         .iter()
         .map(|key| UiConfigKey {
@@ -91,7 +91,6 @@ mod test {
     use crate::validator_info::ValidatorInfo;
     use serde_json::json;
     use solana_config_program::create_config_account;
-    use solana_sdk::account::ReadableAccount;
 
     #[test]
     fn test_parse_config() {
@@ -101,7 +100,11 @@ mod test {
         };
         let stake_config_account = create_config_account(vec![], &stake_config, 10);
         assert_eq!(
-            parse_config(stake_config_account.data(), &stake_config::id()).unwrap(),
+            parse_config(
+                &stake_config_account.data,
+                &solana_stake_program::config::id()
+            )
+            .unwrap(),
             ConfigAccountType::StakeConfig(UiStakeConfig {
                 warmup_cooldown_rate: 0.25,
                 slash_penalty: 50,
@@ -121,7 +124,7 @@ mod test {
             10,
         );
         assert_eq!(
-            parse_config(validator_info_config_account.data(), &info_pubkey).unwrap(),
+            parse_config(&validator_info_config_account.data, &info_pubkey).unwrap(),
             ConfigAccountType::ValidatorInfo(UiConfig {
                 keys: vec![
                     UiConfigKey {

account-decoder/src/parse_stake.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use bincode::deserialize;
 use solana_sdk::clock::{Epoch, UnixTimestamp};
-use solana_sdk::stake::state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState};
+use solana_stake_program::stake_state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState};
 
 pub fn parse_stake(data: &[u8]) -> Result<StakeAccountType, ParseAccountError> {
     let stake_state: StakeState = deserialize(data)

account-decoder/src/parse_token.rs

@@ -14,23 +14,23 @@ use std::str::FromStr;
 // A helper function to convert spl_token_v2_0::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
 pub fn spl_token_id_v2_0() -> Pubkey {
-    Pubkey::new_from_array(spl_token_v2_0::id().to_bytes())
+    Pubkey::from_str(&spl_token_v2_0::id().to_string()).unwrap()
 }
 
 // A helper function to convert spl_token_v2_0::native_mint::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
 pub fn spl_token_v2_0_native_mint() -> Pubkey {
-    Pubkey::new_from_array(spl_token_v2_0::native_mint::id().to_bytes())
+    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::new_from_array(pubkey.to_bytes())
+    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::new_from_array(pubkey.to_bytes())
+    Pubkey::from_str(&pubkey.to_string()).unwrap()
 }
 
 pub fn parse_token(

accounts-bench/Cargo.toml

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

accounts-bench/src/main.rs

@@ -6,12 +6,10 @@ use rayon::prelude::*;
 use solana_measure::measure::Measure;
 use solana_runtime::{
     accounts::{create_test_accounts, update_accounts_bench, Accounts},
-    accounts_db::AccountShrinkThreshold,
-    accounts_index::AccountSecondaryIndexes,
-    ancestors::Ancestors,
+    accounts_index::Ancestors,
 };
 use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
-use std::{env, fs, path::PathBuf};
+use std::{collections::HashSet, env, fs, path::PathBuf};
 
 fn main() {
     solana_logger::setup();
@@ -60,13 +58,8 @@ fn main() {
     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,
-        AccountSecondaryIndexes::default(),
-        false,
-        AccountShrinkThreshold::default(),
-    );
+    let accounts =
+        Accounts::new_with_config(vec![path], &ClusterType::Testnet, HashSet::new(), false);
     println!("Creating {} accounts", num_accounts);
     let mut create_time = Measure::start("create accounts");
     let pubkeys: Vec<_> = (0..num_slots)
@@ -90,19 +83,17 @@ fn main() {
         num_slots,
         create_time
     );
-    let mut ancestors = Vec::with_capacity(num_slots);
-    ancestors.push(0);
+    let mut ancestors: Ancestors = vec![(0, 0)].into_iter().collect();
     for i in 1..num_slots {
-        ancestors.push(i as u64);
+        ancestors.insert(i as u64, i - 1);
         accounts.add_root(i as u64);
     }
-    let ancestors = Ancestors::from(ancestors);
     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");
-            accounts.accounts_db.clean_accounts(None, false);
+            accounts.accounts_db.clean_accounts(None);
             time.stop();
             println!("{}", time);
             for slot in 0..num_slots {
@@ -121,7 +112,6 @@ fn main() {
                 solana_sdk::clock::Slot::default(),
                 &ancestors,
                 None,
-                false,
             );
             time_store.stop();
             if results != results_store {

accounts-cluster-bench/.gitignore

@@ -1 +0,0 @@
-/farf/

accounts-cluster-bench/Cargo.toml

@@ -1,35 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-accounts-cluster-bench"
-version = "1.7.7"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-publish = false
-
-[dependencies]
-clap = "2.33.1"
-log = "0.4.11"
-rand = "0.7.0"
-rayon = "1.4.1"
-solana-account-decoder = { path = "../account-decoder", version = "=1.7.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.7.7" }
-solana-client = { path = "../client", version = "=1.7.7" }
-solana-core = { path = "../core", version = "=1.7.7" }
-solana-faucet = { path = "../faucet", version = "=1.7.7" }
-solana-gossip = { path = "../gossip", version = "=1.7.7" }
-solana-logger = { path = "../logger", version = "=1.7.7" }
-solana-measure = { path = "../measure", version = "=1.7.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.7.7" }
-solana-runtime = { path = "../runtime", version = "=1.7.7" }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.7.7" }
-solana-version = { path = "../version", version = "=1.7.7" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.2.0", features = ["no-entrypoint"] }
-
-[dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "=1.7.7" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

accounts-cluster-bench/src/main.rs

@@ -1,747 +0,0 @@
-#![allow(clippy::integer_arithmetic)]
-use clap::{crate_description, crate_name, value_t, values_t_or_exit, App, Arg};
-use log::*;
-use rand::{thread_rng, Rng};
-use rayon::prelude::*;
-use solana_account_decoder::parse_token::spl_token_v2_0_pubkey;
-use solana_clap_utils::input_parsers::pubkey_of;
-use solana_client::rpc_client::RpcClient;
-use solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT};
-use solana_gossip::gossip_service::discover;
-use solana_measure::measure::Measure;
-use solana_runtime::inline_spl_token_v2_0;
-use solana_sdk::{
-    commitment_config::CommitmentConfig,
-    message::Message,
-    pubkey::Pubkey,
-    rpc_port::DEFAULT_RPC_PORT,
-    signature::{read_keypair_file, Keypair, Signature, Signer},
-    system_instruction, system_program,
-    timing::timestamp,
-    transaction::Transaction,
-};
-use solana_transaction_status::parse_token::spl_token_v2_0_instruction;
-use std::{
-    net::SocketAddr,
-    process::exit,
-    sync::{
-        atomic::{AtomicBool, AtomicU64, Ordering},
-        Arc, RwLock,
-    },
-    thread::{sleep, Builder, JoinHandle},
-    time::{Duration, Instant},
-};
-
-// Create and close messages both require 2 signatures; if transaction construction changes, update
-// this magic number
-const NUM_SIGNATURES: u64 = 2;
-
-pub fn airdrop_lamports(
-    client: &RpcClient,
-    faucet_addr: &SocketAddr,
-    id: &Keypair,
-    desired_balance: u64,
-) -> bool {
-    let starting_balance = client.get_balance(&id.pubkey()).unwrap_or(0);
-    info!("starting balance {}", starting_balance);
-
-    if starting_balance < desired_balance {
-        let airdrop_amount = desired_balance - starting_balance;
-        info!(
-            "Airdropping {:?} lamports from {} for {}",
-            airdrop_amount,
-            faucet_addr,
-            id.pubkey(),
-        );
-
-        let (blockhash, _fee_calculator) = client.get_recent_blockhash().unwrap();
-        match request_airdrop_transaction(faucet_addr, &id.pubkey(), airdrop_amount, blockhash) {
-            Ok(transaction) => {
-                let mut tries = 0;
-                loop {
-                    tries += 1;
-                    let result = client.send_and_confirm_transaction(&transaction);
-
-                    if result.is_ok() {
-                        break;
-                    }
-                    if tries >= 5 {
-                        panic!(
-                            "Error requesting airdrop: to addr: {:?} amount: {} {:?}",
-                            faucet_addr, airdrop_amount, result
-                        )
-                    }
-                }
-            }
-            Err(err) => {
-                panic!(
-                    "Error requesting airdrop: {:?} to addr: {:?} amount: {}",
-                    err, faucet_addr, airdrop_amount
-                );
-            }
-        };
-
-        let current_balance = client.get_balance(&id.pubkey()).unwrap_or_else(|e| {
-            panic!("airdrop error {}", e);
-        });
-        info!("current balance {}...", current_balance);
-
-        if current_balance - starting_balance != airdrop_amount {
-            info!(
-                "Airdrop failed? {} {} {} {}",
-                id.pubkey(),
-                current_balance,
-                starting_balance,
-                airdrop_amount,
-            );
-        }
-    }
-    true
-}
-
-// signature, timestamp, id
-type PendingQueue = Vec<(Signature, u64, u64)>;
-
-struct TransactionExecutor {
-    sig_clear_t: JoinHandle<()>,
-    sigs: Arc<RwLock<PendingQueue>>,
-    cleared: Arc<RwLock<Vec<u64>>>,
-    exit: Arc<AtomicBool>,
-    counter: AtomicU64,
-    client: RpcClient,
-}
-
-impl TransactionExecutor {
-    fn new(entrypoint_addr: SocketAddr) -> Self {
-        let sigs = Arc::new(RwLock::new(Vec::new()));
-        let cleared = Arc::new(RwLock::new(Vec::new()));
-        let exit = Arc::new(AtomicBool::new(false));
-        let sig_clear_t = Self::start_sig_clear_thread(&exit, &sigs, &cleared, entrypoint_addr);
-        let client =
-            RpcClient::new_socket_with_commitment(entrypoint_addr, CommitmentConfig::confirmed());
-        Self {
-            sigs,
-            cleared,
-            sig_clear_t,
-            exit,
-            counter: AtomicU64::new(0),
-            client,
-        }
-    }
-
-    fn num_outstanding(&self) -> usize {
-        self.sigs.read().unwrap().len()
-    }
-
-    fn push_transactions(&self, txs: Vec<Transaction>) -> Vec<u64> {
-        let mut ids = vec![];
-        let new_sigs = txs.into_iter().filter_map(|tx| {
-            let id = self.counter.fetch_add(1, Ordering::Relaxed);
-            ids.push(id);
-            match self.client.send_transaction(&tx) {
-                Ok(sig) => {
-                    return Some((sig, timestamp(), id));
-                }
-                Err(e) => {
-                    info!("error: {:#?}", e);
-                }
-            }
-            None
-        });
-        let mut sigs_w = self.sigs.write().unwrap();
-        sigs_w.extend(new_sigs);
-        ids
-    }
-
-    fn drain_cleared(&self) -> Vec<u64> {
-        std::mem::take(&mut *self.cleared.write().unwrap())
-    }
-
-    fn close(self) {
-        self.exit.store(true, Ordering::Relaxed);
-        self.sig_clear_t.join().unwrap();
-    }
-
-    fn start_sig_clear_thread(
-        exit: &Arc<AtomicBool>,
-        sigs: &Arc<RwLock<PendingQueue>>,
-        cleared: &Arc<RwLock<Vec<u64>>>,
-        entrypoint_addr: SocketAddr,
-    ) -> JoinHandle<()> {
-        let sigs = sigs.clone();
-        let exit = exit.clone();
-        let cleared = cleared.clone();
-        Builder::new()
-            .name("sig_clear".to_string())
-            .spawn(move || {
-                let client = RpcClient::new_socket_with_commitment(
-                    entrypoint_addr,
-                    CommitmentConfig::confirmed(),
-                );
-                let mut success = 0;
-                let mut error_count = 0;
-                let mut timed_out = 0;
-                let mut last_log = Instant::now();
-                while !exit.load(Ordering::Relaxed) {
-                    let sigs_len = sigs.read().unwrap().len();
-                    if sigs_len > 0 {
-                        let mut sigs_w = sigs.write().unwrap();
-                        let mut start = Measure::start("sig_status");
-                        let statuses: Vec<_> = sigs_w
-                            .chunks(200)
-                            .flat_map(|sig_chunk| {
-                                let only_sigs: Vec<_> = sig_chunk.iter().map(|s| s.0).collect();
-                                client
-                                    .get_signature_statuses(&only_sigs)
-                                    .expect("status fail")
-                                    .value
-                            })
-                            .collect();
-                        let mut num_cleared = 0;
-                        let start_len = sigs_w.len();
-                        let now = timestamp();
-                        let mut new_ids = vec![];
-                        let mut i = 0;
-                        let mut j = 0;
-                        while i != sigs_w.len() {
-                            let mut retain = true;
-                            let sent_ts = sigs_w[i].1;
-                            if let Some(e) = &statuses[j] {
-                                debug!("error: {:?}", e);
-                                if e.status.is_ok() {
-                                    success += 1;
-                                } else {
-                                    error_count += 1;
-                                }
-                                num_cleared += 1;
-                                retain = false;
-                            } else if now - sent_ts > 30_000 {
-                                retain = false;
-                                timed_out += 1;
-                            }
-                            if !retain {
-                                new_ids.push(sigs_w.remove(i).2);
-                            } else {
-                                i += 1;
-                            }
-                            j += 1;
-                        }
-                        let final_sigs_len = sigs_w.len();
-                        drop(sigs_w);
-                        cleared.write().unwrap().extend(new_ids);
-                        start.stop();
-                        debug!(
-                            "sigs len: {:?} success: {} took: {}ms cleared: {}/{}",
-                            final_sigs_len,
-                            success,
-                            start.as_ms(),
-                            num_cleared,
-                            start_len,
-                        );
-                        if last_log.elapsed().as_millis() > 5000 {
-                            info!(
-                                "success: {} error: {} timed_out: {}",
-                                success, error_count, timed_out,
-                            );
-                            last_log = Instant::now();
-                        }
-                    }
-                    sleep(Duration::from_millis(200));
-                }
-            })
-            .unwrap()
-    }
-}
-
-struct SeedTracker {
-    max_created: Arc<AtomicU64>,
-    max_closed: Arc<AtomicU64>,
-}
-
-fn make_create_message(
-    keypair: &Keypair,
-    base_keypair: &Keypair,
-    max_created_seed: Arc<AtomicU64>,
-    num_instructions: usize,
-    balance: u64,
-    maybe_space: Option<u64>,
-    mint: Option<Pubkey>,
-) -> Message {
-    let space = maybe_space.unwrap_or_else(|| thread_rng().gen_range(0, 1000));
-
-    let instructions: Vec<_> = (0..num_instructions)
-        .into_iter()
-        .map(|_| {
-            let program_id = if mint.is_some() {
-                inline_spl_token_v2_0::id()
-            } else {
-                system_program::id()
-            };
-            let seed = max_created_seed.fetch_add(1, Ordering::Relaxed).to_string();
-            let to_pubkey =
-                Pubkey::create_with_seed(&base_keypair.pubkey(), &seed, &program_id).unwrap();
-            let mut instructions = vec![system_instruction::create_account_with_seed(
-                &keypair.pubkey(),
-                &to_pubkey,
-                &base_keypair.pubkey(),
-                &seed,
-                balance,
-                space,
-                &program_id,
-            )];
-            if let Some(mint_address) = mint {
-                instructions.push(spl_token_v2_0_instruction(
-                    spl_token_v2_0::instruction::initialize_account(
-                        &spl_token_v2_0::id(),
-                        &spl_token_v2_0_pubkey(&to_pubkey),
-                        &spl_token_v2_0_pubkey(&mint_address),
-                        &spl_token_v2_0_pubkey(&base_keypair.pubkey()),
-                    )
-                    .unwrap(),
-                ));
-            }
-
-            instructions
-        })
-        .collect();
-    let instructions: Vec<_> = instructions.into_iter().flatten().collect();
-
-    Message::new(&instructions, Some(&keypair.pubkey()))
-}
-
-fn make_close_message(
-    keypair: &Keypair,
-    base_keypair: &Keypair,
-    max_closed_seed: Arc<AtomicU64>,
-    num_instructions: usize,
-    balance: u64,
-    spl_token: bool,
-) -> Message {
-    let instructions: Vec<_> = (0..num_instructions)
-        .into_iter()
-        .map(|_| {
-            let program_id = if spl_token {
-                inline_spl_token_v2_0::id()
-            } else {
-                system_program::id()
-            };
-            let seed = max_closed_seed.fetch_add(1, Ordering::Relaxed).to_string();
-            let address =
-                Pubkey::create_with_seed(&base_keypair.pubkey(), &seed, &program_id).unwrap();
-            if spl_token {
-                spl_token_v2_0_instruction(
-                    spl_token_v2_0::instruction::close_account(
-                        &spl_token_v2_0::id(),
-                        &spl_token_v2_0_pubkey(&address),
-                        &spl_token_v2_0_pubkey(&keypair.pubkey()),
-                        &spl_token_v2_0_pubkey(&base_keypair.pubkey()),
-                        &[],
-                    )
-                    .unwrap(),
-                )
-            } else {
-                system_instruction::transfer_with_seed(
-                    &address,
-                    &base_keypair.pubkey(),
-                    seed,
-                    &program_id,
-                    &keypair.pubkey(),
-                    balance,
-                )
-            }
-        })
-        .collect();
-
-    Message::new(&instructions, Some(&keypair.pubkey()))
-}
-
-#[allow(clippy::too_many_arguments)]
-fn run_accounts_bench(
-    entrypoint_addr: SocketAddr,
-    faucet_addr: SocketAddr,
-    payer_keypairs: &[&Keypair],
-    iterations: usize,
-    maybe_space: Option<u64>,
-    batch_size: usize,
-    close_nth_batch: u64,
-    maybe_lamports: Option<u64>,
-    num_instructions: usize,
-    mint: Option<Pubkey>,
-) {
-    assert!(num_instructions > 0);
-    let client =
-        RpcClient::new_socket_with_commitment(entrypoint_addr, CommitmentConfig::confirmed());
-
-    info!("Targeting {}", entrypoint_addr);
-
-    let mut last_blockhash = Instant::now();
-    let mut last_log = Instant::now();
-    let mut count = 0;
-    let mut recent_blockhash = client.get_recent_blockhash().expect("blockhash");
-    let mut tx_sent_count = 0;
-    let mut total_accounts_created = 0;
-    let mut total_accounts_closed = 0;
-    let mut balances: Vec<_> = payer_keypairs
-        .iter()
-        .map(|keypair| client.get_balance(&keypair.pubkey()).unwrap_or(0))
-        .collect();
-    let mut last_balance = Instant::now();
-
-    let default_max_lamports = 1000;
-    let min_balance = maybe_lamports.unwrap_or_else(|| {
-        let space = maybe_space.unwrap_or(default_max_lamports);
-        client
-            .get_minimum_balance_for_rent_exemption(space as usize)
-            .expect("min balance")
-    });
-
-    let base_keypair = Keypair::new();
-    let seed_tracker = SeedTracker {
-        max_created: Arc::new(AtomicU64::default()),
-        max_closed: Arc::new(AtomicU64::default()),
-    };
-
-    info!("Starting balance(s): {:?}", balances);
-
-    let executor = TransactionExecutor::new(entrypoint_addr);
-
-    loop {
-        if last_blockhash.elapsed().as_millis() > 10_000 {
-            recent_blockhash = client.get_recent_blockhash().expect("blockhash");
-            last_blockhash = Instant::now();
-        }
-
-        let fee = recent_blockhash
-            .1
-            .lamports_per_signature
-            .saturating_mul(NUM_SIGNATURES);
-        let lamports = min_balance + fee;
-
-        for (i, balance) in balances.iter_mut().enumerate() {
-            if *balance < lamports || last_balance.elapsed().as_millis() > 2000 {
-                if let Ok(b) = client.get_balance(&payer_keypairs[i].pubkey()) {
-                    *balance = b;
-                }
-                last_balance = Instant::now();
-                if *balance < lamports * 2 {
-                    info!(
-                        "Balance {} is less than needed: {}, doing aidrop...",
-                        balance, lamports
-                    );
-                    if !airdrop_lamports(
-                        &client,
-                        &faucet_addr,
-                        payer_keypairs[i],
-                        lamports * 100_000,
-                    ) {
-                        warn!("failed airdrop, exiting");
-                        return;
-                    }
-                }
-            }
-        }
-
-        // Create accounts
-        let sigs_len = executor.num_outstanding();
-        if sigs_len < batch_size {
-            let num_to_create = batch_size - sigs_len;
-            if num_to_create >= payer_keypairs.len() {
-                info!("creating {} new", num_to_create);
-                let chunk_size = num_to_create / payer_keypairs.len();
-                if chunk_size > 0 {
-                    for (i, keypair) in payer_keypairs.iter().enumerate() {
-                        let txs: Vec<_> = (0..chunk_size)
-                            .into_par_iter()
-                            .map(|_| {
-                                let message = make_create_message(
-                                    keypair,
-                                    &base_keypair,
-                                    seed_tracker.max_created.clone(),
-                                    num_instructions,
-                                    min_balance,
-                                    maybe_space,
-                                    mint,
-                                );
-                                let signers: Vec<&Keypair> = vec![keypair, &base_keypair];
-                                Transaction::new(&signers, message, recent_blockhash.0)
-                            })
-                            .collect();
-                        balances[i] = balances[i].saturating_sub(lamports * txs.len() as u64);
-                        info!("txs: {}", txs.len());
-                        let new_ids = executor.push_transactions(txs);
-                        info!("ids: {}", new_ids.len());
-                        tx_sent_count += new_ids.len();
-                        total_accounts_created += num_instructions * new_ids.len();
-                    }
-                }
-            }
-
-            if close_nth_batch > 0 {
-                let num_batches_to_close =
-                    total_accounts_created as u64 / (close_nth_batch * batch_size as u64);
-                let expected_closed = num_batches_to_close * batch_size as u64;
-                let max_closed_seed = seed_tracker.max_closed.load(Ordering::Relaxed);
-                // Close every account we've created with seed between max_closed_seed..expected_closed
-                if max_closed_seed < expected_closed {
-                    let txs: Vec<_> = (0..expected_closed - max_closed_seed)
-                        .into_par_iter()
-                        .map(|_| {
-                            let message = make_close_message(
-                                payer_keypairs[0],
-                                &base_keypair,
-                                seed_tracker.max_closed.clone(),
-                                1,
-                                min_balance,
-                                mint.is_some(),
-                            );
-                            let signers: Vec<&Keypair> = vec![payer_keypairs[0], &base_keypair];
-                            Transaction::new(&signers, message, recent_blockhash.0)
-                        })
-                        .collect();
-                    balances[0] = balances[0].saturating_sub(fee * txs.len() as u64);
-                    info!("close txs: {}", txs.len());
-                    let new_ids = executor.push_transactions(txs);
-                    info!("close ids: {}", new_ids.len());
-                    tx_sent_count += new_ids.len();
-                    total_accounts_closed += new_ids.len() as u64;
-                }
-            }
-        } else {
-            let _ = executor.drain_cleared();
-        }
-
-        count += 1;
-        if last_log.elapsed().as_millis() > 3000 {
-            info!(
-                "total_accounts_created: {} total_accounts_closed: {} tx_sent_count: {} loop_count: {} balance(s): {:?}",
-                total_accounts_created, total_accounts_closed, tx_sent_count, count, balances
-            );
-            last_log = Instant::now();
-        }
-        if iterations != 0 && count >= iterations {
-            break;
-        }
-        if executor.num_outstanding() >= batch_size {
-            sleep(Duration::from_millis(500));
-        }
-    }
-    executor.close();
-}
-
-fn main() {
-    solana_logger::setup_with_default("solana=info");
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("entrypoint")
-                .long("entrypoint")
-                .takes_value(true)
-                .value_name("HOST:PORT")
-                .help("RPC entrypoint address. Usually <ip>:8899"),
-        )
-        .arg(
-            Arg::with_name("faucet_addr")
-                .long("faucet")
-                .takes_value(true)
-                .value_name("HOST:PORT")
-                .help("Faucet entrypoint address. Usually <ip>:9900"),
-        )
-        .arg(
-            Arg::with_name("space")
-                .long("space")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help("Size of accounts to create"),
-        )
-        .arg(
-            Arg::with_name("lamports")
-                .long("lamports")
-                .takes_value(true)
-                .value_name("LAMPORTS")
-                .help("How many lamports to fund each account"),
-        )
-        .arg(
-            Arg::with_name("identity")
-                .long("identity")
-                .takes_value(true)
-                .multiple(true)
-                .value_name("FILE")
-                .help("keypair file"),
-        )
-        .arg(
-            Arg::with_name("batch_size")
-                .long("batch-size")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help("Number of transactions to send per batch"),
-        )
-        .arg(
-            Arg::with_name("close_nth_batch")
-                .long("close-frequency")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help(
-                    "Every `n` batches, create a batch of close transactions for
-                    the earliest remaining batch of accounts created.
-                    Note: Should be > 1 to avoid situations where the close \
-                    transactions will be submitted before the corresponding \
-                    create transactions have been confirmed",
-                ),
-        )
-        .arg(
-            Arg::with_name("num_instructions")
-                .long("num-instructions")
-                .takes_value(true)
-                .value_name("NUM")
-                .help("Number of accounts to create on each transaction"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .value_name("NUM")
-                .help("Number of iterations to make"),
-        )
-        .arg(
-            Arg::with_name("check_gossip")
-                .long("check-gossip")
-                .help("Just use entrypoint address directly"),
-        )
-        .arg(
-            Arg::with_name("mint")
-                .long("mint")
-                .takes_value(true)
-                .help("Mint address to initialize account"),
-        )
-        .get_matches();
-
-    let skip_gossip = !matches.is_present("check_gossip");
-
-    let port = if skip_gossip { DEFAULT_RPC_PORT } else { 8001 };
-    let mut entrypoint_addr = SocketAddr::from(([127, 0, 0, 1], port));
-    if let Some(addr) = matches.value_of("entrypoint") {
-        entrypoint_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
-            eprintln!("failed to parse entrypoint address: {}", e);
-            exit(1)
-        });
-    }
-    let mut faucet_addr = SocketAddr::from(([127, 0, 0, 1], FAUCET_PORT));
-    if let Some(addr) = matches.value_of("faucet_addr") {
-        faucet_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
-            eprintln!("failed to parse entrypoint address: {}", e);
-            exit(1)
-        });
-    }
-
-    let space = value_t!(matches, "space", u64).ok();
-    let lamports = value_t!(matches, "lamports", u64).ok();
-    let batch_size = value_t!(matches, "batch_size", usize).unwrap_or(4);
-    let close_nth_batch = value_t!(matches, "close_nth_batch", u64).unwrap_or(0);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(10);
-    let num_instructions = value_t!(matches, "num_instructions", usize).unwrap_or(1);
-    if num_instructions == 0 || num_instructions > 500 {
-        eprintln!("bad num_instructions: {}", num_instructions);
-        exit(1);
-    }
-
-    let mint = pubkey_of(&matches, "mint");
-
-    let payer_keypairs: Vec<_> = values_t_or_exit!(matches, "identity", String)
-        .iter()
-        .map(|keypair_string| {
-            read_keypair_file(keypair_string)
-                .unwrap_or_else(|_| panic!("bad keypair {:?}", keypair_string))
-        })
-        .collect();
-    let mut payer_keypair_refs: Vec<&Keypair> = vec![];
-    for keypair in payer_keypairs.iter() {
-        payer_keypair_refs.push(keypair);
-    }
-
-    let rpc_addr = if !skip_gossip {
-        info!("Finding cluster entry: {:?}", entrypoint_addr);
-        let (gossip_nodes, _validators) = discover(
-            None, // keypair
-            Some(&entrypoint_addr),
-            None,                    // num_nodes
-            Duration::from_secs(60), // timeout
-            None,                    // find_node_by_pubkey
-            Some(&entrypoint_addr),  // find_node_by_gossip_addr
-            None,                    // my_gossip_addr
-            0,                       // my_shred_version
-        )
-        .unwrap_or_else(|err| {
-            eprintln!("Failed to discover {} node: {:?}", entrypoint_addr, err);
-            exit(1);
-        });
-
-        info!("done found {} nodes", gossip_nodes.len());
-        gossip_nodes[0].rpc
-    } else {
-        info!("Using {:?} as the RPC address", entrypoint_addr);
-        entrypoint_addr
-    };
-
-    run_accounts_bench(
-        rpc_addr,
-        faucet_addr,
-        &payer_keypair_refs,
-        iterations,
-        space,
-        batch_size,
-        close_nth_batch,
-        lamports,
-        num_instructions,
-        mint,
-    );
-}
-
-#[cfg(test)]
-pub mod test {
-    use super::*;
-    use solana_core::validator::ValidatorConfig;
-    use solana_local_cluster::{
-        local_cluster::{ClusterConfig, LocalCluster},
-        validator_configs::make_identical_validator_configs,
-    };
-    use solana_sdk::poh_config::PohConfig;
-
-    #[test]
-    fn test_accounts_cluster_bench() {
-        solana_logger::setup();
-        let validator_config = ValidatorConfig::default();
-        let num_nodes = 1;
-        let mut config = ClusterConfig {
-            cluster_lamports: 10_000_000,
-            poh_config: PohConfig::new_sleep(Duration::from_millis(50)),
-            node_stakes: vec![100; num_nodes],
-            validator_configs: make_identical_validator_configs(&validator_config, num_nodes),
-            ..ClusterConfig::default()
-        };
-
-        let faucet_addr = SocketAddr::from(([127, 0, 0, 1], 9900));
-        let cluster = LocalCluster::new(&mut config);
-        let iterations = 10;
-        let maybe_space = None;
-        let batch_size = 100;
-        let close_nth_batch = 100;
-        let maybe_lamports = None;
-        let num_instructions = 2;
-        let mut start = Measure::start("total accounts run");
-        run_accounts_bench(
-            cluster.entry_point_info.rpc,
-            faucet_addr,
-            &[&cluster.funding_keypair],
-            iterations,
-            maybe_space,
-            batch_size,
-            close_nth_batch,
-            maybe_lamports,
-            num_instructions,
-            None,
-        );
-        start.stop();
-        info!("{}", start);
-    }
-}

banking-bench/Cargo.toml

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

banking-bench/src/main.rs

@@ -4,8 +4,13 @@ use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
 use rayon::prelude::*;
-use solana_core::banking_stage::BankingStage;
-use solana_gossip::{cluster_info::ClusterInfo, cluster_info::Node};
+use solana_core::{
+    banking_stage::{create_test_recorder, BankingStage},
+    cluster_info::ClusterInfo,
+    cluster_info::Node,
+    poh_recorder::PohRecorder,
+    poh_recorder::WorkingBankEntry,
+};
 use solana_ledger::{
     blockstore::Blockstore,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
@@ -13,7 +18,6 @@ use solana_ledger::{
 };
 use solana_measure::measure::Measure;
 use solana_perf::packet::to_packets_chunked;
-use solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry};
 use solana_runtime::{
     accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
 };
@@ -74,7 +78,7 @@ fn make_accounts_txs(
         .into_par_iter()
         .map(|_| {
             let mut new = dummy.clone();
-            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
+            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
             if !same_payer {
                 new.message.account_keys[0] = solana_sdk::pubkey::new_rand();
             }
@@ -185,7 +189,7 @@ fn main() {
             genesis_config.hash(),
         );
         // Ignore any pesky duplicate signature errors in the case we are using single-payer
-        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
+        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
         fund.signatures = vec![Signature::new(&sig[0..64])];
         let x = bank.process_transaction(&fund);
         x.unwrap();
@@ -195,7 +199,7 @@ fn main() {
     if !skip_sanity {
         //sanity check, make sure all the transactions can execute sequentially
         transactions.iter().for_each(|tx| {
-            let res = bank.process_transaction(tx);
+            let res = bank.process_transaction(&tx);
             assert!(res.is_ok(), "sanity test transactions error: {:?}", res);
         });
         bank.clear_signatures();
@@ -351,7 +355,7 @@ fn main() {
             if bank.slot() > 0 && bank.slot() % 16 == 0 {
                 for tx in transactions.iter_mut() {
                     tx.message.recent_blockhash = bank.last_blockhash();
-                    let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
+                    let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
                     tx.signatures[0] = Signature::new(&sig[0..64]);
                 }
                 verified = to_packets_chunked(&transactions.clone(), packets_per_chunk);

banks-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-banks-client"
-version = "1.7.7"
+version = "1.5.20"
 description = "Solana banks client"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,20 +11,20 @@ edition = "2018"
 
 [dependencies]
 bincode = "1.3.1"
-borsh = "0.9.0"
-borsh-derive = "0.9.0"
+borsh = "0.8.1"
+borsh-derive = "0.8.1"
 futures = "0.3"
 mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.7.7" }
-solana-program = { path = "../sdk/program", version = "=1.7.7" }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-tarpc = { version = "0.24.1", features = ["full"] }
-tokio = { version = "1", features = ["full"] }
-tokio-serde = { version = "0.8", features = ["bincode"] }
+solana-banks-interface = { path = "../banks-interface", version = "=1.5.20" }
+solana-program = { path = "../sdk/program", version = "=1.5.20" }
+solana-sdk = { path = "../sdk", version = "=1.5.20" }
+tarpc = { version = "0.23.0", features = ["full"] }
+tokio = { version = "0.3.5", features = ["full"] }
+tokio-serde = { version = "0.6", features = ["bincode"] }
 
 [dev-dependencies]
-solana-runtime = { path = "../runtime", version = "=1.7.7" }
-solana-banks-server = { path = "../banks-server", version = "=1.7.7" }
+solana-runtime = { path = "../runtime", version = "=1.5.20" }
+solana-banks-server = { path = "../banks-server", version = "=1.5.20" }
 
 [lib]
 crate-type = ["lib"]

banks-client/src/lib.rs

@@ -11,7 +11,7 @@ pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
 use solana_banks_interface::{BanksRequest, BanksResponse};
 use solana_program::{
     clock::Slot, fee_calculator::FeeCalculator, hash::Hash, program_pack::Pack, pubkey::Pubkey,
-    rent::Rent, sysvar::Sysvar,
+    rent::Rent, sysvar,
 };
 use solana_sdk::{
     account::{from_account, Account},
@@ -124,19 +124,15 @@ impl BanksClient {
         self.get_fees_with_commitment_and_context(context::current(), CommitmentLevel::default())
     }
 
-    /// Return the cluster Sysvar
-    pub fn get_sysvar<T: Sysvar>(&mut self) -> impl Future<Output = io::Result<T>> + '_ {
-        self.get_account(T::id()).map(|result| {
-            let sysvar = result?
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Sysvar not present"))?;
-            from_account::<T, _>(&sysvar)
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Failed to deserialize sysvar"))
-        })
-    }
-
     /// Return the cluster rent
     pub fn get_rent(&mut self) -> impl Future<Output = io::Result<Rent>> + '_ {
-        self.get_sysvar::<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")
+            })
+        })
     }
 
     /// Return a recent, rooted blockhash from the server. The cluster will only accept
@@ -381,8 +377,8 @@ mod tests {
 
         let mint_pubkey = &genesis.mint_keypair.pubkey();
         let bob_pubkey = solana_sdk::pubkey::new_rand();
-        let instruction = system_instruction::transfer(mint_pubkey, &bob_pubkey, 1);
-        let message = Message::new(&[instruction], Some(mint_pubkey));
+        let instruction = system_instruction::transfer(&mint_pubkey, &bob_pubkey, 1);
+        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;

banks-interface/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-banks-interface"
-version = "1.7.7"
+version = "1.5.20"
 description = "Solana banks RPC interface"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,12 +11,12 @@ edition = "2018"
 
 [dependencies]
 mio = "0.7.6"
-serde = { version = "1.0.122", features = ["derive"] }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-tarpc = { version = "0.24.1", features = ["full"] }
+serde = { version = "1.0.118", features = ["derive"] }
+solana-sdk = { path = "../sdk", version = "=1.5.20" }
+tarpc = { version = "0.23.0", features = ["full"] }
 
 [dev-dependencies]
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "0.3.5", features = ["full"] }
 
 [lib]
 crate-type = ["lib"]

banks-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-banks-server"
-version = "1.7.7"
+version = "1.5.20"
 description = "Solana banks server"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -14,14 +14,13 @@ bincode = "1.3.1"
 futures = "0.3"
 log = "0.4.11"
 mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.7.7" }
-solana-runtime = { path = "../runtime", version = "=1.7.7" }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-solana-metrics = { path = "../metrics", version = "=1.7.7" }
-tarpc = { version = "0.24.1", features = ["full"] }
-tokio = { version = "1", features = ["full"] }
-tokio-serde = { version = "0.8", features = ["bincode"] }
-tokio-stream = "0.1"
+solana-banks-interface = { path = "../banks-interface", version = "=1.5.20" }
+solana-runtime = { path = "../runtime", version = "=1.5.20" }
+solana-sdk = { path = "../sdk", version = "=1.5.20" }
+solana-metrics = { path = "../metrics", version = "=1.5.20" }
+tarpc = { version = "0.23.0", features = ["full"] }
+tokio = { version = "0.3", features = ["full"] }
+tokio-serde = { version = "0.6", features = ["bincode"] }
 
 [lib]
 crate-type = ["lib"]

banks-server/src/banks_server.rs

@@ -131,13 +131,10 @@ impl BanksServer {
     }
 }
 
-fn verify_transaction(
-    transaction: &Transaction,
-    libsecp256k1_0_5_upgrade_enabled: bool,
-) -> transaction::Result<()> {
+fn verify_transaction(transaction: &Transaction) -> transaction::Result<()> {
     if let Err(err) = transaction.verify() {
         Err(err)
-    } else if let Err(err) = transaction.verify_precompiles(libsecp256k1_0_5_upgrade_enabled) {
+    } else if let Err(err) = transaction.verify_precompiles() {
         Err(err)
     } else {
         Ok(())
@@ -153,7 +150,7 @@ impl Banks for BanksServer {
             .read()
             .unwrap()
             .root_bank()
-            .get_blockhash_last_valid_slot(blockhash)
+            .get_blockhash_last_valid_slot(&blockhash)
             .unwrap();
         let signature = transaction.signatures.get(0).cloned().unwrap_or_default();
         let info =
@@ -218,10 +215,7 @@ impl Banks for BanksServer {
         transaction: Transaction,
         commitment: CommitmentLevel,
     ) -> Option<transaction::Result<()>> {
-        if let Err(err) = verify_transaction(
-            &transaction,
-            self.bank(commitment).libsecp256k1_0_5_upgrade_enabled(),
-        ) {
+        if let Err(err) = verify_transaction(&transaction) {
             return Some(Err(err));
         }
 
@@ -248,7 +242,7 @@ impl Banks for BanksServer {
         commitment: CommitmentLevel,
     ) -> Option<Account> {
         let bank = self.bank(commitment);
-        bank.get_account(&address).map(Account::from)
+        bank.get_account(&address)
     }
 }
 

banks-server/src/rpc_banks_service.rs

@@ -15,7 +15,6 @@ use tokio::{
     runtime::Runtime,
     time::{self, Duration},
 };
-use tokio_stream::wrappers::IntervalStream;
 
 pub struct RpcBanksService {
     thread_hdl: JoinHandle<()>,
@@ -36,7 +35,7 @@ async fn start_abortable_tcp_server(
         block_commitment_cache.clone(),
     )
     .fuse();
-    let interval = IntervalStream::new(time::interval(Duration::from_millis(100))).fuse();
+    let interval = time::interval(Duration::from_millis(100)).fuse();
     pin_mut!(server, interval);
     loop {
         select! {

banks-server/src/send_transaction_service.rs

@@ -138,8 +138,8 @@ impl SendTransactionService {
                         result.retried += 1;
                         inc_new_counter_info!("send_transaction_service-retry", 1);
                         Self::send_transaction(
-                            send_socket,
-                            tpu_address,
+                            &send_socket,
+                            &tpu_address,
                             &transaction_info.wire_transaction,
                         );
                         true

bench-exchange/Cargo.toml

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

bench-exchange/src/bench.rs

@@ -451,13 +451,13 @@ fn swapper<T>(
             let to_swap_txs: Vec<_> = to_swap
                 .par_iter()
                 .map(|(signer, swap, profit)| {
-                    let s: &Keypair = signer;
+                    let s: &Keypair = &signer;
                     let owner = &signer.pubkey();
                     let instruction = exchange_instruction::swap_request(
                         owner,
                         &swap.0.pubkey,
                         &swap.1.pubkey,
-                        profit,
+                        &profit,
                     );
                     let message = Message::new(&[instruction], Some(&s.pubkey()));
                     Transaction::new(&[s], message, blockhash)
@@ -600,7 +600,7 @@ fn trader<T>(
                             src,
                         ),
                     ];
-                    let message = Message::new(&instructions, Some(owner_pubkey));
+                    let message = Message::new(&instructions, Some(&owner_pubkey));
                     Transaction::new(&[owner.as_ref(), trade], message, blockhash)
                 })
                 .collect();
@@ -739,7 +739,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
             let mut to_fund_txs: Vec<_> = chunk
                 .par_iter()
                 .map(|(k, m)| {
-                    let instructions = system_instruction::transfer_many(&k.pubkey(), m);
+                    let instructions = system_instruction::transfer_many(&k.pubkey(), &m);
                     let message = Message::new(&instructions, Some(&k.pubkey()));
                     (k.clone(), Transaction::new_unsigned(message))
                 })
@@ -777,7 +777,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                 let mut waits = 0;
                 loop {
                     sleep(Duration::from_millis(200));
-                    to_fund_txs.retain(|(_, tx)| !verify_funding_transfer(client, tx, amount));
+                    to_fund_txs.retain(|(_, tx)| !verify_funding_transfer(client, &tx, amount));
                     if to_fund_txs.is_empty() {
                         break;
                     }
@@ -836,7 +836,7 @@ pub fn create_token_accounts<T: Client>(
                     );
                     let request_ix =
                         exchange_instruction::account_request(owner_pubkey, &new_keypair.pubkey());
-                    let message = Message::new(&[create_ix, request_ix], Some(owner_pubkey));
+                    let message = Message::new(&[create_ix, request_ix], Some(&owner_pubkey));
                     (
                         (from_keypair, new_keypair),
                         Transaction::new_unsigned(message),
@@ -872,7 +872,7 @@ pub fn create_token_accounts<T: Client>(
                 let mut waits = 0;
                 while !to_create_txs.is_empty() {
                     sleep(Duration::from_millis(200));
-                    to_create_txs.retain(|(_, tx)| !verify_transaction(client, tx));
+                    to_create_txs.retain(|(_, tx)| !verify_transaction(client, &tx));
                     if to_create_txs.is_empty() {
                         break;
                     }
@@ -958,7 +958,7 @@ fn compute_and_report_stats(maxes: &Arc<RwLock<Vec<(String, SampleStats)>>>, tot
 
 fn generate_keypairs(num: u64) -> Vec<Keypair> {
     let mut seed = [0_u8; 32];
-    seed.copy_from_slice(Keypair::new().pubkey().as_ref());
+    seed.copy_from_slice(&Keypair::new().pubkey().as_ref());
     let mut rnd = GenKeys::new(seed);
     rnd.gen_n_keypairs(num)
 }
@@ -989,7 +989,7 @@ pub fn airdrop_lamports<T: Client>(
         let (blockhash, _fee_calculator, _last_valid_slot) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
             .expect("Failed to get blockhash");
-        match request_airdrop_transaction(faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {
+        match request_airdrop_transaction(&faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {
             Ok(transaction) => {
                 let signature = client.async_send_transaction(transaction).unwrap();
 

bench-exchange/src/main.rs

@@ -5,7 +5,7 @@ pub mod order_book;
 
 use crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config};
 use log::*;
-use solana_gossip::gossip_service::{discover_cluster, get_multi_client};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
 use solana_sdk::signature::Signer;
 
 fn main() {

bench-exchange/tests/bench_exchange.rs

@@ -1,21 +1,19 @@
 use log::*;
 use solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
 use solana_core::validator::ValidatorConfig;
-use solana_exchange_program::{
-    exchange_processor::process_instruction, id, solana_exchange_program,
-};
+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_gossip::gossip_service::{discover_cluster, get_multi_client};
-use solana_local_cluster::{
-    local_cluster::{ClusterConfig, LocalCluster},
-    validator_configs::make_identical_validator_configs,
-};
-use solana_runtime::{bank::Bank, bank_client::BankClient};
-use solana_sdk::{
-    genesis_config::create_genesis_config,
-    signature::{Keypair, Signer},
-};
-use std::{process::exit, sync::mpsc::channel, time::Duration};
+use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
+use solana_runtime::bank::Bank;
+use solana_runtime::bank_client::BankClient;
+use solana_sdk::genesis_config::create_genesis_config;
+use solana_sdk::signature::{Keypair, Signer};
+use std::process::exit;
+use std::sync::mpsc::channel;
+use std::time::Duration;
 
 #[test]
 #[ignore]
@@ -46,7 +44,7 @@ fn test_exchange_local_cluster() {
     let cluster = LocalCluster::new(&mut ClusterConfig {
         node_stakes: vec![100_000; NUM_NODES],
         cluster_lamports: 100_000_000_000_000,
-        validator_configs: make_identical_validator_configs(&ValidatorConfig::default(), NUM_NODES),
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
         native_instruction_processors: [solana_exchange_program!()].to_vec(),
         ..ClusterConfig::default()
     });

bench-streamer/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.7.7"
+version = "1.5.20"
 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.7.7" }
-solana-streamer = { path = "../streamer", version = "=1.7.7" }
-solana-logger = { path = "../logger", version = "=1.7.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.7.7" }
-solana-version = { path = "../version", version = "=1.7.7" }
+solana-clap-utils = { path = "../clap-utils", version = "=1.5.20" }
+solana-streamer = { path = "../streamer", version = "=1.5.20" }
+solana-logger = { path = "../logger", version = "=1.5.20" }
+solana-net-utils = { path = "../net-utils", version = "=1.5.20" }
+solana-version = { path = "../version", version = "=1.5.20" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-streamer/src/main.rs

@@ -18,7 +18,7 @@ fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
     msgs.packets.resize(10, Packet::default());
     for w in msgs.packets.iter_mut() {
         w.meta.size = PACKET_DATA_SIZE;
-        w.meta.set_addr(addr);
+        w.meta.set_addr(&addr);
     }
     let msgs = Arc::new(msgs);
     spawn(move || loop {
@@ -75,7 +75,7 @@ fn main() -> Result<()> {
 
     let mut read_channels = Vec::new();
     let mut read_threads = Vec::new();
-    let recycler = PacketsRecycler::default();
+    let recycler = PacketsRecycler::new_without_limit("bench-streamer-recycler-shrink-stats");
     for _ in 0..num_sockets {
         let read = solana_net_utils::bind_to(ip_addr, port, false).unwrap();
         read.set_read_timeout(Some(Duration::new(1, 0))).unwrap();
@@ -92,7 +92,6 @@ fn main() -> Result<()> {
             recycler.clone(),
             "bench-streamer-test",
             1,
-            true,
         ));
     }
 

bench-tps/Cargo.toml

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

bench-tps/src/bench.rs

@@ -8,7 +8,7 @@ use solana_measure::measure::Measure;
 use solana_metrics::{self, datapoint_info};
 use solana_sdk::{
     client::Client,
-    clock::{DEFAULT_S_PER_SLOT, MAX_PROCESSING_AGE},
+    clock::{DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT, MAX_PROCESSING_AGE},
     commitment_config::CommitmentConfig,
     fee_calculator::FeeCalculator,
     hash::Hash,
@@ -32,7 +32,8 @@ use std::{
 };
 
 // The point at which transactions become "too old", in seconds.
-const MAX_TX_QUEUE_AGE: u64 = (MAX_PROCESSING_AGE as f64 * DEFAULT_S_PER_SLOT) as u64;
+const MAX_TX_QUEUE_AGE: u64 =
+    MAX_PROCESSING_AGE as u64 * DEFAULT_TICKS_PER_SLOT / DEFAULT_TICKS_PER_SECOND;
 
 pub const MAX_SPENDS_PER_TX: u64 = 4;
 
@@ -544,12 +545,12 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
 
             // re-sign retained to_fund_txes with updated blockhash
             self.sign(blockhash);
-            self.send(client);
+            self.send(&client);
 
             // Sleep a few slots to allow transactions to process
             sleep(Duration::from_secs(1));
 
-            self.verify(client, to_lamports);
+            self.verify(&client, to_lamports);
 
             // retry anything that seems to have dropped through cracks
             //  again since these txs are all or nothing, they're fine to
@@ -564,7 +565,7 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
         let to_fund_txs: Vec<(&Keypair, Transaction)> = to_fund
             .par_iter()
             .map(|(k, t)| {
-                let instructions = system_instruction::transfer_many(&k.pubkey(), t);
+                let instructions = system_instruction::transfer_many(&k.pubkey(), &t);
                 let message = Message::new(&instructions, Some(&k.pubkey()));
                 (*k, Transaction::new_unsigned(message))
             })
@@ -617,7 +618,7 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
                         return None;
                     }
 
-                    let verified = if verify_funding_transfer(&client, tx, to_lamports) {
+                    let verified = if verify_funding_transfer(&client, &tx, to_lamports) {
                         verified_txs.fetch_add(1, Ordering::Relaxed);
                         Some(k.pubkey())
                     } else {
@@ -733,7 +734,7 @@ pub fn airdrop_lamports<T: Client>(
         );
 
         let (blockhash, _fee_calculator) = get_recent_blockhash(client);
-        match request_airdrop_transaction(faucet_addr, &id.pubkey(), airdrop_amount, blockhash) {
+        match request_airdrop_transaction(&faucet_addr, &id.pubkey(), airdrop_amount, blockhash) {
             Ok(transaction) => {
                 let mut tries = 0;
                 loop {

bench-tps/src/main.rs

@@ -2,8 +2,8 @@
 use log::*;
 use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs};
 use solana_bench_tps::cli;
+use solana_core::gossip_service::{discover_cluster, get_client, get_multi_client};
 use solana_genesis::Base64Account;
-use solana_gossip::gossip_service::{discover_cluster, get_client, get_multi_client};
 use solana_sdk::fee_calculator::FeeRateGovernor;
 use solana_sdk::signature::{Keypair, Signer};
 use solana_sdk::system_program;
@@ -39,7 +39,7 @@ fn main() {
     let keypair_count = *tx_count * keypair_multiplier;
     if *write_to_client_file {
         info!("Generating {} keypairs", keypair_count);
-        let (keypairs, _) = generate_keypairs(id, keypair_count as u64);
+        let (keypairs, _) = generate_keypairs(&id, keypair_count as u64);
         let num_accounts = keypairs.len() as u64;
         let max_fee =
             FeeRateGovernor::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
@@ -68,7 +68,7 @@ fn main() {
     }
 
     info!("Connecting to the cluster");
-    let nodes = discover_cluster(entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
+    let nodes = discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
         eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
         exit(1);
     });
@@ -135,7 +135,7 @@ fn main() {
         generate_and_fund_keypairs(
             client.clone(),
             Some(*faucet_addr),
-            id,
+            &id,
             keypair_count,
             *num_lamports_per_account,
         )

bench-tps/tests/bench_tps.rs

@@ -1,22 +1,15 @@
 #![allow(clippy::integer_arithmetic)]
-use serial_test::serial;
-use solana_bench_tps::{
-    bench::{do_bench_tps, generate_and_fund_keypairs},
-    cli::Config,
-};
+use serial_test_derive::serial;
+use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs};
+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_gossip::cluster_info::VALIDATOR_PORT_RANGE;
-use solana_local_cluster::{
-    local_cluster::{ClusterConfig, LocalCluster},
-    validator_configs::make_identical_validator_configs,
-};
+use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_sdk::signature::{Keypair, Signer};
-use std::{
-    sync::{mpsc::channel, Arc},
-    time::Duration,
-};
+use std::sync::{mpsc::channel, Arc};
+use std::time::Duration;
 
 fn test_bench_tps_local_cluster(config: Config) {
     let native_instruction_processors = vec![];
@@ -26,7 +19,7 @@ fn test_bench_tps_local_cluster(config: Config) {
     let cluster = LocalCluster::new(&mut ClusterConfig {
         node_stakes: vec![999_990; NUM_NODES],
         cluster_lamports: 200_000_000,
-        validator_configs: make_identical_validator_configs(&ValidatorConfig::default(), NUM_NODES),
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
         native_instruction_processors,
         ..ClusterConfig::default()
     });

ci/buildkite-pipeline.sh

@@ -148,33 +148,6 @@ all_test_steps() {
   command_step stable ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-stable.sh" 60
   wait_step
 
-  # BPF test suite
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-bpf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "ci/test-stable-bpf.sh"
-    name: "stable-bpf"
-    timeout_in_minutes: 20
-    artifact_paths: "bpf-dumps.tar.bz2"
-    agents:
-      - "queue=default"
-EOF
-  else
-    annotate --style info \
-      "Stable-BPF skipped as no relevant files were modified"
-  fi
-
   # Perf test suite
   if affects \
              .rs$ \
@@ -192,7 +165,7 @@ EOF
     cat >> "$output_file" <<"EOF"
   - command: "ci/test-stable-perf.sh"
     name: "stable-perf"
-    timeout_in_minutes: 20
+    timeout_in_minutes: 40
     artifact_paths: "log-*.txt"
     agents:
       - "queue=cuda"

ci/buildkite-secondary.yml

@@ -3,19 +3,16 @@
 # Pull requests to not run these steps.
 steps:
   - command: "ci/publish-tarball.sh"
-    agents:
-      - "queue=release-build"
     timeout_in_minutes: 60
     name: "publish tarball"
+  - command: "ci/publish-bpf-sdk.sh"
+    timeout_in_minutes: 5
+    name: "publish bpf sdk"
   - wait
   - command: "sdk/docker-solana/build.sh"
-    agents:
-      - "queue=release-build"
     timeout_in_minutes: 60
     name: "publish docker"
   - command: "ci/publish-crate.sh"
-    agents:
-      - "queue=release-build"
     timeout_in_minutes: 240
     name: "publish crate"
     branches: "!master"

ci/do-audit.sh

@@ -33,10 +33,12 @@ cargo_audit_ignores=(
   # 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
+
   # generic-array: arr! macro erases lifetimes
   #
-  # Blocked on libsecp256k1 releasing with upgraded dependencies
-  # https://github.com/paritytech/libsecp256k1/issues/66
+  # ed25519-dalek and libsecp256k1 not upgraded for v1.5
   --ignore RUSTSEC-2020-0146
 
 )

ci/docker-rust-nightly/Dockerfile

@@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.52.1
+FROM solanalabs/rust:1.49.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.52.1
+FROM rust:1.49.0
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0

ci/env.sh

@@ -74,13 +74,10 @@ else
   export CI_BUILD_ID=
   export CI_COMMIT=
   export CI_JOB_ID=
+  export CI_OS_NAME=
   export CI_PULL_REQUEST=
   export CI_REPO_SLUG=
   export CI_TAG=
-  # Don't override ci/run-local.sh
-  if [[ -z $CI_LOCAL_RUN ]]; then
-    export CI_OS_NAME=
-  fi
 fi
 
 cat <<EOF

ci/localnet-sanity.sh

@@ -78,8 +78,9 @@ nodes=(
     --init-complete-file init-complete-node0.log \
     --dynamic-port-range 8000-8050"
   "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"
 )
@@ -127,7 +128,7 @@ startNode() {
 waitForNodeToInit() {
   declare initCompleteFile=$1
   while [[ ! -r $initCompleteFile ]]; do
-    if [[ $SECONDS -ge 300 ]]; then
+    if [[ $SECONDS -ge 240 ]]; then
       echo "^^^ +++"
       echo "Error: $initCompleteFile not found in $SECONDS seconds"
       exit 1
@@ -200,10 +201,17 @@ killNodes() {
   [[ ${#pids[@]} -gt 0 ]] || return
 
   # Try to use the RPC exit API to cleanly exit the first two nodes
-  # (dynamic nodes, -x, are just killed)
+  # (dynamic nodes, -x, are just killed since their RPC port is not known)
   echo "--- RPC exit"
-  $solana_validator --ledger "$SOLANA_CONFIG_DIR"/bootstrap-validator exit --force || true
-  $solana_validator --ledger "$SOLANA_CONFIG_DIR"/validator exit --force || true
+  for port in 8899 18899; do
+    (
+      set -x
+      curl --retry 5 --retry-delay 2 --retry-connrefused \
+        -X POST -H 'Content-Type: application/json' \
+        -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' \
+        http://localhost:$port
+    )
+  done
 
   # Give the nodes a splash of time to cleanly exit before killing them
   sleep 2

ci/order-crates-for-publishing.py

@@ -12,14 +12,10 @@ import json
 import subprocess
 import sys;
 
-real_file = os.path.realpath(__file__)
-ci_path = os.path.dirname(real_file)
-src_root = os.path.dirname(ci_path)
-
 def load_metadata():
-    cmd = f'{src_root}/cargo metadata --no-deps --format-version=1'
     return json.loads(subprocess.Popen(
-        cmd, shell=True, stdout=subprocess.PIPE).communicate()[0])
+        'cargo metadata --no-deps --format-version=1',
+        shell=True, stdout=subprocess.PIPE).communicate()[0])
 
 def get_packages():
     metadata = load_metadata()

ci/publish-bpf-sdk.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")/.."
+eval "$(ci/channel-info.sh)"
+
+if [[ -n "$CI_TAG" ]]; then
+  CHANNEL_OR_TAG=$CI_TAG
+else
+  CHANNEL_OR_TAG=$CHANNEL
+fi
+
+(
+  set -x
+  sdk/bpf/scripts/package.sh
+  [[ -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"
+fi
+
+exit 0

ci/run-local.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-
-cd "$(dirname "$0")/.."
-
-export CI_LOCAL_RUN=true
-
-set -e
-
-case $(uname -o) in
-  */Linux)
-    export CI_OS_NAME=linux
-    ;;
-  *)
-    echo "local CI runs are only supported on Linux" 1>&2
-    exit 1
-    ;;
-esac
-
-steps=()
-steps+=(test-sanity)
-steps+=(shellcheck)
-steps+=(test-checks)
-steps+=(test-coverage)
-steps+=(test-stable)
-steps+=(test-stable-bpf)
-steps+=(test-stable-perf)
-steps+=(test-downstream-builds)
-steps+=(test-bench)
-steps+=(test-local-cluster)
-
-step_index=0
-if [[ -n "$1" ]]; then
-  start_step="$1"
-  while [[ $step_index -lt ${#steps[@]} ]]; do
-    step="${steps[$step_index]}"
-    if [[ "$step" = "$start_step" ]]; then
-      break
-    fi
-    step_index=$((step_index + 1))
-  done
-  if [[ $step_index -eq ${#steps[@]} ]]; then
-    echo "unexpected start step: \"$start_step\"" 1>&2
-    exit 1
-  else
-    echo "** starting at step: \"$start_step\" **"
-    echo
-  fi
-fi
-
-while [[ $step_index -lt ${#steps[@]} ]]; do
-  step="${steps[$step_index]}"
-  cmd="ci/${step}.sh"
-  $cmd
-  step_index=$((step_index + 1))
-done

ci/run-sanity.sh

@@ -7,7 +7,7 @@ source multinode-demo/common.sh
 
 rm -rf config/run/init-completed config/ledger config/snapshot-ledger
 
-SOLANA_RUN_SH_VALIDATOR_ARGS="--snapshot-interval-slots 200" timeout 120 ./run.sh &
+timeout 120 ./run.sh &
 pid=$!
 
 attempts=20
@@ -16,20 +16,16 @@ while [[ ! -f config/run/init-completed ]]; do
   if ((--attempts == 0)); then
      echo "Error: validator failed to boot"
      exit 1
-  else
-    echo "Checking init"
   fi
 done
 
 snapshot_slot=1
 
 # wait a bit longer than snapshot_slot
-while [[ $($solana_cli --url http://localhost:8899 slot --commitment processed) -le $((snapshot_slot + 1)) ]]; do
+while [[ $($solana_cli --url http://localhost:8899 slot --commitment recent) -le $((snapshot_slot + 1)) ]]; do
   sleep 1
-  echo "Checking slot"
 done
-
-$solana_validator --ledger config/ledger exit --force || true
+curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' http://localhost:8899
 
 wait $pid
 

ci/rust-version.sh

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

ci/test-bench.sh

@@ -27,7 +27,7 @@ BENCH_ARTIFACT=current_bench_results.log
 _ "$cargo" build --manifest-path=keygen/Cargo.toml
 export PATH="$PWD/target/debug":$PATH
 
-# Clear the C dependency files, if dependency moves these files are not regenerated
+# 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
 
@@ -45,14 +45,6 @@ _ "$cargo" nightly bench --manifest-path sdk/Cargo.toml ${V:+--verbose} \
 _ "$cargo" nightly bench --manifest-path runtime/Cargo.toml ${V:+--verbose} \
   -- -Z unstable-options --format=json | tee -a "$BENCH_FILE"
 
-# Run gossip benches
-_ "$cargo" nightly bench --manifest-path gossip/Cargo.toml ${V:+--verbose} \
-  -- -Z unstable-options --format=json | tee -a "$BENCH_FILE"
-
-# Run poh benches
-_ "$cargo" nightly bench --manifest-path poh/Cargo.toml ${V:+--verbose} \
-  -- -Z unstable-options --format=json | tee -a "$BENCH_FILE"
-
 # Run core benches
 _ "$cargo" nightly bench --manifest-path core/Cargo.toml ${V:+--verbose} \
   -- -Z unstable-options --format=json | tee -a "$BENCH_FILE"

ci/test-checks.sh

@@ -14,7 +14,7 @@ scripts/increment-cargo-version.sh check
 
 # Disallow uncommitted Cargo.lock changes
 (
-  _ scripts/cargo-for-all-lock-files.sh tree >/dev/null
+  _ scripts/cargo-for-all-lock-files.sh tree
   set +e
   if ! _ git diff --exit-code; then
     echo -e "\nError: Uncommitted Cargo.lock changes" 1>&2
@@ -35,10 +35,8 @@ echo --- build environment
   "$cargo" stable clippy --version --verbose
   "$cargo" nightly clippy --version --verbose
 
-  # audit is done only with "$cargo stable"
+  # audit is done only with stable
   "$cargo" stable audit --version
-
-  grcov --version
 )
 
 export RUST_BACKTRACE=1
@@ -67,8 +65,7 @@ _ ci/order-crates-for-publishing.py
 
 # -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 --deny=clippy::integer_arithmetic --allow=clippy::inconsistent_struct_constructor
+_ "$cargo" nightly clippy -Zunstable-options --workspace --all-targets -- --deny=warnings --deny=clippy::integer_arithmetic
 
 _ "$cargo" stable fmt --all -- --check
 
@@ -82,6 +79,7 @@ _ ci/do-audit.sh
       cd "$project"
       _ "$cargo" nightly clippy -- --deny=warnings --allow=clippy::missing_safety_doc
       _ "$cargo" stable fmt -- --check
+      _ "$cargo" nightly test
     )
   done
 }

ci/test-downstream-builds.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-
-cd "$(dirname "$0")/.."
-
-export CI_LOCAL_RUN=true
-
-set -ex
-
-scripts/build-downstream-projects.sh

ci/test-stable-bpf.sh

@@ -1 +0,0 @@
-test-stable.sh

ci/test-stable.sh

@@ -21,6 +21,13 @@ export RUST_BACKTRACE=1
 export RUSTFLAGS="-D warnings"
 source scripts/ulimit-n.sh
 
+# 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
+
+# Clear the BPF sysroot files, they are not automatically rebuilt
+rm -rf target/xargo # Issue #3105
+
 # Limit compiler jobs to reduce memory usage
 # on machines with 2gb/thread of memory
 NPROC=$(nproc)
@@ -31,57 +38,25 @@ case $testName in
 test-stable)
   _ "$cargo" stable test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
   ;;
-test-stable-bpf)
-  # 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
-
-  # rustfilt required for dumping BPF assembly listings
-  "$cargo" install rustfilt
-
+test-stable-perf)
   # solana-keygen required when building C programs
   _ "$cargo" build --manifest-path=keygen/Cargo.toml
   export PATH="$PWD/target/debug":$PATH
-  cargo_build_bpf="$(realpath ./cargo-build-bpf)"
 
   # BPF solana-sdk legacy compile test
-  "$cargo_build_bpf" --manifest-path sdk/Cargo.toml
+  ./cargo-build-bpf --manifest-path sdk/Cargo.toml
 
-  # BPF Program unit tests
-  "$cargo" test --manifest-path programs/bpf/Cargo.toml
-  "$cargo_build_bpf" --manifest-path programs/bpf/Cargo.toml --bpf-sdk sdk/bpf
-
-  # BPF program system tests
+  # BPF program tests
   _ make -C programs/bpf/c tests
   _ "$cargo" stable test \
     --manifest-path programs/bpf/Cargo.toml \
     --no-default-features --features=bpf_c,bpf_rust -- --nocapture
 
-  # Dump BPF program assembly listings
-  for bpf_test in programs/bpf/rust/*; do
-    if pushd "$bpf_test"; then
-      "$cargo_build_bpf" --dump
-      popd
-    fi
-  done
-
-  # BPF program instruction count assertion
-  bpf_target_path=programs/bpf/target
-  _ "$cargo" stable test \
-    --manifest-path programs/bpf/Cargo.toml \
-    --no-default-features --features=bpf_c,bpf_rust assert_instruction_count \
-    -- --nocapture &> "${bpf_target_path}"/deploy/instuction_counts.txt
-
-  bpf_dump_archive="bpf-dumps.tar.bz2"
-  rm -f "$bpf_dump_archive"
-  tar cjvf "$bpf_dump_archive" "${bpf_target_path}"/{deploy/*.txt,bpfel-unknown-unknown/release/*.so}
-  ;;
-test-stable-perf)
   if [[ $(uname) = Linux ]]; then
     # Enable persistence mode to keep the CUDA kernel driver loaded, avoiding a
     # lengthy and unexpected delay the first time CUDA is involved when the driver
     # is not yet loaded.
-    sudo --non-interactive ./net/scripts/enable-nvidia-persistence-mode.sh || true
+    sudo --non-interactive ./net/scripts/enable-nvidia-persistence-mode.sh
 
     rm -rf target/perf-libs
     ./fetch-perf-libs.sh

clap-utils/Cargo.toml

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

clap-utils/src/input_parsers.rs

@@ -17,9 +17,6 @@ use {
     std::{str::FromStr, sync::Arc},
 };
 
-// Sentinel value used to indicate to write to screen instead of file
-pub const STDOUT_OUTFILE_TOKEN: &str = "-";
-
 // Return parsed values from matches at `name`
 pub fn values_of<T>(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<T>>
 where
@@ -60,7 +57,7 @@ pub fn keypair_of(matches: &ArgMatches<'_>, name: &str) -> Option<Keypair> {
     if let Some(value) = matches.value_of(name) {
         if value == ASK_KEYWORD {
             let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-            keypair_from_seed_phrase(name, skip_validation, true, None, true).ok()
+            keypair_from_seed_phrase(name, skip_validation, true).ok()
         } else {
             read_keypair_file(value).ok()
         }
@@ -75,7 +72,7 @@ pub fn keypairs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<Keypair>>
             .filter_map(|value| {
                 if value == ASK_KEYWORD {
                     let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-                    keypair_from_seed_phrase(name, skip_validation, true, None, true).ok()
+                    keypair_from_seed_phrase(name, skip_validation, true).ok()
                 } else {
                     read_keypair_file(value).ok()
                 }

clap-utils/src/input_validators.rs

@@ -96,26 +96,6 @@ where
         .map_err(|err| format!("{}", err))
 }
 
-// Return an error if a `SignerSourceKind::Prompt` cannot be parsed
-pub fn is_prompt_signer_source<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + Display,
-{
-    if string.as_ref() == ASK_KEYWORD {
-        return Ok(());
-    }
-    match parse_signer_source(string.as_ref())
-        .map_err(|err| format!("{}", err))?
-        .kind
-    {
-        SignerSourceKind::Prompt => Ok(()),
-        _ => Err(format!(
-            "Unable to parse input as `prompt:` URI scheme or `ASK` keyword: {}",
-            string
-        )),
-    }
-}
-
 // Return an error if string cannot be parsed as pubkey string or keypair file location
 pub fn is_pubkey_or_keypair<T>(string: T) -> Result<(), String>
 where
@@ -215,8 +195,8 @@ where
 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://api.testnet.solana.com",
-        "d" | "devnet" => "https://api.devnet.solana.com",
+        "t" | "testnet" => "https://testnet.solana.com",
+        "d" | "devnet" => "https://devnet.solana.com",
         "l" | "localhost" => "http://localhost:8899",
         url => url,
     }

clap-utils/src/keypair.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        input_parsers::{pubkeys_sigs_of, STDOUT_OUTFILE_TOKEN},
+        input_parsers::pubkeys_sigs_of,
         offline::{SIGNER_ARG, SIGN_ONLY_ARG},
         ArgConstant,
     },
@@ -18,17 +18,14 @@ use {
         message::Message,
         pubkey::Pubkey,
         signature::{
-            generate_seed_from_seed_phrase_and_passphrase, keypair_from_seed,
-            keypair_from_seed_and_derivation_path, keypair_from_seed_phrase_and_passphrase,
-            read_keypair, read_keypair_file, Keypair, NullSigner, Presigner, Signature, Signer,
+            keypair_from_seed, keypair_from_seed_phrase_and_passphrase, read_keypair,
+            read_keypair_file, Keypair, NullSigner, Presigner, Signature, Signer,
         },
     },
     std::{
-        cell::RefCell,
         convert::TryFrom,
         error,
         io::{stdin, stdout, Write},
-        ops::Deref,
         process::exit,
         str::FromStr,
         sync::Arc,
@@ -92,48 +89,12 @@ impl CliSignerInfo {
     }
 }
 
-#[derive(Debug, Default)]
 pub struct DefaultSigner {
     pub arg_name: String,
     pub path: String,
-    is_path_checked: RefCell<bool>,
 }
 
 impl DefaultSigner {
-    pub fn new<AN: AsRef<str>, P: AsRef<str>>(arg_name: AN, path: P) -> Self {
-        let arg_name = arg_name.as_ref().to_string();
-        let path = path.as_ref().to_string();
-        Self {
-            arg_name,
-            path,
-            ..Self::default()
-        }
-    }
-
-    fn path(&self) -> Result<&str, Box<dyn std::error::Error>> {
-        if !self.is_path_checked.borrow().deref() {
-            parse_signer_source(&self.path)
-                .and_then(|s| {
-                    if let SignerSourceKind::Filepath(path) = &s.kind {
-                        std::fs::metadata(path).map(|_| ()).map_err(|e| e.into())
-                    } else {
-                        Ok(())
-                    }
-                })
-                .map_err(|_| {
-                    std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        format!(
-                        "No default signer found, run \"solana-keygen new -o {}\" to create a new one",
-                        self.path
-                    ),
-                    )
-                })?;
-            *self.is_path_checked.borrow_mut() = true;
-        }
-        Ok(&self.path)
-    }
-
     pub fn generate_unique_signers(
         &self,
         bulk_signers: Vec<Option<Box<dyn Signer>>>,
@@ -148,9 +109,11 @@ impl DefaultSigner {
             unique_signers.push(default_signer);
         }
 
-        for signer in bulk_signers.into_iter().flatten() {
-            if !unique_signers.iter().any(|s| s == &signer) {
-                unique_signers.push(signer);
+        for signer in bulk_signers.into_iter() {
+            if let Some(signer) = signer {
+                if !unique_signers.iter().any(|s| s == &signer) {
+                    unique_signers.push(signer);
+                }
             }
         }
         Ok(CliSignerInfo {
@@ -163,7 +126,7 @@ impl DefaultSigner {
         matches: &ArgMatches,
         wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
     ) -> Result<Box<dyn Signer>, Box<dyn std::error::Error>> {
-        signer_from_path(matches, self.path()?, &self.arg_name, wallet_manager)
+        signer_from_path(matches, &self.path, &self.arg_name, wallet_manager)
     }
 
     pub fn signer_from_path_with_config(
@@ -172,20 +135,13 @@ impl DefaultSigner {
         wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
         config: &SignerFromPathConfig,
     ) -> Result<Box<dyn Signer>, Box<dyn std::error::Error>> {
-        signer_from_path_with_config(
-            matches,
-            self.path()?,
-            &self.arg_name,
-            wallet_manager,
-            config,
-        )
+        signer_from_path_with_config(matches, &self.path, &self.arg_name, wallet_manager, config)
     }
 }
 
 pub(crate) struct SignerSource {
     pub kind: SignerSourceKind,
     pub derivation_path: Option<DerivationPath>,
-    pub legacy: bool,
 }
 
 impl SignerSource {
@@ -193,52 +149,18 @@ impl SignerSource {
         Self {
             kind,
             derivation_path: None,
-            legacy: false,
-        }
-    }
-
-    fn new_legacy(kind: SignerSourceKind) -> Self {
-        Self {
-            kind,
-            derivation_path: None,
-            legacy: true,
         }
     }
 }
 
-const SIGNER_SOURCE_PROMPT: &str = "prompt";
-const SIGNER_SOURCE_FILEPATH: &str = "file";
-const SIGNER_SOURCE_USB: &str = "usb";
-const SIGNER_SOURCE_STDIN: &str = "stdin";
-const SIGNER_SOURCE_PUBKEY: &str = "pubkey";
-
 pub(crate) enum SignerSourceKind {
-    Prompt,
+    Ask,
     Filepath(String),
     Usb(RemoteWalletLocator),
     Stdin,
     Pubkey(Pubkey),
 }
 
-impl AsRef<str> for SignerSourceKind {
-    fn as_ref(&self) -> &str {
-        match self {
-            Self::Prompt => SIGNER_SOURCE_PROMPT,
-            Self::Filepath(_) => SIGNER_SOURCE_FILEPATH,
-            Self::Usb(_) => SIGNER_SOURCE_USB,
-            Self::Stdin => SIGNER_SOURCE_STDIN,
-            Self::Pubkey(_) => SIGNER_SOURCE_PUBKEY,
-        }
-    }
-}
-
-impl std::fmt::Debug for SignerSourceKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let s: &str = self.as_ref();
-        write!(f, "{}", s)
-    }
-}
-
 #[derive(Debug, Error)]
 pub(crate) enum SignerSourceError {
     #[error("unrecognized signer source")]
@@ -255,54 +177,33 @@ pub(crate) fn parse_signer_source<S: AsRef<str>>(
     source: S,
 ) -> Result<SignerSource, SignerSourceError> {
     let source = source.as_ref();
-    let source = {
-        #[cfg(target_family = "windows")]
-        {
-            source.replace("\\", "/")
-        }
-        #[cfg(not(target_family = "windows"))]
-        {
-            source.to_string()
-        }
-    };
-    match uriparse::URIReference::try_from(source.as_str()) {
+    match uriparse::URIReference::try_from(source) {
         Err(_) => Err(SignerSourceError::UnrecognizedSource),
         Ok(uri) => {
             if let Some(scheme) = uri.scheme() {
                 let scheme = scheme.as_str().to_ascii_lowercase();
                 match scheme.as_str() {
-                    SIGNER_SOURCE_PROMPT => Ok(SignerSource {
-                        kind: SignerSourceKind::Prompt,
-                        derivation_path: DerivationPath::from_uri_any_query(&uri)?,
-                        legacy: false,
-                    }),
-                    SIGNER_SOURCE_FILEPATH => Ok(SignerSource::new(SignerSourceKind::Filepath(
+                    "ask" => Ok(SignerSource::new(SignerSourceKind::Ask)),
+                    "file" => Ok(SignerSource::new(SignerSourceKind::Filepath(
                         uri.path().to_string(),
                     ))),
-                    SIGNER_SOURCE_USB => Ok(SignerSource {
+                    "stdin" => Ok(SignerSource::new(SignerSourceKind::Stdin)),
+                    "usb" => Ok(SignerSource {
                         kind: SignerSourceKind::Usb(RemoteWalletLocator::new_from_uri(&uri)?),
-                        derivation_path: DerivationPath::from_uri_key_query(&uri)?,
-                        legacy: false,
+                        derivation_path: DerivationPath::from_uri(&uri)?,
                     }),
-                    SIGNER_SOURCE_STDIN => Ok(SignerSource::new(SignerSourceKind::Stdin)),
-                    _ => {
-                        #[cfg(target_family = "windows")]
-                        // On Windows, an absolute path's drive letter will be parsed as the URI
-                        // scheme. Assume a filepath source in case of a single character shceme.
-                        if scheme.len() == 1 {
-                            return Ok(SignerSource::new(SignerSourceKind::Filepath(source)));
-                        }
-                        Err(SignerSourceError::UnrecognizedSource)
-                    }
+                    _ => Err(SignerSourceError::UnrecognizedSource),
                 }
             } else {
-                match source.as_str() {
-                    STDOUT_OUTFILE_TOKEN => Ok(SignerSource::new(SignerSourceKind::Stdin)),
-                    ASK_KEYWORD => Ok(SignerSource::new_legacy(SignerSourceKind::Prompt)),
-                    _ => match Pubkey::from_str(source.as_str()) {
+                match source {
+                    "-" => Ok(SignerSource::new(SignerSourceKind::Stdin)),
+                    ASK_KEYWORD => Ok(SignerSource::new(SignerSourceKind::Ask)),
+                    _ => match Pubkey::from_str(source) {
                         Ok(pubkey) => Ok(SignerSource::new(SignerSourceKind::Pubkey(pubkey))),
-                        Err(_) => std::fs::metadata(source.as_str())
-                            .map(|_| SignerSource::new(SignerSourceKind::Filepath(source)))
+                        Err(_) => std::fs::metadata(source)
+                            .map(|_| {
+                                SignerSource::new(SignerSourceKind::Filepath(source.to_string()))
+                            })
                             .map_err(|err| err.into()),
                     },
                 }
@@ -357,17 +258,14 @@ pub fn signer_from_path_with_config(
     let SignerSource {
         kind,
         derivation_path,
-        legacy,
     } = parse_signer_source(path)?;
     match kind {
-        SignerSourceKind::Prompt => {
+        SignerSourceKind::Ask => {
             let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
             Ok(Box::new(keypair_from_seed_phrase(
                 keypair_name,
                 skip_validation,
                 false,
-                derivation_path,
-                legacy,
             )?))
         }
         SignerSourceKind::Filepath(path) => match read_keypair_file(&path) {
@@ -439,30 +337,18 @@ pub fn resolve_signer_from_path(
     let SignerSource {
         kind,
         derivation_path,
-        legacy,
     } = parse_signer_source(path)?;
     match kind {
-        SignerSourceKind::Prompt => {
+        SignerSourceKind::Ask => {
             let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
             // This method validates the seed phrase, but returns `None` because there is no path
             // on disk or to a device
-            keypair_from_seed_phrase(
-                keypair_name,
-                skip_validation,
-                false,
-                derivation_path,
-                legacy,
-            )
-            .map(|_| None)
+            keypair_from_seed_phrase(keypair_name, skip_validation, false).map(|_| None)
         }
         SignerSourceKind::Filepath(path) => match read_keypair_file(&path) {
             Err(e) => Err(std::io::Error::new(
                 std::io::ErrorKind::Other,
-                format!(
-                    "could not read keypair file \"{}\". \
-                    Run \"solana-keygen new\" to create a keypair file: {}",
-                    path, e
-                ),
+                format!("could not read keypair file \"{}\". Run \"solana-keygen new\" to create a keypair file: {}", path, e),
             )
             .into()),
             Ok(_) => Ok(Some(path.to_string())),
@@ -495,7 +381,7 @@ pub fn resolve_signer_from_path(
     }
 }
 
-// Keyword used to indicate that the user should be prompted for a keypair seed phrase
+// Keyword used to indicate that the user should be asked for a keypair seed phrase
 pub const ASK_KEYWORD: &str = "ASK";
 
 pub const SKIP_SEED_PHRASE_VALIDATION_ARG: ArgConstant<'static> = ArgConstant {
@@ -506,7 +392,7 @@ pub const SKIP_SEED_PHRASE_VALIDATION_ARG: ArgConstant<'static> = ArgConstant {
 
 /// Prompts user for a passphrase and then asks for confirmirmation to check for mistakes
 pub fn prompt_passphrase(prompt: &str) -> Result<String, Box<dyn error::Error>> {
-    let passphrase = prompt_password_stderr(prompt)?;
+    let passphrase = prompt_password_stderr(&prompt)?;
     if !passphrase.is_empty() {
         let confirmed = rpassword::prompt_password_stderr("Enter same passphrase again: ")?;
         if confirmed != passphrase {
@@ -516,56 +402,6 @@ pub fn prompt_passphrase(prompt: &str) -> Result<String, Box<dyn error::Error>>
     Ok(passphrase)
 }
 
-/// Parses a path into a SignerSource and returns a Keypair for supporting SignerSourceKinds
-pub fn keypair_from_path(
-    matches: &ArgMatches,
-    path: &str,
-    keypair_name: &str,
-    confirm_pubkey: bool,
-) -> Result<Keypair, Box<dyn error::Error>> {
-    let SignerSource {
-        kind,
-        derivation_path,
-        legacy,
-    } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Prompt => {
-            let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-            Ok(keypair_from_seed_phrase(
-                keypair_name,
-                skip_validation,
-                confirm_pubkey,
-                derivation_path,
-                legacy,
-            )?)
-        }
-        SignerSourceKind::Filepath(path) => match read_keypair_file(&path) {
-            Err(e) => Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "could not read keypair file \"{}\". \
-                    Run \"solana-keygen new\" to create a keypair file: {}",
-                    path, e
-                ),
-            )
-            .into()),
-            Ok(file) => Ok(file),
-        },
-        SignerSourceKind::Stdin => {
-            let mut stdin = std::io::stdin();
-            Ok(read_keypair(&mut stdin)?)
-        }
-        _ => Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            format!(
-                "signer of type `{:?}` does not support Keypair output",
-                kind
-            ),
-        )
-        .into()),
-    }
-}
-
 /// Reads user input from stdin to retrieve a seed phrase and passphrase for keypair derivation
 /// Optionally skips validation of seed phrase
 /// Optionally confirms recovered public key
@@ -573,8 +409,6 @@ pub fn keypair_from_seed_phrase(
     keypair_name: &str,
     skip_validation: bool,
     confirm_pubkey: bool,
-    derivation_path: Option<DerivationPath>,
-    legacy: bool,
 ) -> Result<Keypair, Box<dyn error::Error>> {
     let seed_phrase = prompt_password_stderr(&format!("[{}] seed phrase: ", keypair_name))?;
     let seed_phrase = seed_phrase.trim();
@@ -585,12 +419,7 @@ pub fn keypair_from_seed_phrase(
 
     let keypair = if skip_validation {
         let passphrase = prompt_passphrase(&passphrase_prompt)?;
-        if legacy {
-            keypair_from_seed_phrase_and_passphrase(seed_phrase, &passphrase)?
-        } else {
-            let seed = generate_seed_from_seed_phrase_and_passphrase(seed_phrase, &passphrase);
-            keypair_from_seed_and_derivation_path(&seed, derivation_path)?
-        }
+        keypair_from_seed_phrase_and_passphrase(&seed_phrase, &passphrase)?
     } else {
         let sanitized = sanitize_seed_phrase(seed_phrase);
         let parse_language_fn = || {
@@ -613,11 +442,7 @@ pub fn keypair_from_seed_phrase(
         let mnemonic = parse_language_fn()?;
         let passphrase = prompt_passphrase(&passphrase_prompt)?;
         let seed = Seed::new(&mnemonic, &passphrase);
-        if legacy {
-            keypair_from_seed(seed.as_bytes())?
-        } else {
-            keypair_from_seed_and_derivation_path(seed.as_bytes(), derivation_path)?
-        }
+        keypair_from_seed(seed.as_bytes())?
     };
 
     if confirm_pubkey {
@@ -692,28 +517,25 @@ mod tests {
     #[test]
     fn test_parse_signer_source() {
         assert!(matches!(
-            parse_signer_source(STDOUT_OUTFILE_TOKEN).unwrap(),
+            parse_signer_source("-").unwrap(),
             SignerSource {
                 kind: SignerSourceKind::Stdin,
                 derivation_path: None,
-                legacy: false,
             }
         ));
-        let stdin = "stdin:".to_string();
+        let ask = "stdin:".to_string();
         assert!(matches!(
-            parse_signer_source(&stdin).unwrap(),
+            parse_signer_source(&ask).unwrap(),
             SignerSource {
                 kind: SignerSourceKind::Stdin,
                 derivation_path: None,
-                legacy: false,
             }
         ));
         assert!(matches!(
             parse_signer_source(ASK_KEYWORD).unwrap(),
             SignerSource {
-                kind: SignerSourceKind::Prompt,
+                kind: SignerSourceKind::Ask,
                 derivation_path: None,
-                legacy: true,
             }
         ));
         let pubkey = Pubkey::new_unique();
@@ -721,7 +543,6 @@ mod tests {
             matches!(parse_signer_source(&pubkey.to_string()).unwrap(), SignerSource {
                 kind: SignerSourceKind::Pubkey(p),
                 derivation_path: None,
-                legacy: false,
             }
             if p == pubkey)
         );
@@ -742,14 +563,12 @@ mod tests {
             matches!(parse_signer_source(absolute_path_str).unwrap(), SignerSource {
                 kind: SignerSourceKind::Filepath(p),
                 derivation_path: None,
-                legacy: false,
             } if p == absolute_path_str)
         );
         assert!(
             matches!(parse_signer_source(&relative_path_str).unwrap(), SignerSource {
                 kind: SignerSourceKind::Filepath(p),
                 derivation_path: None,
-                legacy: false,
             } if p == relative_path_str)
         );
 
@@ -761,7 +580,6 @@ mod tests {
         assert!(matches!(parse_signer_source(&usb).unwrap(), SignerSource {
                 kind: SignerSourceKind::Usb(u),
                 derivation_path: None,
-                legacy: false,
             } if u == expected_locator));
         let usb = "usb://ledger?key=0/0".to_string();
         let expected_locator = RemoteWalletLocator {
@@ -772,7 +590,6 @@ mod tests {
         assert!(matches!(parse_signer_source(&usb).unwrap(), SignerSource {
                 kind: SignerSourceKind::Usb(u),
                 derivation_path: d,
-                legacy: false,
             } if u == expected_locator && d == expected_derivation_path));
         // Catchall into SignerSource::Filepath fails
         let junk = "sometextthatisnotapubkeyorfile".to_string();
@@ -782,27 +599,24 @@ mod tests {
             Err(SignerSourceError::IoError(_))
         ));
 
-        let prompt = "prompt:".to_string();
+        let ask = "ask:".to_string();
         assert!(matches!(
-            parse_signer_source(&prompt).unwrap(),
+            parse_signer_source(&ask).unwrap(),
             SignerSource {
-                kind: SignerSourceKind::Prompt,
+                kind: SignerSourceKind::Ask,
                 derivation_path: None,
-                legacy: false,
             }
         ));
         assert!(
             matches!(parse_signer_source(&format!("file:{}", absolute_path_str)).unwrap(), SignerSource {
                 kind: SignerSourceKind::Filepath(p),
                 derivation_path: None,
-                legacy: false,
             } if p == absolute_path_str)
         );
         assert!(
             matches!(parse_signer_source(&format!("file:{}", relative_path_str)).unwrap(), SignerSource {
                 kind: SignerSourceKind::Filepath(p),
                 derivation_path: None,
-                legacy: false,
             } if p == relative_path_str)
         );
     }

clap-utils/src/lib.rs

@@ -27,6 +27,5 @@ pub mod fee_payer;
 pub mod input_parsers;
 pub mod input_validators;
 pub mod keypair;
-pub mod memo;
 pub mod nonce;
 pub mod offline;

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.7.7"
+version = "1.5.20"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -12,7 +12,7 @@ documentation = "https://docs.rs/solana-cli-config"
 [dependencies]
 dirs-next = "2.0.0"
 lazy_static = "1.4.0"
-serde = "1.0.122"
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_yaml = "0.8.13"
 url = "2.1.1"

cli-config/src/config.rs

@@ -75,8 +75,7 @@ impl Config {
             .set_scheme(if is_secure { "wss" } else { "ws" })
             .expect("unable to set scheme");
         if let Some(port) = json_rpc_url.port() {
-            let port = port.checked_add(1).expect("port out of range");
-            ws_url.set_port(Some(port)).expect("unable to set port");
+            ws_url.set_port(Some(port + 1)).expect("unable to set port");
         }
         ws_url.to_string()
     }
@@ -107,24 +106,24 @@ mod test {
     #[test]
     fn compute_websocket_url() {
         assert_eq!(
-            Config::compute_websocket_url("http://api.devnet.solana.com"),
-            "ws://api.devnet.solana.com/".to_string()
+            Config::compute_websocket_url(&"http://devnet.solana.com"),
+            "ws://devnet.solana.com/".to_string()
         );
 
         assert_eq!(
-            Config::compute_websocket_url("https://api.devnet.solana.com"),
-            "wss://api.devnet.solana.com/".to_string()
+            Config::compute_websocket_url(&"https://devnet.solana.com"),
+            "wss://devnet.solana.com/".to_string()
         );
 
         assert_eq!(
-            Config::compute_websocket_url("http://example.com:8899"),
+            Config::compute_websocket_url(&"http://example.com:8899"),
             "ws://example.com:8900/".to_string()
         );
         assert_eq!(
-            Config::compute_websocket_url("https://example.com:1234"),
+            Config::compute_websocket_url(&"https://example.com:1234"),
             "wss://example.com:1235/".to_string()
         );
 
-        assert_eq!(Config::compute_websocket_url("garbage"), String::new());
+        assert_eq!(Config::compute_websocket_url(&"garbage"), String::new());
     }
 }

cli-config/src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::integer_arithmetic)]
 #[macro_use]
 extern crate lazy_static;
 

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.7.7"
+version = "1.5.20"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -12,20 +12,20 @@ documentation = "https://docs.rs/solana-cli-output"
 [dependencies]
 base64 = "0.13.0"
 chrono = { version = "0.4.11", features = ["serde"] }
-console = "0.14.1"
+console = "0.11.3"
 humantime = "2.0.1"
 Inflector = "0.11.4"
 indicatif = "0.15.0"
-serde = "1.0.122"
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "=1.7.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.7.7" }
-solana-client = { path = "../client", version = "=1.7.7" }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.7.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.7.7" }
-spl-memo = { version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "=1.5.20" }
+solana-clap-utils = { path = "../clap-utils", version = "=1.5.20" }
+solana-client = { path = "../client", version = "=1.5.20" }
+solana-sdk = { path = "../sdk", version = "=1.5.20" }
+solana-stake-program = { path = "../programs/stake", version = "=1.5.20" }
+solana-transaction-status = { path = "../transaction-status", version = "=1.5.20" }
+solana-vote-program = { path = "../programs/vote", version = "=1.5.20" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

cli-output/src/cli_output.rs

@@ -15,8 +15,8 @@ use {
     solana_account_decoder::parse_token::UiTokenAccount,
     solana_clap_utils::keypair::SignOnly,
     solana_client::rpc_response::{
-        RpcAccountBalance, RpcContactInfo, RpcInflationGovernor, RpcInflationRate, RpcKeyedAccount,
-        RpcSupply, RpcVoteAccountInfo,
+        RpcAccountBalance, RpcInflationGovernor, RpcInflationRate, RpcKeyedAccount, RpcSupply,
+        RpcVoteAccountInfo,
     },
     solana_sdk::{
         clock::{Epoch, Slot, UnixTimestamp},
@@ -25,17 +25,17 @@ use {
         native_token::lamports_to_sol,
         pubkey::Pubkey,
         signature::Signature,
-        stake::state::{Authorized, Lockup},
         stake_history::StakeHistoryEntry,
         transaction::{Transaction, TransactionError},
     },
+    solana_stake_program::stake_state::{Authorized, Lockup},
     solana_transaction_status::{
         EncodedConfirmedBlock, EncodedTransaction, TransactionConfirmationStatus,
         UiTransactionStatusMeta,
     },
     solana_vote_program::{
         authorized_voters::AuthorizedVoters,
-        vote_state::{BlockTimestamp, Lockout, MAX_EPOCH_CREDITS_HISTORY, MAX_LOCKOUT_HISTORY},
+        vote_state::{BlockTimestamp, Lockout},
     },
     std::{
         collections::{BTreeMap, HashMap},
@@ -233,10 +233,6 @@ pub struct CliEpochInfo {
     pub epoch_info: EpochInfo,
     #[serde(skip)]
     pub average_slot_time_ms: u64,
-    #[serde(skip)]
-    pub start_block_time: Option<UnixTimestamp>,
-    #[serde(skip)]
-    pub current_block_time: Option<UnixTimestamp>,
 }
 
 impl QuietDisplay for CliEpochInfo {}
@@ -281,41 +277,21 @@ impl fmt::Display for CliEpochInfo {
                 remaining_slots_in_epoch
             ),
         )?;
-        let (time_elapsed, annotation) = if let (Some(start_block_time), Some(current_block_time)) =
-            (self.start_block_time, self.current_block_time)
-        {
-            (
-                Duration::from_secs((current_block_time - start_block_time) as u64),
-                None,
-            )
-        } else {
-            (
-                slot_to_duration(self.epoch_info.slot_index, self.average_slot_time_ms),
-                Some("* estimated based on current slot durations"),
-            )
-        };
-        let time_remaining = slot_to_duration(remaining_slots_in_epoch, self.average_slot_time_ms);
         writeln_name_value(
             f,
             "Epoch Completed Time:",
             &format!(
-                "{}{}/{} ({} remaining)",
-                humantime::format_duration(time_elapsed).to_string(),
-                if annotation.is_some() { "*" } else { "" },
-                humantime::format_duration(time_elapsed + time_remaining).to_string(),
-                humantime::format_duration(time_remaining).to_string(),
+                "{}/{} ({} remaining)",
+                slot_to_human_time(self.epoch_info.slot_index, self.average_slot_time_ms),
+                slot_to_human_time(self.epoch_info.slots_in_epoch, self.average_slot_time_ms),
+                slot_to_human_time(remaining_slots_in_epoch, self.average_slot_time_ms)
             ),
-        )?;
-        if let Some(annotation) = annotation {
-            writeln!(f)?;
-            writeln!(f, "{}", annotation)?;
-        }
-        Ok(())
+        )
     }
 }
 
-fn slot_to_duration(slot: Slot, slot_time_ms: u64) -> Duration {
-    Duration::from_secs((slot * slot_time_ms) / 1000)
+fn slot_to_human_time(slot: Slot, slot_time_ms: u64) -> String {
+    humantime::format_duration(Duration::from_secs((slot * slot_time_ms) / 1000)).to_string()
 }
 
 #[derive(Serialize, Deserialize, Default)]
@@ -327,34 +303,14 @@ pub struct CliValidatorsStakeByVersion {
     pub delinquent_active_stake: u64,
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy)]
-pub enum CliValidatorsSortOrder {
-    Delinquent,
-    Commission,
-    EpochCredits,
-    Identity,
-    LastVote,
-    Root,
-    SkipRate,
-    Stake,
-    VoteAccount,
-}
-
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CliValidators {
     pub total_active_stake: u64,
     pub total_current_stake: u64,
     pub total_delinquent_stake: u64,
-    pub validators: Vec<CliValidator>,
-    pub average_skip_rate: f64,
-    pub average_stake_weighted_skip_rate: f64,
-    #[serde(skip_serializing)]
-    pub validators_sort_order: CliValidatorsSortOrder,
-    #[serde(skip_serializing)]
-    pub validators_reverse_sort: bool,
-    #[serde(skip_serializing)]
-    pub number_validators: bool,
+    pub current_validators: Vec<CliValidator>,
+    pub delinquent_validators: Vec<CliValidator>,
     pub stake_by_version: BTreeMap<String, CliValidatorsStakeByVersion>,
     #[serde(skip_serializing)]
     pub use_lamports_unit: bool,
@@ -370,40 +326,30 @@ impl fmt::Display for CliValidators {
             validator: &CliValidator,
             total_active_stake: u64,
             use_lamports_unit: bool,
-            highest_last_vote: u64,
-            highest_root: u64,
+            delinquent: bool,
         ) -> fmt::Result {
-            fn non_zero_or_dash(v: u64, max_v: u64) -> String {
+            fn non_zero_or_dash(v: u64) -> String {
                 if v == 0 {
-                    "-         ".into()
-                } else if v == max_v {
-                    format!("{:>8} (  0)", v)
-                } else if v > max_v.saturating_sub(100) {
-                    format!("{:>8} ({:>3})", v, -(max_v.saturating_sub(v) as isize))
+                    "-".into()
                 } else {
-                    format!("{:>8}      ", v)
+                    format!("{}", v)
                 }
             }
 
             writeln!(
                 f,
-                "{} {:<44}  {:<44}  {:>3}%  {:>14}  {:>14} {:>7} {:>8}  {:>7}  {}",
-                if validator.delinquent {
+                "{} {:<44}  {:<44}  {:>3}%   {:>8}  {:>10}  {:>10}  {:>8}  {}",
+                if delinquent {
                     WARNING.to_string()
                 } else {
-                    "\u{a0}".to_string()
+                    " ".to_string()
                 },
                 validator.identity_pubkey,
                 validator.vote_account_pubkey,
                 validator.commission,
-                non_zero_or_dash(validator.last_vote, highest_last_vote),
-                non_zero_or_dash(validator.root_slot, highest_root),
-                if let Some(skip_rate) = validator.skip_rate {
-                    format!("{:.2}%", skip_rate)
-                } else {
-                    "- ".to_string()
-                },
-                validator.epoch_credits,
+                non_zero_or_dash(validator.last_vote),
+                non_zero_or_dash(validator.root_slot),
+                validator.credits,
                 validator.version,
                 if validator.activated_stake > 0 {
                     format!(
@@ -416,114 +362,41 @@ impl fmt::Display for CliValidators {
                 },
             )
         }
-
-        let padding = if self.number_validators {
-            ((self.validators.len() + 1) as f64).log10().floor() as usize + 1
-        } else {
-            0
-        };
-        let header = style(format!(
-            "{:padding$} {:<44}  {:<38}  {}  {}  {} {}  {}  {}  {}",
-            " ",
-            "Identity",
-            "Vote Account",
-            "Commission",
-            "Last Vote     ",
-            "Root Slot   ",
-            "Skip Rate",
-            "Credits",
-            "Version",
-            "Active Stake",
-            padding = padding + 1
-        ))
-        .bold();
-        writeln!(f, "{}", header)?;
-
-        let mut sorted_validators = self.validators.clone();
-        match self.validators_sort_order {
-            CliValidatorsSortOrder::Delinquent => {
-                sorted_validators.sort_by_key(|a| a.delinquent);
-            }
-            CliValidatorsSortOrder::Commission => {
-                sorted_validators.sort_by_key(|a| a.commission);
-            }
-            CliValidatorsSortOrder::EpochCredits => {
-                sorted_validators.sort_by_key(|a| a.epoch_credits);
-            }
-            CliValidatorsSortOrder::Identity => {
-                sorted_validators.sort_by(|a, b| a.identity_pubkey.cmp(&b.identity_pubkey));
-            }
-            CliValidatorsSortOrder::LastVote => {
-                sorted_validators.sort_by_key(|a| a.last_vote);
-            }
-            CliValidatorsSortOrder::Root => {
-                sorted_validators.sort_by_key(|a| a.root_slot);
-            }
-            CliValidatorsSortOrder::VoteAccount => {
-                sorted_validators.sort_by(|a, b| a.vote_account_pubkey.cmp(&b.vote_account_pubkey));
-            }
-            CliValidatorsSortOrder::SkipRate => {
-                sorted_validators.sort_by(|a, b| {
-                    use std::cmp::Ordering;
-                    match (a.skip_rate, b.skip_rate) {
-                        (None, None) => Ordering::Equal,
-                        (None, Some(_)) => Ordering::Greater,
-                        (Some(_), None) => Ordering::Less,
-                        (Some(a), Some(b)) => a.partial_cmp(&b).unwrap_or(Ordering::Equal),
-                    }
-                });
-            }
-            CliValidatorsSortOrder::Stake => {
-                sorted_validators.sort_by_key(|a| a.activated_stake);
-            }
-        }
-
-        if self.validators_reverse_sort {
-            sorted_validators.reverse();
-        }
-
-        let highest_root = sorted_validators
-            .iter()
-            .map(|v| v.root_slot)
-            .max()
-            .unwrap_or_default();
-        let highest_last_vote = sorted_validators
-            .iter()
-            .map(|v| v.last_vote)
-            .max()
-            .unwrap_or_default();
-
-        for (i, validator) in sorted_validators.iter().enumerate() {
-            if padding > 0 {
-                write!(f, "{:padding$}", i + 1, padding = padding)?;
-            }
+        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,
-                highest_last_vote,
-                highest_root,
+                false,
             )?;
         }
-
-        // The actual header has long scrolled away.  Print the header once more as a footer
-        if self.validators.len() > 100 {
-            writeln!(f, "{}", header)?;
+        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,
-            "Average Stake-Weighted Skip Rate:",
-            &format!("{:.2}%", self.average_stake_weighted_skip_rate,),
-        )?;
-        writeln_name_value(
-            f,
-            "Average Unweighted Skip Rate:    ",
-            &format!("{:.2}%", self.average_skip_rate),
-        )?;
-
         writeln!(f)?;
         writeln_name_value(
             f,
@@ -580,7 +453,7 @@ impl fmt::Display for CliValidators {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CliValidator {
     pub identity_pubkey: String,
@@ -588,12 +461,9 @@ pub struct CliValidator {
     pub commission: u8,
     pub last_vote: u64,
     pub root_slot: u64,
-    pub credits: u64,       // lifetime credits
-    pub epoch_credits: u64, // credits earned in the current epoch
+    pub credits: u64,
     pub activated_stake: u64,
     pub version: String,
-    pub delinquent: bool,
-    pub skip_rate: Option<f64>,
 }
 
 impl CliValidator {
@@ -601,67 +471,27 @@ impl CliValidator {
         vote_account: &RpcVoteAccountInfo,
         current_epoch: Epoch,
         version: String,
-        skip_rate: Option<f64>,
         address_labels: &HashMap<String, String>,
     ) -> Self {
-        Self::_new(
-            vote_account,
-            current_epoch,
-            version,
-            skip_rate,
-            address_labels,
-            false,
-        )
-    }
-
-    pub fn new_delinquent(
-        vote_account: &RpcVoteAccountInfo,
-        current_epoch: Epoch,
-        version: String,
-        skip_rate: Option<f64>,
-        address_labels: &HashMap<String, String>,
-    ) -> Self {
-        Self::_new(
-            vote_account,
-            current_epoch,
-            version,
-            skip_rate,
-            address_labels,
-            true,
-        )
-    }
-
-    fn _new(
-        vote_account: &RpcVoteAccountInfo,
-        current_epoch: Epoch,
-        version: String,
-        skip_rate: Option<f64>,
-        address_labels: &HashMap<String, String>,
-        delinquent: bool,
-    ) -> Self {
-        let (credits, epoch_credits) = vote_account
-            .epoch_credits
-            .iter()
-            .find_map(|(epoch, credits, pre_credits)| {
-                if *epoch == current_epoch {
-                    Some((*credits, credits.saturating_sub(*pre_credits)))
-                } else {
-                    None
-                }
-            })
-            .unwrap_or((0, 0));
         Self {
             identity_pubkey: format_labeled_address(&vote_account.node_pubkey, address_labels),
             vote_account_pubkey: format_labeled_address(&vote_account.vote_pubkey, address_labels),
             commission: vote_account.commission,
             last_vote: vote_account.last_vote,
             root_slot: vote_account.root_slot,
-            credits,
-            epoch_credits,
+            credits: vote_account
+                .epoch_credits
+                .iter()
+                .find_map(|(epoch, credits, _)| {
+                    if *epoch == current_epoch {
+                        Some(*credits)
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or(0),
             activated_stake: vote_account.activated_stake,
             version,
-            delinquent,
-            skip_rate,
         }
     }
 }
@@ -771,7 +601,6 @@ pub struct CliEpochReward {
     pub post_balance: u64, // lamports
     pub percent_change: f64,
     pub apr: Option<f64>,
-    pub commission: Option<u8>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -816,27 +645,23 @@ impl fmt::Display for CliKeyedEpochRewards {
         writeln!(f, "Epoch Rewards:")?;
         writeln!(
             f,
-            "  {:<44}  {:<18}  {:<18}  {:>14}  {:>14}  {:>10}",
-            "Address", "Amount", "New Balance", "Percent Change", "APR", "Commission"
+            "  {:<44}  {:<18}  {:<18}  {:>14}  {:>14}",
+            "Address", "Amount", "New Balance", "Percent Change", "APR"
         )?;
         for keyed_reward in &self.rewards {
             match &keyed_reward.reward {
                 Some(reward) => {
                     writeln!(
                         f,
-                        "  {:<44}  ◎{:<17.9}  ◎{:<17.9}  {:>13.9}%  {:>14}  {:>10}",
+                        "  {:<44}  ◎{:<17.9}  ◎{:<17.9}  {:>13.2}%  {}",
                         keyed_reward.address,
                         lamports_to_sol(reward.amount),
                         lamports_to_sol(reward.post_balance),
                         reward.percent_change,
                         reward
                             .apr
-                            .map(|apr| format!("{:.2}%", apr))
+                            .map(|apr| format!("{:>13.2}%", apr))
                             .unwrap_or_default(),
-                        reward
-                            .commission
-                            .map(|commission| format!("{}%", commission))
-                            .unwrap_or_else(|| "-".to_string())
                     )?;
                 }
                 None => {
@@ -857,55 +682,17 @@ fn show_votes_and_credits(
         return Ok(());
     }
 
-    // Existence of this should guarantee the occurrence of vote truncation
-    let newest_history_entry = epoch_voting_history.iter().rev().next();
-
+    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,
-        "{} Votes (using {}/{} entries):",
-        (if newest_history_entry.is_none() {
-            "All"
-        } else {
-            "Recent"
-        }),
-        votes.len(),
-        MAX_LOCKOUT_HISTORY
+        "* missed credits include slots unavailable to vote on due to delinquent leaders",
     )?;
-
-    for vote in votes.iter().rev() {
-        writeln!(
-            f,
-            "- slot: {} (confirmation count: {})",
-            vote.slot, vote.confirmation_count
-        )?;
-    }
-    if let Some(newest) = newest_history_entry {
-        writeln!(
-            f,
-            "- ... (truncated {} rooted votes, which have been credited)",
-            newest.credits
-        )?;
-    }
-
-    if !epoch_voting_history.is_empty() {
-        writeln!(
-            f,
-            "{} Epoch Voting History (using {}/{} entries):",
-            (if epoch_voting_history.len() < MAX_EPOCH_CREDITS_HISTORY {
-                "All"
-            } else {
-                "Recent"
-            }),
-            epoch_voting_history.len(),
-            MAX_EPOCH_CREDITS_HISTORY
-        )?;
-        writeln!(
-            f,
-            "* missed credits include slots unavailable to vote on due to delinquent leaders",
-        )?;
-    }
-
-    for entry in epoch_voting_history.iter().rev() {
+    for entry in epoch_voting_history {
         writeln!(
             f, // tame fmt so that this will be folded like following
             "- epoch: {}",
@@ -913,7 +700,7 @@ fn show_votes_and_credits(
         )?;
         writeln!(
             f,
-            "  credits range: ({}..{}]",
+            "  credits range: [{}..{})",
             entry.prev_credits, entry.credits
         )?;
         writeln!(
@@ -922,22 +709,6 @@ fn show_votes_and_credits(
             entry.credits_earned, entry.slots_in_epoch
         )?;
     }
-    if let Some(oldest) = epoch_voting_history.iter().next() {
-        if oldest.prev_credits > 0 {
-            // Oldest entry doesn't start with 0. so history must be truncated...
-
-            // count of this combined pseudo credits range: (0..=oldest.prev_credits] like the above
-            // (or this is just [1..=oldest.prev_credits] for human's simpler minds)
-            let count = oldest.prev_credits;
-
-            writeln!(
-                f,
-                "- ... (omitting {} past rooted votes, which have already been credited)",
-                count
-            )?;
-        }
-    }
-
     Ok(())
 }
 
@@ -953,13 +724,13 @@ fn show_epoch_rewards(
         writeln!(f, "Epoch Rewards:")?;
         writeln!(
             f,
-            "  {:<6}  {:<11}  {:<18}  {:<18}  {:>14}  {:>14}  {:>10}",
-            "Epoch", "Reward Slot", "Amount", "New Balance", "Percent Change", "APR", "Commission"
+            "  {:<6}  {:<11}  {:<18}  {:<18}  {:>14}  {:>14}",
+            "Epoch", "Reward Slot", "Amount", "New Balance", "Percent Change", "APR"
         )?;
         for reward in epoch_rewards {
             writeln!(
                 f,
-                "  {:<6}  {:<11}  ◎{:<17.9}  ◎{:<17.9}  {:>13.9}%  {:>14}  {:>10}",
+                "  {:<6}  {:<11}  ◎{:<17.9}  ◎{:<17.9}  {:>13.2}%  {}",
                 reward.epoch,
                 reward.effective_slot,
                 lamports_to_sol(reward.amount),
@@ -967,12 +738,8 @@ fn show_epoch_rewards(
                 reward.percent_change,
                 reward
                     .apr
-                    .map(|apr| format!("{:.2}%", apr))
+                    .map(|apr| format!("{:>13.2}%", apr))
                     .unwrap_or_default(),
-                reward
-                    .commission
-                    .map(|commission| format!("{}%", commission))
-                    .unwrap_or_else(|| "-".to_string())
             )?;
         }
     }
@@ -1334,7 +1101,7 @@ impl fmt::Display for CliValidatorInfo {
             writeln_name_value(
                 f,
                 &format!("  {}:", to_title_case(key)),
-                value.as_str().unwrap_or("?"),
+                &value.as_str().unwrap_or("?"),
             )?;
         }
         Ok(())
@@ -1372,8 +1139,8 @@ impl fmt::Display for CliVoteAccount {
             build_balance_message(self.account_balance, self.use_lamports_unit, true)
         )?;
         writeln!(f, "Validator Identity: {}", self.validator_identity)?;
-        writeln!(f, "Vote Authority: {}", self.authorized_voters)?;
-        writeln!(f, "Withdraw Authority: {}", self.authorized_withdrawer)?;
+        writeln!(f, "Authorized Voters: {}", self.authorized_voters)?;
+        writeln!(f, "Authorized Withdrawer: {}", self.authorized_withdrawer)?;
         writeln!(f, "Credits: {}", self.credits)?;
         writeln!(f, "Commission: {}%", self.commission)?;
         writeln!(
@@ -1508,18 +1275,18 @@ impl fmt::Display for CliInflation {
         if (self.governor.initial - self.governor.terminal).abs() < f64::EPSILON {
             writeln!(
                 f,
-                "Fixed rate:              {:>5.2}%",
+                "Fixed APR:               {:>5.2}%",
                 self.governor.terminal * 100.
             )?;
         } else {
             writeln!(
                 f,
-                "Initial rate:            {:>5.2}%",
+                "Initial APR:             {:>5.2}%",
                 self.governor.initial * 100.
             )?;
             writeln!(
                 f,
-                "Terminal rate:           {:>5.2}%",
+                "Terminal APR:            {:>5.2}%",
                 self.governor.terminal * 100.
             )?;
             writeln!(
@@ -1527,10 +1294,6 @@ impl fmt::Display for CliInflation {
                 "Rate reduction per year: {:>5.2}%",
                 self.governor.taper * 100.
             )?;
-            writeln!(
-                f,
-                "* Rate reduction is derived using the target slot time in genesis config"
-            )?;
         }
         if self.governor.foundation_term > 0. {
             writeln!(
@@ -1552,23 +1315,19 @@ impl fmt::Display for CliInflation {
         )?;
         writeln!(
             f,
-            "Total rate:              {:>5.2}%",
+            "Total APR:               {:>5.2}%",
             self.current_rate.total * 100.
         )?;
         writeln!(
             f,
-            "Staking rate:            {:>5.2}%",
+            "Staking APR:             {:>5.2}%",
             self.current_rate.validator * 100.
         )?;
-
-        if self.current_rate.foundation > 0. {
-            writeln!(
-                f,
-                "Foundation rate:         {:>5.2}%",
-                self.current_rate.foundation * 100.
-            )?;
-        }
-        Ok(())
+        writeln!(
+            f,
+            "Foundation APR:          {:>5.2}%",
+            self.current_rate.foundation * 100.
+        )
     }
 }
 
@@ -1720,7 +1479,6 @@ pub struct CliFeesInner {
     pub blockhash: String,
     pub lamports_per_signature: u64,
     pub last_valid_slot: Option<Slot>,
-    pub last_valid_block_height: Option<Slot>,
 }
 
 impl QuietDisplay for CliFeesInner {}
@@ -1734,11 +1492,11 @@ impl fmt::Display for CliFeesInner {
             "Lamports per signature:",
             &self.lamports_per_signature.to_string(),
         )?;
-        let last_valid_block_height = self
-            .last_valid_block_height
+        let last_valid_slot = self
+            .last_valid_slot
             .map(|s| s.to_string())
             .unwrap_or_default();
-        writeln_name_value(f, "Last valid block height:", &last_valid_block_height)
+        writeln_name_value(f, "Last valid slot:", &last_valid_slot)
     }
 }
 
@@ -1767,7 +1525,6 @@ impl CliFees {
         blockhash: Hash,
         lamports_per_signature: u64,
         last_valid_slot: Option<Slot>,
-        last_valid_block_height: Option<Slot>,
     ) -> Self {
         Self {
             inner: Some(CliFeesInner {
@@ -1775,7 +1532,6 @@ impl CliFees {
                 blockhash: blockhash.to_string(),
                 lamports_per_signature,
                 last_valid_slot,
-                last_valid_block_height,
             }),
         }
     }
@@ -1822,7 +1578,7 @@ impl fmt::Display for CliTokenAccount {
         writeln_name_value(
             f,
             "Close authority:",
-            account.close_authority.as_ref().unwrap_or(&String::new()),
+            &account.close_authority.as_ref().unwrap_or(&String::new()),
         )?;
         Ok(())
     }
@@ -2060,7 +1816,7 @@ pub fn return_signers_with_config(
 }
 
 pub fn parse_sign_only_reply_string(reply: &str) -> SignOnly {
-    let object: Value = serde_json::from_str(reply).unwrap();
+    let object: Value = serde_json::from_str(&reply).unwrap();
     let blockhash_str = object.get("blockhash").unwrap().as_str().unwrap();
     let blockhash = blockhash_str.parse::<Hash>().unwrap();
     let mut present_signers: Vec<(Pubkey, Signature)> = Vec::new();
@@ -2180,9 +1936,6 @@ impl fmt::Display for CliBlock {
         if let Some(block_time) = self.encoded_confirmed_block.block_time {
             writeln!(f, "Block Time: {:?}", Local.timestamp(block_time, 0))?;
         }
-        if let Some(block_height) = self.encoded_confirmed_block.block_height {
-            writeln!(f, "Block Height: {:?}", block_height)?;
-        }
         if !self.encoded_confirmed_block.rewards.is_empty() {
             let mut rewards = self.encoded_confirmed_block.rewards.clone();
             rewards.sort_by(|a, b| a.pubkey.cmp(&b.pubkey));
@@ -2190,8 +1943,8 @@ impl fmt::Display for CliBlock {
             writeln!(f, "Rewards:")?;
             writeln!(
                 f,
-                "  {:<44}  {:^15}  {:<15}  {:<20}  {:>14}  {:>10}",
-                "Address", "Type", "Amount", "New Balance", "Percent Change", "Commission"
+                "  {:<44}  {:^15}  {:<15}  {:<20}  {:>14}",
+                "Address", "Type", "Amount", "New Balance", "Percent Change"
             )?;
             for reward in rewards {
                 let sign = if reward.lamports < 0 { "-" } else { "" };
@@ -2199,7 +1952,7 @@ impl fmt::Display for CliBlock {
                 total_rewards += reward.lamports;
                 writeln!(
                     f,
-                    "  {:<44}  {:^15}  {:>15}  {}  {}",
+                    "  {:<44}  {:^15}  {:>15}  {}",
                     reward.pubkey,
                     if let Some(reward_type) = reward.reward_type {
                         format!("{}", reward_type)
@@ -2221,11 +1974,7 @@ impl fmt::Display for CliBlock {
                                 / (reward.post_balance as f64 - reward.lamports as f64))
                                 * 100.0
                         )
-                    },
-                    reward
-                        .commission
-                        .map(|commission| format!("{:>9}%", commission))
-                        .unwrap_or_else(|| "    -".to_string())
+                    }
                 )?;
             }
 
@@ -2344,97 +2093,6 @@ impl fmt::Display for CliTransactionConfirmation {
     }
 }
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliGossipNode {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ip_address: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub identity_label: Option<String>,
-    pub identity_pubkey: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gossip_port: Option<u16>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tpu_port: Option<u16>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub rpc_host: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub version: Option<String>,
-}
-
-impl CliGossipNode {
-    pub fn new(info: RpcContactInfo, labels: &HashMap<String, String>) -> Self {
-        Self {
-            ip_address: info.gossip.map(|addr| addr.ip().to_string()),
-            identity_label: labels.get(&info.pubkey).cloned(),
-            identity_pubkey: info.pubkey,
-            gossip_port: info.gossip.map(|addr| addr.port()),
-            tpu_port: info.tpu.map(|addr| addr.port()),
-            rpc_host: info.rpc.map(|addr| addr.to_string()),
-            version: info.version,
-        }
-    }
-}
-
-fn unwrap_to_string_or_none<T>(option: Option<T>) -> String
-where
-    T: std::string::ToString,
-{
-    unwrap_to_string_or_default(option, "none")
-}
-
-fn unwrap_to_string_or_default<T>(option: Option<T>, default: &str) -> String
-where
-    T: std::string::ToString,
-{
-    option
-        .as_ref()
-        .map(|v| v.to_string())
-        .unwrap_or_else(|| default.to_string())
-}
-
-impl fmt::Display for CliGossipNode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "{:15} | {:44} | {:6} | {:5} | {:21} | {}",
-            unwrap_to_string_or_none(self.ip_address.as_ref()),
-            self.identity_label
-                .as_ref()
-                .unwrap_or(&self.identity_pubkey),
-            unwrap_to_string_or_none(self.gossip_port.as_ref()),
-            unwrap_to_string_or_none(self.tpu_port.as_ref()),
-            unwrap_to_string_or_none(self.rpc_host.as_ref()),
-            unwrap_to_string_or_default(self.version.as_ref(), "unknown"),
-        )
-    }
-}
-
-impl QuietDisplay for CliGossipNode {}
-impl VerboseDisplay for CliGossipNode {}
-
-#[derive(Serialize, Deserialize)]
-pub struct CliGossipNodes(pub Vec<CliGossipNode>);
-
-impl fmt::Display for CliGossipNodes {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "IP Address      | Node identifier                              \
-             | Gossip | TPU   | RPC Address           | Version\n\
-             ----------------+----------------------------------------------+\
-             --------+-------+-----------------------+----------------",
-        )?;
-        for node in self.0.iter() {
-            writeln!(f, "{}", node)?;
-        }
-        writeln!(f, "Nodes: {}", self.0.len())
-    }
-}
-
-impl QuietDisplay for CliGossipNodes {}
-impl VerboseDisplay for CliGossipNodes {}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -2466,10 +2124,6 @@ mod tests {
             fn try_sign_message(&self, _message: &[u8]) -> Result<Signature, SignerError> {
                 Ok(Signature::new(&[1u8; 64]))
             }
-
-            fn is_interactive(&self) -> bool {
-                false
-            }
         }
 
         let present: Box<dyn Signer> = Box::new(keypair_from_seed(&[2u8; 32]).unwrap());

cli-output/src/display.rs

@@ -4,12 +4,10 @@ use {
     console::style,
     indicatif::{ProgressBar, ProgressStyle},
     solana_sdk::{
-        clock::UnixTimestamp, hash::Hash, message::Message, native_token::lamports_to_sol,
-        program_utils::limited_deserialize, pubkey::Pubkey, stake, transaction::Transaction,
+        clock::UnixTimestamp, hash::Hash, native_token::lamports_to_sol,
+        program_utils::limited_deserialize, transaction::Transaction,
     },
     solana_transaction_status::UiTransactionStatusMeta,
-    spl_memo::id as spl_memo_id,
-    spl_memo::v1::id as spl_memo_v1_id,
     std::{collections::HashMap, fmt, io},
 };
 
@@ -30,11 +28,6 @@ impl Default for BuildBalanceMessageConfig {
     }
 }
 
-fn is_memo_program(k: &Pubkey) -> bool {
-    let k_str = k.to_string();
-    (k_str == spl_memo_v1_id().to_string()) || (k_str == spl_memo_id().to_string())
-}
-
 pub fn build_balance_message_with_config(
     lamports: u64,
     config: &BuildBalanceMessageConfig,
@@ -132,31 +125,6 @@ pub fn println_signers(
     println!();
 }
 
-fn format_account_mode(message: &Message, index: usize) -> String {
-    format!(
-        "{}r{}{}", // accounts are always readable...
-        if message.is_signer(index) {
-            "s" // stands for signer
-        } else {
-            "-"
-        },
-        if message.is_writable(index) {
-            "w" // comment for consistent rust fmt (no joking; lol)
-        } else {
-            "-"
-        },
-        // account may be executable on-chain while not being
-        // designated as a program-id in the message
-        if message.maybe_executable(index) {
-            "x"
-        } else {
-            // programs to be executed via CPI cannot be identified as
-            // executable from the message
-            "-"
-        },
-    )
-}
-
 pub fn write_transaction<W: io::Write>(
     w: &mut W,
     transaction: &Transaction,
@@ -199,31 +167,16 @@ pub fn write_transaction<W: io::Write>(
             prefix, signature_index, signature, sigverify_status,
         )?;
     }
-    let mut fee_payer_index = None;
+    writeln!(w, "{}{:?}", prefix, message.header)?;
     for (account_index, account) in message.account_keys.iter().enumerate() {
-        if fee_payer_index.is_none() && message.is_non_loader_key(account, account_index) {
-            fee_payer_index = Some(account_index)
-        }
-        writeln!(
-            w,
-            "{}Account {}: {} {}{}",
-            prefix,
-            account_index,
-            format_account_mode(message, account_index),
-            account,
-            if Some(account_index) == fee_payer_index {
-                " (fee payer)"
-            } else {
-                ""
-            },
-        )?;
+        writeln!(w, "{}Account {}: {:?}", prefix, account_index, account)?;
     }
     for (instruction_index, instruction) in message.instructions.iter().enumerate() {
         let program_pubkey = message.account_keys[instruction.program_id_index as usize];
         writeln!(w, "{}Instruction {}", prefix, instruction_index)?;
         writeln!(
             w,
-            "{}  Program:   {} ({})",
+            "{}  Program: {} ({})",
             prefix, program_pubkey, instruction.program_id_index
         )?;
         for (account_index, account) in instruction.accounts.iter().enumerate() {
@@ -244,9 +197,10 @@ pub fn write_transaction<W: io::Write>(
                 writeln!(w, "{}  {:?}", prefix, vote_instruction)?;
                 raw = false;
             }
-        } else if program_pubkey == stake::program::id() {
-            if let Ok(stake_instruction) =
-                limited_deserialize::<stake::instruction::StakeInstruction>(&instruction.data)
+        } else if program_pubkey == solana_stake_program::id() {
+            if let Ok(stake_instruction) = limited_deserialize::<
+                solana_stake_program::stake_instruction::StakeInstruction,
+            >(&instruction.data)
             {
                 writeln!(w, "{}  {:?}", prefix, stake_instruction)?;
                 raw = false;
@@ -259,11 +213,6 @@ pub fn write_transaction<W: io::Write>(
                 writeln!(w, "{}  {:?}", prefix, system_instruction)?;
                 raw = false;
             }
-        } else if is_memo_program(&program_pubkey) {
-            if let Ok(s) = std::str::from_utf8(&instruction.data) {
-                writeln!(w, "{}  Data: \"{}\"", prefix, s)?;
-                raw = false;
-            }
         }
 
         if raw {
@@ -321,38 +270,7 @@ pub fn write_transaction<W: io::Write>(
             if !log_messages.is_empty() {
                 writeln!(w, "{}Log Messages:", prefix,)?;
                 for log_message in log_messages {
-                    writeln!(w, "{}  {}", prefix, log_message)?;
-                }
-            }
-        }
-
-        if let Some(rewards) = &transaction_status.rewards {
-            if !rewards.is_empty() {
-                writeln!(w, "{}Rewards:", prefix,)?;
-                writeln!(
-                    w,
-                    "{}  {:<44}  {:^15}  {:<15}  {:<20}",
-                    prefix, "Address", "Type", "Amount", "New Balance"
-                )?;
-                for reward in rewards {
-                    let sign = if reward.lamports < 0 { "-" } else { "" };
-                    writeln!(
-                        w,
-                        "{}  {:<44}  {:^15}  {:<15}  {}",
-                        prefix,
-                        reward.pubkey,
-                        if let Some(reward_type) = reward.reward_type {
-                            format!("{}", reward_type)
-                        } else {
-                            "-".to_string()
-                        },
-                        format!(
-                            "{}◎{:<14.9}",
-                            sign,
-                            lamports_to_sol(reward.lamports.abs() as u64)
-                        ),
-                        format!("◎{:<18.9}", lamports_to_sol(reward.post_balance),)
-                    )?;
+                    writeln!(w, "{}  {}", prefix, log_message,)?;
                 }
             }
         }

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.7.7"
+version = "1.5.20"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -16,8 +16,7 @@ chrono = { version = "0.4.11", features = ["serde"] }
 clap = "2.33.1"
 criterion-stats = "0.3.0"
 ctrlc = { version = "3.1.5", features = ["termination"] }
-console = "0.14.1"
-const_format = "0.2.14"
+console = "0.11.3"
 dirs-next = "2.0.0"
 log = "0.4.11"
 Inflector = "0.11.4"
@@ -25,33 +24,33 @@ indicatif = "0.15.0"
 humantime = "2.0.1"
 num-traits = "0.2"
 pretty-hex = "0.2.1"
-reqwest = { version = "0.11.2", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde = "1.0.122"
+reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "=1.7.7" }
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "=1.7.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.7.7" }
-solana-cli-config = { path = "../cli-config", version = "=1.7.7" }
-solana-cli-output = { path = "../cli-output", version = "=1.7.7" }
-solana-client = { path = "../client", version = "=1.7.7" }
-solana-config-program = { path = "../programs/config", version = "=1.7.7" }
-solana-faucet = { path = "../faucet", version = "=1.7.7" }
-solana-logger = { path = "../logger", version = "=1.7.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.7.7" }
-solana_rbpf = "=0.2.11"
-solana-remote-wallet = { path = "../remote-wallet", version = "=1.7.7" }
-solana-sdk = { path = "../sdk", version = "=1.7.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.7.7" }
-solana-version = { path = "../version", version = "=1.7.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.7.7" }
-spl-memo = { version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "=1.5.20" }
+solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "=1.5.20" }
+solana-clap-utils = { path = "../clap-utils", version = "=1.5.20" }
+solana-cli-config = { path = "../cli-config", version = "=1.5.20" }
+solana-cli-output = { path = "../cli-output", version = "=1.5.20" }
+solana-client = { path = "../client", version = "=1.5.20" }
+solana-config-program = { path = "../programs/config", version = "=1.5.20" }
+solana-faucet = { path = "../faucet", version = "=1.5.20" }
+solana-logger = { path = "../logger", version = "=1.5.20" }
+solana-net-utils = { path = "../net-utils", version = "=1.5.20" }
+solana_rbpf = "=0.2.7"
+solana-remote-wallet = { path = "../remote-wallet", version = "=1.5.20" }
+solana-sdk = { path = "../sdk", version = "=1.5.20" }
+solana-stake-program = { path = "../programs/stake", version = "=1.5.20" }
+solana-transaction-status = { path = "../transaction-status", version = "=1.5.20" }
+solana-version = { path = "../version", version = "=1.5.20" }
+solana-vote-program = { path = "../programs/vote", version = "=1.5.20" }
 thiserror = "1.0.21"
 tiny-bip39 = "0.7.0"
 url = "2.1.1"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "=1.7.7" }
+solana-core = { path = "../core", version = "=1.5.20" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/checks.rs

@@ -231,9 +231,18 @@ mod tests {
         mocks.insert(RpcRequest::GetBalance, account_balance_response);
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
 
-        assert!(check_account_for_balance(&rpc_client, &pubkey, 1).unwrap());
-        assert!(check_account_for_balance(&rpc_client, &pubkey, account_balance).unwrap());
-        assert!(!check_account_for_balance(&rpc_client, &pubkey, account_balance + 1).unwrap());
+        assert_eq!(
+            check_account_for_balance(&rpc_client, &pubkey, 1).unwrap(),
+            true
+        );
+        assert_eq!(
+            check_account_for_balance(&rpc_client, &pubkey, account_balance).unwrap(),
+            true
+        );
+        assert_eq!(
+            check_account_for_balance(&rpc_client, &pubkey, account_balance + 1).unwrap(),
+            false
+        );
     }
 
     #[test]

cli/src/cluster_query.rs

@@ -24,12 +24,11 @@ use solana_client::{
     pubsub_client::PubsubClient,
     rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient},
     rpc_config::{
-        RpcAccountInfoConfig, RpcBlockConfig, RpcGetVoteAccountsConfig, RpcLargestAccountsConfig,
-        RpcLargestAccountsFilter, RpcProgramAccountsConfig, RpcTransactionConfig,
+        RpcAccountInfoConfig, RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig,
+        RpcLargestAccountsConfig, RpcLargestAccountsFilter, RpcProgramAccountsConfig,
         RpcTransactionLogsConfig, RpcTransactionLogsFilter,
     },
     rpc_filter,
-    rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE,
     rpc_response::SlotInfo,
 };
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
@@ -47,22 +46,21 @@ use solana_sdk::{
     rent::Rent,
     rpc_port::DEFAULT_RPC_PORT_STR,
     signature::Signature,
-    slot_history,
-    stake::{self, state::StakeState},
     system_instruction, system_program,
     sysvar::{
         self,
-        slot_history::SlotHistory,
         stake_history::{self},
     },
     timing,
     transaction::Transaction,
 };
+use solana_stake_program::stake_state::StakeState;
 use solana_transaction_status::UiTransactionEncoding;
 use solana_vote_program::vote_state::VoteState;
 use std::{
     collections::{BTreeMap, HashMap, VecDeque},
     fmt,
+    net::SocketAddr,
     str::FromStr,
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -123,7 +121,7 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .long("our-localhost")
                         .takes_value(false)
                         .value_name("PORT")
-                        .default_value(DEFAULT_RPC_PORT_STR)
+                        .default_value(&DEFAULT_RPC_PORT_STR)
                         .validator(is_port)
                         .help("Guess Identity pubkey and validator rpc node assuming local (possibly private) validator"),
                 )
@@ -177,7 +175,7 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                     .takes_value(true)
                     .value_name("EPOCH")
                     .validator(is_epoch)
-                    .help("Epoch to show leader schedule for. [default: current]")
+                    .help("Epoch to show leader schedule for. (default: current)")
             )
         )
         .subcommand(
@@ -351,57 +349,6 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .long("lamports")
                         .takes_value(false)
                         .help("Display balance in lamports instead of SOL"),
-                )
-                .arg(
-                    Arg::with_name("number")
-                        .long("number")
-                        .short("n")
-                        .takes_value(false)
-                        .help("Number the validators"),
-                )
-                .arg(
-                    Arg::with_name("reverse")
-                        .long("reverse")
-                        .short("r")
-                        .takes_value(false)
-                        .help("Reverse order while sorting"),
-                )
-                .arg(
-                    Arg::with_name("sort")
-                        .long("sort")
-                        .takes_value(true)
-                        .possible_values(&[
-                            "delinquent",
-                            "commission",
-                            "credits",
-                            "identity",
-                            "last-vote",
-                            "root",
-                            "skip-rate",
-                            "stake",
-                            "vote-account",
-                        ])
-                        .default_value("stake")
-                        .help("Sort order (does not affect JSON output)"),
-                )
-                .arg(
-                    Arg::with_name("keep_unstaked_delinquents")
-                        .long("keep-unstaked-delinquents")
-                        .takes_value(false)
-                        .help("Don't discard unstaked, delinquent validators")
-                )
-                .arg(
-                    Arg::with_name("delinquent_slot_distance")
-                        .long("delinquent-slot-distance")
-                        .takes_value(true)
-                        .value_name("SLOT_DISTANCE")
-                        .validator(is_slot)
-                        .help(
-                            concatcp!(
-                                "Minimum slot distance from the tip to consider a validator delinquent. [default: ",
-                                DELINQUENT_VALIDATOR_SLOT_DISTANCE,
-                                "]",
-                        ))
                 ),
         )
         .subcommand(
@@ -635,33 +582,9 @@ pub fn parse_show_stakes(
 
 pub fn parse_show_validators(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let use_lamports_unit = matches.is_present("lamports");
-    let number_validators = matches.is_present("number");
-    let reverse_sort = matches.is_present("reverse");
-    let keep_unstaked_delinquents = matches.is_present("keep_unstaked_delinquents");
-    let delinquent_slot_distance = value_of(matches, "delinquent_slot_distance");
-
-    let sort_order = match value_t_or_exit!(matches, "sort", String).as_str() {
-        "delinquent" => CliValidatorsSortOrder::Delinquent,
-        "commission" => CliValidatorsSortOrder::Commission,
-        "credits" => CliValidatorsSortOrder::EpochCredits,
-        "identity" => CliValidatorsSortOrder::Identity,
-        "last-vote" => CliValidatorsSortOrder::LastVote,
-        "root" => CliValidatorsSortOrder::Root,
-        "skip-rate" => CliValidatorsSortOrder::SkipRate,
-        "stake" => CliValidatorsSortOrder::Stake,
-        "vote-account" => CliValidatorsSortOrder::VoteAccount,
-        _ => unreachable!(),
-    };
 
     Ok(CliCommandInfo {
-        command: CliCommand::ShowValidators {
-            use_lamports_unit,
-            sort_order,
-            reverse_sort,
-            number_validators,
-            keep_unstaked_delinquents,
-            delinquent_slot_distance,
-        },
+        command: CliCommand::ShowValidators { use_lamports_unit },
         signers: vec![],
     })
 }
@@ -962,19 +885,18 @@ pub fn process_fees(
                 *recent_blockhash,
                 fee_calculator.lamports_per_signature,
                 None,
-                None,
             )
         } else {
             CliFees::none()
         }
     } else {
-        let result = rpc_client.get_fees_with_commitment(config.commitment)?;
+        let result = rpc_client.get_recent_blockhash_with_commitment(config.commitment)?;
+        let (recent_blockhash, fee_calculator, last_valid_slot) = result.value;
         CliFees::some(
             result.context.slot,
-            result.value.blockhash,
-            result.value.fee_calculator.lamports_per_signature,
-            None,
-            Some(result.value.last_valid_block_height),
+            recent_blockhash,
+            fee_calculator.lamports_per_signature,
+            Some(last_valid_slot),
         )
     };
     Ok(config.output_format.formatted_string(&fees))
@@ -1053,12 +975,12 @@ pub fn process_get_block(
     };
 
     let encoded_confirmed_block = rpc_client
-        .get_block_with_config(
+        .get_confirmed_block_with_config(
             slot,
-            RpcBlockConfig {
+            RpcConfirmedBlockConfig {
                 encoding: Some(UiTransactionEncoding::Base64),
                 commitment: Some(CommitmentConfig::confirmed()),
-                ..RpcBlockConfig::default()
+                ..RpcConfirmedBlockConfig::default()
             },
         )?
         .into();
@@ -1101,15 +1023,9 @@ pub fn process_get_epoch_info(rpc_client: &RpcClient, config: &CliConfig) -> Pro
             (secs as u64).saturating_mul(1000).checked_div(slots)
         })
         .unwrap_or(clock::DEFAULT_MS_PER_SLOT);
-    let start_block_time = rpc_client
-        .get_block_time(epoch_info.absolute_slot - epoch_info.slot_index)
-        .ok();
-    let current_block_time = rpc_client.get_block_time(epoch_info.absolute_slot).ok();
     let epoch_info = CliEpochInfo {
         epoch_info,
         average_slot_time_ms,
-        start_block_time,
-        current_block_time,
     };
     Ok(config.output_format.formatted_string(&epoch_info))
 }
@@ -1125,8 +1041,8 @@ pub fn process_get_slot(rpc_client: &RpcClient, _config: &CliConfig) -> ProcessR
 }
 
 pub fn process_get_block_height(rpc_client: &RpcClient, _config: &CliConfig) -> ProcessResult {
-    let block_height = rpc_client.get_block_height()?;
-    Ok(block_height.to_string())
+    let epoch_info = rpc_client.get_epoch_info()?;
+    Ok(epoch_info.block_height.to_string())
 }
 
 pub fn parse_show_block_production(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
@@ -1153,6 +1069,8 @@ pub fn process_show_block_production(
         return Err(format!("Epoch {} is in the future", epoch).into());
     }
 
+    let minimum_ledger_slot = rpc_client.minimum_ledger_slot()?;
+
     let first_slot_in_epoch = epoch_schedule.get_first_slot_in_epoch(epoch);
     let end_slot = std::cmp::min(
         epoch_info.absolute_slot,
@@ -1165,60 +1083,32 @@ pub fn process_show_block_production(
         first_slot_in_epoch
     };
 
+    if minimum_ledger_slot > end_slot {
+        return Err(format!(
+            "Ledger data not available for slots {} to {} (minimum ledger slot is {})",
+            start_slot, end_slot, minimum_ledger_slot
+        )
+        .into());
+    }
+
+    if minimum_ledger_slot > start_slot {
+        println!(
+            "\n{}",
+            style(format!(
+                "Note: Requested start slot was {} but minimum ledger slot is {}",
+                start_slot, minimum_ledger_slot
+            ))
+            .italic(),
+        );
+        start_slot = minimum_ledger_slot;
+    }
+
     let progress_bar = new_spinner_progress_bar();
     progress_bar.set_message(&format!(
         "Fetching confirmed blocks between slots {} and {}...",
         start_slot, end_slot
     ));
-
-    let slot_history_account = rpc_client
-        .get_account_with_commitment(&sysvar::slot_history::id(), CommitmentConfig::finalized())?
-        .value
-        .unwrap();
-
-    let slot_history: SlotHistory = from_account(&slot_history_account).ok_or_else(|| {
-        CliError::RpcRequestError("Failed to deserialize slot history".to_string())
-    })?;
-
-    let (confirmed_blocks, start_slot) =
-        if start_slot >= slot_history.oldest() && end_slot <= slot_history.newest() {
-            // Fast, more reliable path using the SlotHistory sysvar
-
-            let confirmed_blocks: Vec<_> = (start_slot..=end_slot)
-                .filter(|slot| slot_history.check(*slot) == slot_history::Check::Found)
-                .collect();
-            (confirmed_blocks, start_slot)
-        } else {
-            // Slow, less reliable path using `getBlocks`.
-            //
-            // "less reliable" because if the RPC node has holds in its ledger then the block production data will be
-            // incorrect.  This condition currently can't be detected over RPC
-            //
-
-            let minimum_ledger_slot = rpc_client.minimum_ledger_slot()?;
-            if minimum_ledger_slot > end_slot {
-                return Err(format!(
-                    "Ledger data not available for slots {} to {} (minimum ledger slot is {})",
-                    start_slot, end_slot, minimum_ledger_slot
-                )
-                .into());
-            }
-
-            if minimum_ledger_slot > start_slot {
-                progress_bar.println(format!(
-                    "{}",
-                    style(format!(
-                        "Note: Requested start slot was {} but minimum ledger slot is {}",
-                        start_slot, minimum_ledger_slot
-                    ))
-                    .italic(),
-                ));
-                start_slot = minimum_ledger_slot;
-            }
-
-            let confirmed_blocks = rpc_client.get_blocks(start_slot, Some(end_slot))?;
-            (confirmed_blocks, start_slot)
-        };
+    let confirmed_blocks = rpc_client.get_confirmed_blocks(start_slot, Some(end_slot))?;
 
     let start_slot_index = (start_slot - first_slot_in_epoch) as usize;
     let end_slot_index = (end_slot - first_slot_in_epoch) as usize;
@@ -1481,7 +1371,9 @@ pub fn process_ping(
 
                     // Sleep for half a slot
                     if signal_receiver
-                        .recv_timeout(Duration::from_millis(clock::DEFAULT_MS_PER_SLOT / 2))
+                        .recv_timeout(Duration::from_millis(
+                            500 * clock::DEFAULT_TICKS_PER_SLOT / clock::DEFAULT_TICKS_PER_SECOND,
+                        ))
                         .is_ok()
                     {
                         break 'mainloop;
@@ -1686,14 +1578,40 @@ pub fn process_live_slots(config: &CliConfig) -> ProcessResult {
 pub fn process_show_gossip(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
     let cluster_nodes = rpc_client.get_cluster_nodes()?;
 
-    let nodes: Vec<_> = cluster_nodes
+    fn format_port(addr: Option<SocketAddr>) -> String {
+        addr.map(|addr| addr.port().to_string())
+            .unwrap_or_else(|| "none".to_string())
+    }
+
+    let s: Vec<_> = cluster_nodes
         .into_iter()
-        .map(|node| CliGossipNode::new(node, &config.address_labels))
+        .map(|node| {
+            format!(
+                "{:15} | {:44} | {:6} | {:5} | {:21} | {}",
+                node.gossip
+                    .map(|addr| addr.ip().to_string())
+                    .unwrap_or_else(|| "none".to_string()),
+                format_labeled_address(&node.pubkey, &config.address_labels),
+                format_port(node.gossip),
+                format_port(node.tpu),
+                node.rpc
+                    .map(|addr| addr.to_string())
+                    .unwrap_or_else(|| "none".to_string()),
+                node.version.unwrap_or_else(|| "unknown".to_string()),
+            )
+        })
         .collect();
 
-    Ok(config
-        .output_format
-        .formatted_string(&CliGossipNodes(nodes)))
+    Ok(format!(
+        "IP Address      | Node identifier                              \
+         | Gossip | TPU   | RPC Address           | Version\n\
+         ----------------+----------------------------------------------+\
+         --------+-------+-----------------------+----------------\n\
+         {}\n\
+         Nodes: {}",
+        s.join("\n"),
+        s.len(),
+    ))
 }
 
 pub fn process_show_stakes(
@@ -1708,11 +1626,11 @@ pub fn process_show_stakes(
     progress_bar.set_message("Fetching stake accounts...");
 
     let mut program_accounts_config = RpcProgramAccountsConfig {
+        filters: None,
         account_config: RpcAccountInfoConfig {
             encoding: Some(solana_account_decoder::UiAccountEncoding::Base64),
             ..RpcAccountInfoConfig::default()
         },
-        ..RpcProgramAccountsConfig::default()
     };
 
     if let Some(vote_account_pubkeys) = vote_account_pubkeys {
@@ -1739,7 +1657,7 @@ pub fn process_show_stakes(
         }
     }
     let all_stake_accounts = rpc_client
-        .get_program_accounts_with_config(&stake::program::id(), program_accounts_config)?;
+        .get_program_accounts_with_config(&solana_stake_program::id(), program_accounts_config)?;
     let stake_history_account = rpc_client.get_account(&stake_history::id())?;
     let clock_account = rpc_client.get_account(&sysvar::clock::id())?;
     let clock: Clock = from_account(&clock_account).ok_or_else(|| {
@@ -1814,42 +1732,10 @@ pub fn process_show_validators(
     rpc_client: &RpcClient,
     config: &CliConfig,
     use_lamports_unit: bool,
-    validators_sort_order: CliValidatorsSortOrder,
-    validators_reverse_sort: bool,
-    number_validators: bool,
-    keep_unstaked_delinquents: bool,
-    delinquent_slot_distance: Option<Slot>,
 ) -> ProcessResult {
-    let progress_bar = new_spinner_progress_bar();
-    progress_bar.set_message("Fetching vote accounts...");
     let epoch_info = rpc_client.get_epoch_info()?;
-    let vote_accounts = rpc_client.get_vote_accounts_with_config(RpcGetVoteAccountsConfig {
-        keep_unstaked_delinquents: Some(keep_unstaked_delinquents),
-        delinquent_slot_distance,
-        ..RpcGetVoteAccountsConfig::default()
-    })?;
+    let vote_accounts = rpc_client.get_vote_accounts()?;
 
-    progress_bar.set_message("Fetching block production...");
-    let skip_rate: HashMap<_, _> = rpc_client
-        .get_block_production()
-        .ok()
-        .map(|result| {
-            result
-                .value
-                .by_identity
-                .into_iter()
-                .map(|(identity, (leader_slots, blocks_produced))| {
-                    (
-                        identity,
-                        100. * (leader_slots.saturating_sub(blocks_produced)) as f64
-                            / leader_slots as f64,
-                    )
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-
-    progress_bar.set_message("Fetching version information...");
     let mut node_version = HashMap::new();
     let unknown_version = "unknown".to_string();
     for contact_info in rpc_client.get_cluster_nodes()? {
@@ -1861,8 +1747,6 @@ pub fn process_show_validators(
         );
     }
 
-    progress_bar.finish_and_clear();
-
     let total_active_stake = vote_accounts
         .current
         .iter()
@@ -1877,8 +1761,9 @@ pub fn process_show_validators(
         .sum();
     let total_current_stake = total_active_stake - total_delinquent_stake;
 
-    let current_validators: Vec<CliValidator> = vote_accounts
-        .current
+    let mut current = vote_accounts.current;
+    current.sort_by(|a, b| b.activated_stake.cmp(&a.activated_stake));
+    let current_validators: Vec<CliValidator> = current
         .iter()
         .map(|vote_account| {
             CliValidator::new(
@@ -1888,23 +1773,22 @@ pub fn process_show_validators(
                     .get(&vote_account.node_pubkey)
                     .unwrap_or(&unknown_version)
                     .clone(),
-                skip_rate.get(&vote_account.node_pubkey).cloned(),
                 &config.address_labels,
             )
         })
         .collect();
-    let delinquent_validators: Vec<CliValidator> = vote_accounts
-        .delinquent
+    let mut delinquent = vote_accounts.delinquent;
+    delinquent.sort_by(|a, b| b.activated_stake.cmp(&a.activated_stake));
+    let delinquent_validators: Vec<CliValidator> = delinquent
         .iter()
         .map(|vote_account| {
-            CliValidator::new_delinquent(
+            CliValidator::new(
                 vote_account,
                 epoch_info.epoch,
                 node_version
                     .get(&vote_account.node_pubkey)
                     .unwrap_or(&unknown_version)
                     .clone(),
-                skip_rate.get(&vote_account.node_pubkey).cloned(),
                 &config.address_labels,
             )
         })
@@ -1926,43 +1810,12 @@ pub fn process_show_validators(
         entry.delinquent_active_stake += validator.activated_stake;
     }
 
-    let validators: Vec<_> = current_validators
-        .into_iter()
-        .chain(delinquent_validators.into_iter())
-        .collect();
-
-    let (average_skip_rate, average_stake_weighted_skip_rate) = {
-        let mut skip_rate_len = 0;
-        let mut skip_rate_sum = 0.;
-        let mut skip_rate_weighted_sum = 0.;
-        for validator in validators.iter() {
-            if let Some(skip_rate) = validator.skip_rate {
-                skip_rate_sum += skip_rate;
-                skip_rate_len += 1;
-                skip_rate_weighted_sum += skip_rate * validator.activated_stake as f64;
-            }
-        }
-
-        if skip_rate_len > 0 && total_active_stake > 0 {
-            (
-                skip_rate_sum / skip_rate_len as f64,
-                skip_rate_weighted_sum / total_active_stake as f64,
-            )
-        } else {
-            (100., 100.) // Impossible?
-        }
-    };
-
     let cli_validators = CliValidators {
         total_active_stake,
         total_current_stake,
         total_delinquent_stake,
-        validators,
-        average_skip_rate,
-        average_stake_weighted_skip_rate,
-        validators_sort_order,
-        validators_reverse_sort,
-        number_validators,
+        current_validators,
+        delinquent_validators,
         stake_by_version,
         use_lamports_unit,
     };
@@ -1978,7 +1831,7 @@ pub fn process_transaction_history(
     limit: usize,
     show_transactions: bool,
 ) -> ProcessResult {
-    let results = rpc_client.get_signatures_for_address_with_config(
+    let results = rpc_client.get_confirmed_signatures_for_address2_with_config(
         address,
         GetConfirmedSignaturesForAddress2Config {
             before,
@@ -2017,9 +1870,9 @@ pub fn process_transaction_history(
 
         if show_transactions {
             if let Ok(signature) = result.signature.parse::<Signature>() {
-                match rpc_client.get_transaction_with_config(
+                match rpc_client.get_confirmed_transaction_with_config(
                     &signature,
-                    RpcTransactionConfig {
+                    RpcConfirmedTransactionConfig {
                         encoding: Some(UiTransactionEncoding::Base64),
                         commitment: Some(CommitmentConfig::confirmed()),
                     },
@@ -2162,7 +2015,10 @@ mod tests {
         let default_keypair = Keypair::new();
         let (default_keypair_file, mut tmp_file) = make_tmp_file();
         write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
-        let default_signer = DefaultSigner::new("", &default_keypair_file);
+        let default_signer = DefaultSigner {
+            path: default_keypair_file,
+            arg_name: String::new(),
+        };
 
         let test_cluster_version = test_commands
             .clone()

cli/src/feature.rs

@@ -10,7 +10,6 @@ use solana_cli_output::{QuietDisplay, VerboseDisplay};
 use solana_client::{client_error::ClientError, rpc_client::RpcClient};
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
-    account::Account,
     clock::Slot,
     feature::{self, Feature},
     feature_set::FEATURE_NAMES,
@@ -313,31 +312,6 @@ fn feature_activation_allowed(rpc_client: &RpcClient, quiet: bool) -> Result<boo
     Ok(feature_activation_allowed)
 }
 
-fn status_from_account(account: Account) -> Option<CliFeatureStatus> {
-    feature::from_account(&account).map(|feature| match feature.activated_at {
-        None => CliFeatureStatus::Pending,
-        Some(activation_slot) => CliFeatureStatus::Active(activation_slot),
-    })
-}
-
-fn get_feature_status(
-    rpc_client: &RpcClient,
-    feature_id: &Pubkey,
-) -> Result<Option<CliFeatureStatus>, Box<dyn std::error::Error>> {
-    rpc_client
-        .get_account(feature_id)
-        .map(status_from_account)
-        .map_err(|e| e.into())
-}
-
-pub fn get_feature_is_active(
-    rpc_client: &RpcClient,
-    feature_id: &Pubkey,
-) -> Result<bool, Box<dyn std::error::Error>> {
-    get_feature_status(rpc_client, feature_id)
-        .map(|status| matches!(status, Some(CliFeatureStatus::Active(_))))
-}
-
 fn process_status(
     rpc_client: &RpcClient,
     config: &CliConfig,
@@ -353,7 +327,11 @@ fn process_status(
         let feature_id = &feature_ids[i];
         let feature_name = FEATURE_NAMES.get(feature_id).unwrap();
         if let Some(account) = account {
-            if let Some(feature_status) = status_from_account(account) {
+            if let Some(feature) = feature::from_account(&account) {
+                let feature_status = match feature.activated_at {
+                    None => CliFeatureStatus::Pending,
+                    Some(activation_slot) => CliFeatureStatus::Active(activation_slot),
+                };
                 features.push(CliFeature {
                     id: feature_id.to_string(),
                     description: feature_name.to_string(),

cli/src/inflation.rs

@@ -102,7 +102,7 @@ fn process_rewards(
     rewards_epoch: Option<Epoch>,
 ) -> ProcessResult {
     let rewards = rpc_client
-        .get_inflation_reward(addresses, rewards_epoch)
+        .get_inflation_reward(&addresses, rewards_epoch)
         .map_err(|err| {
             if let Some(epoch) = rewards_epoch {
                 format!("Rewards not available for epoch {}", epoch)

cli/src/lib.rs

@@ -10,6 +10,7 @@ macro_rules! ACCOUNT_STRING {
     };
 }
 
+#[macro_use]
 macro_rules! pubkey {
     ($arg:expr, $help:expr) => {
         $arg.takes_value(true)
@@ -18,9 +19,6 @@ macro_rules! pubkey {
     };
 }
 
-#[macro_use]
-extern crate const_format;
-
 extern crate serde_derive;
 
 pub mod checks;
@@ -28,9 +26,9 @@ pub mod cli;
 pub mod cluster_query;
 pub mod feature;
 pub mod inflation;
-pub mod memo;
 pub mod nonce;
 pub mod program;
+pub mod send_tpu;
 pub mod spend_utils;
 pub mod stake;
 pub mod test_utils;

cli/src/main.rs

@@ -10,7 +10,7 @@ use solana_clap_utils::{
 };
 use solana_cli::cli::{
     app, parse_command, process_command, CliCommandInfo, CliConfig, SettingType,
-    DEFAULT_CONFIRM_TX_TIMEOUT_SECONDS, DEFAULT_RPC_TIMEOUT_SECONDS,
+    DEFAULT_RPC_TIMEOUT_SECONDS,
 };
 use solana_cli_config::{Config, CONFIG_FILE};
 use solana_cli_output::{display::println_name_value, OutputFormat};
@@ -167,11 +167,6 @@ pub fn parse_args<'a>(
     let rpc_timeout = value_t_or_exit!(matches, "rpc_timeout", u64);
     let rpc_timeout = Duration::from_secs(rpc_timeout);
 
-    let confirm_transaction_initial_timeout =
-        value_t_or_exit!(matches, "confirm_transaction_initial_timeout", u64);
-    let confirm_transaction_initial_timeout =
-        Duration::from_secs(confirm_transaction_initial_timeout);
-
     let (_, websocket_url) = CliConfig::compute_websocket_url_setting(
         matches.value_of("websocket_url").unwrap_or(""),
         &config.websocket_url,
@@ -184,12 +179,15 @@ pub fn parse_args<'a>(
         &config.keypair_path,
     );
 
-    let default_signer = DefaultSigner::new(default_signer_arg_name, &default_signer_path);
+    let default_signer = DefaultSigner {
+        arg_name: default_signer_arg_name,
+        path: default_signer_path.clone(),
+    };
 
     let CliCommandInfo {
         command,
         mut signers,
-    } = parse_command(matches, &default_signer, &mut wallet_manager)?;
+    } = parse_command(&matches, &default_signer, &mut wallet_manager)?;
 
     if signers.is_empty() {
         if let Ok(signer_info) =
@@ -240,7 +238,6 @@ pub fn parse_args<'a>(
                 preflight_commitment: Some(commitment.commitment),
                 ..RpcSendTransactionConfig::default()
             },
-            confirm_transaction_initial_timeout,
             address_labels,
         },
         signers,
@@ -263,7 +260,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
             .global(true)
             .help("Configuration file to use");
         if let Some(ref config_file) = *CONFIG_FILE {
-            arg.default_value(config_file)
+            arg.default_value(&config_file)
         } else {
             arg
         }
@@ -356,16 +353,6 @@ fn main() -> Result<(), Box<dyn error::Error>> {
             .hidden(true)
             .help("Timeout value for RPC requests"),
     )
-    .arg(
-        Arg::with_name("confirm_transaction_initial_timeout")
-            .long("confirm-timeout")
-            .value_name("SECONDS")
-            .takes_value(true)
-            .default_value(DEFAULT_CONFIRM_TX_TIMEOUT_SECONDS)
-            .global(true)
-            .hidden(true)
-            .help("Timeout value for initial transaction status"),
-    )
     .subcommand(
         SubCommand::with_name("config")
             .about("Solana command-line tool configuration settings")
@@ -427,10 +414,10 @@ fn main() -> Result<(), Box<dyn error::Error>> {
 }
 
 fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
-    if parse_settings(matches)? {
+    if parse_settings(&matches)? {
         let mut wallet_manager = None;
 
-        let (mut config, signers) = parse_args(matches, &mut wallet_manager)?;
+        let (mut config, signers) = parse_args(&matches, &mut wallet_manager)?;
         config.signers = signers.iter().map(|s| s.as_ref()).collect();
         let result = process_command(&config)?;
         println!("{}", result);

cli/src/memo.rs

@@ -1,22 +0,0 @@
-use solana_sdk::instruction::Instruction;
-use solana_sdk::pubkey::Pubkey;
-use spl_memo::id;
-
-pub trait WithMemo {
-    fn with_memo<T: AsRef<str>>(self, memo: Option<T>) -> Self;
-}
-
-impl WithMemo for Vec<Instruction> {
-    fn with_memo<T: AsRef<str>>(mut self, memo: Option<T>) -> Self {
-        if let Some(memo) = &memo {
-            let memo = memo.as_ref();
-            let memo_ix = Instruction {
-                program_id: Pubkey::new(&id().to_bytes()),
-                accounts: vec![],
-                data: memo.as_bytes().to_vec(),
-            };
-            self.push(memo_ix);
-        }
-        self
-    }
-}

cli/src/nonce.rs

@@ -1,11 +1,9 @@
 use crate::{
     checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
-        log_instruction_custom_error, log_instruction_custom_error_ex, CliCommand, CliCommandInfo,
-        CliConfig, CliError, ProcessResult,
+        log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
+        ProcessResult,
     },
-    feature::get_feature_is_active,
-    memo::WithMemo,
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
@@ -13,7 +11,6 @@ use solana_clap_utils::{
     input_parsers::*,
     input_validators::*,
     keypair::{DefaultSigner, SignerIndex},
-    memo::{memo_arg, MEMO_ARG},
     nonce::*,
 };
 use solana_cli_output::CliNonceAccount;
@@ -21,19 +18,16 @@ use solana_client::{nonce_utils::*, rpc_client::RpcClient};
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     account::Account,
-    feature_set::merge_nonce_error_into_system_error,
     hash::Hash,
-    instruction::InstructionError,
     message::Message,
     nonce::{self, State},
     pubkey::Pubkey,
     system_instruction::{
         advance_nonce_account, authorize_nonce_account, create_nonce_account,
-        create_nonce_account_with_seed, instruction_to_nonce_error, withdraw_nonce_account,
-        NonceError, SystemError,
+        create_nonce_account_with_seed, withdraw_nonce_account, NonceError, SystemError,
     },
     system_program,
-    transaction::{Transaction, TransactionError},
+    transaction::Transaction,
 };
 use std::sync::Arc;
 
@@ -60,8 +54,7 @@ impl NonceSubCommands for App<'_, '_> {
                         .required(true),
                         "Account to be granted authority of the nonce account. "),
                 )
-                .arg(nonce_authority_arg())
-                .arg(memo_arg()),
+                .arg(nonce_authority_arg()),
         )
         .subcommand(
             SubCommand::with_name("create-nonce-account")
@@ -96,8 +89,7 @@ impl NonceSubCommands for App<'_, '_> {
                         .value_name("STRING")
                         .takes_value(true)
                         .help("Seed for address generation; if specified, the resulting account will be at a derived address of the NONCE_ACCOUNT pubkey")
-                )
-                .arg(memo_arg()),
+                ),
         )
         .subcommand(
             SubCommand::with_name("nonce")
@@ -121,8 +113,7 @@ impl NonceSubCommands for App<'_, '_> {
                         .required(true),
                         "Address of the nonce account. "),
                 )
-                .arg(nonce_authority_arg())
-                .arg(memo_arg()),
+                .arg(nonce_authority_arg()),
         )
         .subcommand(
             SubCommand::with_name("nonce-account")
@@ -168,8 +159,7 @@ impl NonceSubCommands for App<'_, '_> {
                         .validator(is_amount)
                         .help("The amount to withdraw from the nonce account, in SOL"),
                 )
-                .arg(nonce_authority_arg())
-                .arg(memo_arg()),
+                .arg(nonce_authority_arg()),
         )
     }
 }
@@ -181,7 +171,6 @@ pub fn parse_authorize_nonce_account(
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
     let new_authority = pubkey_of_signer(matches, "new_authority", wallet_manager)?.unwrap();
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
     let (nonce_authority, nonce_authority_pubkey) =
         signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
 
@@ -196,7 +185,6 @@ pub fn parse_authorize_nonce_account(
         command: CliCommand::AuthorizeNonceAccount {
             nonce_account,
             nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
-            memo,
             new_authority,
         },
         signers: signer_info.signers,
@@ -213,7 +201,6 @@ pub fn parse_nonce_create_account(
     let seed = matches.value_of("seed").map(|s| s.to_string());
     let amount = SpendAmount::new_from_matches(matches, "amount");
     let nonce_authority = pubkey_of_signer(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
 
     let payer_provided = None;
     let signer_info = default_signer.generate_unique_signers(
@@ -227,7 +214,6 @@ pub fn parse_nonce_create_account(
             nonce_account: signer_info.index_of(nonce_account_pubkey).unwrap(),
             seed,
             nonce_authority,
-            memo,
             amount,
         },
         signers: signer_info.signers,
@@ -253,7 +239,6 @@ pub fn parse_new_nonce(
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
     let (nonce_authority, nonce_authority_pubkey) =
         signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
 
@@ -268,7 +253,6 @@ pub fn parse_new_nonce(
         command: CliCommand::NewNonce {
             nonce_account,
             nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -300,7 +284,6 @@ pub fn parse_withdraw_from_nonce_account(
     let destination_account_pubkey =
         pubkey_of_signer(matches, "destination_account_pubkey", wallet_manager)?.unwrap();
     let lamports = lamports_of_sol(matches, "amount").unwrap();
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
     let (nonce_authority, nonce_authority_pubkey) =
         signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
 
@@ -315,7 +298,6 @@ pub fn parse_withdraw_from_nonce_account(
         command: CliCommand::WithdrawFromNonceAccount {
             nonce_account,
             nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
-            memo,
             destination_account_pubkey,
             lamports,
         },
@@ -348,19 +330,13 @@ pub fn process_authorize_nonce_account(
     config: &CliConfig,
     nonce_account: &Pubkey,
     nonce_authority: SignerIndex,
-    memo: Option<&String>,
     new_authority: &Pubkey,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
 
     let nonce_authority = config.signers[nonce_authority];
-    let ixs = vec![authorize_nonce_account(
-        nonce_account,
-        &nonce_authority.pubkey(),
-        new_authority,
-    )]
-    .with_memo(memo);
-    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
+    let ix = authorize_nonce_account(nonce_account, &nonce_authority.pubkey(), new_authority);
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
 
@@ -371,21 +347,8 @@ pub fn process_authorize_nonce_account(
         &tx.message,
         config.commitment,
     )?;
-    let merge_errors =
-        get_feature_is_active(rpc_client, &merge_nonce_error_into_system_error::id())?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-
-    if merge_errors {
-        log_instruction_custom_error::<SystemError>(result, config)
-    } else {
-        log_instruction_custom_error_ex::<NonceError, _>(result, config, |ix_error| {
-            if let InstructionError::Custom(_) = ix_error {
-                instruction_to_nonce_error(ix_error, merge_errors)
-            } else {
-                None
-            }
-        })
-    }
+    log_instruction_custom_error::<NonceError>(result, &config)
 }
 
 pub fn process_create_nonce_account(
@@ -394,7 +357,6 @@ pub fn process_create_nonce_account(
     nonce_account: SignerIndex,
     seed: Option<String>,
     nonce_authority: Option<Pubkey>,
-    memo: Option<&String>,
     amount: SpendAmount,
 ) -> ProcessResult {
     let nonce_account_pubkey = config.signers[nonce_account].pubkey();
@@ -421,7 +383,6 @@ pub fn process_create_nonce_account(
                 &nonce_authority,
                 lamports,
             )
-            .with_memo(memo)
         } else {
             create_nonce_account(
                 &config.signers[0].pubkey(),
@@ -429,7 +390,6 @@ pub fn process_create_nonce_account(
                 &nonce_authority,
                 lamports,
             )
-            .with_memo(memo)
         };
         Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
@@ -469,40 +429,8 @@ pub fn process_create_nonce_account(
 
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
-    let merge_errors =
-        get_feature_is_active(rpc_client, &merge_nonce_error_into_system_error::id())?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-
-    let err_ix_index = if let Err(err) = &result {
-        err.get_transaction_error().and_then(|tx_err| {
-            if let TransactionError::InstructionError(ix_index, _) = tx_err {
-                Some(ix_index)
-            } else {
-                None
-            }
-        })
-    } else {
-        None
-    };
-
-    match err_ix_index {
-        // SystemInstruction::InitializeNonceAccount failed
-        Some(1) => {
-            if merge_errors {
-                log_instruction_custom_error::<SystemError>(result, config)
-            } else {
-                log_instruction_custom_error_ex::<NonceError, _>(result, config, |ix_error| {
-                    if let InstructionError::Custom(_) = ix_error {
-                        instruction_to_nonce_error(ix_error, merge_errors)
-                    } else {
-                        None
-                    }
-                })
-            }
-        }
-        // SystemInstruction::CreateAccount{,WithSeed} failed
-        _ => log_instruction_custom_error::<SystemError>(result, config),
-    }
+    log_instruction_custom_error::<SystemError>(result, &config)
 }
 
 pub fn process_get_nonce(
@@ -523,14 +451,13 @@ pub fn process_new_nonce(
     config: &CliConfig,
     nonce_account: &Pubkey,
     nonce_authority: SignerIndex,
-    memo: Option<&String>,
 ) -> ProcessResult {
     check_unique_pubkeys(
         (&config.signers[0].pubkey(), "cli keypair".to_string()),
-        (nonce_account, "nonce_account_pubkey".to_string()),
+        (&nonce_account, "nonce_account_pubkey".to_string()),
     )?;
 
-    if let Err(err) = rpc_client.get_account(nonce_account) {
+    if let Err(err) = rpc_client.get_account(&nonce_account) {
         return Err(CliError::BadParameter(format!(
             "Unable to advance nonce account {}. error: {}",
             nonce_account, err
@@ -539,13 +466,9 @@ pub fn process_new_nonce(
     }
 
     let nonce_authority = config.signers[nonce_authority];
-    let ixs = vec![advance_nonce_account(
-        nonce_account,
-        &nonce_authority.pubkey(),
-    )]
-    .with_memo(memo);
+    let ix = advance_nonce_account(&nonce_account, &nonce_authority.pubkey());
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
     check_account_for_fee_with_commitment(
@@ -555,21 +478,8 @@ pub fn process_new_nonce(
         &tx.message,
         config.commitment,
     )?;
-    let merge_errors =
-        get_feature_is_active(rpc_client, &merge_nonce_error_into_system_error::id())?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-
-    if merge_errors {
-        log_instruction_custom_error::<SystemError>(result, config)
-    } else {
-        log_instruction_custom_error_ex::<NonceError, _>(result, config, |ix_error| {
-            if let InstructionError::Custom(_) = ix_error {
-                instruction_to_nonce_error(ix_error, merge_errors)
-            } else {
-                None
-            }
-        })
-    }
+    log_instruction_custom_error::<SystemError>(result, &config)
 }
 
 pub fn process_show_nonce_account(
@@ -588,7 +498,7 @@ pub fn process_show_nonce_account(
             use_lamports_unit,
             ..CliNonceAccount::default()
         };
-        if let Some(data) = data {
+        if let Some(ref data) = data {
             nonce_account.nonce = Some(data.blockhash.to_string());
             nonce_account.lamports_per_signature = Some(data.fee_calculator.lamports_per_signature);
             nonce_account.authority = Some(data.authority.to_string());
@@ -607,21 +517,19 @@ pub fn process_withdraw_from_nonce_account(
     config: &CliConfig,
     nonce_account: &Pubkey,
     nonce_authority: SignerIndex,
-    memo: Option<&String>,
     destination_account_pubkey: &Pubkey,
     lamports: u64,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
 
     let nonce_authority = config.signers[nonce_authority];
-    let ixs = vec![withdraw_nonce_account(
+    let ix = withdraw_nonce_account(
         nonce_account,
         &nonce_authority.pubkey(),
         destination_account_pubkey,
         lamports,
-    )]
-    .with_memo(memo);
-    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
+    );
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
     check_account_for_fee_with_commitment(
@@ -631,21 +539,8 @@ pub fn process_withdraw_from_nonce_account(
         &tx.message,
         config.commitment,
     )?;
-    let merge_errors =
-        get_feature_is_active(rpc_client, &merge_nonce_error_into_system_error::id())?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-
-    if merge_errors {
-        log_instruction_custom_error::<SystemError>(result, config)
-    } else {
-        log_instruction_custom_error_ex::<NonceError, _>(result, config, |ix_error| {
-            if let InstructionError::Custom(_) = ix_error {
-                instruction_to_nonce_error(ix_error, merge_errors)
-            } else {
-                None
-            }
-        })
-    }
+    log_instruction_custom_error::<NonceError>(result, &config)
 }
 
 #[cfg(test)]
@@ -675,7 +570,10 @@ mod tests {
         let default_keypair = Keypair::new();
         let (default_keypair_file, mut tmp_file) = make_tmp_file();
         write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
-        let default_signer = DefaultSigner::new("", &default_keypair_file);
+        let default_signer = DefaultSigner {
+            path: default_keypair_file.clone(),
+            arg_name: String::new(),
+        };
         let (keypair_file, mut tmp_file) = make_tmp_file();
         let nonce_account_keypair = Keypair::new();
         write_keypair(&nonce_account_keypair, tmp_file.as_file_mut()).unwrap();
@@ -699,7 +597,6 @@ mod tests {
                 command: CliCommand::AuthorizeNonceAccount {
                     nonce_account: nonce_account_pubkey,
                     nonce_authority: 0,
-                    memo: None,
                     new_authority: Pubkey::default(),
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
@@ -721,7 +618,6 @@ mod tests {
                 command: CliCommand::AuthorizeNonceAccount {
                     nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
                     nonce_authority: 1,
-                    memo: None,
                     new_authority: Pubkey::default(),
                 },
                 signers: vec![
@@ -745,7 +641,6 @@ mod tests {
                     nonce_account: 1,
                     seed: None,
                     nonce_authority: None,
-                    memo: None,
                     amount: SpendAmount::Some(50_000_000_000),
                 },
                 signers: vec![
@@ -771,7 +666,6 @@ mod tests {
                     nonce_account: 1,
                     seed: None,
                     nonce_authority: Some(nonce_authority_keypair.pubkey()),
-                    memo: None,
                     amount: SpendAmount::Some(50_000_000_000),
                 },
                 signers: vec![
@@ -807,7 +701,6 @@ mod tests {
                 command: CliCommand::NewNonce {
                     nonce_account: nonce_account.pubkey(),
                     nonce_authority: 0,
-                    memo: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -828,7 +721,6 @@ mod tests {
                 command: CliCommand::NewNonce {
                     nonce_account: nonce_account.pubkey(),
                     nonce_authority: 1,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -873,7 +765,6 @@ mod tests {
                 command: CliCommand::WithdrawFromNonceAccount {
                     nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
                     nonce_authority: 0,
-                    memo: None,
                     destination_account_pubkey: nonce_account_pubkey,
                     lamports: 42_000_000_000
                 },
@@ -902,7 +793,6 @@ mod tests {
                 command: CliCommand::WithdrawFromNonceAccount {
                     nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
                     nonce_authority: 1,
-                    memo: None,
                     destination_account_pubkey: nonce_account_pubkey,
                     lamports: 42_000_000_000
                 },

cli/src/program.rs

@@ -1,3 +1,4 @@
+use crate::send_tpu::{get_leader_tpus, send_transaction_tpu};
 use crate::{
     checks::*,
     cli::{
@@ -5,15 +6,16 @@ use crate::{
         ProcessResult,
     },
 };
+use bincode::serialize;
 use bip39::{Language, Mnemonic, MnemonicType, Seed};
 use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
 use log::*;
+use serde_json::{self, json, Value};
 use solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig};
 use solana_bpf_loader_program::{bpf_verifier, BpfError, ThisInstructionMeter};
 use solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*};
 use solana_cli_output::{
-    display::new_spinner_progress_bar, CliProgram, CliProgramAccountType, CliProgramAuthority,
-    CliProgramBuffer, CliProgramId, CliUpgradeableBuffer, CliUpgradeableBuffers,
+    display::new_spinner_progress_bar, CliProgram, CliUpgradeableBuffer, CliUpgradeableBuffers,
     CliUpgradeableProgram,
 };
 use solana_client::{
@@ -23,7 +25,7 @@ use solana_client::{
     rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig},
     rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType},
     rpc_request::MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS,
-    tpu_client::{TpuClient, TpuClientConfig},
+    rpc_response::RpcLeaderSchedule,
 };
 use solana_rbpf::vm::{Config, Executable};
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
@@ -49,17 +51,20 @@ use solana_sdk::{
 };
 use solana_transaction_status::TransactionConfirmationStatus;
 use std::{
+    cmp::min,
     collections::HashMap,
     error,
     fs::File,
     io::{Read, Write},
+    net::UdpSocket,
     path::PathBuf,
     sync::Arc,
     thread::sleep,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 const DATA_CHUNK_SIZE: usize = 229; // Keep program chunks under PACKET_DATA_SIZE
+const NUM_TPU_LEADERS: u64 = 2;
 
 #[derive(Debug, PartialEq)]
 pub enum ProgramCliCommand {
@@ -150,7 +155,7 @@ impl ProgramSubCommands for App<'_, '_> {
                             pubkey!(Arg::with_name("program_id")
                                 .long("program-id")
                                 .value_name("PROGRAM_ID"),
-                                "Executable program's address, must be a keypair for initial deploys, can be a pubkey for upgrades \
+                                "Executable program's address, must be a signer for initial deploys, can be a pubkey for upgrades \
                                 [default: address of keypair at /path/to/program-keypair.json if present, otherwise a random address]"),
                         )
                         .arg(
@@ -617,7 +622,7 @@ pub fn parse_program_subcommand(
 }
 
 pub fn process_program_subcommand(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     program_subcommand: &ProgramCliCommand,
 ) -> ProcessResult {
@@ -633,7 +638,7 @@ pub fn process_program_subcommand(
             max_len,
             allow_excessive_balance,
         } => process_program_deploy(
-            rpc_client,
+            &rpc_client,
             config,
             program_location,
             *program_signer_index,
@@ -652,7 +657,7 @@ pub fn process_program_subcommand(
             buffer_authority_signer_index,
             max_len,
         } => process_write_buffer(
-            rpc_client,
+            &rpc_client,
             config,
             program_location,
             *buffer_signer_index,
@@ -741,7 +746,7 @@ fn get_default_program_keypair(program_location: &Option<String>) -> Keypair {
 /// Deploy using upgradeable loader
 #[allow(clippy::too_many_arguments)]
 fn process_program_deploy(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     program_location: &Option<String>,
     program_signer_index: Option<SignerIndex>,
@@ -767,7 +772,7 @@ fn process_program_deploy(
     };
     let upgrade_authority_signer = config.signers[upgrade_authority_signer_index];
 
-    let default_program_keypair = get_default_program_keypair(program_location);
+    let default_program_keypair = get_default_program_keypair(&program_location);
     let (program_signer, program_pubkey) = if let Some(i) = program_signer_index {
         (Some(config.signers[i]), config.signers[i].pubkey())
     } else if let Some(program_pubkey) = program_pubkey {
@@ -843,7 +848,7 @@ fn process_program_deploy(
     };
 
     let (program_data, program_len) = if let Some(program_location) = program_location {
-        let program_data = read_and_verify_elf(program_location)?;
+        let program_data = read_and_verify_elf(&program_location)?;
         let program_len = program_data.len();
         (program_data, program_len)
     } else if buffer_provided {
@@ -886,13 +891,8 @@ fn process_program_deploy(
     )?;
 
     let result = if do_deploy {
-        if program_signer.is_none() {
-            return Err(
-                "Initial deployments require a keypair be provided for the program id".into(),
-            );
-        }
         do_process_program_write_and_deploy(
-            rpc_client.clone(),
+            rpc_client,
             config,
             &program_data,
             buffer_data_len,
@@ -907,7 +907,7 @@ fn process_program_deploy(
         )
     } else {
         do_process_program_upgrade(
-            rpc_client.clone(),
+            rpc_client,
             config,
             &program_data,
             &program_pubkey,
@@ -918,7 +918,7 @@ fn process_program_deploy(
     };
     if result.is_ok() && is_final {
         process_set_authority(
-            &rpc_client,
+            rpc_client,
             config,
             Some(program_pubkey),
             None,
@@ -933,7 +933,7 @@ fn process_program_deploy(
 }
 
 fn process_write_buffer(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     program_location: &str,
     buffer_signer_index: Option<SignerIndex>,
@@ -1071,17 +1071,7 @@ fn process_set_authority(
         )
         .map_err(|e| format!("Setting authority failed: {}", e))?;
 
-    let authority = CliProgramAuthority {
-        authority: new_authority
-            .map(|pubkey| pubkey.to_string())
-            .unwrap_or_else(|| "none".to_string()),
-        account_type: if program_pubkey.is_some() {
-            CliProgramAccountType::Program
-        } else {
-            CliProgramAccountType::Buffer
-        },
-    };
-    Ok(config.output_format.formatted_string(&authority))
+    Ok(option_pubkey_to_string("authority", new_authority).to_string())
 }
 
 fn get_buffers(
@@ -1107,7 +1097,6 @@ fn get_buffers(
                 data_slice: Some(UiDataSliceConfig { offset: 0, length }),
                 ..RpcAccountInfoConfig::default()
             },
-            ..RpcProgramAccountsConfig::default()
         },
     )?;
     Ok(results)
@@ -1259,7 +1248,7 @@ fn process_dump(
                                 UpgradeableLoaderState::programdata_data_offset().unwrap_or(0);
                             let program_data = &programdata_account.data[offset..];
                             let mut f = File::create(output_location)?;
-                            f.write_all(program_data)?;
+                            f.write_all(&program_data)?;
                             Ok(format!("Wrote program to {}", output_location))
                         } else {
                             Err(
@@ -1279,7 +1268,7 @@ fn process_dump(
                     let offset = UpgradeableLoaderState::buffer_data_offset().unwrap_or(0);
                     let program_data = &account.data[offset..];
                     let mut f = File::create(output_location)?;
-                    f.write_all(program_data)?;
+                    f.write_all(&program_data)?;
                     Ok(format!("Wrote program to {}", output_location))
                 } else {
                     Err(format!(
@@ -1310,8 +1299,8 @@ fn close(
 
     let mut tx = Transaction::new_unsigned(Message::new(
         &[bpf_loader_upgradeable::close(
-            account_pubkey,
-            recipient_pubkey,
+            &account_pubkey,
+            &recipient_pubkey,
             &authority_signer.pubkey(),
         )],
         Some(&config.signers[0].pubkey()),
@@ -1412,7 +1401,6 @@ fn process_close(
                     data_slice: Some(UiDataSliceConfig { offset: 0, length }),
                     ..RpcAccountInfoConfig::default()
                 },
-                ..RpcProgramAccountsConfig::default()
             },
         )?;
 
@@ -1420,7 +1408,7 @@ fn process_close(
             if close(
                 rpc_client,
                 config,
-                address,
+                &address,
                 &recipient_pubkey,
                 authority_signer,
             )
@@ -1452,7 +1440,7 @@ fn process_close(
 
 /// Deploy using non-upgradeable loader
 pub fn process_deploy(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     program_location: &str,
     buffer_signer_index: Option<SignerIndex>,
@@ -1497,7 +1485,7 @@ pub fn process_deploy(
 
 #[allow(clippy::too_many_arguments)]
 fn do_process_program_write_and_deploy(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     program_data: &[u8],
     buffer_data_len: usize,
@@ -1521,7 +1509,7 @@ fn do_process_program_write_and_deploy(
                 .value
             {
                 complete_partial_program_init(
-                    loader_id,
+                    &loader_id,
                     &config.signers[0].pubkey(),
                     buffer_pubkey,
                     &account,
@@ -1551,7 +1539,7 @@ fn do_process_program_write_and_deploy(
                         buffer_pubkey,
                         minimum_balance,
                         buffer_data_len as u64,
-                        loader_id,
+                        &loader_id,
                     )],
                     minimum_balance,
                 )
@@ -1579,7 +1567,7 @@ fn do_process_program_write_and_deploy(
                 } else {
                     loader_instruction::write(
                         buffer_pubkey,
-                        loader_id,
+                        &loader_id,
                         (i * DATA_CHUNK_SIZE) as u32,
                         chunk.to_vec(),
                     )
@@ -1623,7 +1611,7 @@ fn do_process_program_write_and_deploy(
             )
         } else {
             Message::new(
-                &[loader_instruction::finalize(buffer_pubkey, loader_id)],
+                &[loader_instruction::finalize(buffer_pubkey, &loader_id)],
                 Some(&config.signers[0].pubkey()),
             )
         };
@@ -1635,7 +1623,7 @@ fn do_process_program_write_and_deploy(
         messages.push(message);
     }
 
-    check_payer(&rpc_client, config, balance_needed, &messages)?;
+    check_payer(rpc_client, config, balance_needed, &messages)?;
 
     send_deploy_messages(
         rpc_client,
@@ -1649,20 +1637,20 @@ fn do_process_program_write_and_deploy(
     )?;
 
     if let Some(program_signers) = program_signers {
-        let program_id = CliProgramId {
-            program_id: program_signers[0].pubkey().to_string(),
-        };
-        Ok(config.output_format.formatted_string(&program_id))
+        Ok(json!({
+            "programId": format!("{}", program_signers[0].pubkey()),
+        })
+        .to_string())
     } else {
-        let buffer = CliProgramBuffer {
-            buffer: buffer_pubkey.to_string(),
-        };
-        Ok(config.output_format.formatted_string(&buffer))
+        Ok(json!({
+            "buffer": format!("{}", buffer_pubkey),
+        })
+        .to_string())
     }
 }
 
 fn do_process_program_upgrade(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     program_data: &[u8],
     program_id: &Pubkey,
@@ -1749,8 +1737,8 @@ fn do_process_program_upgrade(
     // Create and add final message
     let final_message = Message::new(
         &[bpf_loader_upgradeable::upgrade(
-            program_id,
-            buffer_pubkey,
+            &program_id,
+            &buffer_pubkey,
             &upgrade_authority.pubkey(),
             &config.signers[0].pubkey(),
         )],
@@ -1758,7 +1746,7 @@ fn do_process_program_upgrade(
     );
     messages.push(&final_message);
 
-    check_payer(&rpc_client, config, balance_needed, &messages)?;
+    check_payer(rpc_client, config, balance_needed, &messages)?;
     send_deploy_messages(
         rpc_client,
         config,
@@ -1770,10 +1758,10 @@ fn do_process_program_upgrade(
         Some(&[upgrade_authority]),
     )?;
 
-    let program_id = CliProgramId {
-        program_id: program_id.to_string(),
-    };
-    Ok(config.output_format.formatted_string(&program_id))
+    Ok(json!({
+        "programId": format!("{}", program_id),
+    })
+    .to_string())
 }
 
 fn read_and_verify_elf(program_location: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
@@ -1784,9 +1772,9 @@ fn read_and_verify_elf(program_location: &str) -> Result<Vec<u8>, Box<dyn std::e
         .map_err(|err| format!("Unable to read program file: {}", err))?;
 
     // Verify the program
-    <dyn Executable<BpfError, ThisInstructionMeter>>::from_elf(
+    Executable::<BpfError, ThisInstructionMeter>::from_elf(
         &program_data,
-        Some(|x| bpf_verifier::check(x)),
+        Some(|x| bpf_verifier::check(x, false)),
         Config::default(),
     )
     .map_err(|err| format!("ELF error: {}", err))?;
@@ -1818,7 +1806,7 @@ fn complete_partial_program_init(
             account_data_len as u64,
         ));
         if account.owner != *loader_id {
-            instructions.push(system_instruction::assign(elf_pubkey, loader_id));
+            instructions.push(system_instruction::assign(elf_pubkey, &loader_id));
         }
     }
     if account.lamports < minimum_balance {
@@ -1863,7 +1851,7 @@ fn check_payer(
 }
 
 fn send_deploy_messages(
-    rpc_client: Arc<RpcClient>,
+    rpc_client: &RpcClient,
     config: &CliConfig,
     initial_message: &Option<Message>,
     write_messages: &Option<Vec<Message>>,
@@ -1890,7 +1878,7 @@ fn send_deploy_messages(
                 initial_transaction.try_sign(&[payer_signer], blockhash)?;
             }
             let result = rpc_client.send_and_confirm_transaction_with_spinner(&initial_transaction);
-            log_instruction_custom_error::<SystemError>(result, config)
+            log_instruction_custom_error::<SystemError>(result, &config)
                 .map_err(|err| format!("Account allocation failed: {}", err))?;
         } else {
             return Err("Buffer account not created yet, must provide a key pair".into());
@@ -1911,8 +1899,7 @@ fn send_deploy_messages(
             }
 
             send_and_confirm_transactions_with_spinner(
-                rpc_client.clone(),
-                &config.websocket_url,
+                &rpc_client,
                 write_transactions,
                 &[payer_signer, write_signer],
                 config.commitment,
@@ -1980,9 +1967,19 @@ fn report_ephemeral_mnemonic(words: usize, mnemonic: bip39::Mnemonic) {
     );
 }
 
+fn option_pubkey_to_string(tag: &str, option: Option<Pubkey>) -> Value {
+    match option {
+        Some(pubkey) => json!({
+            tag: format!("{:?}", pubkey),
+        }),
+        None => json!({
+            tag: "none",
+        }),
+    }
+}
+
 fn send_and_confirm_transactions_with_spinner<T: Signers>(
-    rpc_client: Arc<RpcClient>,
-    websocket_url: &str,
+    rpc_client: &RpcClient,
     mut transactions: Vec<Transaction>,
     signer_keys: &T,
     commitment: CommitmentConfig,
@@ -1990,19 +1987,39 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
 ) -> Result<(), Box<dyn error::Error>> {
     let progress_bar = new_spinner_progress_bar();
     let mut send_retries = 5;
+    let mut leader_schedule: Option<RpcLeaderSchedule> = None;
+    let mut leader_schedule_epoch = 0;
+    let send_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
+    let cluster_nodes = rpc_client.get_cluster_nodes().ok();
 
-    progress_bar.set_message("Finding leader nodes...");
-    let tpu_client = TpuClient::new(
-        rpc_client.clone(),
-        websocket_url,
-        TpuClientConfig::default(),
-    )?;
     loop {
+        progress_bar.set_message("Finding leader nodes...");
+        let epoch_info = rpc_client.get_epoch_info()?;
+        let mut slot = epoch_info.absolute_slot;
+        let mut last_epoch_fetch = Instant::now();
+        if epoch_info.epoch > leader_schedule_epoch || leader_schedule.is_none() {
+            leader_schedule = rpc_client.get_leader_schedule(Some(epoch_info.absolute_slot))?;
+            leader_schedule_epoch = epoch_info.epoch;
+        }
+
+        let mut tpu_addresses = get_leader_tpus(
+            min(epoch_info.slot_index + 1, epoch_info.slots_in_epoch),
+            NUM_TPU_LEADERS,
+            leader_schedule.as_ref(),
+            cluster_nodes.as_ref(),
+        );
+
         // Send all transactions
         let mut pending_transactions = HashMap::new();
         let num_transactions = transactions.len();
         for transaction in transactions {
-            if !tpu_client.send_transaction(&transaction) {
+            if !tpu_addresses.is_empty() {
+                let wire_transaction =
+                    serialize(&transaction).expect("serialization should succeed");
+                for tpu_address in &tpu_addresses {
+                    send_transaction_tpu(&send_socket, &tpu_address, &wire_transaction);
+                }
+            } else {
                 let _result = rpc_client
                     .send_transaction_with_config(
                         &transaction,
@@ -2022,11 +2039,22 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
 
             // Throttle transactions to about 100 TPS
             sleep(Duration::from_millis(10));
+
+            // Update leader periodically
+            if last_epoch_fetch.elapsed() > Duration::from_millis(400) {
+                let epoch_info = rpc_client.get_epoch_info()?;
+                last_epoch_fetch = Instant::now();
+                tpu_addresses = get_leader_tpus(
+                    min(epoch_info.slot_index + 1, epoch_info.slots_in_epoch),
+                    NUM_TPU_LEADERS,
+                    leader_schedule.as_ref(),
+                    cluster_nodes.as_ref(),
+                );
+            }
         }
 
         // Collect statuses for all the transactions, drop those that are confirmed
         loop {
-            let mut slot = 0;
             let pending_signatures = pending_transactions.keys().cloned().collect::<Vec<_>>();
             for pending_signatures_chunk in
                 pending_signatures.chunks(MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS)
@@ -2068,8 +2096,22 @@ fn send_and_confirm_transactions_with_spinner<T: Signers>(
                 break;
             }
 
+            let epoch_info = rpc_client.get_epoch_info()?;
+            tpu_addresses = get_leader_tpus(
+                min(epoch_info.slot_index + 1, epoch_info.slots_in_epoch),
+                NUM_TPU_LEADERS,
+                leader_schedule.as_ref(),
+                cluster_nodes.as_ref(),
+            );
+
             for transaction in pending_transactions.values() {
-                if !tpu_client.send_transaction(transaction) {
+                if !tpu_addresses.is_empty() {
+                    let wire_transaction =
+                        serialize(&transaction).expect("serialization should succeed");
+                    for tpu_address in &tpu_addresses {
+                        send_transaction_tpu(&send_socket, &tpu_address, &wire_transaction);
+                    }
+                } else {
                     let _result = rpc_client
                         .send_transaction_with_config(
                             transaction,
@@ -2111,7 +2153,6 @@ mod tests {
     use super::*;
     use crate::cli::{app, parse_command, process_command};
     use serde_json::Value;
-    use solana_cli_output::OutputFormat;
     use solana_sdk::signature::write_keypair_file;
 
     fn make_tmp_path(name: &str) -> String {
@@ -2136,16 +2177,19 @@ mod tests {
         let default_keypair = Keypair::new();
         let keypair_file = make_tmp_path("keypair_file");
         write_keypair_file(&default_keypair, &keypair_file).unwrap();
-        let default_signer = DefaultSigner::new("", &keypair_file);
+        let default_signer = DefaultSigner {
+            path: keypair_file.clone(),
+            arg_name: "".to_string(),
+        };
 
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "deploy",
             "/Users/test/program.so",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::Deploy {
                     program_location: Some("/Users/test/program.so".to_string()),
@@ -2162,7 +2206,7 @@ mod tests {
             }
         );
 
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "deploy",
@@ -2171,7 +2215,7 @@ mod tests {
             "42",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::Deploy {
                     program_location: Some("/Users/test/program.so".to_string()),
@@ -2191,7 +2235,7 @@ mod tests {
         let buffer_keypair = Keypair::new();
         let buffer_keypair_file = make_tmp_path("buffer_keypair_file");
         write_keypair_file(&buffer_keypair, &buffer_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "deploy",
@@ -2199,7 +2243,7 @@ mod tests {
             &buffer_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::Deploy {
                     program_location: None,
@@ -2281,7 +2325,7 @@ mod tests {
         let authority_keypair = Keypair::new();
         let authority_keypair_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&authority_keypair, &authority_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "deploy",
@@ -2290,7 +2334,7 @@ mod tests {
             &authority_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::Deploy {
                     program_location: Some("/Users/test/program.so".to_string()),
@@ -2310,7 +2354,7 @@ mod tests {
             }
         );
 
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "deploy",
@@ -2318,7 +2362,7 @@ mod tests {
             "--final",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::Deploy {
                     program_location: Some("/Users/test/program.so".to_string()),
@@ -2344,17 +2388,20 @@ mod tests {
         let default_keypair = Keypair::new();
         let keypair_file = make_tmp_path("keypair_file");
         write_keypair_file(&default_keypair, &keypair_file).unwrap();
-        let default_signer = DefaultSigner::new("", &keypair_file);
+        let default_signer = DefaultSigner {
+            path: keypair_file.clone(),
+            arg_name: "".to_string(),
+        };
 
         // defaults
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "write-buffer",
             "/Users/test/program.so",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::WriteBuffer {
                     program_location: "/Users/test/program.so".to_string(),
@@ -2368,7 +2415,7 @@ mod tests {
         );
 
         // specify max len
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "write-buffer",
@@ -2377,7 +2424,7 @@ mod tests {
             "42",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::WriteBuffer {
                     program_location: "/Users/test/program.so".to_string(),
@@ -2394,7 +2441,7 @@ mod tests {
         let buffer_keypair = Keypair::new();
         let buffer_keypair_file = make_tmp_path("buffer_keypair_file");
         write_keypair_file(&buffer_keypair, &buffer_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "write-buffer",
@@ -2403,7 +2450,7 @@ mod tests {
             &buffer_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::WriteBuffer {
                     program_location: "/Users/test/program.so".to_string(),
@@ -2423,7 +2470,7 @@ mod tests {
         let authority_keypair = Keypair::new();
         let authority_keypair_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&authority_keypair, &authority_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "write-buffer",
@@ -2432,7 +2479,7 @@ mod tests {
             &authority_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::WriteBuffer {
                     program_location: "/Users/test/program.so".to_string(),
@@ -2455,7 +2502,7 @@ mod tests {
         let authority_keypair = Keypair::new();
         let authority_keypair_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&authority_keypair, &authority_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "write-buffer",
@@ -2466,7 +2513,7 @@ mod tests {
             &authority_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::WriteBuffer {
                     program_location: "/Users/test/program.so".to_string(),
@@ -2492,11 +2539,14 @@ mod tests {
         let default_keypair = Keypair::new();
         let keypair_file = make_tmp_path("keypair_file");
         write_keypair_file(&default_keypair, &keypair_file).unwrap();
-        let default_signer = DefaultSigner::new("", &keypair_file);
+        let default_signer = DefaultSigner {
+            path: keypair_file.clone(),
+            arg_name: "".to_string(),
+        };
 
         let program_pubkey = Pubkey::new_unique();
         let new_authority_pubkey = Pubkey::new_unique();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "set-upgrade-authority",
@@ -2505,7 +2555,7 @@ mod tests {
             &new_authority_pubkey.to_string(),
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::SetUpgradeAuthority {
                     program_pubkey,
@@ -2520,7 +2570,7 @@ mod tests {
         let new_authority_pubkey = Keypair::new();
         let new_authority_pubkey_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&new_authority_pubkey, &new_authority_pubkey_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "set-upgrade-authority",
@@ -2529,7 +2579,7 @@ mod tests {
             &new_authority_pubkey_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::SetUpgradeAuthority {
                     program_pubkey,
@@ -2544,7 +2594,7 @@ mod tests {
         let new_authority_pubkey = Keypair::new();
         let new_authority_pubkey_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&new_authority_pubkey, &new_authority_pubkey_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "set-upgrade-authority",
@@ -2552,7 +2602,7 @@ mod tests {
             "--final",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::SetUpgradeAuthority {
                     program_pubkey,
@@ -2567,7 +2617,7 @@ mod tests {
         let authority = Keypair::new();
         let authority_keypair_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&authority, &authority_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "set-upgrade-authority",
@@ -2577,7 +2627,7 @@ mod tests {
             "--final",
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::SetUpgradeAuthority {
                     program_pubkey,
@@ -2600,11 +2650,14 @@ mod tests {
         let default_keypair = Keypair::new();
         let keypair_file = make_tmp_path("keypair_file");
         write_keypair_file(&default_keypair, &keypair_file).unwrap();
-        let default_signer = DefaultSigner::new("", &keypair_file);
+        let default_signer = DefaultSigner {
+            path: keypair_file.clone(),
+            arg_name: "".to_string(),
+        };
 
         let buffer_pubkey = Pubkey::new_unique();
         let new_authority_pubkey = Pubkey::new_unique();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "set-buffer-authority",
@@ -2613,7 +2666,7 @@ mod tests {
             &new_authority_pubkey.to_string(),
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::SetBufferAuthority {
                     buffer_pubkey,
@@ -2628,7 +2681,7 @@ mod tests {
         let new_authority_keypair = Keypair::new();
         let new_authority_keypair_file = make_tmp_path("authority_keypair_file");
         write_keypair_file(&new_authority_keypair, &new_authority_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
+        let test_deploy = test_commands.clone().get_matches_from(vec![
             "test",
             "program",
             "set-buffer-authority",
@@ -2637,7 +2690,7 @@ mod tests {
             &new_authority_keypair_file,
         ]);
         assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
+            parse_command(&test_deploy, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::Program(ProgramCliCommand::SetBufferAuthority {
                     buffer_pubkey,
@@ -2657,7 +2710,10 @@ mod tests {
         let default_keypair = Keypair::new();
         let keypair_file = make_tmp_path("keypair_file");
         write_keypair_file(&default_keypair, &keypair_file).unwrap();
-        let default_signer = DefaultSigner::new("", &keypair_file);
+        let default_signer = DefaultSigner {
+            path: keypair_file,
+            arg_name: "".to_string(),
+        };
 
         // defaults
         let buffer_pubkey = Pubkey::new_unique();
@@ -2756,7 +2812,10 @@ mod tests {
         let default_keypair = Keypair::new();
         let keypair_file = make_tmp_path("keypair_file");
         write_keypair_file(&default_keypair, &keypair_file).unwrap();
-        let default_signer = DefaultSigner::new("", &keypair_file);
+        let default_signer = DefaultSigner {
+            path: keypair_file.clone(),
+            arg_name: "".to_string(),
+        };
 
         // defaults
         let buffer_pubkey = Pubkey::new_unique();
@@ -2874,7 +2933,7 @@ mod tests {
         write_keypair_file(&program_pubkey, &program_keypair_location).unwrap();
 
         let config = CliConfig {
-            rpc_client: Some(Arc::new(RpcClient::new_mock("".to_string()))),
+            rpc_client: Some(RpcClient::new_mock("".to_string())),
             command: CliCommand::Program(ProgramCliCommand::Deploy {
                 program_location: Some(program_location.to_str().unwrap().to_string()),
                 buffer_signer_index: None,
@@ -2887,7 +2946,6 @@ mod tests {
                 allow_excessive_balance: false,
             }),
             signers: vec![&default_keypair],
-            output_format: OutputFormat::JsonCompact,
             ..CliConfig::default()
         };
 

cli/src/send_tpu.rs

@@ -0,0 +1,46 @@
+use log::*;
+use solana_client::rpc_response::{RpcContactInfo, RpcLeaderSchedule};
+use solana_sdk::clock::NUM_CONSECUTIVE_LEADER_SLOTS;
+use std::net::{SocketAddr, UdpSocket};
+
+pub fn get_leader_tpus(
+    slot_index: u64,
+    num_leaders: u64,
+    leader_schedule: Option<&RpcLeaderSchedule>,
+    cluster_nodes: Option<&Vec<RpcContactInfo>>,
+) -> Vec<SocketAddr> {
+    let leaders: Vec<_> = (0..num_leaders)
+        .filter_map(|i| {
+            leader_schedule?
+                .iter()
+                .find(|(_pubkey, slots)| {
+                    slots.iter().any(|slot| {
+                        *slot as u64 == (slot_index + (i * NUM_CONSECUTIVE_LEADER_SLOTS))
+                    })
+                })
+                .and_then(|(pubkey, _)| {
+                    cluster_nodes?
+                        .iter()
+                        .find(|contact_info| contact_info.pubkey == *pubkey)
+                        .and_then(|contact_info| contact_info.tpu)
+                })
+        })
+        .collect();
+    let mut unique_leaders = vec![];
+    for leader in leaders.into_iter() {
+        if !unique_leaders.contains(&leader) {
+            unique_leaders.push(leader);
+        }
+    }
+    unique_leaders
+}
+
+pub fn send_transaction_tpu(
+    send_socket: &UdpSocket,
+    tpu_address: &SocketAddr,
+    wire_transaction: &[u8],
+) {
+    if let Err(err) = send_socket.send_to(wire_transaction, tpu_address) {
+        warn!("Failed to send transaction to {}: {:?}", tpu_address, err);
+    }
+}

cli/src/spend_utils.rs

@@ -92,7 +92,7 @@ where
         Ok((message, spend))
     } else {
         let from_balance = rpc_client
-            .get_balance_with_commitment(from_pubkey, commitment)?
+            .get_balance_with_commitment(&from_pubkey, commitment)?
             .value;
         let (message, SpendAndFee { spend, fee }) = resolve_spend_message(
             amount,

cli/src/validator_info.rs

@@ -119,7 +119,7 @@ fn parse_validator_info(
     let key_list: ConfigKeys = deserialize(&account.data)?;
     if !key_list.keys.is_empty() {
         let (validator_pubkey, _) = key_list.keys[1];
-        let validator_info_string: String = deserialize(get_config_data(&account.data)?)?;
+        let validator_info_string: String = deserialize(&get_config_data(&account.data)?)?;
         let validator_info: Map<_, _> = serde_json::from_str(&validator_info_string)?;
         Ok((validator_pubkey, validator_info))
     } else {
@@ -246,7 +246,7 @@ pub fn process_set_validator_info(
 ) -> ProcessResult {
     // Validate keybase username
     if let Some(string) = validator_info.get("keybaseUsername") {
-        let result = verify_keybase(&config.signers[0].pubkey(), string);
+        let result = verify_keybase(&config.signers[0].pubkey(), &string);
         if result.is_err() {
             if force_keybase {
                 println!("--force supplied, ignoring: {:?}", result);
@@ -272,7 +272,7 @@ pub fn process_set_validator_info(
             },
         )
         .find(|(pubkey, account)| {
-            let (validator_pubkey, _) = parse_validator_info(pubkey, account).unwrap();
+            let (validator_pubkey, _) = parse_validator_info(&pubkey, &account).unwrap();
             validator_pubkey == config.signers[0].pubkey()
         });
 
@@ -393,7 +393,7 @@ pub fn process_get_validator_info(
     }
     for (validator_info_pubkey, validator_info_account) in validator_info.iter() {
         let (validator_pubkey, validator_info) =
-            parse_validator_info(validator_info_pubkey, validator_info_account)?;
+            parse_validator_info(&validator_info_pubkey, &validator_info_account)?;
         validator_info_list.push(CliValidatorInfo {
             identity_pubkey: validator_pubkey.to_string(),
             info_pubkey: validator_info_pubkey.to_string(),
@@ -451,7 +451,7 @@ mod tests {
             "name": "Alice",
             "keybaseUsername": "alice_keybase",
         });
-        assert_eq!(parse_args(matches), expected);
+        assert_eq!(parse_args(&matches), expected);
     }
 
     #[test]

cli/src/vote.rs

@@ -4,7 +4,6 @@ use crate::{
         log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
         ProcessResult,
     },
-    memo::WithMemo,
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
@@ -12,7 +11,6 @@ use solana_clap_utils::{
     input_parsers::*,
     input_validators::*,
     keypair::{DefaultSigner, SignerIndex},
-    memo::{memo_arg, MEMO_ARG},
 };
 use solana_cli_output::{CliEpochVotingHistory, CliLockout, CliVoteAccount};
 use solana_client::rpc_client::RpcClient;
@@ -81,8 +79,7 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("STRING")
                         .takes_value(true)
                         .help("Seed for address generation; if specified, the resulting account will be at a derived address of the VOTE ACCOUNT pubkey")
-                )
-                .arg(memo_arg())
+                ),
         )
         .subcommand(
             SubCommand::with_name("vote-authorize-voter")
@@ -108,8 +105,7 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("NEW_AUTHORIZED_PUBKEY")
                         .required(true),
                         "New authorized vote signer. "),
-                )
-                .arg(memo_arg())
+                ),
         )
         .subcommand(
             SubCommand::with_name("vote-authorize-withdrawer")
@@ -135,66 +131,7 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("AUTHORIZED_PUBKEY")
                         .required(true),
                         "New authorized withdrawer. "),
-                )
-                .arg(memo_arg())
-        )
-        .subcommand(
-            SubCommand::with_name("vote-authorize-voter-checked")
-                .about("Authorize a new vote signing keypair for the given vote account, \
-                    checking the new authority as a signer")
-                .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
-                        .index(1)
-                        .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account in which to set the authorized voter. "),
-                )
-                .arg(
-                    Arg::with_name("authorized")
-                        .index(2)
-                        .value_name("AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("Current authorized vote signer."),
-                )
-                .arg(
-                    Arg::with_name("new_authorized")
-                        .index(3)
-                        .value_name("NEW_AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("New authorized vote signer."),
-                )
-                .arg(memo_arg())
-        )
-        .subcommand(
-            SubCommand::with_name("vote-authorize-withdrawer-checked")
-                .about("Authorize a new withdraw signing keypair for the given vote account, \
-                    checking the new authority as a signer")
-                .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
-                        .index(1)
-                        .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account in which to set the authorized withdrawer. "),
-                )
-                .arg(
-                    Arg::with_name("authorized")
-                        .index(2)
-                        .value_name("AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("Current authorized withdrawer."),
-                )
-                .arg(
-                    Arg::with_name("new_authorized")
-                        .index(3)
-                        .value_name("NEW_AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("New authorized withdrawer."),
-                )
-                .arg(memo_arg())
+                ),
         )
         .subcommand(
             SubCommand::with_name("vote-update-validator")
@@ -224,7 +161,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer keypair"),
                 )
-                .arg(memo_arg())
         )
         .subcommand(
             SubCommand::with_name("vote-update-commission")
@@ -254,7 +190,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer keypair"),
                 )
-                .arg(memo_arg())
         )
         .subcommand(
             SubCommand::with_name("vote-account")
@@ -324,7 +259,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer [default: cli config keypair]"),
                 )
-                .arg(memo_arg())
         )
     }
 }
@@ -341,7 +275,6 @@ pub fn parse_create_vote_account(
     let commission = value_t_or_exit!(matches, "commission", u8);
     let authorized_voter = pubkey_of_signer(matches, "authorized_voter", wallet_manager)?;
     let authorized_withdrawer = pubkey_of_signer(matches, "authorized_withdrawer", wallet_manager)?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
 
     let payer_provided = None;
     let signer_info = default_signer.generate_unique_signers(
@@ -358,7 +291,6 @@ pub fn parse_create_vote_account(
             authorized_voter,
             authorized_withdrawer,
             commission,
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -369,39 +301,25 @@ pub fn parse_vote_authorize(
     default_signer: &DefaultSigner,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
     vote_authorize: VoteAuthorize,
-    checked: bool,
 ) -> Result<CliCommandInfo, CliError> {
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
-    let (authorized, authorized_pubkey) = signer_of(matches, "authorized", wallet_manager)?;
+    let new_authorized_pubkey =
+        pubkey_of_signer(matches, "new_authorized_pubkey", wallet_manager)?.unwrap();
+    let (authorized, _) = signer_of(matches, "authorized", wallet_manager)?;
 
     let payer_provided = None;
-    let mut signers = vec![payer_provided, authorized];
-
-    let new_authorized_pubkey = if checked {
-        let (new_authorized_signer, new_authorized_pubkey) =
-            signer_of(matches, "new_authorized", wallet_manager)?;
-        signers.push(new_authorized_signer);
-        new_authorized_pubkey.unwrap()
-    } else {
-        pubkey_of_signer(matches, "new_authorized_pubkey", wallet_manager)?.unwrap()
-    };
-
-    let signer_info = default_signer.generate_unique_signers(signers, matches, wallet_manager)?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
+    let signer_info = default_signer.generate_unique_signers(
+        vec![payer_provided, authorized],
+        matches,
+        wallet_manager,
+    )?;
 
     Ok(CliCommandInfo {
         command: CliCommand::VoteAuthorize {
             vote_account_pubkey,
             new_authorized_pubkey,
             vote_authorize,
-            memo,
-            authorized: signer_info.index_of(authorized_pubkey).unwrap(),
-            new_authorized: if checked {
-                signer_info.index_of(Some(new_authorized_pubkey))
-            } else {
-                None
-            },
         },
         signers: signer_info.signers,
     })
@@ -425,14 +343,12 @@ pub fn parse_vote_update_validator(
         matches,
         wallet_manager,
     )?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
 
     Ok(CliCommandInfo {
         command: CliCommand::VoteUpdateValidator {
             vote_account_pubkey,
             new_identity_account: signer_info.index_of(new_identity_pubkey).unwrap(),
             withdraw_authority: signer_info.index_of(authorized_withdrawer_pubkey).unwrap(),
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -455,14 +371,12 @@ pub fn parse_vote_update_commission(
         matches,
         wallet_manager,
     )?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
 
     Ok(CliCommandInfo {
         command: CliCommand::VoteUpdateCommission {
             vote_account_pubkey,
             commission,
             withdraw_authority: signer_info.index_of(authorized_withdrawer_pubkey).unwrap(),
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -510,7 +424,6 @@ pub fn parse_withdraw_from_vote_account(
         matches,
         wallet_manager,
     )?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
 
     Ok(CliCommandInfo {
         command: CliCommand::WithdrawFromVoteAccount {
@@ -518,7 +431,6 @@ pub fn parse_withdraw_from_vote_account(
             destination_account_pubkey,
             withdraw_authority: signer_info.index_of(withdraw_authority_pubkey).unwrap(),
             withdraw_amount,
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -533,12 +445,11 @@ pub fn process_create_vote_account(
     authorized_voter: &Option<Pubkey>,
     authorized_withdrawer: &Option<Pubkey>,
     commission: u8,
-    memo: Option<&String>,
 ) -> ProcessResult {
     let vote_account = config.signers[vote_account];
     let vote_account_pubkey = vote_account.pubkey();
     let vote_account_address = if let Some(seed) = seed {
-        Pubkey::create_with_seed(&vote_account_pubkey, seed, &solana_vote_program::id())?
+        Pubkey::create_with_seed(&vote_account_pubkey, &seed, &solana_vote_program::id())?
     } else {
         vote_account_pubkey
     };
@@ -576,7 +487,6 @@ pub fn process_create_vote_account(
                 &vote_init,
                 lamports,
             )
-            .with_memo(memo)
         } else {
             vote_instruction::create_account(
                 &config.signers[0].pubkey(),
@@ -584,7 +494,6 @@ pub fn process_create_vote_account(
                 &vote_init,
                 lamports,
             )
-            .with_memo(memo)
         };
         Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
@@ -619,7 +528,7 @@ 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);
-    log_instruction_custom_error::<SystemError>(result, config)
+    log_instruction_custom_error::<SystemError>(result, &config)
 }
 
 pub fn process_vote_authorize(
@@ -628,34 +537,26 @@ pub fn process_vote_authorize(
     vote_account_pubkey: &Pubkey,
     new_authorized_pubkey: &Pubkey,
     vote_authorize: VoteAuthorize,
-    authorized: SignerIndex,
-    new_authorized: Option<SignerIndex>,
-    memo: Option<&String>,
 ) -> ProcessResult {
-    let authorized = config.signers[authorized];
-    let new_authorized_signer = new_authorized.map(|index| config.signers[index]);
+    // If the `authorized_account` is also the fee payer, `config.signers` will only have one
+    // keypair in it
+    let authorized = if config.signers.len() == 2 {
+        config.signers[1]
+    } else {
+        config.signers[0]
+    };
 
     check_unique_pubkeys(
         (&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 vote_ix = if new_authorized_signer.is_some() {
-        vote_instruction::authorize_checked(
-            vote_account_pubkey,   // vote account to update
-            &authorized.pubkey(),  // current authorized
-            new_authorized_pubkey, // new vote signer/withdrawer
-            vote_authorize,        // vote or withdraw
-        )
-    } else {
-        vote_instruction::authorize(
-            vote_account_pubkey,   // vote account to update
-            &authorized.pubkey(),  // current authorized
-            new_authorized_pubkey, // new vote signer/withdrawer
-            vote_authorize,        // vote or withdraw
-        )
-    };
-    let ixs = vec![vote_ix].with_memo(memo);
+    let ixs = vec![vote_instruction::authorize(
+        vote_account_pubkey,   // vote account to update
+        &authorized.pubkey(),  // current authorized
+        new_authorized_pubkey, // new vote signer/withdrawer
+        vote_authorize,        // vote or withdraw
+    )];
 
     let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
@@ -668,7 +569,7 @@ pub fn process_vote_authorize(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 pub fn process_vote_update_validator(
@@ -677,7 +578,6 @@ pub fn process_vote_update_validator(
     vote_account_pubkey: &Pubkey,
     new_identity_account: SignerIndex,
     withdraw_authority: SignerIndex,
-    memo: Option<&String>,
 ) -> ProcessResult {
     let authorized_withdrawer = config.signers[withdraw_authority];
     let new_identity_account = config.signers[new_identity_account];
@@ -691,8 +591,7 @@ pub fn process_vote_update_validator(
         vote_account_pubkey,
         &authorized_withdrawer.pubkey(),
         &new_identity_pubkey,
-    )]
-    .with_memo(memo);
+    )];
 
     let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
@@ -705,7 +604,7 @@ pub fn process_vote_update_validator(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 pub fn process_vote_update_commission(
@@ -714,7 +613,6 @@ pub fn process_vote_update_commission(
     vote_account_pubkey: &Pubkey,
     commission: u8,
     withdraw_authority: SignerIndex,
-    memo: Option<&String>,
 ) -> ProcessResult {
     let authorized_withdrawer = config.signers[withdraw_authority];
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
@@ -722,8 +620,7 @@ pub fn process_vote_update_commission(
         vote_account_pubkey,
         &authorized_withdrawer.pubkey(),
         commission,
-    )]
-    .with_memo(memo);
+    )];
 
     let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
@@ -736,7 +633,7 @@ pub fn process_vote_update_commission(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 fn get_vote_account(
@@ -834,12 +731,11 @@ pub fn process_withdraw_from_vote_account(
     withdraw_authority: SignerIndex,
     withdraw_amount: SpendAmount,
     destination_account_pubkey: &Pubkey,
-    memo: Option<&String>,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
     let withdraw_authority = config.signers[withdraw_authority];
 
-    let current_balance = rpc_client.get_balance(vote_account_pubkey)?;
+    let current_balance = rpc_client.get_balance(&vote_account_pubkey)?;
     let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(VoteState::size_of())?;
 
     let lamports = match withdraw_amount {
@@ -855,15 +751,14 @@ pub fn process_withdraw_from_vote_account(
         }
     };
 
-    let ixs = vec![withdraw(
+    let ix = withdraw(
         vote_account_pubkey,
         &withdraw_authority.pubkey(),
         lamports,
         destination_account_pubkey,
-    )]
-    .with_memo(memo);
+    );
 
-    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut transaction = Transaction::new_unsigned(message);
     transaction.try_sign(&config.signers, recent_blockhash)?;
     check_account_for_fee_with_commitment(
@@ -874,7 +769,7 @@ pub fn process_withdraw_from_vote_account(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&transaction);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 #[cfg(test)]
@@ -902,7 +797,10 @@ mod tests {
         let default_keypair = Keypair::new();
         let (default_keypair_file, mut tmp_file) = make_tmp_file();
         write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
-        let default_signer = DefaultSigner::new("", &default_keypair_file);
+        let default_signer = DefaultSigner {
+            path: default_keypair_file.clone(),
+            arg_name: String::new(),
+        };
 
         let test_authorize_voter = test_commands.clone().get_matches_from(vec![
             "test",
@@ -917,10 +815,7 @@ mod tests {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
                     new_authorized_pubkey: pubkey2,
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 0,
-                    new_authorized: None,
+                    vote_authorize: VoteAuthorize::Voter
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -943,10 +838,7 @@ mod tests {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
                     new_authorized_pubkey: pubkey2,
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 1,
-                    new_authorized: None,
+                    vote_authorize: VoteAuthorize::Voter
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -955,70 +847,6 @@ mod tests {
             }
         );
 
-        let (voter_keypair_file, mut tmp_file) = make_tmp_file();
-        let voter_keypair = Keypair::new();
-        write_keypair(&voter_keypair, tmp_file.as_file_mut()).unwrap();
-
-        let test_authorize_voter = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-authorize-voter-checked",
-            &pubkey_string,
-            &default_keypair_file,
-            &voter_keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_authorize_voter, &default_signer, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::VoteAuthorize {
-                    vote_account_pubkey: pubkey,
-                    new_authorized_pubkey: voter_keypair.pubkey(),
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 0,
-                    new_authorized: Some(1),
-                },
-                signers: vec![
-                    read_keypair_file(&default_keypair_file).unwrap().into(),
-                    read_keypair_file(&voter_keypair_file).unwrap().into()
-                ],
-            }
-        );
-
-        let test_authorize_voter = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-authorize-voter-checked",
-            &pubkey_string,
-            &authorized_keypair_file,
-            &voter_keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_authorize_voter, &default_signer, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::VoteAuthorize {
-                    vote_account_pubkey: pubkey,
-                    new_authorized_pubkey: voter_keypair.pubkey(),
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 1,
-                    new_authorized: Some(2),
-                },
-                signers: vec![
-                    read_keypair_file(&default_keypair_file).unwrap().into(),
-                    read_keypair_file(&authorized_keypair_file).unwrap().into(),
-                    read_keypair_file(&voter_keypair_file).unwrap().into(),
-                ],
-            }
-        );
-
-        let test_authorize_voter = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-authorize-voter-checked",
-            &pubkey_string,
-            &authorized_keypair_file,
-            &pubkey2_string,
-        ]);
-        assert!(parse_command(&test_authorize_voter, &default_signer, &mut None).is_err());
-
         let (keypair_file, mut tmp_file) = make_tmp_file();
         let keypair = Keypair::new();
         write_keypair(&keypair, tmp_file.as_file_mut()).unwrap();
@@ -1044,7 +872,6 @@ mod tests {
                     authorized_voter: None,
                     authorized_withdrawer: None,
                     commission: 10,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1074,7 +901,6 @@ mod tests {
                     authorized_voter: None,
                     authorized_withdrawer: None,
                     commission: 100,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1107,8 +933,7 @@ mod tests {
                     identity_account: 2,
                     authorized_voter: Some(authed),
                     authorized_withdrawer: None,
-                    commission: 100,
-                    memo: None,
+                    commission: 100
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1139,8 +964,7 @@ mod tests {
                     identity_account: 2,
                     authorized_voter: None,
                     authorized_withdrawer: Some(authed),
-                    commission: 100,
-                    memo: None,
+                    commission: 100
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1164,7 +988,6 @@ mod tests {
                     vote_account_pubkey: pubkey,
                     new_identity_account: 2,
                     withdraw_authority: 1,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1188,7 +1011,6 @@ mod tests {
                     vote_account_pubkey: pubkey,
                     commission: 42,
                     withdraw_authority: 1,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1213,7 +1035,6 @@ mod tests {
                     destination_account_pubkey: pubkey,
                     withdraw_authority: 0,
                     withdraw_amount: SpendAmount::Some(42_000_000_000),
-                    memo: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -1235,7 +1056,6 @@ mod tests {
                     destination_account_pubkey: pubkey,
                     withdraw_authority: 0,
                     withdraw_amount: SpendAmount::All,
-                    memo: None,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -1262,7 +1082,6 @@ mod tests {
                     destination_account_pubkey: pubkey,
                     withdraw_authority: 1,
                     withdraw_amount: SpendAmount::Some(42_000_000_000),
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),

cli/tests/nonce.rs

@@ -101,7 +101,6 @@ fn full_battery_tests(
         nonce_account: 1,
         seed,
         nonce_authority: optional_authority,
-        memo: None,
         amount: SpendAmount::Some(1000),
     };
 
@@ -135,7 +134,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: index,
-        memo: None,
     };
     process_command(&config_payer).unwrap();
 
@@ -153,7 +151,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::WithdrawFromNonceAccount {
         nonce_account,
         nonce_authority: index,
-        memo: None,
         destination_account_pubkey: payee_pubkey,
         lamports: 100,
     };
@@ -174,7 +171,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::AuthorizeNonceAccount {
         nonce_account,
         nonce_authority: index,
-        memo: None,
         new_authority: new_authority.pubkey(),
     };
     process_command(&config_payer).unwrap();
@@ -183,7 +179,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: index,
-        memo: None,
     };
     process_command(&config_payer).unwrap_err();
 
@@ -192,7 +187,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: 1,
-        memo: None,
     };
     process_command(&config_payer).unwrap();
 
@@ -200,7 +194,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::WithdrawFromNonceAccount {
         nonce_account,
         nonce_authority: 1,
-        memo: None,
         destination_account_pubkey: payee_pubkey,
         lamports: 100,
     };
@@ -260,7 +253,6 @@ fn test_create_account_with_seed() {
         nonce_account: 0,
         seed: Some(seed),
         nonce_authority: Some(authority_pubkey),
-        memo: None,
         amount: SpendAmount::Some(241),
     };
     process_command(&creator_config).unwrap();
@@ -292,12 +284,10 @@ fn test_create_account_with_seed() {
         from: 0,
         sign_only: true,
         dump_transaction_message: true,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_address),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -318,7 +308,6 @@ fn test_create_account_with_seed() {
         from: 0,
         sign_only: false,
         dump_transaction_message: true,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_address),
@@ -326,7 +315,6 @@ fn test_create_account_with_seed() {
         ),
         nonce_account: Some(nonce_address),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,

cli/tests/program.rs

@@ -58,7 +58,6 @@ fn test_cli_program_deploy_non_upgradeable() {
         use_deprecated_loader: false,
         allow_excessive_balance: false,
     };
-    config.output_format = OutputFormat::JsonCompact;
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
     let program_id_str = json
@@ -68,11 +67,11 @@ fn test_cli_program_deploy_non_upgradeable() {
         .unwrap()
         .as_str()
         .unwrap();
-    let program_id = Pubkey::from_str(program_id_str).unwrap();
+    let program_id = Pubkey::from_str(&program_id_str).unwrap();
     let account0 = rpc_client.get_account(&program_id).unwrap();
     assert_eq!(account0.lamports, minimum_balance_for_rent_exemption);
     assert_eq!(account0.owner, bpf_loader::id());
-    assert!(account0.executable);
+    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();
@@ -93,7 +92,7 @@ fn test_cli_program_deploy_non_upgradeable() {
         .unwrap();
     assert_eq!(account1.lamports, minimum_balance_for_rent_exemption);
     assert_eq!(account1.owner, bpf_loader::id());
-    assert!(account1.executable);
+    assert_eq!(account1.executable, true);
     assert_eq!(account1.data, account0.data);
 
     // Attempt to redeploy to the same address
@@ -129,7 +128,7 @@ fn test_cli_program_deploy_non_upgradeable() {
         .unwrap();
     assert_eq!(account2.lamports, 2 * minimum_balance_for_rent_exemption);
     assert_eq!(account2.owner, bpf_loader::id());
-    assert!(account2.executable);
+    assert_eq!(account2.executable, true);
     assert_eq!(account2.data, account0.data);
 }
 
@@ -188,7 +187,6 @@ fn test_cli_program_deploy_no_authority() {
         is_final: true,
         max_len: None,
     });
-    config.output_format = OutputFormat::JsonCompact;
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
     let program_id_str = json
@@ -198,7 +196,7 @@ fn test_cli_program_deploy_no_authority() {
         .unwrap()
         .as_str()
         .unwrap();
-    let program_id = Pubkey::from_str(program_id_str).unwrap();
+    let program_id = Pubkey::from_str(&program_id_str).unwrap();
 
     // Attempt to upgrade the program
     config.signers = vec![&keypair, &upgrade_authority];
@@ -284,12 +282,12 @@ fn test_cli_program_deploy_with_authority() {
         .unwrap();
     assert_eq!(
         program_keypair.pubkey(),
-        Pubkey::from_str(program_pubkey_str).unwrap()
+        Pubkey::from_str(&program_pubkey_str).unwrap()
     );
     let program_account = rpc_client.get_account(&program_keypair.pubkey()).unwrap();
     assert_eq!(program_account.lamports, minimum_balance_for_program);
     assert_eq!(program_account.owner, bpf_loader_upgradeable::id());
-    assert!(program_account.executable);
+    assert_eq!(program_account.executable, true);
     let (programdata_pubkey, _) = Pubkey::find_program_address(
         &[program_keypair.pubkey().as_ref()],
         &bpf_loader_upgradeable::id(),
@@ -300,7 +298,7 @@ fn test_cli_program_deploy_with_authority() {
         minimum_balance_for_programdata
     );
     assert_eq!(programdata_account.owner, bpf_loader_upgradeable::id());
-    assert!(!programdata_account.executable);
+    assert_eq!(programdata_account.executable, false);
     assert_eq!(
         programdata_account.data[UpgradeableLoaderState::programdata_data_offset().unwrap()..],
         program_data[..]
@@ -328,11 +326,11 @@ fn test_cli_program_deploy_with_authority() {
         .unwrap()
         .as_str()
         .unwrap();
-    let program_pubkey = Pubkey::from_str(program_pubkey_str).unwrap();
+    let program_pubkey = Pubkey::from_str(&program_pubkey_str).unwrap();
     let program_account = rpc_client.get_account(&program_pubkey).unwrap();
     assert_eq!(program_account.lamports, minimum_balance_for_program);
     assert_eq!(program_account.owner, bpf_loader_upgradeable::id());
-    assert!(program_account.executable);
+    assert_eq!(program_account.executable, true);
     let (programdata_pubkey, _) =
         Pubkey::find_program_address(&[program_pubkey.as_ref()], &bpf_loader_upgradeable::id());
     let programdata_account = rpc_client.get_account(&programdata_pubkey).unwrap();
@@ -341,7 +339,7 @@ fn test_cli_program_deploy_with_authority() {
         minimum_balance_for_programdata
     );
     assert_eq!(programdata_account.owner, bpf_loader_upgradeable::id());
-    assert!(!programdata_account.executable);
+    assert_eq!(programdata_account.executable, false);
     assert_eq!(
         programdata_account.data[UpgradeableLoaderState::programdata_data_offset().unwrap()..],
         program_data[..]
@@ -364,7 +362,7 @@ fn test_cli_program_deploy_with_authority() {
     let program_account = rpc_client.get_account(&program_pubkey).unwrap();
     assert_eq!(program_account.lamports, minimum_balance_for_program);
     assert_eq!(program_account.owner, bpf_loader_upgradeable::id());
-    assert!(program_account.executable);
+    assert_eq!(program_account.executable, true);
     let (programdata_pubkey, _) =
         Pubkey::find_program_address(&[program_pubkey.as_ref()], &bpf_loader_upgradeable::id());
     let programdata_account = rpc_client.get_account(&programdata_pubkey).unwrap();
@@ -373,7 +371,7 @@ fn test_cli_program_deploy_with_authority() {
         minimum_balance_for_programdata
     );
     assert_eq!(programdata_account.owner, bpf_loader_upgradeable::id());
-    assert!(!programdata_account.executable);
+    assert_eq!(programdata_account.executable, false);
     assert_eq!(
         programdata_account.data[UpgradeableLoaderState::programdata_data_offset().unwrap()..],
         program_data[..]
@@ -397,7 +395,7 @@ fn test_cli_program_deploy_with_authority() {
         .as_str()
         .unwrap();
     assert_eq!(
-        Pubkey::from_str(new_upgrade_authority_str).unwrap(),
+        Pubkey::from_str(&new_upgrade_authority_str).unwrap(),
         new_upgrade_authority.pubkey()
     );
 
@@ -418,7 +416,7 @@ fn test_cli_program_deploy_with_authority() {
     let program_account = rpc_client.get_account(&program_pubkey).unwrap();
     assert_eq!(program_account.lamports, minimum_balance_for_program);
     assert_eq!(program_account.owner, bpf_loader_upgradeable::id());
-    assert!(program_account.executable);
+    assert_eq!(program_account.executable, true);
     let (programdata_pubkey, _) =
         Pubkey::find_program_address(&[program_pubkey.as_ref()], &bpf_loader_upgradeable::id());
     let programdata_account = rpc_client.get_account(&programdata_pubkey).unwrap();
@@ -427,7 +425,7 @@ fn test_cli_program_deploy_with_authority() {
         minimum_balance_for_programdata
     );
     assert_eq!(programdata_account.owner, bpf_loader_upgradeable::id());
-    assert!(!programdata_account.executable);
+    assert_eq!(programdata_account.executable, false);
     assert_eq!(
         programdata_account.data[UpgradeableLoaderState::programdata_data_offset().unwrap()..],
         program_data[..]
@@ -452,7 +450,7 @@ fn test_cli_program_deploy_with_authority() {
         .unwrap();
     assert_eq!(
         new_upgrade_authority.pubkey(),
-        Pubkey::from_str(authority_pubkey_str).unwrap()
+        Pubkey::from_str(&authority_pubkey_str).unwrap()
     );
 
     // Set no authority
@@ -510,7 +508,7 @@ fn test_cli_program_deploy_with_authority() {
         .unwrap()
         .as_str()
         .unwrap();
-    let program_pubkey = Pubkey::from_str(program_pubkey_str).unwrap();
+    let program_pubkey = Pubkey::from_str(&program_pubkey_str).unwrap();
     let (programdata_pubkey, _) =
         Pubkey::find_program_address(&[program_pubkey.as_ref()], &bpf_loader_upgradeable::id());
     let programdata_account = rpc_client.get_account(&programdata_pubkey).unwrap();
@@ -606,7 +604,7 @@ fn test_cli_program_write_buffer() {
         .unwrap()
         .as_str()
         .unwrap();
-    let new_buffer_pubkey = Pubkey::from_str(buffer_pubkey_str).unwrap();
+    let new_buffer_pubkey = Pubkey::from_str(&buffer_pubkey_str).unwrap();
     let buffer_account = rpc_client.get_account(&new_buffer_pubkey).unwrap();
     assert_eq!(buffer_account.lamports, minimum_balance_for_buffer_default);
     assert_eq!(buffer_account.owner, bpf_loader_upgradeable::id());
@@ -641,7 +639,7 @@ fn test_cli_program_write_buffer() {
         .unwrap();
     assert_eq!(
         buffer_keypair.pubkey(),
-        Pubkey::from_str(buffer_pubkey_str).unwrap()
+        Pubkey::from_str(&buffer_pubkey_str).unwrap()
     );
     let buffer_account = rpc_client.get_account(&buffer_keypair.pubkey()).unwrap();
     assert_eq!(buffer_account.lamports, minimum_balance_for_buffer);
@@ -675,7 +673,7 @@ fn test_cli_program_write_buffer() {
         .unwrap();
     assert_eq!(
         keypair.pubkey(),
-        Pubkey::from_str(authority_pubkey_str).unwrap()
+        Pubkey::from_str(&authority_pubkey_str).unwrap()
     );
 
     // Specify buffer authority
@@ -700,7 +698,7 @@ fn test_cli_program_write_buffer() {
         .unwrap();
     assert_eq!(
         buffer_keypair.pubkey(),
-        Pubkey::from_str(buffer_pubkey_str).unwrap()
+        Pubkey::from_str(&buffer_pubkey_str).unwrap()
     );
     let buffer_account = rpc_client.get_account(&buffer_keypair.pubkey()).unwrap();
     assert_eq!(buffer_account.lamports, minimum_balance_for_buffer_default);
@@ -735,7 +733,7 @@ fn test_cli_program_write_buffer() {
         .unwrap()
         .as_str()
         .unwrap();
-    let buffer_pubkey = Pubkey::from_str(buffer_pubkey_str).unwrap();
+    let buffer_pubkey = Pubkey::from_str(&buffer_pubkey_str).unwrap();
     let buffer_account = rpc_client.get_account(&buffer_pubkey).unwrap();
     assert_eq!(buffer_account.lamports, minimum_balance_for_buffer_default);
     assert_eq!(buffer_account.owner, bpf_loader_upgradeable::id());
@@ -768,7 +766,7 @@ fn test_cli_program_write_buffer() {
         .unwrap();
     assert_eq!(
         authority_keypair.pubkey(),
-        Pubkey::from_str(authority_pubkey_str).unwrap()
+        Pubkey::from_str(&authority_pubkey_str).unwrap()
     );
 
     // Close buffer
@@ -806,7 +804,7 @@ fn test_cli_program_write_buffer() {
         .unwrap()
         .as_str()
         .unwrap();
-    let new_buffer_pubkey = Pubkey::from_str(buffer_pubkey_str).unwrap();
+    let new_buffer_pubkey = Pubkey::from_str(&buffer_pubkey_str).unwrap();
 
     // Close buffers and deposit default keypair
     let pre_lamports = rpc_client.get_account(&keypair.pubkey()).unwrap().lamports;
@@ -890,7 +888,6 @@ fn test_cli_program_set_buffer_authority() {
         buffer_authority_index: Some(0),
         new_buffer_authority: new_buffer_authority.pubkey(),
     });
-    config.output_format = OutputFormat::JsonCompact;
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
     let new_buffer_authority_str = json
@@ -901,7 +898,7 @@ fn test_cli_program_set_buffer_authority() {
         .as_str()
         .unwrap();
     assert_eq!(
-        Pubkey::from_str(new_buffer_authority_str).unwrap(),
+        Pubkey::from_str(&new_buffer_authority_str).unwrap(),
         new_buffer_authority.pubkey()
     );
     let buffer_account = rpc_client.get_account(&buffer_keypair.pubkey()).unwrap();
@@ -928,7 +925,7 @@ fn test_cli_program_set_buffer_authority() {
         .as_str()
         .unwrap();
     assert_eq!(
-        Pubkey::from_str(buffer_authority_str).unwrap(),
+        Pubkey::from_str(&buffer_authority_str).unwrap(),
         buffer_keypair.pubkey()
     );
     let buffer_account = rpc_client.get_account(&buffer_keypair.pubkey()).unwrap();
@@ -1101,7 +1098,7 @@ fn test_cli_program_show() {
         .unwrap();
     assert_eq!(
         buffer_keypair.pubkey(),
-        Pubkey::from_str(address_str).unwrap()
+        Pubkey::from_str(&address_str).unwrap()
     );
     let authority_str = json
         .as_object()
@@ -1112,7 +1109,7 @@ fn test_cli_program_show() {
         .unwrap();
     assert_eq!(
         authority_keypair.pubkey(),
-        Pubkey::from_str(authority_str).unwrap()
+        Pubkey::from_str(&authority_str).unwrap()
     );
     let data_len = json
         .as_object()
@@ -1161,7 +1158,7 @@ fn test_cli_program_show() {
         .unwrap();
     assert_eq!(
         program_keypair.pubkey(),
-        Pubkey::from_str(address_str).unwrap()
+        Pubkey::from_str(&address_str).unwrap()
     );
     let programdata_address_str = json
         .as_object()
@@ -1176,7 +1173,7 @@ fn test_cli_program_show() {
     );
     assert_eq!(
         programdata_pubkey,
-        Pubkey::from_str(programdata_address_str).unwrap()
+        Pubkey::from_str(&programdata_address_str).unwrap()
     );
     let authority_str = json
         .as_object()
@@ -1187,7 +1184,7 @@ fn test_cli_program_show() {
         .unwrap();
     assert_eq!(
         authority_keypair.pubkey(),
-        Pubkey::from_str(authority_str).unwrap()
+        Pubkey::from_str(&authority_str).unwrap()
     );
     let deployed_slot = json
         .as_object()

cli/tests/stake.rs

@@ -1,7 +1,6 @@
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     spend_utils::SpendAmount,
-    stake::StakeAuthorizationIndexed,
     test_utils::{check_ready, check_recent_balance},
 };
 use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
@@ -18,11 +17,10 @@ use solana_sdk::{
     nonce::State as NonceState,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, Signer},
-    stake::{
-        self,
-        instruction::LockupArgs,
-        state::{Lockup, StakeAuthorize, StakeState},
-    },
+};
+use solana_stake_program::{
+    stake_instruction::LockupArgs,
+    stake_state::{Lockup, StakeAuthorize, StakeState},
 };
 
 #[test]
@@ -53,7 +51,6 @@ fn test_stake_delegation_force() {
         authorized_voter: None,
         authorized_withdrawer: None,
         commission: 0,
-        memo: None,
     };
     process_command(&config).unwrap();
 
@@ -65,7 +62,6 @@ fn test_stake_delegation_force() {
         seed: None,
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -73,7 +69,6 @@ fn test_stake_delegation_force() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -91,7 +86,6 @@ fn test_stake_delegation_force() {
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap_err();
@@ -107,7 +101,6 @@ fn test_stake_delegation_force() {
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -142,7 +135,7 @@ fn test_seed_stake_delegation_and_deactivation() {
     let stake_address = Pubkey::create_with_seed(
         &config_validator.signers[0].pubkey(),
         "hi there",
-        &stake::program::id(),
+        &solana_stake_program::id(),
     )
     .expect("bad seed");
 
@@ -153,7 +146,6 @@ fn test_seed_stake_delegation_and_deactivation() {
         seed: Some("hi there".to_string()),
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -161,7 +153,6 @@ fn test_seed_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -178,7 +169,6 @@ fn test_seed_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
@@ -192,8 +182,6 @@ fn test_seed_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
@@ -234,7 +222,6 @@ fn test_stake_delegation_and_deactivation() {
         seed: None,
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -242,7 +229,6 @@ fn test_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -260,7 +246,6 @@ fn test_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
@@ -274,8 +259,6 @@ fn test_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
@@ -336,7 +319,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         seed: None,
         staker: Some(config_offline.signers[0].pubkey()),
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -344,7 +326,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -362,7 +343,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
@@ -383,7 +363,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config_payer).unwrap();
@@ -398,8 +377,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     let sig_response = process_command(&config_offline).unwrap();
@@ -417,8 +394,6 @@ fn test_offline_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config_payer).unwrap();
@@ -456,7 +431,6 @@ fn test_nonced_stake_delegation_and_deactivation() {
         seed: None,
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -464,7 +438,6 @@ fn test_nonced_stake_delegation_and_deactivation() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -477,7 +450,6 @@ fn test_nonced_stake_delegation_and_deactivation() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(config.signers[0].pubkey()),
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -507,7 +479,6 @@ fn test_nonced_stake_delegation_and_deactivation() {
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -534,8 +505,6 @@ fn test_nonced_stake_delegation_and_deactivation() {
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -587,7 +556,6 @@ fn test_stake_authorize() {
         seed: None,
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -595,7 +563,6 @@ fn test_stake_authorize() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -607,21 +574,14 @@ fn test_stake_authorize() {
     config.signers.pop();
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: online_authority_pubkey,
-            authority: 0,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, online_authority_pubkey, 0)],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
@@ -641,28 +601,16 @@ fn test_stake_authorize() {
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
         new_authorizations: vec![
-            StakeAuthorizationIndexed {
-                authorization_type: StakeAuthorize::Staker,
-                new_authority_pubkey: online_authority2_pubkey,
-                authority: 1,
-                new_authority_signer: None,
-            },
-            StakeAuthorizationIndexed {
-                authorization_type: StakeAuthorize::Withdrawer,
-                new_authority_pubkey: withdraw_authority_pubkey,
-                authority: 0,
-                new_authority_signer: None,
-            },
+            (StakeAuthorize::Staker, online_authority2_pubkey, 1),
+            (StakeAuthorize::Withdrawer, withdraw_authority_pubkey, 0),
         ],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
@@ -679,21 +627,14 @@ fn test_stake_authorize() {
     config.signers.push(&online_authority2);
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: offline_authority_pubkey,
-            authority: 1,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, offline_authority_pubkey, 1)],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
@@ -710,21 +651,14 @@ fn test_stake_authorize() {
     let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: nonced_authority_pubkey,
-            authority: 0,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, nonced_authority_pubkey, 0)],
         sign_only: true,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
     let sign_reply = process_command(&config_offline).unwrap();
@@ -734,21 +668,14 @@ fn test_stake_authorize() {
     config.signers = vec![&offline_presigner];
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: nonced_authority_pubkey,
-            authority: 0,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, nonced_authority_pubkey, 0)],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
@@ -769,7 +696,6 @@ fn test_stake_authorize() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_authority_pubkey),
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -790,21 +716,14 @@ fn test_stake_authorize() {
     config_offline.signers.push(&nonced_authority);
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: online_authority_pubkey,
-            authority: 1,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, online_authority_pubkey, 1)],
         sign_only: true,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     let sign_reply = process_command(&config_offline).unwrap();
     let sign_only = parse_sign_only_reply_string(&sign_reply);
@@ -815,12 +734,7 @@ fn test_stake_authorize() {
     config.signers = vec![&offline_presigner, &nonced_authority_presigner];
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: online_authority_pubkey,
-            authority: 1,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, online_authority_pubkey, 1)],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
@@ -829,10 +743,8 @@ fn test_stake_authorize() {
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
@@ -908,7 +820,6 @@ fn test_stake_authorize_with_fee_payer() {
         seed: None,
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -916,7 +827,6 @@ fn test_stake_authorize_with_fee_payer() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -928,21 +838,14 @@ fn test_stake_authorize_with_fee_payer() {
     config.signers = vec![&default_signer, &payer_keypair];
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: offline_pubkey,
-            authority: 0,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, offline_pubkey, 0)],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 1,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     // `config` balance has not changed, despite submitting the TX
@@ -955,21 +858,14 @@ fn test_stake_authorize_with_fee_payer() {
     let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: payer_pubkey,
-            authority: 0,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, payer_pubkey, 0)],
         sign_only: true,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
     let sign_reply = process_command(&config_offline).unwrap();
@@ -979,21 +875,14 @@ fn test_stake_authorize_with_fee_payer() {
     config.signers = vec![&offline_presigner];
     config.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: payer_pubkey,
-            authority: 0,
-            new_authority_signer: None,
-        }],
+        new_authorizations: vec![(StakeAuthorize::Staker, payer_pubkey, 0)],
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
-        no_wait: false,
     };
     process_command(&config).unwrap();
     // `config`'s balance again has not changed
@@ -1048,7 +937,6 @@ fn test_stake_split() {
         seed: None,
         staker: Some(offline_pubkey),
         withdrawer: Some(offline_pubkey),
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(10 * minimum_stake_balance),
         sign_only: false,
@@ -1056,7 +944,6 @@ fn test_stake_split() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1077,7 +964,6 @@ fn test_stake_split() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_pubkey),
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -1105,7 +991,6 @@ fn test_stake_split() {
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         split_stake_account: 1,
         seed: None,
         lamports: 2 * minimum_stake_balance,
@@ -1128,7 +1013,6 @@ fn test_stake_split() {
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         split_stake_account: 1,
         seed: None,
         lamports: 2 * minimum_stake_balance,
@@ -1198,8 +1082,7 @@ fn test_stake_set_lockup() {
         stake_account: 1,
         seed: None,
         staker: Some(offline_pubkey),
-        withdrawer: Some(config.signers[0].pubkey()),
-        withdrawer_signer: None,
+        withdrawer: Some(offline_pubkey),
         lockup,
         amount: SpendAmount::Some(10 * minimum_stake_balance),
         sign_only: false,
@@ -1207,7 +1090,6 @@ fn test_stake_set_lockup() {
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1228,14 +1110,12 @@ fn test_stake_set_lockup() {
     config.command = CliCommand::StakeSetLockup {
         stake_account_pubkey,
         lockup,
-        new_custodian_signer: None,
         custodian: 0,
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1264,14 +1144,12 @@ fn test_stake_set_lockup() {
     config.command = CliCommand::StakeSetLockup {
         stake_account_pubkey,
         lockup,
-        new_custodian_signer: None,
         custodian: 0,
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1285,14 +1163,12 @@ fn test_stake_set_lockup() {
     config.command = CliCommand::StakeSetLockup {
         stake_account_pubkey,
         lockup,
-        new_custodian_signer: None,
         custodian: 1,
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1318,14 +1194,12 @@ fn test_stake_set_lockup() {
     config.command = CliCommand::StakeSetLockup {
         stake_account_pubkey,
         lockup,
-        new_custodian_signer: None,
         custodian: 1,
         sign_only: false,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1341,7 +1215,6 @@ fn test_stake_set_lockup() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_pubkey),
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -1366,14 +1239,12 @@ fn test_stake_set_lockup() {
     config_offline.command = CliCommand::StakeSetLockup {
         stake_account_pubkey,
         lockup,
-        new_custodian_signer: None,
         custodian: 0,
         sign_only: true,
         dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_account_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
@@ -1385,7 +1256,6 @@ fn test_stake_set_lockup() {
     config.command = CliCommand::StakeSetLockup {
         stake_account_pubkey,
         lockup,
-        new_custodian_signer: None,
         custodian: 0,
         sign_only: false,
         dump_transaction_message: false,
@@ -1395,7 +1265,6 @@ fn test_stake_set_lockup() {
         ),
         nonce_account: Some(nonce_account_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1456,7 +1325,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         nonce_account: 1,
         seed: None,
         nonce_authority: Some(offline_pubkey),
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -1480,7 +1348,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         seed: None,
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: true,
@@ -1488,7 +1355,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1504,7 +1370,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         seed: None,
         staker: Some(offline_pubkey),
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -1515,7 +1380,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         ),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1539,7 +1403,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     config_offline.command = CliCommand::WithdrawStake {
         stake_account_pubkey: stake_pubkey,
         destination_account_pubkey: recipient_pubkey,
-        amount: SpendAmount::Some(42),
+        lamports: 42,
         withdraw_authority: 0,
         custodian: None,
         sign_only: true,
@@ -1547,8 +1411,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     let sig_response = process_command(&config_offline).unwrap();
@@ -1558,7 +1420,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     config.command = CliCommand::WithdrawStake {
         stake_account_pubkey: stake_pubkey,
         destination_account_pubkey: recipient_pubkey,
-        amount: SpendAmount::Some(42),
+        lamports: 42,
         withdraw_authority: 0,
         custodian: None,
         sign_only: false,
@@ -1569,8 +1431,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         ),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1594,7 +1454,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         seed: Some(seed.to_string()),
         staker: None,
         withdrawer: None,
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: true,
@@ -1602,7 +1461,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1616,7 +1474,6 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         seed: Some(seed.to_string()),
         staker: Some(offline_pubkey),
         withdrawer: Some(offline_pubkey),
-        withdrawer_signer: None,
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
@@ -1627,237 +1484,11 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         ),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
     process_command(&config).unwrap();
     let seed_address =
-        Pubkey::create_with_seed(&stake_pubkey, seed, &stake::program::id()).unwrap();
+        Pubkey::create_with_seed(&stake_pubkey, seed, &solana_stake_program::id()).unwrap();
     check_recent_balance(50_000, &rpc_client, &seed_address);
 }
-
-#[test]
-fn test_stake_checked_instructions() {
-    solana_logger::setup();
-
-    let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
-    let faucet_addr = run_local_faucet(mint_keypair, None);
-    let test_validator = TestValidator::with_no_fees(mint_pubkey, Some(faucet_addr));
-
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
-    let default_signer = Keypair::new();
-
-    let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
-    config.signers = vec![&default_signer];
-
-    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 100_000)
-        .unwrap();
-
-    // Create stake account with withdrawer
-    let stake_keypair = Keypair::new();
-    let stake_account_pubkey = stake_keypair.pubkey();
-    let withdrawer_keypair = Keypair::new();
-    let withdrawer_pubkey = withdrawer_keypair.pubkey();
-    config.signers.push(&stake_keypair);
-    config.command = CliCommand::CreateStakeAccount {
-        stake_account: 1,
-        seed: None,
-        staker: None,
-        withdrawer: Some(withdrawer_pubkey),
-        withdrawer_signer: Some(1),
-        lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        from: 0,
-    };
-    process_command(&config).unwrap_err(); // unsigned authority should fail
-
-    config.signers = vec![&default_signer, &stake_keypair, &withdrawer_keypair];
-    config.command = CliCommand::CreateStakeAccount {
-        stake_account: 1,
-        seed: None,
-        staker: None,
-        withdrawer: Some(withdrawer_pubkey),
-        withdrawer_signer: Some(1),
-        lockup: Lockup::default(),
-        amount: SpendAmount::Some(50_000),
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        from: 0,
-    };
-    process_command(&config).unwrap();
-
-    // Re-authorize account, checking new authority
-    let staker_keypair = Keypair::new();
-    let staker_pubkey = staker_keypair.pubkey();
-    config.signers = vec![&default_signer];
-    config.command = CliCommand::StakeAuthorize {
-        stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: staker_pubkey,
-            authority: 0,
-            new_authority_signer: Some(0),
-        }],
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::default(),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        custodian: None,
-        no_wait: false,
-    };
-    process_command(&config).unwrap_err(); // unsigned authority should fail
-
-    config.signers = vec![&default_signer, &staker_keypair];
-    config.command = CliCommand::StakeAuthorize {
-        stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Staker,
-            new_authority_pubkey: staker_pubkey,
-            authority: 0,
-            new_authority_signer: Some(1),
-        }],
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::default(),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        custodian: None,
-        no_wait: false,
-    };
-    process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
-    let stake_state: StakeState = stake_account.state().unwrap();
-    let current_authority = match stake_state {
-        StakeState::Initialized(meta) => meta.authorized.staker,
-        _ => panic!("Unexpected stake state!"),
-    };
-    assert_eq!(current_authority, staker_pubkey);
-
-    let new_withdrawer_keypair = Keypair::new();
-    let new_withdrawer_pubkey = new_withdrawer_keypair.pubkey();
-    config.signers = vec![&default_signer, &withdrawer_keypair];
-    config.command = CliCommand::StakeAuthorize {
-        stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Withdrawer,
-            new_authority_pubkey: new_withdrawer_pubkey,
-            authority: 1,
-            new_authority_signer: Some(1),
-        }],
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::default(),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        custodian: None,
-        no_wait: false,
-    };
-    process_command(&config).unwrap_err(); // unsigned authority should fail
-
-    config.signers = vec![
-        &default_signer,
-        &withdrawer_keypair,
-        &new_withdrawer_keypair,
-    ];
-    config.command = CliCommand::StakeAuthorize {
-        stake_account_pubkey,
-        new_authorizations: vec![StakeAuthorizationIndexed {
-            authorization_type: StakeAuthorize::Withdrawer,
-            new_authority_pubkey: new_withdrawer_pubkey,
-            authority: 1,
-            new_authority_signer: Some(2),
-        }],
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::default(),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        custodian: None,
-        no_wait: false,
-    };
-    process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
-    let stake_state: StakeState = stake_account.state().unwrap();
-    let current_authority = match stake_state {
-        StakeState::Initialized(meta) => meta.authorized.withdrawer,
-        _ => panic!("Unexpected stake state!"),
-    };
-    assert_eq!(current_authority, new_withdrawer_pubkey);
-
-    // Set lockup, checking new custodian
-    let custodian = Keypair::new();
-    let custodian_pubkey = custodian.pubkey();
-    let lockup = LockupArgs {
-        unix_timestamp: Some(1_581_534_570),
-        epoch: Some(200),
-        custodian: Some(custodian_pubkey),
-    };
-    config.signers = vec![&default_signer, &new_withdrawer_keypair];
-    config.command = CliCommand::StakeSetLockup {
-        stake_account_pubkey,
-        lockup,
-        new_custodian_signer: Some(1),
-        custodian: 1,
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::default(),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-    };
-    process_command(&config).unwrap_err(); // unsigned new custodian should fail
-
-    config.signers = vec![&default_signer, &new_withdrawer_keypair, &custodian];
-    config.command = CliCommand::StakeSetLockup {
-        stake_account_pubkey,
-        lockup,
-        new_custodian_signer: Some(2),
-        custodian: 1,
-        sign_only: false,
-        dump_transaction_message: false,
-        blockhash_query: BlockhashQuery::default(),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-    };
-    process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
-    let stake_state: StakeState = stake_account.state().unwrap();
-    let current_lockup = match stake_state {
-        StakeState::Initialized(meta) => meta.lockup,
-        _ => panic!("Unexpected stake state!"),
-    };
-    assert_eq!(
-        current_lockup.unix_timestamp,
-        lockup.unix_timestamp.unwrap()
-    );
-    assert_eq!(current_lockup.epoch, lockup.epoch.unwrap());
-    assert_eq!(current_lockup.custodian, custodian_pubkey);
-}

cli/tests/transfer.rs

@@ -16,7 +16,6 @@ use solana_sdk::{
     nonce::State as NonceState,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, NullSigner, Signer},
-    stake,
 };
 
 #[test]
@@ -53,12 +52,10 @@ fn test_transfer() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -74,12 +71,10 @@ fn test_transfer() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -107,12 +102,10 @@ fn test_transfer() {
         from: 0,
         sign_only: true,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -129,12 +122,10 @@ fn test_transfer() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -153,7 +144,6 @@ fn test_transfer() {
         nonce_account: 1,
         seed: None,
         nonce_authority: None,
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -177,7 +167,6 @@ fn test_transfer() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
@@ -185,7 +174,6 @@ fn test_transfer() {
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -208,7 +196,6 @@ fn test_transfer() {
     config.command = CliCommand::AuthorizeNonceAccount {
         nonce_account: nonce_account.pubkey(),
         nonce_authority: 0,
-        memo: None,
         new_authority: offline_pubkey,
     };
     process_command(&config).unwrap();
@@ -232,12 +219,10 @@ fn test_transfer() {
         from: 0,
         sign_only: true,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -253,7 +238,6 @@ fn test_transfer() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
@@ -261,7 +245,6 @@ fn test_transfer() {
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -322,12 +305,10 @@ fn test_transfer_multisession_signing() {
         from: 1,
         sign_only: true,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -353,12 +334,10 @@ fn test_transfer_multisession_signing() {
         from: 1,
         sign_only: true,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -381,12 +360,10 @@ fn test_transfer_multisession_signing() {
         from: 1,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -431,12 +408,10 @@ fn test_transfer_all() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -446,54 +421,6 @@ fn test_transfer_all() {
     check_recent_balance(49_999, &rpc_client, &recipient_pubkey);
 }
 
-#[test]
-fn test_transfer_unfunded_recipient() {
-    solana_logger::setup();
-    let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
-    let faucet_addr = run_local_faucet(mint_keypair, None);
-    let test_validator = TestValidator::with_custom_fees(mint_pubkey, 1, Some(faucet_addr));
-
-    let rpc_client =
-        RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
-
-    let default_signer = Keypair::new();
-
-    let mut config = CliConfig::recent_for_tests();
-    config.json_rpc_url = test_validator.rpc_url();
-    config.signers = vec![&default_signer];
-
-    let sender_pubkey = config.signers[0].pubkey();
-    let recipient_pubkey = Pubkey::new(&[1u8; 32]);
-
-    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 50_000).unwrap();
-    check_recent_balance(50_000, &rpc_client, &sender_pubkey);
-    check_recent_balance(0, &rpc_client, &recipient_pubkey);
-
-    check_ready(&rpc_client);
-
-    // Plain ole transfer
-    config.command = CliCommand::Transfer {
-        amount: SpendAmount::All,
-        to: recipient_pubkey,
-        from: 0,
-        sign_only: false,
-        dump_transaction_message: false,
-        allow_unfunded_recipient: false,
-        no_wait: false,
-        blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
-        nonce_account: None,
-        nonce_authority: 0,
-        memo: None,
-        fee_payer: 0,
-        derived_address_seed: None,
-        derived_address_program_id: None,
-    };
-
-    // Expect failure due to unfunded recipient and the lack of the `allow_unfunded_recipient` flag
-    process_command(&config).unwrap_err();
-}
-
 #[test]
 fn test_transfer_with_seed() {
     solana_logger::setup();
@@ -514,7 +441,7 @@ fn test_transfer_with_seed() {
     let sender_pubkey = config.signers[0].pubkey();
     let recipient_pubkey = Pubkey::new(&[1u8; 32]);
     let derived_address_seed = "seed".to_string();
-    let derived_address_program_id = stake::program::id();
+    let derived_address_program_id = solana_stake_program::id();
     let derived_address = Pubkey::create_with_seed(
         &sender_pubkey,
         &derived_address_seed,
@@ -537,12 +464,10 @@ fn test_transfer_with_seed() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: Some(derived_address_seed),
         derived_address_program_id: Some(derived_address_program_id),

cli/tests/vote.rs

@@ -45,7 +45,6 @@ fn test_vote_authorize_and_withdraw() {
         authorized_voter: None,
         authorized_withdrawer: Some(config.signers[0].pubkey()),
         commission: 0,
-        memo: None,
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
@@ -68,12 +67,10 @@ fn test_vote_authorize_and_withdraw() {
         from: 0,
         sign_only: false,
         dump_transaction_message: false,
-        allow_unfunded_recipient: true,
         no_wait: false,
         blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         derived_address_seed: None,
         derived_address_program_id: None,
@@ -83,48 +80,12 @@ fn test_vote_authorize_and_withdraw() {
     check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
 
     // Authorize vote account withdrawal to another signer
-    let first_withdraw_authority = Keypair::new();
+    let withdraw_authority = Keypair::new();
     config.signers = vec![&default_signer];
-    config.command = CliCommand::VoteAuthorize {
-        vote_account_pubkey,
-        new_authorized_pubkey: first_withdraw_authority.pubkey(),
-        vote_authorize: VoteAuthorize::Withdrawer,
-        memo: None,
-        authorized: 0,
-        new_authorized: None,
-    };
-    process_command(&config).unwrap();
-    let vote_account = rpc_client
-        .get_account(&vote_account_keypair.pubkey())
-        .unwrap();
-    let vote_state: VoteStateVersions = vote_account.state().unwrap();
-    let authorized_withdrawer = vote_state.convert_to_current().authorized_withdrawer;
-    assert_eq!(authorized_withdrawer, first_withdraw_authority.pubkey());
-
-    // Authorize vote account withdrawal to another signer with checked instruction
-    let withdraw_authority = Keypair::new();
-    config.signers = vec![&default_signer, &first_withdraw_authority];
     config.command = CliCommand::VoteAuthorize {
         vote_account_pubkey,
         new_authorized_pubkey: withdraw_authority.pubkey(),
         vote_authorize: VoteAuthorize::Withdrawer,
-        memo: None,
-        authorized: 1,
-        new_authorized: Some(1),
-    };
-    process_command(&config).unwrap_err(); // unsigned by new authority should fail
-    config.signers = vec![
-        &default_signer,
-        &first_withdraw_authority,
-        &withdraw_authority,
-    ];
-    config.command = CliCommand::VoteAuthorize {
-        vote_account_pubkey,
-        new_authorized_pubkey: withdraw_authority.pubkey(),
-        vote_authorize: VoteAuthorize::Withdrawer,
-        memo: None,
-        authorized: 1,
-        new_authorized: Some(2),
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
@@ -142,7 +103,6 @@ fn test_vote_authorize_and_withdraw() {
         withdraw_authority: 1,
         withdraw_amount: SpendAmount::Some(100),
         destination_account_pubkey: destination_account,
-        memo: None,
     };
     process_command(&config).unwrap();
     check_recent_balance(expected_balance - 100, &rpc_client, &vote_account_pubkey);
@@ -155,7 +115,6 @@ fn test_vote_authorize_and_withdraw() {
         vote_account_pubkey,
         new_identity_account: 2,
         withdraw_authority: 1,
-        memo: None,
     };
     process_command(&config).unwrap();
 }

client/Cargo.toml

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

client/src/blockhash_query.rs

@@ -1,15 +1,12 @@
-use {
-    crate::{nonce_utils, rpc_client::RpcClient},
-    clap::ArgMatches,
-    solana_clap_utils::{
-        input_parsers::{pubkey_of, value_of},
-        nonce::*,
-        offline::*,
-    },
-    solana_sdk::{
-        commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, hash::Hash,
-        pubkey::Pubkey,
-    },
+use crate::{nonce_utils, rpc_client::RpcClient};
+use clap::ArgMatches;
+use solana_clap_utils::{
+    input_parsers::{pubkey_of, value_of},
+    nonce::*,
+    offline::*,
+};
+use solana_sdk::{
+    commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey,
 };
 
 #[derive(Debug, PartialEq)]
@@ -361,7 +358,7 @@ mod tests {
         let nonce_pubkey = Pubkey::new(&[4u8; 32]);
         let rpc_nonce_account = UiAccount::encode(
             &nonce_pubkey,
-            &nonce_account,
+            nonce_account,
             UiAccountEncoding::Base64,
             None,
             None,

client/src/client_error.rs

@@ -1,12 +1,10 @@
-use {
-    crate::{rpc_request, rpc_response},
-    solana_faucet::faucet::FaucetError,
-    solana_sdk::{
-        signature::SignerError, transaction::TransactionError, transport::TransportError,
-    },
-    std::io,
-    thiserror::Error,
+use crate::rpc_request;
+use solana_faucet::faucet::FaucetError;
+use solana_sdk::{
+    signature::SignerError, transaction::TransactionError, transport::TransportError,
 };
+use std::io;
+use thiserror::Error;
 
 pub use reqwest; // export `reqwest` for clients
 
@@ -30,24 +28,6 @@ pub enum ClientErrorKind {
     Custom(String),
 }
 
-impl ClientErrorKind {
-    pub fn get_transaction_error(&self) -> Option<TransactionError> {
-        match self {
-            Self::RpcError(rpc_request::RpcError::RpcResponseError {
-                data:
-                    rpc_request::RpcResponseErrorData::SendTransactionPreflightFailure(
-                        rpc_response::RpcSimulateTransactionResult {
-                            err: Some(tx_err), ..
-                        },
-                    ),
-                ..
-            }) => Some(tx_err.clone()),
-            Self::TransactionError(tx_err) => Some(tx_err.clone()),
-            _ => None,
-        }
-    }
-}
-
 impl From<TransportError> for ClientErrorKind {
     fn from(err: TransportError) -> Self {
         match err {
@@ -104,10 +84,6 @@ impl ClientError {
     pub fn kind(&self) -> &ClientErrorKind {
         &self.kind
     }
-
-    pub fn get_transaction_error(&self) -> Option<TransactionError> {
-        self.kind.get_transaction_error()
-    }
 }
 
 impl From<ClientErrorKind> for ClientError {

client/src/fees.rs

@@ -1,9 +0,0 @@
-use crate::{fee_calculator::FeeCalculator, hash::Hash};
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct Fees {
-    pub blockhash: Hash,
-    pub fee_calculator: FeeCalculator,
-    pub last_valid_block_height: u64,
-}

client/src/http_sender.rs

@@ -1,31 +1,17 @@
-use {
-    crate::{
-        client_error::Result,
-        rpc_custom_error,
-        rpc_request::{RpcError, RpcRequest, RpcResponseErrorData},
-        rpc_response::RpcSimulateTransactionResult,
-        rpc_sender::RpcSender,
-    },
-    log::*,
-    reqwest::{
-        self,
-        header::{CONTENT_TYPE, RETRY_AFTER},
-        StatusCode,
-    },
-    std::{
-        sync::{
-            atomic::{AtomicU64, Ordering},
-            Arc,
-        },
-        thread::sleep,
-        time::Duration,
-    },
+use crate::{
+    client_error::Result,
+    rpc_custom_error,
+    rpc_request::{RpcError, RpcRequest, RpcResponseErrorData},
+    rpc_response::RpcSimulateTransactionResult,
+    rpc_sender::RpcSender,
 };
+use log::*;
+use reqwest::{self, header::CONTENT_TYPE, StatusCode};
+use std::{thread::sleep, time::Duration};
 
 pub struct HttpSender {
-    client: Arc<reqwest::blocking::Client>,
+    client: reqwest::blocking::Client,
     url: String,
-    request_id: AtomicU64,
 }
 
 impl HttpSender {
@@ -34,22 +20,12 @@ impl HttpSender {
     }
 
     pub fn new_with_timeout(url: String, timeout: Duration) -> Self {
-        // `reqwest::blocking::Client` panics if run in a tokio async context.  Shuttle the
-        // request to a different tokio thread to avoid this
-        let client = Arc::new(
-            tokio::task::block_in_place(move || {
-                reqwest::blocking::Client::builder()
-                    .timeout(timeout)
-                    .build()
-            })
-            .expect("build rpc client"),
-        );
+        let client = reqwest::blocking::Client::builder()
+            .timeout(timeout)
+            .build()
+            .expect("build rpc client");
 
-        Self {
-            client,
-            url,
-            request_id: AtomicU64::new(0),
-        }
+        Self { client, url }
     }
 }
 
@@ -62,57 +38,39 @@ struct RpcErrorObject {
 
 impl RpcSender for HttpSender {
     fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value> {
-        let request_id = self.request_id.fetch_add(1, Ordering::Relaxed);
-        let request_json = request.build_request_json(request_id, params).to_string();
+        // Concurrent requests are not supported so reuse the same request id for all requests
+        let request_id = 1;
+
+        let request_json = request.build_request_json(request_id, params);
 
         let mut too_many_requests_retries = 5;
         loop {
-            // `reqwest::blocking::Client` panics if run in a tokio async context.  Shuttle the
-            // request to a different tokio thread to avoid this
-            let response = {
-                let client = self.client.clone();
-                let request_json = request_json.clone();
-                tokio::task::block_in_place(move || {
-                    client
-                        .post(&self.url)
-                        .header(CONTENT_TYPE, "application/json")
-                        .body(request_json)
-                        .send()
-                })
-            };
-
-            match response {
+            match self
+                .client
+                .post(&self.url)
+                .header(CONTENT_TYPE, "application/json")
+                .body(request_json.to_string())
+                .send()
+            {
                 Ok(response) => {
                     if !response.status().is_success() {
                         if response.status() == StatusCode::TOO_MANY_REQUESTS
                             && too_many_requests_retries > 0
                         {
-                            let mut duration = Duration::from_millis(500);
-                            if let Some(retry_after) = response.headers().get(RETRY_AFTER) {
-                                if let Ok(retry_after) = retry_after.to_str() {
-                                    if let Ok(retry_after) = retry_after.parse::<u64>() {
-                                        if retry_after < 120 {
-                                            duration = Duration::from_secs(retry_after);
-                                        }
-                                    }
-                                }
-                            }
-
                             too_many_requests_retries -= 1;
                             debug!(
-                                "Too many requests: server responded with {:?}, {} retries left, pausing for {:?}",
-                                response, too_many_requests_retries, duration
+                                "Server responded with {:?}, {} retries left",
+                                response, too_many_requests_retries
                             );
 
-                            sleep(duration);
+                            // Sleep for 500ms to give the server a break
+                            sleep(Duration::from_millis(500));
                             continue;
                         }
                         return Err(response.error_for_status().unwrap_err().into());
                     }
 
-                    let response_text = tokio::task::block_in_place(move || response.text())?;
-
-                    let json: serde_json::Value = serde_json::from_str(&response_text)?;
+                    let json: serde_json::Value = serde_json::from_str(&response.text()?)?;
                     if json["error"].is_object() {
                         return match serde_json::from_value::<RpcErrorObject>(json["error"].clone())
                         {
@@ -162,22 +120,3 @@ impl RpcSender for HttpSender {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn http_sender_on_tokio_multi_thread() {
-        let http_sender = HttpSender::new("http://localhost:1234".to_string());
-        let _ = http_sender.send(RpcRequest::GetVersion, serde_json::Value::Null);
-    }
-
-    #[tokio::test(flavor = "current_thread")]
-    #[should_panic(expected = "can call blocking only when running on the multi-threaded runtime")]
-    async fn http_sender_ontokio_current_thread_should_panic() {
-        // RpcClient::new() will panic in the tokio current-thread runtime due to `tokio::task::block_in_place()` usage, and there
-        // doesn't seem to be a way to detect whether the tokio runtime is multi_thread or current_thread...
-        let _ = HttpSender::new("http://localhost:1234".to_string());
-    }
-}

client/src/lib.rs

@@ -13,10 +13,8 @@ pub mod rpc_cache;
 pub mod rpc_client;
 pub mod rpc_config;
 pub mod rpc_custom_error;
-pub mod rpc_deprecated_config;
 pub mod rpc_filter;
 pub mod rpc_request;
 pub mod rpc_response;
 pub mod rpc_sender;
 pub mod thin_client;
-pub mod tpu_client;

client/src/mock_sender.rs

@@ -1,22 +1,20 @@
-use {
-    crate::{
-        client_error::Result,
-        rpc_request::RpcRequest,
-        rpc_response::{Response, RpcResponseContext, RpcVersionInfo},
-        rpc_sender::RpcSender,
-    },
-    serde_json::{json, Number, Value},
-    solana_sdk::{
-        epoch_info::EpochInfo,
-        fee_calculator::{FeeCalculator, FeeRateGovernor},
-        instruction::InstructionError,
-        signature::Signature,
-        transaction::{self, Transaction, TransactionError},
-    },
-    solana_transaction_status::{TransactionConfirmationStatus, TransactionStatus},
-    solana_version::Version,
-    std::{collections::HashMap, sync::RwLock},
+use crate::{
+    client_error::Result,
+    rpc_request::RpcRequest,
+    rpc_response::{Response, RpcResponseContext, RpcVersionInfo},
+    rpc_sender::RpcSender,
 };
+use serde_json::{json, Number, Value};
+use solana_sdk::{
+    epoch_info::EpochInfo,
+    fee_calculator::{FeeCalculator, FeeRateGovernor},
+    instruction::InstructionError,
+    signature::Signature,
+    transaction::{self, Transaction, TransactionError},
+};
+use solana_transaction_status::{TransactionConfirmationStatus, TransactionStatus};
+use solana_version::Version;
+use std::{collections::HashMap, sync::RwLock};
 
 pub const PUBKEY: &str = "7RoSF9fUmdphVCpabEoefH81WwrW7orsWonXWqTXkKV8";
 pub const SIGNATURE: &str =
@@ -124,7 +122,6 @@ impl RpcSender for MockSender {
             }
             RpcRequest::GetTransactionCount => Value::Number(Number::from(1234)),
             RpcRequest::GetSlot => Value::Number(Number::from(0)),
-            RpcRequest::GetMaxShredInsertSlot => Value::Number(Number::from(0)),
             RpcRequest::RequestAirdrop => Value::String(Signature::new(&[8; 64]).to_string()),
             RpcRequest::SendTransaction => {
                 let signature = if self.url == "malicious" {

client/src/nonce_utils.rs

@@ -1,16 +1,14 @@
-use {
-    crate::rpc_client::RpcClient,
-    solana_sdk::{
-        account::{Account, ReadableAccount},
-        account_utils::StateMut,
-        commitment_config::CommitmentConfig,
-        nonce::{
-            state::{Data, Versions},
-            State,
-        },
-        pubkey::Pubkey,
-        system_program,
+use crate::rpc_client::RpcClient;
+use solana_sdk::{
+    account::Account,
+    account_utils::StateMut,
+    commitment_config::CommitmentConfig,
+    nonce::{
+        state::{Data, Versions},
+        State,
     },
+    pubkey::Pubkey,
+    system_program,
 };
 
 #[derive(Debug, thiserror::Error, PartialEq)]
@@ -51,28 +49,24 @@ pub fn get_account_with_commitment(
         .and_then(|a| account_identity_ok(&a).map(|()| a))
 }
 
-pub fn account_identity_ok<T: ReadableAccount>(account: &T) -> Result<(), Error> {
-    if account.owner() != &system_program::id() {
+pub fn account_identity_ok(account: &Account) -> Result<(), Error> {
+    if account.owner != system_program::id() {
         Err(Error::InvalidAccountOwner)
-    } else if account.data().is_empty() {
+    } else if account.data.is_empty() {
         Err(Error::UnexpectedDataSize)
     } else {
         Ok(())
     }
 }
 
-pub fn state_from_account<T: ReadableAccount + StateMut<Versions>>(
-    account: &T,
-) -> Result<State, Error> {
+pub fn state_from_account(account: &Account) -> Result<State, Error> {
     account_identity_ok(account)?;
     StateMut::<Versions>::state(account)
         .map_err(|_| Error::InvalidAccountData)
         .map(|v| v.convert_to_current())
 }
 
-pub fn data_from_account<T: ReadableAccount + StateMut<Versions>>(
-    account: &T,
-) -> Result<Data, Error> {
+pub fn data_from_account(account: &Account) -> Result<Data, Error> {
     account_identity_ok(account)?;
     state_from_account(account).and_then(|ref s| data_from_state(s).map(|d| d.clone()))
 }

client/src/perf_utils.rs

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

client/src/pubsub_client.rs

@@ -1,33 +1,27 @@
-use {
-    crate::{
-        rpc_config::{
-            RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
-        },
-        rpc_response::{
-            Response as RpcResponse, RpcLogsResponse, RpcSignatureResult, SlotInfo, SlotUpdate,
-        },
-    },
-    log::*,
-    serde::de::DeserializeOwned,
-    serde_json::{
-        json,
-        value::Value::{Number, Object},
-        Map, Value,
-    },
-    solana_sdk::signature::Signature,
-    std::{
-        marker::PhantomData,
-        sync::{
-            atomic::{AtomicBool, Ordering},
-            mpsc::{channel, Receiver},
-            Arc, RwLock,
-        },
-        thread::JoinHandle,
-    },
-    thiserror::Error,
-    tungstenite::{client::AutoStream, connect, Message, WebSocket},
-    url::{ParseError, Url},
+use crate::{
+    rpc_config::{RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter},
+    rpc_response::{Response as RpcResponse, RpcLogsResponse, RpcSignatureResult, SlotInfo},
 };
+use log::*;
+use serde::de::DeserializeOwned;
+use serde_json::{
+    json,
+    value::Value::{Number, Object},
+    Map, Value,
+};
+use solana_sdk::signature::Signature;
+use std::{
+    marker::PhantomData,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        mpsc::{channel, Receiver},
+        Arc, RwLock,
+    },
+    thread::JoinHandle,
+};
+use thiserror::Error;
+use tungstenite::{client::AutoStream, connect, Message, WebSocket};
+use url::{ParseError, Url};
 
 #[derive(Debug, Error)]
 pub enum PubsubClientError {
@@ -342,54 +336,6 @@ impl PubsubClient {
 
         Ok((result, receiver))
     }
-
-    pub fn slot_updates_subscribe(
-        url: &str,
-        handler: impl Fn(SlotUpdate) + Send + 'static,
-    ) -> Result<PubsubClientSubscription<SlotUpdate>, PubsubClientError> {
-        let url = Url::parse(url)?;
-        let (socket, _response) = connect(url)?;
-
-        let socket = Arc::new(RwLock::new(socket));
-        let exit = Arc::new(AtomicBool::new(false));
-        let exit_clone = exit.clone();
-        let subscription_id = PubsubClientSubscription::<SlotUpdate>::send_subscribe(
-            &socket,
-            json!({
-                "jsonrpc":"2.0","id":1,"method":"slotsUpdatesSubscribe","params":[]
-            })
-            .to_string(),
-        )?;
-
-        let t_cleanup = {
-            let socket = socket.clone();
-            std::thread::spawn(move || {
-                loop {
-                    if exit_clone.load(Ordering::Relaxed) {
-                        break;
-                    }
-                    match PubsubClientSubscription::read_message(&socket) {
-                        Ok(message) => handler(message),
-                        Err(err) => {
-                            info!("receive error: {:?}", err);
-                            break;
-                        }
-                    }
-                }
-
-                info!("websocket - exited receive loop");
-            })
-        };
-
-        Ok(PubsubClientSubscription {
-            message_type: PhantomData,
-            operation: "slotsUpdates",
-            socket,
-            subscription_id,
-            t_cleanup: Some(t_cleanup),
-            exit,
-        })
-    }
 }
 
 #[cfg(test)]

client/src/rpc_cache.rs

@@ -1,9 +1,7 @@
-use {
-    crate::{rpc_config::RpcLargestAccountsFilter, rpc_response::RpcAccountBalance},
-    std::{
-        collections::HashMap,
-        time::{Duration, SystemTime},
-    },
+use crate::{rpc_config::RpcLargestAccountsFilter, rpc_response::RpcAccountBalance};
+use std::{
+    collections::HashMap,
+    time::{Duration, SystemTime},
 };
 
 #[derive(Debug, Clone)]
@@ -31,7 +29,7 @@ impl LargestAccountsCache {
         &self,
         filter: &Option<RpcLargestAccountsFilter>,
     ) -> Option<(u64, Vec<RpcAccountBalance>)> {
-        self.cache.get(filter).and_then(|value| {
+        self.cache.get(&filter).and_then(|value| {
             if let Ok(elapsed) = value.cached_time.elapsed() {
                 if elapsed < Duration::from_secs(self.duration) {
                     return Some((value.slot, value.accounts.clone()));

client/src/rpc_config.rs

@@ -1,12 +1,10 @@
-use {
-    crate::rpc_filter::RpcFilterType,
-    solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig},
-    solana_sdk::{
-        clock::{Epoch, Slot},
-        commitment_config::{CommitmentConfig, CommitmentLevel},
-    },
-    solana_transaction_status::{TransactionDetails, UiTransactionEncoding},
+use crate::rpc_filter::RpcFilterType;
+use solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig};
+use solana_sdk::{
+    clock::{Epoch, Slot},
+    commitment_config::{CommitmentConfig, CommitmentLevel},
 };
+use solana_transaction_status::{TransactionDetails, UiTransactionEncoding};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -23,24 +21,14 @@ pub struct RpcSendTransactionConfig {
     pub encoding: Option<UiTransactionEncoding>,
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcSimulateTransactionAccountsConfig {
-    pub encoding: Option<UiAccountEncoding>,
-    pub addresses: Vec<String>,
-}
-
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcSimulateTransactionConfig {
     #[serde(default)]
     pub sig_verify: bool,
-    #[serde(default)]
-    pub replace_recent_blockhash: bool,
     #[serde(flatten)]
     pub commitment: Option<CommitmentConfig>,
     pub encoding: Option<UiTransactionEncoding>,
-    pub accounts: Option<RpcSimulateTransactionAccountsConfig>,
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
@@ -51,56 +39,6 @@ pub struct RpcRequestAirdropConfig {
     pub commitment: Option<CommitmentConfig>,
 }
 
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcLeaderScheduleConfig {
-    pub identity: Option<String>, // validator identity, as a base-58 encoded string
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcBlockProductionConfigRange {
-    pub first_slot: Slot,
-    pub last_slot: Option<Slot>,
-}
-
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcBlockProductionConfig {
-    pub identity: Option<String>, // validator identity, as a base-58 encoded string
-    pub range: Option<RpcBlockProductionConfigRange>, // current epoch if `None`
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcGetVoteAccountsConfig {
-    pub vote_pubkey: Option<String>, // validator vote address, as a base-58 encoded string
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-    pub keep_unstaked_delinquents: Option<bool>,
-    pub delinquent_slot_distance: Option<u64>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum RpcLeaderScheduleConfigWrapper {
-    SlotOnly(Option<Slot>),
-    ConfigOnly(Option<RpcLeaderScheduleConfig>),
-}
-
-impl RpcLeaderScheduleConfigWrapper {
-    pub fn unzip(&self) -> (Option<Slot>, Option<RpcLeaderScheduleConfig>) {
-        match &self {
-            RpcLeaderScheduleConfigWrapper::SlotOnly(slot) => (*slot, None),
-            RpcLeaderScheduleConfigWrapper::ConfigOnly(config) => (None, config.clone()),
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum RpcLargestAccountsFilter {
@@ -139,7 +77,6 @@ pub struct RpcProgramAccountsConfig {
     pub filters: Option<Vec<RpcFilterType>>,
     #[serde(flatten)]
     pub account_config: RpcAccountInfoConfig,
-    pub with_context: Option<bool>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -174,7 +111,7 @@ pub struct RpcSignatureSubscribeConfig {
 
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct RpcSignaturesForAddressConfig {
+pub struct RpcGetConfirmedSignaturesForAddress2Config {
     pub before: Option<String>, // Signature as base-58 string
     pub until: Option<String>,  // Signature as base-58 string
     pub limit: Option<usize>,
@@ -196,17 +133,6 @@ impl<T: EncodingConfig + Default + Copy> RpcEncodingConfigWrapper<T> {
             RpcEncodingConfigWrapper::Current(config) => config.unwrap_or_default(),
         }
     }
-
-    pub fn convert<U: EncodingConfig + From<T>>(&self) -> RpcEncodingConfigWrapper<U> {
-        match self {
-            RpcEncodingConfigWrapper::Deprecated(encoding) => {
-                RpcEncodingConfigWrapper::Deprecated(*encoding)
-            }
-            RpcEncodingConfigWrapper::Current(config) => {
-                RpcEncodingConfigWrapper::Current(config.map(|config| config.into()))
-            }
-        }
-    }
 }
 
 pub trait EncodingConfig {
@@ -215,7 +141,7 @@ pub trait EncodingConfig {
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct RpcBlockConfig {
+pub struct RpcConfirmedBlockConfig {
     pub encoding: Option<UiTransactionEncoding>,
     pub transaction_details: Option<TransactionDetails>,
     pub rewards: Option<bool>,
@@ -223,7 +149,7 @@ pub struct RpcBlockConfig {
     pub commitment: Option<CommitmentConfig>,
 }
 
-impl EncodingConfig for RpcBlockConfig {
+impl EncodingConfig for RpcConfirmedBlockConfig {
     fn new_with_encoding(encoding: &Option<UiTransactionEncoding>) -> Self {
         Self {
             encoding: *encoding,
@@ -232,7 +158,7 @@ impl EncodingConfig for RpcBlockConfig {
     }
 }
 
-impl RpcBlockConfig {
+impl RpcConfirmedBlockConfig {
     pub fn rewards_only() -> Self {
         Self {
             transaction_details: Some(TransactionDetails::None),
@@ -249,21 +175,21 @@ impl RpcBlockConfig {
     }
 }
 
-impl From<RpcBlockConfig> for RpcEncodingConfigWrapper<RpcBlockConfig> {
-    fn from(config: RpcBlockConfig) -> Self {
+impl From<RpcConfirmedBlockConfig> for RpcEncodingConfigWrapper<RpcConfirmedBlockConfig> {
+    fn from(config: RpcConfirmedBlockConfig) -> Self {
         RpcEncodingConfigWrapper::Current(Some(config))
     }
 }
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct RpcTransactionConfig {
+pub struct RpcConfirmedTransactionConfig {
     pub encoding: Option<UiTransactionEncoding>,
     #[serde(flatten)]
     pub commitment: Option<CommitmentConfig>,
 }
 
-impl EncodingConfig for RpcTransactionConfig {
+impl EncodingConfig for RpcConfirmedTransactionConfig {
     fn new_with_encoding(encoding: &Option<UiTransactionEncoding>) -> Self {
         Self {
             encoding: *encoding,
@@ -274,16 +200,16 @@ impl EncodingConfig for RpcTransactionConfig {
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(untagged)]
-pub enum RpcBlocksConfigWrapper {
+pub enum RpcConfirmedBlocksConfigWrapper {
     EndSlotOnly(Option<Slot>),
     CommitmentOnly(Option<CommitmentConfig>),
 }
 
-impl RpcBlocksConfigWrapper {
+impl RpcConfirmedBlocksConfigWrapper {
     pub fn unzip(&self) -> (Option<Slot>, Option<CommitmentConfig>) {
         match &self {
-            RpcBlocksConfigWrapper::EndSlotOnly(end_slot) => (*end_slot, None),
-            RpcBlocksConfigWrapper::CommitmentOnly(commitment) => (None, *commitment),
+            RpcConfirmedBlocksConfigWrapper::EndSlotOnly(end_slot) => (*end_slot, None),
+            RpcConfirmedBlocksConfigWrapper::CommitmentOnly(commitment) => (None, *commitment),
         }
     }
 }

client/src/rpc_custom_error.rs

@@ -1,10 +1,8 @@
 //! Implementation defined RPC server errors
-use thiserror::Error;
-use {
-    crate::rpc_response::RpcSimulateTransactionResult,
-    jsonrpc_core::{Error, ErrorCode},
-    solana_sdk::clock::Slot,
-};
+
+use crate::rpc_response::RpcSimulateTransactionResult;
+use jsonrpc_core::{Error, ErrorCode};
+use solana_sdk::clock::Slot;
 
 pub const JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: i64 = -32001;
 pub const JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: i64 = -32002;
@@ -15,45 +13,31 @@ pub const JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: i64
 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 const JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: i64 = -32010;
-pub const JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: i64 = -32011;
-pub const JSON_RPC_SCAN_ERROR: i64 = -32012;
-pub const JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: i64 = -32013;
 
-#[derive(Error, Debug)]
 pub enum RpcCustomError {
-    #[error("BlockCleanedUp")]
     BlockCleanedUp {
         slot: Slot,
         first_available_block: Slot,
     },
-    #[error("SendTransactionPreflightFailure")]
     SendTransactionPreflightFailure {
         message: String,
         result: RpcSimulateTransactionResult,
     },
-    #[error("TransactionSignatureVerificationFailure")]
     TransactionSignatureVerificationFailure,
-    #[error("BlockNotAvailable")]
-    BlockNotAvailable { slot: Slot },
-    #[error("NodeUnhealthy")]
-    NodeUnhealthy { num_slots_behind: Option<Slot> },
-    #[error("TransactionPrecompileVerificationFailure")]
+    BlockNotAvailable {
+        slot: Slot,
+    },
+    NodeUnhealthy {
+        num_slots_behind: Option<Slot>,
+    },
     TransactionPrecompileVerificationFailure(solana_sdk::transaction::TransactionError),
-    #[error("SlotSkipped")]
-    SlotSkipped { slot: Slot },
-    #[error("NoSnapshot")]
+    SlotSkipped {
+        slot: Slot,
+    },
     NoSnapshot,
-    #[error("LongTermStorageSlotSkipped")]
-    LongTermStorageSlotSkipped { slot: Slot },
-    #[error("KeyExcludedFromSecondaryIndex")]
-    KeyExcludedFromSecondaryIndex { index_key: String },
-    #[error("TransactionHistoryNotAvailable")]
-    TransactionHistoryNotAvailable,
-    #[error("ScanError")]
-    ScanError { message: String },
-    #[error("TransactionSignatureLenMismatch")]
-    TransactionSignatureLenMismatch,
+    LongTermStorageSlotSkipped {
+        slot: Slot,
+    },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -131,36 +115,6 @@ impl From<RpcCustomError> for Error {
                 message: format!("Slot {} was skipped, or missing in long-term storage", slot),
                 data: None,
             },
-            RpcCustomError::KeyExcludedFromSecondaryIndex { index_key } => Self {
-                code: ErrorCode::ServerError(
-                    JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX,
-                ),
-                message: format!(
-                    "{} excluded from account secondary indexes; \
-                    this RPC method unavailable for key",
-                    index_key
-                ),
-                data: None,
-            },
-            RpcCustomError::TransactionHistoryNotAvailable => Self {
-                code: ErrorCode::ServerError(
-                    JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE,
-                ),
-                message: "Transaction history is not available from this node".to_string(),
-                data: None,
-            },
-            RpcCustomError::ScanError { message } => Self {
-                code: ErrorCode::ServerError(JSON_RPC_SCAN_ERROR),
-                message,
-                data: None,
-            },
-            RpcCustomError::TransactionSignatureLenMismatch => Self {
-                code: ErrorCode::ServerError(
-                    JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH,
-                ),
-                message: "Transaction signature length mismatch".to_string(),
-                data: None,
-            },
         }
     }
 }