Remove old feature: cumulative_rent_related_fixes (bp #15754) (#15757)

* Remove old feature: cumulative_rent_related_fixes (#15754)

(cherry picked from commit 8b0c6db871)

# Conflicts:
#	runtime/src/accounts.rs
#	runtime/src/bank.rs
#	sdk/src/feature_set.rs

* Fix conflicts

* Remove stale comment

Co-authored-by: Ryo Onodera <ryoqun@gmail.com>

.buildkite/env/secrets.ejson

@@ -2,6 +2,6 @@
     "_public_key": "ae29f4f7ad2fc92de70d470e411c8426d5d48db8817c9e3dae574b122192335f",
     "_comment": "These credentials are encrypted and pose no risk",
     "environment": {
-      "CODECOV_TOKEN": "EJ[1:KToenD1Sr3w82lHGxz1n+j3hwNlLk/1pYrjZHlvY6kE=:hN1Q25omtJ+4yYVn+qzIsPLKT3O6J9XN:DMLNLXi/pkWgvwF6gNIcNF222sgsRR9LnwLZYj0P0wGj7q6w8YQnd1Rskj+sRroI/z5pQg==]"
+      "CODECOV_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:3K68mE38LJ2RB98VWmjuNLFBNn1XTGR4:cR4r05/TOZQKmEZp1v4CSgUJtC6QJiOaL85QjXW0qZ061fMnsBA8AtAPMDoDq4WCGOZM1A==]"
     }
 }

.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

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "accounts-cluster-bench",
     "bench-exchange",
     "bench-streamer",
     "bench-tps",
@@ -77,6 +76,3 @@ members = [
 exclude = [
     "programs/bpf",
 ]
-
-[profile.dev]
-split-debuginfo = "unpacked"

README.md

@@ -107,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

@@ -1,155 +0,0 @@
-# Security Policy
-
-1. [Reporting security problems](#reporting)
-4. [Security Bug Bounties](#bounty)
-2. [Incident Response Process](#process)
-
-<a name="reporting"></a>
-## Reporting security problems to Solana
-
-**DO NOT CREATE AN ISSUE** to report a security problem. Instead, please send an
-email to security@solana.com and provide your github username so we can add you
-to a new draft security advisory for further discussion.
-
-Expect a response as fast as possible, within one business day at the latest.
-
-<a name="bounty"></a>
-## Security Bug Bounties
-We offer bounties for critical security issues. Please see below for more details.
-
-Loss of Funds:
-$500,000 USD in locked SOL tokens (locked for 12 months)
-* Theft of funds without users signature from any account
-* Theft of funds without users interaction in system, token, stake, vote programs
-* Theft of funds that requires users signature - creating a vote program that drains the delegated stakes.
-
-Consensus/Safety Violations:
-$250,000 USD in locked SOL tokens (locked for 12 months)
-* Consensus safety violation
-* Tricking a validator to accept an optimistic confirmation or rooted slot without a double vote, etc..
-
-Other Attacks:
- $100,000 USD in locked SOL tokens (locked for 12 months)
-* Protocol liveness attacks,
-* Eclipse attacks,
-* Remote attacks that partition the network,
-
-DoS Attacks:
-$25,000 USD in locked SOL tokens (locked for 12 months)
-* Remote resource exaustion via Non-RPC protocols
-
-RPC DoS/Crashes:
-$5,000 USD in locked SOL tokens (locked for 12 months)
-* RPC attacks
-
-Out of Scope:
-The following components are out of scope for the bounty program
-* Metrics: `/metrics` in the monorepo as well as https://metrics.solana.com
-* Explorer: `/explorer` in the monorepo as well as https://explorer.solana.com
-* Any encrypted credentials, auth tokens, etc. checked into the repo
-* Bugs in dependencies. Please take them upstream!
-* Attacks that require social engineering
-
-Eligibility:
-* 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.
-
-Notes:
-* All locked tokens can be staked during the lockup period
-
-<a name="process"></a>
-## Incident Response Process
-
-In case an incident is discovered or reported, the following process will be
-followed to contain, respond and remediate:
-
-### 1. Establish a new draft security advisory
-In response to an email to security@solana.com, a member of the `solana-labs/admins` group will
-1. Create a new draft security advisory for the incident at https://github.com/solana-labs/solana/security/advisories
-1. Add the reporter's github user and the `solana-labs/security-incident-response` group to the draft security advisory
-1. Create a private fork of the repository (grey button towards the bottom of the page)
-1. Respond to the reporter by email, sharing a link to the draft security advisory
-
-### 2. Triage
-Within the draft security advisory, discuss and determine the severity of the
-issue. If necessary, members of the `solana-labs/security-incident-response`
-group may add other github users to the advisory to assist.
-
-If it is determined that this not a critical network issue then the advisory
-should be closed and if more follow-up is required a normal Solana public github
-issue should be created.
-
-### 3. Prepare Fixes
-For the affected branches, typically all three (edge, beta and stable), prepare
-a fix for the issue and push them to the corresponding branch in the private
-repository associated with the draft security advisory.
-
-There is no CI available in the private repository so you must build from source
-and manually verify fixes.
-
-Code review from the reporter is ideal, as well as from multiple members of the
-core development team.
-
-### 4. Notify Security Group Validators
-Once an ETA is available for the fix, a member of the
-`solana-labs/security-incident-response` group should notify the validators so
-they can prepare for an update using the "Solana Red Alert" notification system.
-
-The teams are all over the world and it's critical to provide actionable
-information at the right time. Don't be the person that wakes everybody up at
-2am when a fix won't be available for hours.
-
-### 5. Ship the patch
-Once the fix is accepted, a member of the
-`solana-labs/security-incident-response` group should prepare a single patch
-file for each affected branch. The commit title for the patch should only
-contain the advisory id, and not disclose any further details about the
-incident.
-
-Copy the patches to https://release.solana.com/ under a subdirectory named after
-the advisory id (example:
-https://release.solana.com/GHSA-hx59-f5g4-jghh/v1.4.patch). Contact a member of
-the `solana-labs/admins` group if you require access to release.solana.com
-
-Using the "Solana Red Alert" channel:
-1. Notify validators that there's an issue and a patch will be provided in X minutes
-2. If X minutes expires and there's no patch, notify of the delay and provide a
-   new ETA
-3. Provide links to patches of https://release.solana.com/ for each affected branch
-
-Validators can be expected to build the patch from source against the latest
-release for the affected branch.
-
-Since the software version will not change after the patch is applied, request
-that each validator notify in the existing channel once they've updated. Manually
-monitor the roll out until a sufficient amount of stake has updated - typically
-at least 33.3% or 66.6% depending on the issue.
-
-### 6. Public Disclosure and Release
-Once the fix has been deployed to the security group validators, the patches from the security
-advisory may be merged into the main source repository. A new official release
-for each affected branch should be shipped and all validators requested to
-upgrade as quickly as possible.
-
-### 7. Security Advisory Bounty Accounting and Cleanup
-
-If this issue is eligible for a bounty, prefix the title of the security
-advisory with one of the following, depending on the severity:
-* `[Bounty Category: Critical: Loss of Funds]`
-* `[Bounty Category: Critical: Loss of Availability]`
-* `[Bounty Category: Critical: DoS]`
-* `[Bounty Category: Critical: Other]`
-* `[Bounty Category: Non-critical]`
-* `[Bounty Category: RPC]`
-
-Confirm with the reporter that they agree with the severity assessment, and
-discuss as required to reach a conclusion.
-
-We currently do not use the Github workflow to publish security advisories.
-Once the issue and fix have been disclosed, and a bounty category is assessed if
-appropriate, the GitHub security advisory is no longer needed and can be closed.
-
-Bounties are currently awarded once a quarter (TODO: link to this process, or
-inline the workflow)

account-decoder/Cargo.toml

@@ -1,11 +1,10 @@
 [package]
 name = "solana-account-decoder"
-version = "1.6.7"
+version = "1.5.14"
 description = "Solana account decoder"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-account-decoder"
 license = "Apache-2.0"
 edition = "2018"
 
@@ -16,13 +15,13 @@ 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.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-stake-program = { path = "../programs/stake", version = "=1.6.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.6.7" }
+solana-config-program = { path = "../programs/config", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.14" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.14" }
 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,
@@ -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_config.rs

@@ -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() {
@@ -102,7 +101,7 @@ mod test {
         let stake_config_account = create_config_account(vec![], &stake_config, 10);
         assert_eq!(
             parse_config(
-                &stake_config_account.data(),
+                &stake_config_account.data,
                 &solana_stake_program::config::id()
             )
             .unwrap(),
@@ -125,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_nonce.rs

@@ -9,13 +9,7 @@ pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> {
         .map_err(|_| ParseAccountError::from(InstructionError::InvalidAccountData))?;
     let nonce_state = nonce_state.convert_to_current();
     match nonce_state {
-        // This prevents parsing an allocated System-owned account with empty data of any non-zero
-        // length as `uninitialized` nonce. An empty account of the wrong length can never be
-        // initialized as a nonce account, and an empty account of the correct length may not be an
-        // uninitialized nonce account, since it can be assigned to another program.
-        State::Uninitialized => Err(ParseAccountError::from(
-            InstructionError::InvalidAccountData,
-        )),
+        State::Uninitialized => Ok(UiNonceState::Uninitialized),
         State::Initialized(data) => Ok(UiNonceState::Initialized(UiNonceData {
             authority: data.authority.to_string(),
             blockhash: data.blockhash.to_string(),

account-decoder/src/parse_sysvar.rs

@@ -214,13 +214,13 @@ pub struct UiStakeHistoryEntry {
 mod test {
     use super::*;
     use solana_sdk::{
-        account::create_account_for_test, fee_calculator::FeeCalculator, hash::Hash,
+        account::create_account, fee_calculator::FeeCalculator, hash::Hash,
         sysvar::recent_blockhashes::IterItem,
     };
 
     #[test]
     fn test_parse_sysvars() {
-        let clock_sysvar = create_account_for_test(&Clock::default());
+        let clock_sysvar = create_account(&Clock::default(), 1);
         assert_eq!(
             parse_sysvar(&clock_sysvar.data, &sysvar::clock::id()).unwrap(),
             SysvarAccountType::Clock(UiClock::default()),
@@ -233,13 +233,13 @@ mod test {
             first_normal_epoch: 1,
             first_normal_slot: 12,
         };
-        let epoch_schedule_sysvar = create_account_for_test(&epoch_schedule);
+        let epoch_schedule_sysvar = create_account(&epoch_schedule, 1);
         assert_eq!(
             parse_sysvar(&epoch_schedule_sysvar.data, &sysvar::epoch_schedule::id()).unwrap(),
             SysvarAccountType::EpochSchedule(epoch_schedule),
         );
 
-        let fees_sysvar = create_account_for_test(&Fees::default());
+        let fees_sysvar = create_account(&Fees::default(), 1);
         assert_eq!(
             parse_sysvar(&fees_sysvar.data, &sysvar::fees::id()).unwrap(),
             SysvarAccountType::Fees(UiFees::default()),
@@ -252,7 +252,7 @@ mod test {
         let recent_blockhashes: RecentBlockhashes = vec![IterItem(0, &hash, &fee_calculator)]
             .into_iter()
             .collect();
-        let recent_blockhashes_sysvar = create_account_for_test(&recent_blockhashes);
+        let recent_blockhashes_sysvar = create_account(&recent_blockhashes, 1);
         assert_eq!(
             parse_sysvar(
                 &recent_blockhashes_sysvar.data,
@@ -270,13 +270,13 @@ mod test {
             exemption_threshold: 2.0,
             burn_percent: 5,
         };
-        let rent_sysvar = create_account_for_test(&rent);
+        let rent_sysvar = create_account(&rent, 1);
         assert_eq!(
             parse_sysvar(&rent_sysvar.data, &sysvar::rent::id()).unwrap(),
             SysvarAccountType::Rent(rent.into()),
         );
 
-        let rewards_sysvar = create_account_for_test(&Rewards::default());
+        let rewards_sysvar = create_account(&Rewards::default(), 1);
         assert_eq!(
             parse_sysvar(&rewards_sysvar.data, &sysvar::rewards::id()).unwrap(),
             SysvarAccountType::Rewards(UiRewards::default()),
@@ -284,7 +284,7 @@ mod test {
 
         let mut slot_hashes = SlotHashes::default();
         slot_hashes.add(1, hash);
-        let slot_hashes_sysvar = create_account_for_test(&slot_hashes);
+        let slot_hashes_sysvar = create_account(&slot_hashes, 1);
         assert_eq!(
             parse_sysvar(&slot_hashes_sysvar.data, &sysvar::slot_hashes::id()).unwrap(),
             SysvarAccountType::SlotHashes(vec![UiSlotHashEntry {
@@ -295,7 +295,7 @@ mod test {
 
         let mut slot_history = SlotHistory::default();
         slot_history.add(42);
-        let slot_history_sysvar = create_account_for_test(&slot_history);
+        let slot_history_sysvar = create_account(&slot_history, 1);
         assert_eq!(
             parse_sysvar(&slot_history_sysvar.data, &sysvar::slot_history::id()).unwrap(),
             SysvarAccountType::SlotHistory(UiSlotHistory {
@@ -311,7 +311,7 @@ mod test {
             deactivating: 3,
         };
         stake_history.add(1, stake_history_entry.clone());
-        let stake_history_sysvar = create_account_for_test(&stake_history);
+        let stake_history_sysvar = create_account(&stake_history, 1);
         assert_eq!(
             parse_sysvar(&stake_history_sysvar.data, &sysvar::stake_history::id()).unwrap(),
             SysvarAccountType::StakeHistory(vec![UiStakeHistoryEntry {

account-decoder/src/parse_token.rs

@@ -172,12 +172,10 @@ pub fn real_number_string(amount: u64, decimals: u8) -> StringDecimals {
 }
 
 pub fn real_number_string_trimmed(amount: u64, decimals: u8) -> StringDecimals {
-    let mut s = real_number_string(amount, decimals);
-    if decimals > 0 {
-        let zeros_trimmed = s.trim_end_matches('0');
-        s = zeros_trimmed.trim_end_matches('.').to_string();
-    }
-    s
+    let s = real_number_string(amount, decimals);
+    let zeros_trimmed = s.trim_end_matches('0');
+    let decimal_trimmed = zeros_trimmed.trim_end_matches('.');
+    decimal_trimmed.to_string()
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
@@ -365,14 +363,6 @@ mod test {
             real_number_string_trimmed(1, 0)
         );
         assert_eq!(token_amount.ui_amount, Some(1.0));
-        assert_eq!(&real_number_string(10, 0), "10");
-        assert_eq!(&real_number_string_trimmed(10, 0), "10");
-        let token_amount = token_amount_to_ui_amount(10, 0);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(10, 0)
-        );
-        assert_eq!(token_amount.ui_amount, Some(10.0));
         assert_eq!(&real_number_string(1, 9), "0.000000001");
         assert_eq!(&real_number_string_trimmed(1, 9), "0.000000001");
         let token_amount = token_amount_to_ui_amount(1, 9);
@@ -412,32 +402,4 @@ mod test {
         );
         assert_eq!(token_amount.ui_amount, None);
     }
-
-    #[test]
-    fn test_ui_token_amount_real_string_zero() {
-        assert_eq!(&real_number_string(0, 0), "0");
-        assert_eq!(&real_number_string_trimmed(0, 0), "0");
-        let token_amount = token_amount_to_ui_amount(0, 0);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(0, 0)
-        );
-        assert_eq!(token_amount.ui_amount, Some(0.0));
-        assert_eq!(&real_number_string(0, 9), "0.000000000");
-        assert_eq!(&real_number_string_trimmed(0, 9), "0");
-        let token_amount = token_amount_to_ui_amount(0, 9);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(0, 9)
-        );
-        assert_eq!(token_amount.ui_amount, Some(0.0));
-        assert_eq!(&real_number_string(0, 25), "0.0000000000000000000000000");
-        assert_eq!(&real_number_string_trimmed(0, 25), "0");
-        let token_amount = token_amount_to_ui_amount(0, 20);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(0, 20)
-        );
-        assert_eq!(token_amount.ui_amount, None);
-    }
 }

accounts-bench/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-accounts-bench"
-version = "1.6.7"
+version = "1.5.14"
 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.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-measure = { path = "../measure", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
+rayon = "1.4.0"
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-measure = { path = "../measure", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
 rand = "0.7.0"
 clap = "2.33.1"
 crossbeam-channel = "0.4"

accounts-bench/src/main.rs

@@ -103,7 +103,9 @@ fn main() {
         } else {
             let mut pubkeys: Vec<Pubkey> = vec![];
             let mut time = Measure::start("hash");
-            let results = accounts.accounts_db.update_accounts_hash(0, &ancestors);
+            let results = accounts
+                .accounts_db
+                .update_accounts_hash(0, &ancestors, true);
             time.stop();
             let mut time_store = Measure::start("hash using store");
             let results_store = accounts.accounts_db.update_accounts_hash_with_index_option(
@@ -111,6 +113,7 @@ fn main() {
                 false,
                 solana_sdk::clock::Slot::default(),
                 &ancestors,
+                true,
                 None,
             );
             time_store.stop();

accounts-cluster-bench/.gitignore

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

accounts-cluster-bench/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-accounts-cluster-bench"
-version = "1.6.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.6.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.7" }
-solana-client = { path = "../client", version = "=1.6.7" }
-solana-core = { path = "../core", version = "=1.6.7" }
-solana-measure = { path = "../measure", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana-faucet = { path = "../faucet", version = "=1.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.1.0", features = ["no-entrypoint"] }
-
-[dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "=1.6.7" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

accounts-cluster-bench/src/main.rs

@@ -1,742 +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_core::gossip_service::discover;
-use solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT};
-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: 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;
-                    }
-                }
-            }
-        }
-
-        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 > 0 {
-                let expected_closed = total_accounts_created as u64 / close_nth;
-                if expected_closed > total_accounts_closed {
-                    let txs: Vec<_> = (0..expected_closed - total_accounts_closed)
-                        .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")
-                .long("close-frequency")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help(
-                    "Send close transactions after this many accounts created. \
-                    Note: a `close-frequency` value near or below `batch-size` \
-                    may result in transaction-simulation errors, as 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 = value_t!(matches, "close_nth", 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,
-            Some(&entrypoint_addr),
-            None,
-            Some(60),
-            None,
-            Some(&entrypoint_addr),
-            None,
-            0,
-        )
-        .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,
-        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 = 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,
-            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.6.7"
+version = "1.5.14"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -13,17 +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.6.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.7" }
-solana-streamer = { path = "../streamer", version = "=1.6.7" }
-solana-perf = { path = "../perf", version = "=1.6.7" }
-solana-ledger = { path = "../ledger", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-measure = { path = "../measure", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
+rayon = "1.4.0"
+solana-core = { path = "../core", version = "1.5.14" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-streamer = { path = "../streamer", version = "1.5.14" }
+solana-perf = { path = "../perf", version = "1.5.14" }
+solana-ledger = { path = "../ledger", version = "1.5.14" }
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-measure = { path = "../measure", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

banks-client/Cargo.toml

@@ -1,12 +1,11 @@
 [package]
 name = "solana-banks-client"
-version = "1.6.7"
+version = "1.5.14"
 description = "Solana banks client"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-banks-client"
 edition = "2018"
 
 [dependencies]
@@ -15,16 +14,16 @@ borsh = "0.8.1"
 borsh-derive = "0.8.1"
 futures = "0.3"
 mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.6.7" }
-solana-program = { path = "../sdk/program", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.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.14" }
+solana-program = { path = "../sdk/program", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+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.6.7" }
-solana-banks-server = { path = "../banks-server", version = "=1.6.7" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-banks-server = { path = "../banks-server", version = "1.5.14" }
 
 [lib]
 crate-type = ["lib"]

banks-client/src/lib.rs

@@ -129,7 +129,7 @@ impl BanksClient {
         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(|| {
+            from_account::<Rent>(&rent_sysvar).ok_or_else(|| {
                 io::Error::new(io::ErrorKind::Other, "Failed to deserialize Rent sysvar")
             })
         })

banks-interface/Cargo.toml

@@ -1,22 +1,21 @@
 [package]
 name = "solana-banks-interface"
-version = "1.6.7"
+version = "1.5.14"
 description = "Solana banks RPC interface"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-banks-interface"
 edition = "2018"
 
 [dependencies]
 mio = "0.7.6"
-serde = { version = "1.0.122", features = ["derive"] }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-tarpc = { version = "0.24.1", features = ["full"] }
+serde = { version = "1.0.118", features = ["derive"] }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+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,12 +1,11 @@
 [package]
 name = "solana-banks-server"
-version = "1.6.7"
+version = "1.5.14"
 description = "Solana banks server"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-banks-server"
 edition = "2018"
 
 [dependencies]
@@ -14,14 +13,13 @@ bincode = "1.3.1"
 futures = "0.3"
 log = "0.4.11"
 mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-metrics = { path = "../metrics", version = "=1.6.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.14" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-metrics = { path = "../metrics", version = "1.5.14" }
+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

@@ -242,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! {

bench-exchange/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.6.7"
+version = "1.5.14"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -15,24 +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.6.7" }
-solana-core = { path = "../core", version = "=1.6.7" }
-solana-genesis = { path = "../genesis", version = "=1.6.7" }
-solana-client = { path = "../client", version = "=1.6.7" }
-solana-faucet = { path = "../faucet", version = "=1.6.7" }
-solana-exchange-program = { path = "../programs/exchange", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-metrics = { path = "../metrics", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-core = { path = "../core", version = "1.5.14" }
+solana-genesis = { path = "../genesis", version = "1.5.14" }
+solana-client = { path = "../client", version = "1.5.14" }
+solana-faucet = { path = "../faucet", version = "1.5.14" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.5.14" }
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-metrics = { path = "../metrics", version = "1.5.14" }
+solana-net-utils = { path = "../net-utils", version = "1.5.14" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
 
 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "=1.6.7" }
+solana-local-cluster = { path = "../local-cluster", version = "1.5.14" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-exchange/tests/bench_exchange.rs

@@ -1,23 +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},
-    validator::ValidatorConfig,
-};
-use solana_exchange_program::{
-    exchange_processor::process_instruction, id, solana_exchange_program,
-};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
+use solana_core::validator::ValidatorConfig;
+use solana_exchange_program::exchange_processor::process_instruction;
+use solana_exchange_program::id;
+use solana_exchange_program::solana_exchange_program;
 use solana_faucet::faucet::run_local_faucet_with_port;
-use solana_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]
@@ -48,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.6.7"
+version = "1.5.14"
 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.6.7" }
-solana-streamer = { path = "../streamer", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-streamer = { path = "../streamer", version = "1.5.14" }
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-net-utils = { path = "../net-utils", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-tps/Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.6.7"
+version = "1.5.14"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -12,25 +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.6.7" }
-solana-core = { path = "../core", version = "=1.6.7" }
-solana-genesis = { path = "../genesis", version = "=1.6.7" }
-solana-client = { path = "../client", version = "=1.6.7" }
-solana-faucet = { path = "../faucet", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-metrics = { path = "../metrics", version = "=1.6.7" }
-solana-measure = { path = "../measure", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-core = { path = "../core", version = "1.5.14" }
+solana-genesis = { path = "../genesis", version = "1.5.14" }
+solana-client = { path = "../client", version = "1.5.14" }
+solana-faucet = { path = "../faucet", version = "1.5.14" }
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-metrics = { path = "../metrics", version = "1.5.14" }
+solana-measure = { path = "../measure", version = "1.5.14" }
+solana-net-utils = { path = "../net-utils", version = "1.5.14" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
 
 [dev-dependencies]
 serial_test = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "=1.6.7" }
+serial_test_derive = "0.4.0"
+solana-local-cluster = { path = "../local-cluster", version = "1.5.14" }
 
 [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;
 

bench-tps/tests/bench_tps.rs

@@ -1,21 +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, validator::ValidatorConfig};
+use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
+use solana_core::validator::ValidatorConfig;
 use solana_faucet::faucet::run_local_faucet_with_port;
-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![];
@@ -25,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()
     });

cargo

@@ -3,22 +3,25 @@
 # shellcheck source=ci/rust-version.sh
 here=$(dirname "$0")
 
+source "${here}"/ci/rust-version.sh all
+
 toolchain=
 case "$1" in
   stable)
-    source "${here}"/ci/rust-version.sh stable
     # shellcheck disable=SC2054 # rust_stable is sourced from rust-version.sh
     toolchain="$rust_stable"
     shift
     ;;
   nightly)
-    source "${here}"/ci/rust-version.sh nightly
     # shellcheck disable=SC2054 # rust_nightly is sourced from rust-version.sh
     toolchain="$rust_nightly"
     shift
     ;;
+  +*)
+    toolchain="${1#+}"
+    shift
+    ;;
   *)
-    source "${here}"/ci/rust-version.sh stable
     # shellcheck disable=SC2054 # rust_stable is sourced from rust-version.sh
     toolchain="$rust_stable"
     ;;

ci/channel-info.sh

@@ -105,18 +105,11 @@ if [[ -z "$CHANNEL" ]]; then
   fi
 fi
 
-if [[ $CHANNEL = beta ]]; then
-  CHANNEL_LATEST_TAG="$BETA_CHANNEL_LATEST_TAG"
-elif [[ $CHANNEL = stable ]]; then
-  CHANNEL_LATEST_TAG="$STABLE_CHANNEL_LATEST_TAG"
-fi
-
 echo EDGE_CHANNEL="$EDGE_CHANNEL"
 echo BETA_CHANNEL="$BETA_CHANNEL"
 echo BETA_CHANNEL_LATEST_TAG="$BETA_CHANNEL_LATEST_TAG"
 echo STABLE_CHANNEL="$STABLE_CHANNEL"
 echo STABLE_CHANNEL_LATEST_TAG="$STABLE_CHANNEL_LATEST_TAG"
 echo CHANNEL="$CHANNEL"
-echo CHANNEL_LATEST_TAG="$CHANNEL_LATEST_TAG"
 
 exit 0

ci/do-audit.sh

@@ -7,6 +7,8 @@ src_root="$(readlink -f "${here}/..")"
 
 cd "${src_root}"
 
+source ci/rust-version.sh stable
+
 cargo_audit_ignores=(
   # failure is officially deprecated/unmaintained
   #
@@ -33,11 +35,13 @@ 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
 
 )
-scripts/cargo-for-all-lock-files.sh stable audit "${cargo_audit_ignores[@]}"
+scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit "${cargo_audit_ignores[@]}"

ci/docker-rust-nightly/Dockerfile

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

ci/localnet-sanity.sh

@@ -70,7 +70,7 @@ done
 
 source ci/upload-ci-artifact.sh
 source scripts/configure-metrics.sh
-source multinode-demo/common.sh --prebuild
+source multinode-demo/common.sh
 
 nodes=(
   "multinode-demo/bootstrap-validator.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"
 )
@@ -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/publish-tarball.sh

@@ -83,7 +83,7 @@ echo --- Creating release tarball
   export CHANNEL
 
   source ci/rust-version.sh stable
-  scripts/cargo-install-all.sh stable "${RELEASE_BASENAME}"
+  scripts/cargo-install-all.sh +"$rust_stable" "${RELEASE_BASENAME}"
 
   tar cvf "${TARBALL_BASENAME}"-$TARGET.tar "${RELEASE_BASENAME}"
   bzip2 "${TARBALL_BASENAME}"-$TARGET.tar

ci/run-sanity.sh

@@ -22,11 +22,10 @@ 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
 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.51.0
+  stable_version=1.49.0
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2021-04-18
+  nightly_version=2021-01-23
 fi
 
 

ci/test-checks.sh

@@ -45,7 +45,7 @@ export RUSTFLAGS="-D warnings -A incomplete_features"
 # Only force up-to-date lock files on edge
 if [[ $CI_BASE_BRANCH = "$EDGE_CHANNEL" ]]; then
   # Exclude --benches as it's not available in rust stable yet
-  if _ scripts/cargo-for-all-lock-files.sh stable check --locked --tests --bins --examples; then
+  if _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" check --locked --tests --bins --examples; then
     true
   else
     check_status=$?
@@ -56,7 +56,7 @@ if [[ $CI_BASE_BRANCH = "$EDGE_CHANNEL" ]]; then
   fi
 
   # Ensure nightly and --benches
-  _ scripts/cargo-for-all-lock-files.sh nightly check --locked --all-targets
+  _ scripts/cargo-for-all-lock-files.sh +"$rust_nightly" check --locked --all-targets
 else
   echo "Note: cargo-for-all-lock-files.sh skipped because $CI_BASE_BRANCH != $EDGE_CHANNEL"
 fi
@@ -79,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-sanity.sh

@@ -25,29 +25,4 @@ echo
 _ ci/nits.sh
 _ ci/check-ssh-keys.sh
 
-
-# Ensure the current channel version is not equal ("greater") than
-# the version of the latest tag
-if [[ -z $CI_TAG ]]; then
-  echo "--- channel version check"
-  (
-    eval "$(ci/channel-info.sh)"
-
-    if [[ -n $CHANNEL_LATEST_TAG ]]; then
-      source scripts/read-cargo-variable.sh
-
-      version=$(readCargoVariable version "version/Cargo.toml")
-      echo "version: v$version"
-      echo "latest channel tag: $CHANNEL_LATEST_TAG"
-
-      if [[ $CHANNEL_LATEST_TAG = v$version ]]; then
-        echo "Error: please run ./scripts/increment-cargo-version.sh"
-        exit 1
-      fi
-    else
-      echo "Skipped. CHANNEL_LATEST_TAG (CHANNEL=$CHANNEL) unset"
-    fi
-  )
-fi
-
 echo --- ok

ci/test-stable.sh

@@ -25,6 +25,9 @@ source scripts/ulimit-n.sh
 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)
@@ -43,11 +46,7 @@ test-stable-perf)
   # BPF solana-sdk legacy compile test
   ./cargo-build-bpf --manifest-path sdk/Cargo.toml
 
-  # BPF Program unit tests
-  "$cargo" stable 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 \

clap-utils/Cargo.toml

@@ -1,28 +1,23 @@
 [package]
 name = "solana-clap-utils"
-version = "1.6.7"
+version = "1.5.14"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-clap-utils"
 edition = "2018"
 
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
 thiserror = "1.0.21"
-tiny-bip39 = "0.8.0"
-uriparse = "0.6.3"
+tiny-bip39 = "0.7.0"
 url = "2.1.0"
 chrono = "0.4"
 
-[dev-dependencies]
-tempfile = "3.1.0"
-
 [lib]
 name = "solana_clap_utils"
 

clap-utils/src/fee_payer.rs

@@ -1,7 +1,5 @@
-use {
-    crate::{input_validators, ArgConstant},
-    clap::Arg,
-};
+use crate::{input_validators, ArgConstant};
+use clap::Arg;
 
 pub const FEE_PAYER_ARG: ArgConstant<'static> = ArgConstant {
     name: "fee_payer",

clap-utils/src/input_parsers.rs

@@ -1,21 +1,19 @@
-use {
-    crate::keypair::{
-        keypair_from_seed_phrase, pubkey_from_path, resolve_signer_from_path, signer_from_path,
-        ASK_KEYWORD, SKIP_SEED_PHRASE_VALIDATION_ARG,
-    },
-    chrono::DateTime,
-    clap::ArgMatches,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
-        clock::UnixTimestamp,
-        commitment_config::CommitmentConfig,
-        genesis_config::ClusterType,
-        native_token::sol_to_lamports,
-        pubkey::Pubkey,
-        signature::{read_keypair_file, Keypair, Signature, Signer},
-    },
-    std::{str::FromStr, sync::Arc},
+use crate::keypair::{
+    keypair_from_seed_phrase, pubkey_from_path, resolve_signer_from_path, signer_from_path,
+    ASK_KEYWORD, SKIP_SEED_PHRASE_VALIDATION_ARG,
 };
+use chrono::DateTime;
+use clap::ArgMatches;
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_sdk::{
+    clock::UnixTimestamp,
+    commitment_config::CommitmentConfig,
+    genesis_config::ClusterType,
+    native_token::sol_to_lamports,
+    pubkey::Pubkey,
+    signature::{read_keypair_file, Keypair, Signature, Signer},
+};
+use std::{str::FromStr, sync::Arc};
 
 // Return parsed values from matches at `name`
 pub fn values_of<T>(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<T>>
@@ -57,7 +55,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).ok()
+            keypair_from_seed_phrase(name, skip_validation, true).ok()
         } else {
             read_keypair_file(value).ok()
         }
@@ -72,7 +70,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).ok()
+                    keypair_from_seed_phrase(name, skip_validation, true).ok()
                 } else {
                     read_keypair_file(value).ok()
                 }

clap-utils/src/input_validators.rs

@@ -1,15 +1,13 @@
-use {
-    crate::keypair::{parse_signer_source, SignerSourceKind, ASK_KEYWORD},
-    chrono::DateTime,
-    solana_sdk::{
-        clock::{Epoch, Slot},
-        hash::Hash,
-        pubkey::{Pubkey, MAX_SEED_LEN},
-        signature::{read_keypair_file, Signature},
-    },
-    std::fmt::Display,
-    std::str::FromStr,
+use crate::keypair::{parse_keypair_path, KeypairUrl, ASK_KEYWORD};
+use chrono::DateTime;
+use solana_sdk::{
+    clock::{Epoch, Slot},
+    hash::Hash,
+    pubkey::{Pubkey, MAX_SEED_LEN},
+    signature::{read_keypair_file, Signature},
 };
+use std::fmt::Display;
+use std::str::FromStr;
 
 fn is_parsable_generic<U, T>(string: T) -> Result<(), String>
 where
@@ -34,29 +32,6 @@ where
     is_parsable_generic::<T, String>(string)
 }
 
-// Return an error if string cannot be parsed as numeric type T, and value not within specified
-// range
-pub fn is_within_range<T>(string: String, range_min: T, range_max: T) -> Result<(), String>
-where
-    T: FromStr + Copy + std::fmt::Debug + PartialOrd + std::ops::Add<Output = T> + From<usize>,
-    T::Err: Display,
-{
-    match string.parse::<T>() {
-        Ok(input) => {
-            let range = range_min..range_max + 1.into();
-            if !range.contains(&input) {
-                Err(format!(
-                    "input '{:?}' out of range ({:?}..{:?}]",
-                    input, range_min, range_max
-                ))
-            } else {
-                Ok(())
-            }
-        }
-        Err(err) => Err(format!("error parsing '{}': {}", string, err)),
-    }
-}
-
 // Return an error if a pubkey cannot be parsed.
 pub fn is_pubkey<T>(string: T) -> Result<(), String>
 where
@@ -110,11 +85,8 @@ pub fn is_valid_pubkey<T>(string: T) -> Result<(), String>
 where
     T: AsRef<str> + Display,
 {
-    match parse_signer_source(string.as_ref())
-        .map_err(|err| format!("{}", err))?
-        .kind
-    {
-        SignerSourceKind::Filepath(path) => is_keypair(path),
+    match parse_keypair_path(string.as_ref()) {
+        KeypairUrl::Filepath(path) => is_keypair(path),
         _ => Ok(()),
     }
 }

clap-utils/src/keypair.rs

@@ -1,41 +1,33 @@
-use {
-    crate::{
-        input_parsers::pubkeys_sigs_of,
-        offline::{SIGNER_ARG, SIGN_ONLY_ARG},
-        ArgConstant,
+use crate::{
+    input_parsers::pubkeys_sigs_of,
+    offline::{SIGNER_ARG, SIGN_ONLY_ARG},
+    ArgConstant,
+};
+use bip39::{Language, Mnemonic, Seed};
+use clap::ArgMatches;
+use rpassword::prompt_password_stderr;
+use solana_remote_wallet::{
+    remote_keypair::generate_remote_keypair,
+    remote_wallet::{maybe_wallet_manager, RemoteWalletError, RemoteWalletManager},
+};
+use solana_sdk::{
+    hash::Hash,
+    pubkey::Pubkey,
+    signature::{
+        keypair_from_seed, keypair_from_seed_phrase_and_passphrase, read_keypair,
+        read_keypair_file, Keypair, NullSigner, Presigner, Signature, Signer,
     },
-    bip39::{Language, Mnemonic, Seed},
-    clap::ArgMatches,
-    rpassword::prompt_password_stderr,
-    solana_remote_wallet::{
-        locator::{Locator as RemoteWalletLocator, LocatorError as RemoteWalletLocatorError},
-        remote_keypair::generate_remote_keypair,
-        remote_wallet::{maybe_wallet_manager, RemoteWalletError, RemoteWalletManager},
-    },
-    solana_sdk::{
-        derivation_path::{DerivationPath, DerivationPathError},
-        hash::Hash,
-        message::Message,
-        pubkey::Pubkey,
-        signature::{
-            generate_seed_from_seed_phrase_and_passphrase, keypair_from_seed_and_derivation_path,
-            read_keypair, read_keypair_file, Keypair, NullSigner, Presigner, Signature, Signer,
-        },
-    },
-    std::{
-        convert::TryFrom,
-        error,
-        io::{stdin, stdout, Write},
-        process::exit,
-        str::FromStr,
-        sync::Arc,
-    },
-    thiserror::Error,
+};
+use std::{
+    error,
+    io::{stdin, stdout, Write},
+    process::exit,
+    str::FromStr,
+    sync::Arc,
 };
 
 pub struct SignOnly {
     pub blockhash: Hash,
-    pub message: Option<String>,
     pub present_signers: Vec<(Pubkey, Signature)>,
     pub absent_signers: Vec<Pubkey>,
     pub bad_signers: Vec<Pubkey>,
@@ -75,18 +67,6 @@ impl CliSignerInfo {
             None
         }
     }
-    pub fn signers_for_message(&self, message: &Message) -> Vec<&dyn Signer> {
-        self.signers
-            .iter()
-            .filter_map(|k| {
-                if message.signer_keys().contains(&&k.pubkey()) {
-                    Some(k.as_ref())
-                } else {
-                    None
-                }
-            })
-            .collect()
-    }
 }
 
 pub struct DefaultSigner {
@@ -109,9 +89,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 {
@@ -126,90 +108,27 @@ impl DefaultSigner {
     ) -> Result<Box<dyn Signer>, Box<dyn std::error::Error>> {
         signer_from_path(matches, &self.path, &self.arg_name, wallet_manager)
     }
-
-    pub fn signer_from_path_with_config(
-        &self,
-        matches: &ArgMatches,
-        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)
-    }
 }
 
-pub(crate) struct SignerSource {
-    pub kind: SignerSourceKind,
-    pub derivation_path: Option<DerivationPath>,
-}
-
-impl SignerSource {
-    fn new(kind: SignerSourceKind) -> Self {
-        Self {
-            kind,
-            derivation_path: None,
-        }
-    }
-}
-
-pub(crate) enum SignerSourceKind {
+pub enum KeypairUrl {
     Ask,
     Filepath(String),
-    Usb(RemoteWalletLocator),
+    Usb(String),
     Stdin,
     Pubkey(Pubkey),
 }
 
-#[derive(Debug, Error)]
-pub(crate) enum SignerSourceError {
-    #[error("unrecognized signer source")]
-    UnrecognizedSource,
-    #[error(transparent)]
-    RemoteWalletLocatorError(#[from] RemoteWalletLocatorError),
-    #[error(transparent)]
-    DerivationPathError(#[from] DerivationPathError),
-    #[error(transparent)]
-    IoError(#[from] std::io::Error),
-}
-
-pub(crate) fn parse_signer_source<S: AsRef<str>>(
-    source: S,
-) -> Result<SignerSource, SignerSourceError> {
-    let source = source.as_ref();
-    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() {
-                    "ask" => Ok(SignerSource {
-                        kind: SignerSourceKind::Ask,
-                        derivation_path: DerivationPath::from_uri_any_query(&uri)?,
-                    }),
-                    "file" => Ok(SignerSource::new(SignerSourceKind::Filepath(
-                        uri.path().to_string(),
-                    ))),
-                    "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)?,
-                    }),
-                    _ => Err(SignerSourceError::UnrecognizedSource),
-                }
-            } else {
-                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)
-                            .map(|_| {
-                                SignerSource::new(SignerSourceKind::Filepath(source.to_string()))
-                            })
-                            .map_err(|err| err.into()),
-                    },
-                }
-            }
-        }
+pub fn parse_keypair_path(path: &str) -> KeypairUrl {
+    if path == "-" {
+        KeypairUrl::Stdin
+    } else if path == ASK_KEYWORD {
+        KeypairUrl::Ask
+    } else if path.starts_with("usb://") {
+        KeypairUrl::Usb(path.to_string())
+    } else if let Ok(pubkey) = Pubkey::from_str(path) {
+        KeypairUrl::Pubkey(pubkey)
+    } else {
+        KeypairUrl::Filepath(path.to_string())
     }
 }
 
@@ -226,51 +145,22 @@ pub fn presigner_from_pubkey_sigs(
     })
 }
 
-#[derive(Debug)]
-pub struct SignerFromPathConfig {
-    pub allow_null_signer: bool,
-}
-
-impl Default for SignerFromPathConfig {
-    fn default() -> Self {
-        Self {
-            allow_null_signer: false,
-        }
-    }
-}
-
 pub fn signer_from_path(
     matches: &ArgMatches,
     path: &str,
     keypair_name: &str,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<Box<dyn Signer>, Box<dyn error::Error>> {
-    let config = SignerFromPathConfig::default();
-    signer_from_path_with_config(matches, path, keypair_name, wallet_manager, &config)
-}
-
-pub fn signer_from_path_with_config(
-    matches: &ArgMatches,
-    path: &str,
-    keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-    config: &SignerFromPathConfig,
-) -> Result<Box<dyn Signer>, Box<dyn error::Error>> {
-    let SignerSource {
-        kind,
-        derivation_path,
-    } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Ask => {
+    match parse_keypair_path(path) {
+        KeypairUrl::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,
             )?))
         }
-        SignerSourceKind::Filepath(path) => match read_keypair_file(&path) {
+        KeypairUrl::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),
@@ -278,18 +168,17 @@ pub fn signer_from_path_with_config(
             .into()),
             Ok(file) => Ok(Box::new(file)),
         },
-        SignerSourceKind::Stdin => {
+        KeypairUrl::Stdin => {
             let mut stdin = std::io::stdin();
             Ok(Box::new(read_keypair(&mut stdin)?))
         }
-        SignerSourceKind::Usb(locator) => {
+        KeypairUrl::Usb(path) => {
             if wallet_manager.is_none() {
                 *wallet_manager = maybe_wallet_manager()?;
             }
             if let Some(wallet_manager) = wallet_manager {
                 Ok(Box::new(generate_remote_keypair(
-                    locator,
-                    derivation_path.unwrap_or_default(),
+                    path,
                     wallet_manager,
                     matches.is_present("confirm_key"),
                     keypair_name,
@@ -298,13 +187,13 @@ pub fn signer_from_path_with_config(
                 Err(RemoteWalletError::NoDeviceFound.into())
             }
         }
-        SignerSourceKind::Pubkey(pubkey) => {
+        KeypairUrl::Pubkey(pubkey) => {
             let presigner = pubkeys_sigs_of(matches, SIGNER_ARG.name)
                 .as_ref()
                 .and_then(|presigners| presigner_from_pubkey_sigs(&pubkey, presigners));
             if let Some(presigner) = presigner {
                 Ok(Box::new(presigner))
-            } else if config.allow_null_signer || matches.is_present(SIGN_ONLY_ARG.name) {
+            } else if matches.is_present(SIGN_ONLY_ARG.name) {
                 Ok(Box::new(NullSigner::new(&pubkey)))
             } else {
                 Err(std::io::Error::new(
@@ -323,9 +212,8 @@ pub fn pubkey_from_path(
     keypair_name: &str,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<Pubkey, Box<dyn error::Error>> {
-    let SignerSource { kind, .. } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Pubkey(pubkey) => Ok(pubkey),
+    match parse_keypair_path(path) {
+        KeypairUrl::Pubkey(pubkey) => Ok(pubkey),
         _ => Ok(signer_from_path(matches, path, keypair_name, wallet_manager)?.pubkey()),
     }
 }
@@ -336,18 +224,14 @@ pub fn resolve_signer_from_path(
     keypair_name: &str,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<Option<String>, Box<dyn error::Error>> {
-    let SignerSource {
-        kind,
-        derivation_path,
-    } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Ask => {
+    match parse_keypair_path(path) {
+        KeypairUrl::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).map(|_| None)
+            keypair_from_seed_phrase(keypair_name, skip_validation, false).map(|_| None)
         }
-        SignerSourceKind::Filepath(path) => match read_keypair_file(&path) {
+        KeypairUrl::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),
@@ -355,20 +239,19 @@ pub fn resolve_signer_from_path(
             .into()),
             Ok(_) => Ok(Some(path.to_string())),
         },
-        SignerSourceKind::Stdin => {
+        KeypairUrl::Stdin => {
             let mut stdin = std::io::stdin();
             // This method validates the keypair from stdin, but returns `None` because there is no
             // path on disk or to a device
             read_keypair(&mut stdin).map(|_| None)
         }
-        SignerSourceKind::Usb(locator) => {
+        KeypairUrl::Usb(path) => {
             if wallet_manager.is_none() {
                 *wallet_manager = maybe_wallet_manager()?;
             }
             if let Some(wallet_manager) = wallet_manager {
                 let path = generate_remote_keypair(
-                    locator,
-                    derivation_path.unwrap_or_default(),
+                    path,
                     wallet_manager,
                     matches.is_present("confirm_key"),
                     keypair_name,
@@ -411,7 +294,6 @@ pub fn keypair_from_seed_phrase(
     keypair_name: &str,
     skip_validation: bool,
     confirm_pubkey: bool,
-    derivation_path: Option<DerivationPath>,
 ) -> Result<Keypair, Box<dyn error::Error>> {
     let seed_phrase = prompt_password_stderr(&format!("[{}] seed phrase: ", keypair_name))?;
     let seed_phrase = seed_phrase.trim();
@@ -422,8 +304,7 @@ pub fn keypair_from_seed_phrase(
 
     let keypair = if skip_validation {
         let passphrase = prompt_passphrase(&passphrase_prompt)?;
-        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 = || {
@@ -446,7 +327,7 @@ pub fn keypair_from_seed_phrase(
         let mnemonic = parse_language_fn()?;
         let passphrase = prompt_passphrase(&passphrase_prompt)?;
         let seed = Seed::new(&mnemonic, &passphrase);
-        keypair_from_seed_and_derivation_path(&seed.as_bytes(), derivation_path)?
+        keypair_from_seed(seed.as_bytes())?
     };
 
     if confirm_pubkey {
@@ -474,9 +355,6 @@ fn sanitize_seed_phrase(seed_phrase: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use solana_remote_wallet::locator::Manufacturer;
-    use solana_sdk::system_instruction;
-    use tempfile::NamedTempFile;
 
     #[test]
     fn test_sanitize_seed_phrase() {
@@ -486,142 +364,4 @@ mod tests {
             sanitize_seed_phrase(seed_phrase)
         );
     }
-
-    #[test]
-    fn test_signer_info_signers_for_message() {
-        let source = Keypair::new();
-        let fee_payer = Keypair::new();
-        let nonsigner1 = Keypair::new();
-        let nonsigner2 = Keypair::new();
-        let recipient = Pubkey::new_unique();
-        let message = Message::new(
-            &[system_instruction::transfer(
-                &source.pubkey(),
-                &recipient,
-                42,
-            )],
-            Some(&fee_payer.pubkey()),
-        );
-        let signers = vec![
-            Box::new(fee_payer) as Box<dyn Signer>,
-            Box::new(source) as Box<dyn Signer>,
-            Box::new(nonsigner1) as Box<dyn Signer>,
-            Box::new(nonsigner2) as Box<dyn Signer>,
-        ];
-        let signer_info = CliSignerInfo { signers };
-        let msg_signers = signer_info.signers_for_message(&message);
-        let signer_pubkeys = msg_signers.iter().map(|s| s.pubkey()).collect::<Vec<_>>();
-        let expect = vec![
-            signer_info.signers[0].pubkey(),
-            signer_info.signers[1].pubkey(),
-        ];
-        assert_eq!(signer_pubkeys, expect);
-    }
-
-    #[test]
-    fn test_parse_signer_source() {
-        assert!(matches!(
-            parse_signer_source("-").unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Stdin,
-                derivation_path: None,
-            }
-        ));
-        let ask = "stdin:".to_string();
-        assert!(matches!(
-            parse_signer_source(&ask).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Stdin,
-                derivation_path: None,
-            }
-        ));
-        assert!(matches!(
-            parse_signer_source(ASK_KEYWORD).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Ask,
-                derivation_path: None,
-            }
-        ));
-        let pubkey = Pubkey::new_unique();
-        assert!(
-            matches!(parse_signer_source(&pubkey.to_string()).unwrap(), SignerSource {
-                kind: SignerSourceKind::Pubkey(p),
-                derivation_path: None,
-            }
-            if p == pubkey)
-        );
-
-        // Set up absolute and relative path strs
-        let file0 = NamedTempFile::new().unwrap();
-        let path = file0.path();
-        assert!(path.is_absolute());
-        let absolute_path_str = path.to_str().unwrap();
-
-        let file1 = NamedTempFile::new_in(std::env::current_dir().unwrap()).unwrap();
-        let path = file1.path().file_name().unwrap().to_str().unwrap();
-        let path = std::path::Path::new(path);
-        assert!(path.is_relative());
-        let relative_path_str = path.to_str().unwrap();
-
-        assert!(
-            matches!(parse_signer_source(absolute_path_str).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-            } if p == absolute_path_str)
-        );
-        assert!(
-            matches!(parse_signer_source(&relative_path_str).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-            } if p == relative_path_str)
-        );
-
-        let usb = "usb://ledger".to_string();
-        let expected_locator = RemoteWalletLocator {
-            manufacturer: Manufacturer::Ledger,
-            pubkey: None,
-        };
-        assert!(matches!(parse_signer_source(&usb).unwrap(), SignerSource {
-                kind: SignerSourceKind::Usb(u),
-                derivation_path: None,
-            } if u == expected_locator));
-        let usb = "usb://ledger?key=0/0".to_string();
-        let expected_locator = RemoteWalletLocator {
-            manufacturer: Manufacturer::Ledger,
-            pubkey: None,
-        };
-        let expected_derivation_path = Some(DerivationPath::new_bip44(Some(0), Some(0)));
-        assert!(matches!(parse_signer_source(&usb).unwrap(), SignerSource {
-                kind: SignerSourceKind::Usb(u),
-                derivation_path: d,
-            } if u == expected_locator && d == expected_derivation_path));
-        // Catchall into SignerSource::Filepath fails
-        let junk = "sometextthatisnotapubkeyorfile".to_string();
-        assert!(Pubkey::from_str(&junk).is_err());
-        assert!(matches!(
-            parse_signer_source(&junk),
-            Err(SignerSourceError::IoError(_))
-        ));
-
-        let ask = "ask:".to_string();
-        assert!(matches!(
-            parse_signer_source(&ask).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Ask,
-                derivation_path: None,
-            }
-        ));
-        assert!(
-            matches!(parse_signer_source(&format!("file:{}", absolute_path_str)).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-            } if p == absolute_path_str)
-        );
-        assert!(
-            matches!(parse_signer_source(&format!("file:{}", relative_path_str)).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-            } 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;

clap-utils/src/memo.rs

@@ -1,15 +0,0 @@
-use {crate::ArgConstant, clap::Arg};
-
-pub const MEMO_ARG: ArgConstant<'static> = ArgConstant {
-    name: "memo",
-    long: "--with-memo",
-    help: "Specify a memo string to include in the transaction.",
-};
-
-pub fn memo_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(MEMO_ARG.name)
-        .long(MEMO_ARG.long)
-        .takes_value(true)
-        .value_name("MEMO")
-        .help(MEMO_ARG.help)
-}

clap-utils/src/nonce.rs

@@ -1,7 +1,5 @@
-use {
-    crate::{input_validators::*, offline::BLOCKHASH_ARG, ArgConstant},
-    clap::{App, Arg},
-};
+use crate::{input_validators::*, offline::BLOCKHASH_ARG, ArgConstant};
+use clap::{App, Arg};
 
 pub const NONCE_ARG: ArgConstant<'static> = ArgConstant {
     name: "nonce",

clap-utils/src/offline.rs

@@ -1,7 +1,5 @@
-use {
-    crate::{input_validators::*, ArgConstant},
-    clap::{App, Arg},
-};
+use crate::{input_validators::*, ArgConstant};
+use clap::{App, Arg};
 
 pub const BLOCKHASH_ARG: ArgConstant<'static> = ArgConstant {
     name: "blockhash",
@@ -21,12 +19,6 @@ pub const SIGNER_ARG: ArgConstant<'static> = ArgConstant {
     help: "Provide a public-key/signature pair for the transaction",
 };
 
-pub const DUMP_TRANSACTION_MESSAGE: ArgConstant<'static> = ArgConstant {
-    name: "dump_transaction_message",
-    long: "dump-transaction-message",
-    help: "Display the base64 encoded binary transaction message in sign-only mode",
-};
-
 pub fn blockhash_arg<'a, 'b>() -> Arg<'a, 'b> {
     Arg::with_name(BLOCKHASH_ARG.name)
         .long(BLOCKHASH_ARG.long)
@@ -55,14 +47,6 @@ fn signer_arg<'a, 'b>() -> Arg<'a, 'b> {
         .help(SIGNER_ARG.help)
 }
 
-pub fn dump_transaction_message<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(DUMP_TRANSACTION_MESSAGE.name)
-        .long(DUMP_TRANSACTION_MESSAGE.long)
-        .takes_value(false)
-        .requires(SIGN_ONLY_ARG.name)
-        .help(DUMP_TRANSACTION_MESSAGE.help)
-}
-
 pub trait ArgsConfig {
     fn blockhash_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
         arg
@@ -73,9 +57,6 @@ pub trait ArgsConfig {
     fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
         arg
     }
-    fn dump_transaction_message_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg
-    }
 }
 
 pub trait OfflineArgs {
@@ -88,7 +69,6 @@ impl OfflineArgs for App<'_, '_> {
         self.arg(config.blockhash_arg(blockhash_arg()))
             .arg(config.sign_only_arg(sign_only_arg()))
             .arg(config.signer_arg(signer_arg()))
-            .arg(config.dump_transaction_message_arg(dump_transaction_message()))
     }
     fn offline_args(self) -> Self {
         struct NullArgsConfig {}

cli-config/Cargo.toml

@@ -3,16 +3,15 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-config"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.6.7"
+version = "1.5.14"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-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()
     }

cli-config/src/lib.rs

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

cli-output/Cargo.toml

@@ -3,30 +3,27 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-output"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.6.7"
+version = "1.5.14"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-cli-output"
 
 [dependencies]
-base64 = "0.13.0"
 chrono = { version = "0.4.11", features = ["serde"] }
 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.6.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.7" }
-solana-client = { path = "../client", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-stake-program = { path = "../programs/stake", version = "=1.6.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.6.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.6.7" }
-spl-memo = { version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "1.5.14" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-client = { path = "../client", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.14" }
+solana-transaction-status = { path = "../transaction-status", version = "1.5.14" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.14" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

cli-output/src/cli_output.rs

@@ -19,7 +19,7 @@ use {
         RpcVoteAccountInfo,
     },
     solana_sdk::{
-        clock::{Epoch, Slot, UnixTimestamp},
+        clock::{self, Epoch, Slot, UnixTimestamp},
         epoch_info::EpochInfo,
         hash::Hash,
         native_token::lamports_to_sol,
@@ -35,7 +35,7 @@ use {
     },
     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},
@@ -231,8 +231,12 @@ pub struct CliSlotStatus {
 pub struct CliEpochInfo {
     #[serde(flatten)]
     pub epoch_info: EpochInfo,
-    #[serde(skip)]
-    pub average_slot_time_ms: u64,
+}
+
+impl From<EpochInfo> for CliEpochInfo {
+    fn from(epoch_info: EpochInfo) -> Self {
+        Self { epoch_info }
+    }
 }
 
 impl QuietDisplay for CliEpochInfo {}
@@ -282,16 +286,19 @@ impl fmt::Display for CliEpochInfo {
             "Epoch Completed Time:",
             &format!(
                 "{}/{} ({} 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)
+                slot_to_human_time(self.epoch_info.slot_index),
+                slot_to_human_time(self.epoch_info.slots_in_epoch),
+                slot_to_human_time(remaining_slots_in_epoch)
             ),
         )
     }
 }
 
-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()
+fn slot_to_human_time(slot: Slot) -> String {
+    humantime::format_duration(Duration::from_secs(
+        slot * clock::DEFAULT_TICKS_PER_SLOT / clock::DEFAULT_TICKS_PER_SECOND,
+    ))
+    .to_string()
 }
 
 #[derive(Serialize, Deserialize, Default)]
@@ -303,32 +310,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>,
-    #[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,
@@ -344,40 +333,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!(
@@ -390,100 +369,39 @@ 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)?;
@@ -542,7 +460,7 @@ impl fmt::Display for CliValidators {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CliValidator {
     pub identity_pubkey: String,
@@ -550,12 +468,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 {
@@ -563,67 +478,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,
         }
     }
 }
@@ -735,76 +610,6 @@ pub struct CliEpochReward {
     pub apr: Option<f64>,
 }
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliKeyedEpochReward {
-    pub address: String,
-    pub reward: Option<CliEpochReward>,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliEpochRewardshMetadata {
-    pub epoch: Epoch,
-    pub effective_slot: Slot,
-    pub block_time: UnixTimestamp,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliKeyedEpochRewards {
-    #[serde(flatten, skip_serializing_if = "Option::is_none")]
-    pub epoch_metadata: Option<CliEpochRewardshMetadata>,
-    pub rewards: Vec<CliKeyedEpochReward>,
-}
-
-impl QuietDisplay for CliKeyedEpochRewards {}
-impl VerboseDisplay for CliKeyedEpochRewards {}
-
-impl fmt::Display for CliKeyedEpochRewards {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.rewards.is_empty() {
-            writeln!(f, "No rewards found in epoch")?;
-            return Ok(());
-        }
-
-        if let Some(metadata) = &self.epoch_metadata {
-            writeln!(f, "Epoch: {}", metadata.epoch)?;
-            writeln!(f, "Reward Slot: {}", metadata.effective_slot)?;
-            let timestamp = metadata.block_time;
-            writeln!(f, "Block Time: {}", unix_timestamp_to_string(timestamp))?;
-        }
-        writeln!(f, "Epoch Rewards:")?;
-        writeln!(
-            f,
-            "  {:<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.2}%  {}",
-                        keyed_reward.address,
-                        lamports_to_sol(reward.amount),
-                        lamports_to_sol(reward.post_balance),
-                        reward.percent_change,
-                        reward
-                            .apr
-                            .map(|apr| format!("{:>13.2}%", apr))
-                            .unwrap_or_default(),
-                    )?;
-                }
-                None => {
-                    writeln!(f, "  {:<44}  No rewards in epoch", keyed_reward.address,)?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
 fn show_votes_and_credits(
     f: &mut fmt::Formatter,
     votes: &[CliLockout],
@@ -814,55 +619,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: {}",
@@ -870,7 +637,7 @@ fn show_votes_and_credits(
         )?;
         writeln!(
             f,
-            "  credits range: ({}..{}]",
+            "  credits range: [{}..{})",
             entry.prev_credits, entry.credits
         )?;
         writeln!(
@@ -879,22 +646,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(())
 }
 
@@ -910,13 +661,13 @@ fn show_epoch_rewards(
         writeln!(f, "Epoch Rewards:")?;
         writeln!(
             f,
-            "  {:<6}  {:<11}  {:<18}  {:<18}  {:>14}  {:>14}",
+            "  {:<6}  {:<11}  {:<16}  {:<16}  {:>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.2}%  {}",
+                "  {:<6}  {:<11}  ◎{:<16.9}  ◎{:<14.9}  {:>13.2}%  {}",
                 reward.epoch,
                 reward.effective_slot,
                 lamports_to_sol(reward.amount),
@@ -1461,18 +1212,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!(
@@ -1480,10 +1231,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!(
@@ -1505,17 +1252,17 @@ 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.
         )?;
         writeln!(
             f,
-            "Foundation rate:         {:>5.2}%",
+            "Foundation APR:          {:>5.2}%",
             self.current_rate.foundation * 100.
         )
     }
@@ -1525,8 +1272,6 @@ impl fmt::Display for CliInflation {
 #[serde(rename_all = "camelCase")]
 pub struct CliSignOnlyData {
     pub blockhash: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub message: Option<String>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub signers: Vec<String>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
@@ -1542,9 +1287,6 @@ impl fmt::Display for CliSignOnlyData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(f)?;
         writeln_name_value(f, "Blockhash:", &self.blockhash)?;
-        if let Some(message) = self.message.as_ref() {
-            writeln_name_value(f, "Transaction Message:", message)?;
-        }
         if !self.signers.is_empty() {
             writeln!(f, "{}", style("Signers (Pubkey=Signature):").bold())?;
             for signer in self.signers.iter() {
@@ -1598,7 +1340,7 @@ impl fmt::Display for CliAccountBalances {
         writeln!(
             f,
             "{}",
-            style(format!("{:<44}  {}", "Address", "Balance")).bold()
+            style(format!("{:<44}  {}", "Address", "Balance",)).bold()
         )?;
         for account in &self.accounts {
             writeln!(
@@ -1890,9 +1632,6 @@ pub struct CliUpgradeableBuffer {
     pub address: String,
     pub authority: String,
     pub data_len: usize,
-    pub lamports: u64,
-    #[serde(skip_serializing)]
-    pub use_lamports_unit: bool,
 }
 impl QuietDisplay for CliUpgradeableBuffer {}
 impl VerboseDisplay for CliUpgradeableBuffer {}
@@ -1901,74 +1640,18 @@ impl fmt::Display for CliUpgradeableBuffer {
         writeln!(f)?;
         writeln_name_value(f, "Buffer Address:", &self.address)?;
         writeln_name_value(f, "Authority:", &self.authority)?;
-        writeln_name_value(
-            f,
-            "Balance:",
-            &build_balance_message(self.lamports, self.use_lamports_unit, true),
-        )?;
         writeln_name_value(
             f,
             "Data Length:",
             &format!("{:?} ({:#x?}) bytes", self.data_len, self.data_len),
         )?;
-
         Ok(())
     }
 }
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliUpgradeableBuffers {
-    pub buffers: Vec<CliUpgradeableBuffer>,
-    #[serde(skip_serializing)]
-    pub use_lamports_unit: bool,
-}
-impl QuietDisplay for CliUpgradeableBuffers {}
-impl VerboseDisplay for CliUpgradeableBuffers {}
-impl fmt::Display for CliUpgradeableBuffers {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln!(
-            f,
-            "{}",
-            style(format!(
-                "{:<44} | {:<44} | {}",
-                "Buffer Address", "Authority", "Balance"
-            ))
-            .bold()
-        )?;
-        for buffer in self.buffers.iter() {
-            writeln!(
-                f,
-                "{}",
-                &format!(
-                    "{:<44} | {:<44} | {}",
-                    buffer.address,
-                    buffer.authority,
-                    build_balance_message(buffer.lamports, self.use_lamports_unit, true)
-                )
-            )?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct ReturnSignersConfig {
-    pub dump_transaction_message: bool,
-}
-
 pub fn return_signers(
     tx: &Transaction,
     output_format: &OutputFormat,
-) -> Result<String, Box<dyn std::error::Error>> {
-    return_signers_with_config(tx, output_format, &ReturnSignersConfig::default())
-}
-
-pub fn return_signers_with_config(
-    tx: &Transaction,
-    output_format: &OutputFormat,
-    config: &ReturnSignersConfig,
 ) -> Result<String, Box<dyn std::error::Error>> {
     let verify_results = tx.verify_with_results();
     let mut signers = Vec::new();
@@ -1987,16 +1670,9 @@ pub fn return_signers_with_config(
                 bad_sig.push(key.to_string());
             }
         });
-    let message = if config.dump_transaction_message {
-        let message_data = tx.message_data();
-        Some(base64::encode(&message_data))
-    } else {
-        None
-    };
 
     let cli_command = CliSignOnlyData {
         blockhash: tx.message.recent_blockhash.to_string(),
-        message,
         signers,
         absent,
         bad_sig,
@@ -2051,14 +1727,8 @@ pub fn parse_sign_only_reply_string(reply: &str) -> SignOnly {
             .collect();
     }
 
-    let message = object
-        .get("message")
-        .and_then(|o| o.as_str())
-        .map(|m| m.to_string());
-
     SignOnly {
         blockhash,
-        message,
         present_signers,
         absent_signers,
         bad_signers,
@@ -2337,25 +2007,6 @@ mod tests {
         let res = return_signers(&tx, &OutputFormat::JsonCompact).unwrap();
         let sign_only = parse_sign_only_reply_string(&res);
         assert_eq!(sign_only.blockhash, blockhash);
-        assert_eq!(sign_only.message, None);
-        assert_eq!(sign_only.present_signers[0].0, present.pubkey());
-        assert_eq!(sign_only.absent_signers[0], absent.pubkey());
-        assert_eq!(sign_only.bad_signers[0], bad.pubkey());
-
-        let expected_msg = "AwECBwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDgTl3Dqh9\
-            F19Wo1Rmw0x+zMuNipG07jeiXfYPW4/Js5QEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE\
-            BAQEBAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBQUFBQUFBQUFBQUFBQUFBQUF\
-            BQUFBQUFBQUFBQUFBQUGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAAAAAAAAAAA\
-            AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH\
-            BwcCBgMDBQIEBAAAAAYCAQQMAgAAACoAAAAAAAAA"
-            .to_string();
-        let config = ReturnSignersConfig {
-            dump_transaction_message: true,
-        };
-        let res = return_signers_with_config(&tx, &OutputFormat::JsonCompact, &config).unwrap();
-        let sign_only = parse_sign_only_reply_string(&res);
-        assert_eq!(sign_only.blockhash, blockhash);
-        assert_eq!(sign_only.message, Some(expected_msg));
         assert_eq!(sign_only.present_signers[0].0, present.pubkey());
         assert_eq!(sign_only.absent_signers[0], absent.pubkey());
         assert_eq!(sign_only.bad_signers[0], bad.pubkey());

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, 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, /*demote_sysvar_write_locks=*/ true) {
-            "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() {
@@ -260,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 {

cli/Cargo.toml

@@ -3,11 +3,10 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.6.7"
+version = "1.5.14"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-cli"
 
 [dependencies]
 bincode = "1.3.1"
@@ -24,34 +23,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.6.7" }
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "=1.6.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.7" }
-solana-cli-config = { path = "../cli-config", version = "=1.6.7" }
-solana-cli-output = { path = "../cli-output", version = "=1.6.7" }
-solana-client = { path = "../client", version = "=1.6.7" }
-solana-config-program = { path = "../programs/config", version = "=1.6.7" }
-solana-faucet = { path = "../faucet", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana_rbpf = "=0.2.8"
-solana-remote-wallet = { path = "../remote-wallet", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-stake-program = { path = "../programs/stake", version = "=1.6.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.6.7" }
-spl-memo = { version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "1.5.14" }
+solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.5.14" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-cli-config = { path = "../cli-config", version = "1.5.14" }
+solana-cli-output = { path = "../cli-output", version = "1.5.14" }
+solana-client = { path = "../client", version = "1.5.14" }
+solana-config-program = { path = "../programs/config", version = "1.5.14" }
+solana-faucet = { path = "../faucet", version = "1.5.14" }
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-net-utils = { path = "../net-utils", version = "1.5.14" }
+solana_rbpf = "=0.2.5"
+solana-remote-wallet = { path = "../remote-wallet", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.14" }
+solana-transaction-status = { path = "../transaction-status", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.14" }
 thiserror = "1.0.21"
 tiny-bip39 = "0.7.0"
 url = "2.1.1"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "=1.6.7" }
+solana-core = { path = "../core", version = "1.5.14" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/cluster_query.rs

@@ -24,9 +24,8 @@ use solana_client::{
     pubsub_client::PubsubClient,
     rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient},
     rpc_config::{
-        RpcAccountInfoConfig, RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig,
-        RpcLargestAccountsConfig, RpcLargestAccountsFilter, RpcProgramAccountsConfig,
-        RpcTransactionLogsConfig, RpcTransactionLogsFilter,
+        RpcAccountInfoConfig, RpcLargestAccountsConfig, RpcLargestAccountsFilter,
+        RpcProgramAccountsConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
     },
     rpc_filter,
     rpc_response::SlotInfo,
@@ -41,28 +40,23 @@ use solana_sdk::{
     hash::Hash,
     message::Message,
     native_token::lamports_to_sol,
-    nonce::State as NonceState,
     pubkey::{self, Pubkey},
     rent::Rent,
     rpc_port::DEFAULT_RPC_PORT_STR,
     signature::Signature,
-    slot_history, system_instruction, system_program,
+    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},
         Arc,
@@ -70,7 +64,6 @@ use std::{
     thread::sleep,
     time::{Duration, Instant, SystemTime, UNIX_EPOCH},
 };
-use thiserror::Error;
 
 static CHECK_MARK: Emoji = Emoji("✅ ", "");
 static CROSS_MARK: Emoji = Emoji("❌ ", "");
@@ -350,38 +343,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)"),
                 ),
         )
         .subcommand(
@@ -435,14 +396,9 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                 .arg(
                     Arg::with_name("data_length")
                         .index(1)
-                        .value_name("DATA_LENGTH_OR_MONIKER")
+                        .value_name("DATA_LENGTH")
                         .required(true)
-                        .validator(|s| {
-                            RentLengthValue::from_str(&s)
-                                .map(|_| ())
-                                .map_err(|e| e.to_string())
-                        })
-                        .help("Length of data in the account to calculate rent for, or moniker: [nonce, stake, system, vote]"),
+                        .help("Length of data in the account to calculate rent for"),
                 )
                 .arg(
                     Arg::with_name("lamports")
@@ -615,29 +571,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 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,
-        },
+        command: CliCommand::ShowValidators { use_lamports_unit },
         signers: vec![],
     })
 }
@@ -806,10 +742,6 @@ pub fn process_catchup(
         }
     };
 
-    let start_node_slot = get_slot_while_retrying(&node_client)?;
-    let start_rpc_slot = get_slot_while_retrying(rpc_client)?;
-    let start_slot_distance = start_rpc_slot as i64 - start_node_slot as i64;
-    let mut total_sleep_interval = 0;
     loop {
         // humbly retry; the reference node (rpc_client) could be spotty,
         // especially if pointing to api.meinnet-beta.solana.com at times
@@ -826,37 +758,14 @@ pub fn process_catchup(
         let slot_distance = rpc_slot as i64 - node_slot as i64;
         let slots_per_second =
             (previous_slot_distance - slot_distance) as f64 / f64::from(sleep_interval);
-
-        let average_time_remaining = if slot_distance == 0 || total_sleep_interval == 0 {
+        let time_remaining = (slot_distance as f64 / slots_per_second).round();
+        let time_remaining = if !time_remaining.is_normal() || time_remaining <= 0.0 {
             "".to_string()
         } else {
-            let distance_delta = start_slot_distance as i64 - slot_distance as i64;
-            let average_catchup_slots_per_second =
-                distance_delta as f64 / f64::from(total_sleep_interval);
-            let average_time_remaining =
-                (slot_distance as f64 / average_catchup_slots_per_second).round();
-            if !average_time_remaining.is_normal() {
-                "".to_string()
-            } else if average_time_remaining < 0.0 {
-                format!(
-                    " (AVG: {:.1} slots/second (falling))",
-                    average_catchup_slots_per_second
-                )
-            } else {
-                // important not to miss next scheduled lead slots
-                let total_node_slot_delta = node_slot as i64 - start_node_slot as i64;
-                let average_node_slots_per_second =
-                    total_node_slot_delta as f64 / f64::from(total_sleep_interval);
-                let expected_finish_slot = (node_slot as f64
-                    + average_time_remaining as f64 * average_node_slots_per_second as f64)
-                    .round();
-                format!(
-                    " (AVG: {:.1} slots/second, ETA: slot {} in {})",
-                    average_catchup_slots_per_second,
-                    expected_finish_slot,
-                    humantime::format_duration(Duration::from_secs_f64(average_time_remaining))
-                )
-            }
+            format!(
+                ". Time remaining: {}",
+                humantime::format_duration(Duration::from_secs_f64(time_remaining))
+            )
         };
 
         progress_bar.set_message(&format!(
@@ -881,7 +790,7 @@ pub fn process_catchup(
                         "gaining"
                     },
                     slots_per_second,
-                    average_time_remaining
+                    time_remaining
                 )
             },
         ));
@@ -892,7 +801,6 @@ pub fn process_catchup(
         sleep(Duration::from_secs(sleep_interval as u64));
         previous_rpc_slot = rpc_slot;
         previous_slot_distance = slot_distance;
-        total_sleep_interval += sleep_interval;
     }
 }
 
@@ -1027,16 +935,8 @@ pub fn process_get_block(
         rpc_client.get_slot_with_commitment(CommitmentConfig::finalized())?
     };
 
-    let encoded_confirmed_block = rpc_client
-        .get_confirmed_block_with_config(
-            slot,
-            RpcConfirmedBlockConfig {
-                encoding: Some(UiTransactionEncoding::Base64),
-                commitment: Some(CommitmentConfig::confirmed()),
-                ..RpcConfirmedBlockConfig::default()
-            },
-        )?
-        .into();
+    let encoded_confirmed_block =
+        rpc_client.get_confirmed_block_with_encoding(slot, UiTransactionEncoding::Base64)?;
     let cli_block = CliBlock {
         encoded_confirmed_block,
         slot,
@@ -1065,21 +965,7 @@ pub fn process_get_epoch(rpc_client: &RpcClient, _config: &CliConfig) -> Process
 }
 
 pub fn process_get_epoch_info(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
-    let epoch_info = rpc_client.get_epoch_info()?;
-    let average_slot_time_ms = rpc_client
-        .get_recent_performance_samples(Some(60))
-        .ok()
-        .and_then(|samples| {
-            let (slots, secs) = samples.iter().fold((0, 0), |(slots, secs), sample| {
-                (slots + sample.num_slots, secs + sample.sample_period_secs)
-            });
-            (secs as u64).saturating_mul(1000).checked_div(slots)
-        })
-        .unwrap_or(clock::DEFAULT_MS_PER_SLOT);
-    let epoch_info = CliEpochInfo {
-        epoch_info,
-        average_slot_time_ms,
-    };
+    let epoch_info: CliEpochInfo = rpc_client.get_epoch_info()?.into();
     Ok(config.output_format.formatted_string(&epoch_info))
 }
 
@@ -1094,8 +980,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 epoch_info = rpc_client.get_epoch_info()?;
-    Ok(epoch_info.block_height.to_string())
+    let epoch_info: CliEpochInfo = rpc_client.get_epoch_info()?.into();
+    Ok(epoch_info.epoch_info.block_height.to_string())
 }
 
 pub fn parse_show_block_production(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
@@ -1122,6 +1008,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,
@@ -1134,60 +1022,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_confirmed_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;
@@ -1313,8 +1173,8 @@ pub fn process_supply(
 }
 
 pub fn process_total_supply(rpc_client: &RpcClient, _config: &CliConfig) -> ProcessResult {
-    let supply = rpc_client.supply()?.value;
-    Ok(format!("{} SOL", lamports_to_sol(supply.total)))
+    let total_supply = rpc_client.total_supply()?;
+    Ok(format!("{} SOL", lamports_to_sol(total_supply)))
 }
 
 pub fn process_get_transaction_count(rpc_client: &RpcClient, _config: &CliConfig) -> ProcessResult {
@@ -1450,7 +1310,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;
@@ -1698,6 +1560,7 @@ pub fn process_show_stakes(
     vote_account_pubkeys: Option<&[Pubkey]>,
 ) -> ProcessResult {
     use crate::stake::build_stake_state;
+    use solana_stake_program::stake_state::StakeState;
 
     let progress_bar = new_spinner_progress_bar();
     progress_bar.set_message("Fetching stake accounts...");
@@ -1809,36 +1672,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,
 ) -> 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()?;
 
-    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()? {
@@ -1850,8 +1687,6 @@ pub fn process_show_validators(
         );
     }
 
-    progress_bar.finish_and_clear();
-
     let total_active_stake = vote_accounts
         .current
         .iter()
@@ -1866,8 +1701,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(
@@ -1877,23 +1713,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,
             )
         })
@@ -1919,13 +1754,8 @@ pub fn process_show_validators(
         total_active_stake,
         total_current_stake,
         total_delinquent_stake,
-        validators: current_validators
-            .into_iter()
-            .chain(delinquent_validators.into_iter())
-            .collect(),
-        validators_sort_order,
-        validators_reverse_sort,
-        number_validators,
+        current_validators,
+        delinquent_validators,
         stake_by_version,
         use_lamports_unit,
     };
@@ -1947,7 +1777,6 @@ pub fn process_transaction_history(
             before,
             until,
             limit: Some(limit),
-            commitment: Some(CommitmentConfig::confirmed()),
         },
     )?;
 
@@ -1964,13 +1793,9 @@ pub fn process_transaction_history(
                     Some(block_time) =>
                         format!("timestamp={} ", unix_timestamp_to_string(block_time)),
                 },
-                if let Some(err) = result.err {
-                    format!("Failed: {:?}", err)
-                } else {
-                    match result.confirmation_status {
-                        None => "Finalized".to_string(),
-                        Some(status) => format!("{:?}", status),
-                    }
+                match result.err {
+                    None => "Confirmed".to_string(),
+                    Some(err) => format!("Failed: {:?}", err),
                 },
                 result.memo.unwrap_or_else(|| "".to_string()),
             );
@@ -1980,13 +1805,9 @@ pub fn process_transaction_history(
 
         if show_transactions {
             if let Ok(signature) = result.signature.parse::<Signature>() {
-                match rpc_client.get_confirmed_transaction_with_config(
-                    &signature,
-                    RpcConfirmedTransactionConfig {
-                        encoding: Some(UiTransactionEncoding::Base64),
-                        commitment: Some(CommitmentConfig::confirmed()),
-                    },
-                ) {
+                match rpc_client
+                    .get_confirmed_transaction(&signature, UiTransactionEncoding::Base64)
+                {
                     Ok(confirmed_transaction) => {
                         println_transaction(
                             &confirmed_transaction
@@ -2039,47 +1860,6 @@ impl fmt::Display for CliRentCalculation {
 impl QuietDisplay for CliRentCalculation {}
 impl VerboseDisplay for CliRentCalculation {}
 
-#[derive(Debug, PartialEq)]
-pub enum RentLengthValue {
-    Nonce,
-    Stake,
-    System,
-    Vote,
-    Bytes(usize),
-}
-
-impl RentLengthValue {
-    pub fn length(&self) -> usize {
-        match self {
-            Self::Nonce => NonceState::size(),
-            Self::Stake => std::mem::size_of::<StakeState>(),
-            Self::System => 0,
-            Self::Vote => VoteState::size_of(),
-            Self::Bytes(l) => *l,
-        }
-    }
-}
-
-#[derive(Debug, Error)]
-#[error("expected number or moniker, got \"{0}\"")]
-pub struct RentLengthValueError(pub String);
-
-impl FromStr for RentLengthValue {
-    type Err = RentLengthValueError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_ascii_lowercase();
-        match s.as_str() {
-            "nonce" => Ok(Self::Nonce),
-            "stake" => Ok(Self::Stake),
-            "system" => Ok(Self::System),
-            "vote" => Ok(Self::Vote),
-            _ => usize::from_str(&s)
-                .map(Self::Bytes)
-                .map_err(|_| RentLengthValueError(s)),
-        }
-    }
-}
-
 pub fn process_calculate_rent(
     rpc_client: &RpcClient,
     config: &CliConfig,

cli/src/inflation.rs

@@ -1,22 +1,14 @@
 use crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult};
-use clap::{App, Arg, ArgMatches, SubCommand};
-use solana_clap_utils::{
-    input_parsers::{pubkeys_of, value_of},
-    input_validators::is_valid_pubkey,
-    keypair::*,
-};
-use solana_cli_output::{
-    CliEpochRewardshMetadata, CliInflation, CliKeyedEpochReward, CliKeyedEpochRewards,
-};
+use clap::{App, ArgMatches, SubCommand};
+use solana_clap_utils::keypair::*;
+use solana_cli_output::CliInflation;
 use solana_client::rpc_client::RpcClient;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
-use solana_sdk::{clock::Epoch, pubkey::Pubkey};
 use std::sync::Arc;
 
 #[derive(Debug, PartialEq)]
 pub enum InflationCliCommand {
     Show,
-    Rewards(Vec<Pubkey>, Option<Epoch>),
 }
 
 pub trait InflationSubCommands {
@@ -25,47 +17,17 @@ pub trait InflationSubCommands {
 
 impl InflationSubCommands for App<'_, '_> {
     fn inflation_subcommands(self) -> Self {
-        self.subcommand(
-            SubCommand::with_name("inflation")
-                .about("Show inflation information")
-                .subcommand(
-                    SubCommand::with_name("rewards")
-                        .about("Show inflation rewards for a set of addresses")
-                        .arg(pubkey!(
-                            Arg::with_name("addresses")
-                                .value_name("ADDRESS")
-                                .index(1)
-                                .multiple(true)
-                                .required(true),
-                            "Address of account to query for rewards. "
-                        ))
-                        .arg(
-                            Arg::with_name("rewards_epoch")
-                                .long("rewards-epoch")
-                                .takes_value(true)
-                                .value_name("EPOCH")
-                                .help("Display rewards for specific epoch [default: latest epoch]"),
-                        ),
-                ),
-        )
+        self.subcommand(SubCommand::with_name("inflation").about("Show inflation information"))
     }
 }
 
 pub fn parse_inflation_subcommand(
-    matches: &ArgMatches<'_>,
+    _matches: &ArgMatches<'_>,
     _default_signer: &DefaultSigner,
     _wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
-    let command = match matches.subcommand() {
-        ("rewards", Some(matches)) => {
-            let addresses = pubkeys_of(matches, "addresses").unwrap();
-            let rewards_epoch = value_of(matches, "rewards_epoch");
-            InflationCliCommand::Rewards(addresses, rewards_epoch)
-        }
-        _ => InflationCliCommand::Show,
-    };
     Ok(CliCommandInfo {
-        command: CliCommand::Inflation(command),
+        command: CliCommand::Inflation(InflationCliCommand::Show),
         signers: vec![],
     })
 }
@@ -75,15 +37,8 @@ pub fn process_inflation_subcommand(
     config: &CliConfig,
     inflation_subcommand: &InflationCliCommand,
 ) -> ProcessResult {
-    match inflation_subcommand {
-        InflationCliCommand::Show => process_show(rpc_client, config),
-        InflationCliCommand::Rewards(ref addresses, rewards_epoch) => {
-            process_rewards(rpc_client, config, addresses, *rewards_epoch)
-        }
-    }
-}
+    assert_eq!(*inflation_subcommand, InflationCliCommand::Show);
 
-fn process_show(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
     let governor = rpc_client.get_inflation_governor()?;
     let current_rate = rpc_client.get_inflation_rate()?;
 
@@ -94,49 +49,3 @@ fn process_show(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
 
     Ok(config.output_format.formatted_string(&inflation))
 }
-
-fn process_rewards(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    addresses: &[Pubkey],
-    rewards_epoch: Option<Epoch>,
-) -> ProcessResult {
-    let rewards = rpc_client
-        .get_inflation_reward(&addresses, rewards_epoch)
-        .map_err(|err| {
-            if let Some(epoch) = rewards_epoch {
-                format!("Rewards not available for epoch {}", epoch)
-            } else {
-                format!("Rewards not available {}", err)
-            }
-        })?;
-    let epoch_schedule = rpc_client.get_epoch_schedule()?;
-
-    let mut epoch_rewards: Vec<CliKeyedEpochReward> = vec![];
-    let epoch_metadata = if let Some(Some(first_reward)) = rewards.iter().find(|&v| v.is_some()) {
-        let (epoch_start_time, epoch_end_time) =
-            crate::stake::get_epoch_boundary_timestamps(rpc_client, first_reward, &epoch_schedule)?;
-        for (reward, address) in rewards.iter().zip(addresses) {
-            let cli_reward = reward.as_ref().and_then(|reward| {
-                crate::stake::make_cli_reward(reward, epoch_start_time, epoch_end_time)
-            });
-            epoch_rewards.push(CliKeyedEpochReward {
-                address: address.to_string(),
-                reward: cli_reward,
-            });
-        }
-        let block_time = rpc_client.get_block_time(first_reward.effective_slot)?;
-        Some(CliEpochRewardshMetadata {
-            epoch: first_reward.epoch,
-            effective_slot: first_reward.effective_slot,
-            block_time,
-        })
-    } else {
-        None
-    };
-    let cli_rewards = CliKeyedEpochRewards {
-        epoch_metadata,
-        rewards: epoch_rewards,
-    };
-    Ok(config.output_format.formatted_string(&cli_rewards))
-}

cli/src/lib.rs

@@ -26,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/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

@@ -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::{App, Arg, ArgMatches, SubCommand};
@@ -12,7 +11,6 @@ use solana_clap_utils::{
     input_parsers::*,
     input_validators::*,
     keypair::{DefaultSigner, SignerIndex},
-    memo::MEMO_ARG,
     nonce::*,
 };
 use solana_cli_output::CliNonceAccount;
@@ -173,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)?;
 
@@ -188,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,
@@ -205,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(
@@ -219,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,
@@ -245,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)?;
 
@@ -260,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,
     })
@@ -292,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)?;
 
@@ -307,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,
         },
@@ -340,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)?;
 
@@ -373,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();
@@ -400,7 +383,6 @@ pub fn process_create_nonce_account(
                 &nonce_authority,
                 lamports,
             )
-            .with_memo(memo)
         } else {
             create_nonce_account(
                 &config.signers[0].pubkey(),
@@ -408,7 +390,6 @@ pub fn process_create_nonce_account(
                 &nonce_authority,
                 lamports,
             )
-            .with_memo(memo)
         };
         Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
@@ -470,7 +451,6 @@ 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()),
@@ -486,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(
@@ -541,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(
@@ -623,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()],
@@ -645,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![
@@ -669,7 +641,6 @@ mod tests {
                     nonce_account: 1,
                     seed: None,
                     nonce_authority: None,
-                    memo: None,
                     amount: SpendAmount::Some(50_000_000_000),
                 },
                 signers: vec![
@@ -695,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![
@@ -731,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()],
             }
@@ -752,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(),
@@ -797,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
                 },
@@ -826,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/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/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,8 +131,7 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("AUTHORIZED_PUBKEY")
                         .required(true),
                         "New authorized withdrawer. "),
-                )
-		.arg(memo_arg())
+                ),
         )
         .subcommand(
             SubCommand::with_name("vote-update-validator")
@@ -166,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")
@@ -196,7 +190,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer keypair"),
                 )
-		.arg(memo_arg())
         )
         .subcommand(
             SubCommand::with_name("vote-account")
@@ -214,22 +207,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .long("lamports")
                         .takes_value(false)
                         .help("Display balance in lamports instead of SOL"),
-                )
-                .arg(
-                    Arg::with_name("with_rewards")
-                        .long("with-rewards")
-                        .takes_value(false)
-                        .help("Display inflation rewards"),
-                )
-                .arg(
-                    Arg::with_name("num_rewards_epochs")
-                        .long("num-rewards-epochs")
-                        .takes_value(true)
-                        .value_name("NUM")
-                        .validator(|s| is_within_range(s, 1, 10))
-                        .default_value_if("with_rewards", None, "1")
-                        .requires("with_rewards")
-                        .help("Display rewards for NUM recent epochs, max 10 [default: latest epoch only]"),
                 ),
         )
         .subcommand(
@@ -266,7 +243,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer [default: cli config keypair]"),
                 )
-		.arg(memo_arg())
         )
     }
 }
@@ -283,7 +259,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(
@@ -300,7 +275,6 @@ pub fn parse_create_vote_account(
             authorized_voter,
             authorized_withdrawer,
             commission,
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -324,14 +298,12 @@ pub fn parse_vote_authorize(
         matches,
         wallet_manager,
     )?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
 
     Ok(CliCommandInfo {
         command: CliCommand::VoteAuthorize {
             vote_account_pubkey,
             new_authorized_pubkey,
             vote_authorize,
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -355,14 +327,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,
     })
@@ -385,14 +355,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,
     })
@@ -405,16 +373,10 @@ pub fn parse_vote_get_account_command(
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
     let use_lamports_unit = matches.is_present("lamports");
-    let with_rewards = if matches.is_present("with_rewards") {
-        Some(value_of(matches, "num_rewards_epochs").unwrap())
-    } else {
-        None
-    };
     Ok(CliCommandInfo {
         command: CliCommand::ShowVoteAccount {
             pubkey: vote_account_pubkey,
             use_lamports_unit,
-            with_rewards,
         },
         signers: vec![],
     })
@@ -440,7 +402,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 {
@@ -448,7 +409,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,
     })
@@ -463,7 +423,6 @@ 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();
@@ -506,7 +465,6 @@ pub fn process_create_vote_account(
                 &vote_init,
                 lamports,
             )
-            .with_memo(memo)
         } else {
             vote_instruction::create_account(
                 &config.signers[0].pubkey(),
@@ -514,7 +472,6 @@ pub fn process_create_vote_account(
                 &vote_init,
                 lamports,
             )
-            .with_memo(memo)
         };
         Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
@@ -558,7 +515,6 @@ pub fn process_vote_authorize(
     vote_account_pubkey: &Pubkey,
     new_authorized_pubkey: &Pubkey,
     vote_authorize: VoteAuthorize,
-    memo: Option<&String>,
 ) -> ProcessResult {
     // If the `authorized_account` is also the fee payer, `config.signers` will only have one
     // keypair in it
@@ -578,8 +534,7 @@ pub fn process_vote_authorize(
         &authorized.pubkey(),  // current authorized
         new_authorized_pubkey, // new vote signer/withdrawer
         vote_authorize,        // vote or withdraw
-    )]
-    .with_memo(memo);
+    )];
 
     let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
@@ -601,7 +556,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];
@@ -615,8 +569,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);
@@ -638,7 +591,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()?;
@@ -646,8 +598,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);
@@ -696,7 +647,6 @@ pub fn process_show_vote_account(
     config: &CliConfig,
     vote_account_address: &Pubkey,
     use_lamports_unit: bool,
-    with_rewards: Option<usize>,
 ) -> ProcessResult {
     let (vote_account, vote_state) =
         get_vote_account(rpc_client, vote_account_address, config.commitment)?;
@@ -722,16 +672,14 @@ pub fn process_show_vote_account(
         }
     }
 
-    let epoch_rewards =
-        with_rewards.and_then(|num_epochs| {
-            match crate::stake::fetch_epoch_rewards(rpc_client, vote_account_address, num_epochs) {
-                Ok(rewards) => Some(rewards),
-                Err(error) => {
-                    eprintln!("Failed to fetch epoch rewards: {:?}", error);
-                    None
-                }
-            }
-        });
+    let epoch_rewards = match crate::stake::fetch_epoch_rewards(rpc_client, vote_account_address, 1)
+    {
+        Ok(rewards) => Some(rewards),
+        Err(error) => {
+            eprintln!("Failed to fetch epoch rewards: {:?}", error);
+            None
+        }
+    };
 
     let vote_account_data = CliVoteAccount {
         account_balance: vote_account.lamports,
@@ -758,7 +706,6 @@ 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];
@@ -779,15 +726,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(
@@ -844,8 +790,7 @@ mod tests {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
                     new_authorized_pubkey: pubkey2,
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
+                    vote_authorize: VoteAuthorize::Voter
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -868,8 +813,7 @@ mod tests {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
                     new_authorized_pubkey: pubkey2,
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
+                    vote_authorize: VoteAuthorize::Voter
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -903,7 +847,6 @@ mod tests {
                     authorized_voter: None,
                     authorized_withdrawer: None,
                     commission: 10,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -933,7 +876,6 @@ mod tests {
                     authorized_voter: None,
                     authorized_withdrawer: None,
                     commission: 100,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -966,8 +908,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(),
@@ -998,8 +939,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(),
@@ -1023,7 +963,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(),
@@ -1047,7 +986,6 @@ mod tests {
                     vote_account_pubkey: pubkey,
                     commission: 42,
                     withdraw_authority: 1,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1072,7 +1010,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()],
             }
@@ -1094,7 +1031,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()],
             }
@@ -1121,7 +1057,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

@@ -22,38 +22,44 @@ use solana_sdk::{
 #[test]
 fn test_nonce() {
     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));
-
-    full_battery_tests(test_validator, None, false);
+    full_battery_tests(
+        TestValidator::with_no_fees(mint_keypair.pubkey()),
+        mint_keypair,
+        None,
+        false,
+    );
 }
 
 #[test]
 fn test_nonce_with_seed() {
     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));
-
-    full_battery_tests(test_validator, Some(String::from("seed")), false);
+    full_battery_tests(
+        TestValidator::with_no_fees(mint_keypair.pubkey()),
+        mint_keypair,
+        Some(String::from("seed")),
+        false,
+    );
 }
 
 #[test]
 fn test_nonce_with_authority() {
     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));
-
-    full_battery_tests(test_validator, None, true);
+    full_battery_tests(
+        TestValidator::with_no_fees(mint_keypair.pubkey()),
+        mint_keypair,
+        None,
+        true,
+    );
 }
 
 fn full_battery_tests(
     test_validator: TestValidator,
+    mint_keypair: Keypair,
     seed: Option<String>,
     use_nonce_authority: bool,
 ) {
+    let faucet_addr = run_local_faucet(mint_keypair, None);
+
     let rpc_client =
         RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
     let json_rpc_url = test_validator.rpc_url();
@@ -65,9 +71,10 @@ fn full_battery_tests(
 
     request_and_confirm_airdrop(
         &rpc_client,
-        &config_payer,
+        &faucet_addr,
         &config_payer.signers[0].pubkey(),
         2000,
+        &config_payer,
     )
     .unwrap();
     check_recent_balance(2000, &rpc_client, &config_payer.signers[0].pubkey());
@@ -101,7 +108,6 @@ fn full_battery_tests(
         nonce_account: 1,
         seed,
         nonce_authority: optional_authority,
-        memo: None,
         amount: SpendAmount::Some(1000),
     };
 
@@ -135,7 +141,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: index,
-        memo: None,
     };
     process_command(&config_payer).unwrap();
 
@@ -153,7 +158,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 +178,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 +186,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 +194,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: 1,
-        memo: None,
     };
     process_command(&config_payer).unwrap();
 
@@ -200,7 +201,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::WithdrawFromNonceAccount {
         nonce_account,
         nonce_authority: 1,
-        memo: None,
         destination_account_pubkey: payee_pubkey,
         lamports: 100,
     };
@@ -214,29 +214,32 @@ fn full_battery_tests(
 fn test_create_account_with_seed() {
     solana_logger::setup();
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
+
     let faucet_addr = run_local_faucet(mint_keypair, None);
-    let test_validator = TestValidator::with_custom_fees(mint_pubkey, 1, Some(faucet_addr));
 
     let offline_nonce_authority_signer = keypair_from_seed(&[1u8; 32]).unwrap();
     let online_nonce_creator_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     let to_address = Pubkey::new(&[3u8; 32]);
+    let config = CliConfig::recent_for_tests();
 
     // Setup accounts
     let rpc_client =
         RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
     request_and_confirm_airdrop(
         &rpc_client,
-        &CliConfig::recent_for_tests(),
+        &faucet_addr,
         &offline_nonce_authority_signer.pubkey(),
         42,
+        &config,
     )
     .unwrap();
     request_and_confirm_airdrop(
         &rpc_client,
-        &CliConfig::recent_for_tests(),
+        &faucet_addr,
         &online_nonce_creator_signer.pubkey(),
         4242,
+        &config,
     )
     .unwrap();
     check_recent_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
@@ -260,7 +263,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();
@@ -291,13 +293,10 @@ fn test_create_account_with_seed() {
         to: to_address,
         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,
@@ -317,8 +316,6 @@ fn test_create_account_with_seed() {
         to: to_address,
         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 +323,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

@@ -28,9 +28,8 @@ fn test_cli_program_deploy_non_upgradeable() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -47,6 +46,8 @@ fn test_cli_program_deploy_non_upgradeable() {
     config.json_rpc_url = test_validator.rpc_url();
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 4 * minimum_balance_for_rent_exemption, // min balance for rent exemption for three programs + leftover for tx processing
     };
@@ -58,7 +59,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
@@ -103,6 +103,8 @@ fn test_cli_program_deploy_non_upgradeable() {
     let custom_address_keypair = Keypair::new();
     config.signers = vec![&custom_address_keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 2 * minimum_balance_for_rent_exemption, // Anything over minimum_balance_for_rent_exemption should trigger err
     };
@@ -144,9 +146,8 @@ fn test_cli_program_deploy_no_authority() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -169,6 +170,8 @@ fn test_cli_program_deploy_no_authority() {
     let keypair = Keypair::new();
     config.json_rpc_url = test_validator.rpc_url();
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_programdata + minimum_balance_for_program,
     };
@@ -188,7 +191,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
@@ -227,9 +229,8 @@ fn test_cli_program_deploy_with_authority() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -253,6 +254,8 @@ fn test_cli_program_deploy_with_authority() {
     config.json_rpc_url = test_validator.rpc_url();
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_programdata + minimum_balance_for_program,
     };
@@ -437,9 +440,6 @@ fn test_cli_program_deploy_with_authority() {
     config.signers = vec![&keypair];
     config.command = CliCommand::Program(ProgramCliCommand::Show {
         account_pubkey: Some(program_pubkey),
-        authority_pubkey: keypair.pubkey(),
-        all: false,
-        use_lamports_unit: false,
     });
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -528,9 +528,6 @@ fn test_cli_program_deploy_with_authority() {
     config.signers = vec![&keypair];
     config.command = CliCommand::Program(ProgramCliCommand::Show {
         account_pubkey: Some(program_pubkey),
-        authority_pubkey: keypair.pubkey(),
-        all: false,
-        use_lamports_unit: false,
     });
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -555,9 +552,8 @@ fn test_cli_program_write_buffer() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -582,6 +578,8 @@ fn test_cli_program_write_buffer() {
     config.json_rpc_url = test_validator.rpc_url();
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_buffer,
     };
@@ -657,12 +655,9 @@ fn test_cli_program_write_buffer() {
     );
 
     // Get buffer authority
-    config.signers = vec![];
+    config.signers = vec![&keypair];
     config.command = CliCommand::Program(ProgramCliCommand::Show {
         account_pubkey: Some(buffer_keypair.pubkey()),
-        authority_pubkey: keypair.pubkey(),
-        all: false,
-        use_lamports_unit: false,
     });
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -750,12 +745,9 @@ fn test_cli_program_write_buffer() {
     );
 
     // Get buffer authority
-    config.signers = vec![];
+    config.signers = vec![&keypair];
     config.command = CliCommand::Program(ProgramCliCommand::Show {
         account_pubkey: Some(buffer_pubkey),
-        authority_pubkey: keypair.pubkey(),
-        all: false,
-        use_lamports_unit: false,
     });
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -770,60 +762,6 @@ fn test_cli_program_write_buffer() {
         authority_keypair.pubkey(),
         Pubkey::from_str(&authority_pubkey_str).unwrap()
     );
-
-    // Close buffer
-    let close_account = rpc_client.get_account(&buffer_pubkey).unwrap();
-    assert_eq!(minimum_balance_for_buffer, close_account.lamports);
-    let recipient_pubkey = Pubkey::new_unique();
-    config.signers = vec![&keypair, &authority_keypair];
-    config.command = CliCommand::Program(ProgramCliCommand::Close {
-        account_pubkey: Some(buffer_pubkey),
-        recipient_pubkey,
-        authority_index: 1,
-        use_lamports_unit: false,
-    });
-    process_command(&config).unwrap();
-    rpc_client.get_account(&buffer_pubkey).unwrap_err();
-    let recipient_account = rpc_client.get_account(&recipient_pubkey).unwrap();
-    assert_eq!(minimum_balance_for_buffer, recipient_account.lamports);
-
-    // Write a buffer with default params
-    config.signers = vec![&keypair];
-    config.command = CliCommand::Program(ProgramCliCommand::WriteBuffer {
-        program_location: pathbuf.to_str().unwrap().to_string(),
-        buffer_signer_index: None,
-        buffer_pubkey: None,
-        buffer_authority_signer_index: None,
-        max_len: None,
-    });
-    config.output_format = OutputFormat::JsonCompact;
-    let response = process_command(&config);
-    let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
-    let buffer_pubkey_str = json
-        .as_object()
-        .unwrap()
-        .get("buffer")
-        .unwrap()
-        .as_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;
-    config.signers = vec![&keypair];
-    config.command = CliCommand::Program(ProgramCliCommand::Close {
-        account_pubkey: Some(new_buffer_pubkey),
-        recipient_pubkey: keypair.pubkey(),
-        authority_index: 0,
-        use_lamports_unit: false,
-    });
-    process_command(&config).unwrap();
-    rpc_client.get_account(&new_buffer_pubkey).unwrap_err();
-    let recipient_account = rpc_client.get_account(&keypair.pubkey()).unwrap();
-    assert_eq!(
-        pre_lamports + minimum_balance_for_buffer,
-        recipient_account.lamports
-    );
 }
 
 #[test]
@@ -837,9 +775,8 @@ fn test_cli_program_set_buffer_authority() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -859,6 +796,8 @@ fn test_cli_program_set_buffer_authority() {
     config.json_rpc_url = test_validator.rpc_url();
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_buffer,
     };
@@ -890,7 +829,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
@@ -950,9 +888,8 @@ fn test_cli_program_mismatch_buffer_authority() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -972,6 +909,8 @@ fn test_cli_program_mismatch_buffer_authority() {
     config.json_rpc_url = test_validator.rpc_url();
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_buffer,
     };
@@ -1039,9 +978,8 @@ fn test_cli_program_show() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -1064,6 +1002,8 @@ fn test_cli_program_show() {
     // Airdrop
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_buffer,
     };
@@ -1086,9 +1026,6 @@ fn test_cli_program_show() {
     config.signers = vec![&keypair];
     config.command = CliCommand::Program(ProgramCliCommand::Show {
         account_pubkey: Some(buffer_keypair.pubkey()),
-        authority_pubkey: keypair.pubkey(),
-        all: false,
-        use_lamports_unit: false,
     });
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -1146,9 +1083,6 @@ fn test_cli_program_show() {
     config.signers = vec![&keypair];
     config.command = CliCommand::Program(ProgramCliCommand::Show {
         account_pubkey: Some(program_keypair.pubkey()),
-        authority_pubkey: keypair.pubkey(),
-        all: false,
-        use_lamports_unit: false,
     });
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -1219,9 +1153,8 @@ fn test_cli_program_dump() {
     pathbuf.set_extension("so");
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -1244,6 +1177,8 @@ fn test_cli_program_dump() {
     // Airdrop
     config.signers = vec![&keypair];
     config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 100 * minimum_balance_for_buffer,
     };

cli/tests/request_airdrop.rs

@@ -10,13 +10,15 @@ use solana_sdk::{
 #[test]
 fn test_cli_request_airdrop() {
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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 mut bob_config = CliConfig::recent_for_tests();
     bob_config.json_rpc_url = test_validator.rpc_url();
     bob_config.command = CliCommand::Airdrop {
+        faucet_host: None,
+        faucet_port: faucet_addr.port(),
         pubkey: None,
         lamports: 50,
     };

cli/tests/stake.rs

@@ -26,9 +26,8 @@ use solana_stake_program::{
 #[test]
 fn test_stake_delegation_force() {
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -38,8 +37,14 @@ fn test_stake_delegation_force() {
     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();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        100_000,
+        &config,
+    )
+    .unwrap();
 
     // Create vote account
     let vote_keypair = Keypair::new();
@@ -51,7 +56,6 @@ fn test_stake_delegation_force() {
         authorized_voter: None,
         authorized_withdrawer: None,
         commission: 0,
-        memo: None,
     };
     process_command(&config).unwrap();
 
@@ -66,11 +70,9 @@ fn test_stake_delegation_force() {
         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,
     };
@@ -84,11 +86,9 @@ fn test_stake_delegation_force() {
         stake_authority: 0,
         force: false,
         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();
@@ -100,11 +100,9 @@ fn test_stake_delegation_force() {
         stake_authority: 0,
         force: true,
         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();
@@ -115,9 +113,8 @@ fn test_seed_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -129,9 +126,10 @@ fn test_seed_stake_delegation_and_deactivation() {
 
     request_and_confirm_airdrop(
         &rpc_client,
-        &config_validator,
+        &faucet_addr,
         &config_validator.signers[0].pubkey(),
         100_000,
+        &config_validator,
     )
     .unwrap();
     check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
@@ -153,11 +151,9 @@ fn test_seed_stake_delegation_and_deactivation() {
         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,
     };
@@ -170,11 +166,9 @@ fn test_seed_stake_delegation_and_deactivation() {
         stake_authority: 0,
         force: true,
         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_validator).unwrap();
@@ -184,12 +178,9 @@ fn test_seed_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_address,
         stake_authority: 0,
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
@@ -200,9 +191,8 @@ fn test_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -216,9 +206,10 @@ fn test_stake_delegation_and_deactivation() {
 
     request_and_confirm_airdrop(
         &rpc_client,
-        &config_validator,
+        &faucet_addr,
         &config_validator.signers[0].pubkey(),
         100_000,
+        &config_validator,
     )
     .unwrap();
     check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
@@ -233,11 +224,9 @@ fn test_stake_delegation_and_deactivation() {
         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,
     };
@@ -251,11 +240,9 @@ fn test_stake_delegation_and_deactivation() {
         stake_authority: 0,
         force: true,
         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_validator).unwrap();
@@ -265,12 +252,9 @@ fn test_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         stake_authority: 0,
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config_validator).unwrap();
@@ -281,9 +265,8 @@ fn test_offline_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -308,18 +291,20 @@ fn test_offline_stake_delegation_and_deactivation() {
 
     request_and_confirm_airdrop(
         &rpc_client,
-        &config_validator,
+        &faucet_addr,
         &config_validator.signers[0].pubkey(),
         100_000,
+        &config_offline,
     )
     .unwrap();
     check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     request_and_confirm_airdrop(
         &rpc_client,
-        &config_offline,
+        &faucet_addr,
         &config_offline.signers[0].pubkey(),
         100_000,
+        &config_validator,
     )
     .unwrap();
     check_recent_balance(100_000, &rpc_client, &config_offline.signers[0].pubkey());
@@ -334,11 +319,9 @@ fn test_offline_stake_delegation_and_deactivation() {
         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,
     };
@@ -352,11 +335,9 @@ fn test_offline_stake_delegation_and_deactivation() {
         stake_authority: 0,
         force: true,
         sign_only: true,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     config_offline.output_format = OutputFormat::JsonCompact;
@@ -373,11 +354,9 @@ fn test_offline_stake_delegation_and_deactivation() {
         stake_authority: 0,
         force: true,
         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,
     };
     process_command(&config_payer).unwrap();
@@ -388,12 +367,9 @@ fn test_offline_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         stake_authority: 0,
         sign_only: true,
-        dump_transaction_message: false,
         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();
@@ -407,12 +383,9 @@ fn test_offline_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         stake_authority: 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,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config_payer).unwrap();
@@ -423,9 +396,8 @@ fn test_nonced_stake_delegation_and_deactivation() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -439,8 +411,14 @@ fn test_nonced_stake_delegation_and_deactivation() {
         .get_minimum_balance_for_rent_exemption(NonceState::size())
         .unwrap();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 100_000)
-        .unwrap();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        100_000,
+        &config,
+    )
+    .unwrap();
 
     // Create stake account
     let stake_keypair = Keypair::new();
@@ -453,11 +431,9 @@ fn test_nonced_stake_delegation_and_deactivation() {
         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,
     };
@@ -470,7 +446,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();
@@ -493,14 +468,12 @@ fn test_nonced_stake_delegation_and_deactivation() {
         stake_authority: 0,
         force: true,
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
             nonce_hash,
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -520,15 +493,12 @@ fn test_nonced_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         stake_authority: 0,
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
             nonce_hash,
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -539,9 +509,8 @@ fn test_stake_authorize() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -551,8 +520,14 @@ fn test_stake_authorize() {
     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();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        100_000,
+        &config,
+    )
+    .unwrap();
 
     let offline_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
     let mut config_offline = CliConfig::recent_for_tests();
@@ -565,9 +540,10 @@ fn test_stake_authorize() {
 
     request_and_confirm_airdrop(
         &rpc_client,
-        &config_offline,
+        &faucet_addr,
         &config_offline.signers[0].pubkey(),
         100_000,
+        &config,
     )
     .unwrap();
 
@@ -583,11 +559,9 @@ fn test_stake_authorize() {
         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,
     };
@@ -601,11 +575,9 @@ fn test_stake_authorize() {
         stake_account_pubkey,
         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,
     };
@@ -631,11 +603,9 @@ fn test_stake_authorize() {
             (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,
     };
@@ -656,11 +626,9 @@ fn test_stake_authorize() {
         stake_account_pubkey,
         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,
     };
@@ -681,11 +649,9 @@ fn test_stake_authorize() {
         stake_account_pubkey,
         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,
     };
@@ -699,11 +665,9 @@ fn test_stake_authorize() {
         stake_account_pubkey,
         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,
     };
@@ -726,7 +690,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();
@@ -749,11 +712,9 @@ fn test_stake_authorize() {
         stake_account_pubkey,
         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,
     };
@@ -768,14 +729,12 @@ fn test_stake_authorize() {
         stake_account_pubkey,
         new_authorizations: vec![(StakeAuthorize::Staker, online_authority_pubkey, 1)],
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
             sign_only.blockhash,
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         custodian: None,
     };
@@ -805,9 +764,8 @@ fn test_stake_authorize_with_fee_payer() {
     const SIG_FEE: u64 = 42;
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), SIG_FEE);
     let faucet_addr = run_local_faucet(mint_keypair, None);
-    let test_validator = TestValidator::with_custom_fees(mint_pubkey, SIG_FEE, Some(faucet_addr));
 
     let rpc_client =
         RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
@@ -833,13 +791,16 @@ fn test_stake_authorize_with_fee_payer() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &default_pubkey, 100_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &default_pubkey, 100_000, &config)
+        .unwrap();
     check_recent_balance(100_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_payer, &payer_pubkey, 100_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &payer_pubkey, 100_000, &config)
+        .unwrap();
     check_recent_balance(100_000, &rpc_client, &payer_pubkey);
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
+        .unwrap();
     check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     check_ready(&rpc_client);
@@ -856,11 +817,9 @@ fn test_stake_authorize_with_fee_payer() {
         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,
     };
@@ -874,11 +833,9 @@ fn test_stake_authorize_with_fee_payer() {
         stake_account_pubkey,
         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,
     };
@@ -895,11 +852,9 @@ fn test_stake_authorize_with_fee_payer() {
         stake_account_pubkey,
         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,
     };
@@ -913,11 +868,9 @@ fn test_stake_authorize_with_fee_payer() {
         stake_account_pubkey,
         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,
     };
@@ -934,9 +887,8 @@ fn test_stake_split() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
     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());
@@ -955,11 +907,18 @@ fn test_stake_split() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 500_000)
-        .unwrap();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        500_000,
+        &config,
+    )
+    .unwrap();
     check_recent_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
+        .unwrap();
     check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
@@ -977,11 +936,9 @@ fn test_stake_split() {
         lockup: Lockup::default(),
         amount: SpendAmount::Some(10 * minimum_stake_balance),
         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,
     };
@@ -1002,7 +959,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();
@@ -1026,11 +982,9 @@ fn test_stake_split() {
         stake_account_pubkey,
         stake_authority: 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,
         split_stake_account: 1,
         seed: None,
         lamports: 2 * minimum_stake_balance,
@@ -1046,14 +1000,12 @@ fn test_stake_split() {
         stake_account_pubkey,
         stake_authority: 0,
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
             sign_only.blockhash,
         ),
         nonce_account: Some(nonce_account.pubkey()),
         nonce_authority: 0,
-        memo: None,
         split_stake_account: 1,
         seed: None,
         lamports: 2 * minimum_stake_balance,
@@ -1077,9 +1029,8 @@ fn test_stake_set_lockup() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
     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());
@@ -1098,11 +1049,18 @@ fn test_stake_set_lockup() {
     config_offline.command = CliCommand::ClusterVersion;
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 500_000)
-        .unwrap();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        500_000,
+        &config,
+    )
+    .unwrap();
     check_recent_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
+        .unwrap();
     check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
@@ -1127,11 +1085,9 @@ fn test_stake_set_lockup() {
         lockup,
         amount: SpendAmount::Some(10 * minimum_stake_balance),
         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,
     };
@@ -1154,11 +1110,9 @@ fn test_stake_set_lockup() {
         lockup,
         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();
@@ -1189,11 +1143,9 @@ fn test_stake_set_lockup() {
         lockup,
         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();
@@ -1209,11 +1161,9 @@ fn test_stake_set_lockup() {
         lockup,
         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();
@@ -1241,11 +1191,9 @@ fn test_stake_set_lockup() {
         lockup,
         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();
@@ -1261,7 +1209,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();
@@ -1288,11 +1235,9 @@ fn test_stake_set_lockup() {
         lockup,
         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;
@@ -1306,14 +1251,12 @@ fn test_stake_set_lockup() {
         lockup,
         custodian: 0,
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account_pubkey),
             sign_only.blockhash,
         ),
         nonce_account: Some(nonce_account_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1336,9 +1279,8 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     solana_logger::setup();
 
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -1356,11 +1298,18 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     // Verify that we cannot reach the cluster
     process_command(&config_offline).unwrap_err();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &config.signers[0].pubkey(), 200_000)
-        .unwrap();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        200_000,
+        &config,
+    )
+    .unwrap();
     check_recent_balance(200_000, &rpc_client, &config.signers[0].pubkey());
 
-    request_and_confirm_airdrop(&rpc_client, &config_offline, &offline_pubkey, 100_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
+        .unwrap();
     check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create nonce account
@@ -1374,7 +1323,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();
@@ -1401,11 +1349,9 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: true,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1424,14 +1370,12 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_pubkey),
             sign_only.blockhash,
         ),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1455,16 +1399,13 @@ 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,
-        dump_transaction_message: false,
         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();
@@ -1474,19 +1415,16 @@ 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,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_pubkey),
             sign_only.blockhash,
         ),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
-        seed: None,
         fee_payer: 0,
     };
     process_command(&config).unwrap();
@@ -1513,11 +1451,9 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: true,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::None(nonce_hash),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };
@@ -1534,14 +1470,12 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         lockup: Lockup::default(),
         amount: SpendAmount::Some(50_000),
         sign_only: false,
-        dump_transaction_message: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_pubkey),
             sign_only.blockhash,
         ),
         nonce_account: Some(nonce_pubkey),
         nonce_authority: 0,
-        memo: None,
         fee_payer: 0,
         from: 0,
     };

cli/tests/transfer.rs

@@ -22,9 +22,8 @@ use solana_sdk::{
 fn test_transfer() {
     solana_logger::setup();
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
     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());
@@ -39,7 +38,8 @@ fn test_transfer() {
     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();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000, &config)
+        .unwrap();
     check_recent_balance(50_000, &rpc_client, &sender_pubkey);
     check_recent_balance(0, &rpc_client, &recipient_pubkey);
 
@@ -51,13 +51,10 @@ fn test_transfer() {
         to: recipient_pubkey,
         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,
@@ -72,13 +69,10 @@ fn test_transfer() {
         to: recipient_pubkey,
         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,
@@ -95,7 +89,7 @@ fn test_transfer() {
     process_command(&offline).unwrap_err();
 
     let offline_pubkey = offline.signers[0].pubkey();
-    request_and_confirm_airdrop(&rpc_client, &offline, &offline_pubkey, 50).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 50, &config).unwrap();
     check_recent_balance(50, &rpc_client, &offline_pubkey);
 
     // Offline transfer
@@ -105,13 +99,10 @@ fn test_transfer() {
         to: recipient_pubkey,
         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,
@@ -127,13 +118,10 @@ fn test_transfer() {
         to: recipient_pubkey,
         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,
@@ -152,7 +140,6 @@ fn test_transfer() {
         nonce_account: 1,
         seed: None,
         nonce_authority: None,
-        memo: None,
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
@@ -175,8 +162,6 @@ fn test_transfer() {
         to: recipient_pubkey,
         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()),
@@ -184,7 +169,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,
@@ -207,7 +191,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();
@@ -230,13 +213,10 @@ fn test_transfer() {
         to: recipient_pubkey,
         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,
@@ -251,8 +231,6 @@ fn test_transfer() {
         to: recipient_pubkey,
         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()),
@@ -260,7 +238,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,
@@ -274,30 +251,32 @@ fn test_transfer() {
 fn test_transfer_multisession_signing() {
     solana_logger::setup();
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
     let faucet_addr = run_local_faucet(mint_keypair, None);
-    let test_validator = TestValidator::with_custom_fees(mint_pubkey, 1, Some(faucet_addr));
 
     let to_pubkey = Pubkey::new(&[1u8; 32]);
     let offline_from_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     let offline_fee_payer_signer = keypair_from_seed(&[3u8; 32]).unwrap();
     let from_null_signer = NullSigner::new(&offline_from_signer.pubkey());
+    let config = CliConfig::recent_for_tests();
 
     // Setup accounts
     let rpc_client =
         RpcClient::new_with_commitment(test_validator.rpc_url(), CommitmentConfig::processed());
     request_and_confirm_airdrop(
         &rpc_client,
-        &CliConfig::recent_for_tests(),
+        &faucet_addr,
         &offline_from_signer.pubkey(),
         43,
+        &config,
     )
     .unwrap();
     request_and_confirm_airdrop(
         &rpc_client,
-        &CliConfig::recent_for_tests(),
+        &faucet_addr,
         &offline_fee_payer_signer.pubkey(),
         3,
+        &config,
     )
     .unwrap();
     check_recent_balance(43, &rpc_client, &offline_from_signer.pubkey());
@@ -320,13 +299,10 @@ fn test_transfer_multisession_signing() {
         to: to_pubkey,
         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,
@@ -351,13 +327,10 @@ fn test_transfer_multisession_signing() {
         to: to_pubkey,
         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,
@@ -379,13 +352,10 @@ fn test_transfer_multisession_signing() {
         to: to_pubkey,
         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,
@@ -401,9 +371,8 @@ fn test_transfer_multisession_signing() {
 fn test_transfer_all() {
     solana_logger::setup();
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
     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());
@@ -417,7 +386,8 @@ fn test_transfer_all() {
     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();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000, &config)
+        .unwrap();
     check_recent_balance(50_000, &rpc_client, &sender_pubkey);
     check_recent_balance(0, &rpc_client, &recipient_pubkey);
 
@@ -429,13 +399,10 @@ fn test_transfer_all() {
         to: recipient_pubkey,
         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,
@@ -445,61 +412,12 @@ 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();
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_custom_fees(mint_keypair.pubkey(), 1);
     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());
@@ -521,8 +439,9 @@ fn test_transfer_with_seed() {
     )
     .unwrap();
 
-    request_and_confirm_airdrop(&rpc_client, &config, &sender_pubkey, 1).unwrap();
-    request_and_confirm_airdrop(&rpc_client, &config, &derived_address, 50_000).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 1, &config).unwrap();
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &derived_address, 50_000, &config)
+        .unwrap();
     check_recent_balance(1, &rpc_client, &sender_pubkey);
     check_recent_balance(50_000, &rpc_client, &derived_address);
     check_recent_balance(0, &rpc_client, &recipient_pubkey);
@@ -535,13 +454,10 @@ fn test_transfer_with_seed() {
         to: recipient_pubkey,
         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

@@ -19,9 +19,8 @@ use solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersion
 #[test]
 fn test_vote_authorize_and_withdraw() {
     let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
+    let test_validator = TestValidator::with_no_fees(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());
@@ -31,8 +30,14 @@ fn test_vote_authorize_and_withdraw() {
     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();
+    request_and_confirm_airdrop(
+        &rpc_client,
+        &faucet_addr,
+        &config.signers[0].pubkey(),
+        100_000,
+        &config,
+    )
+    .unwrap();
 
     // Create vote account
     let vote_account_keypair = Keypair::new();
@@ -45,7 +50,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
@@ -67,13 +71,10 @@ fn test_vote_authorize_and_withdraw() {
         to: vote_account_pubkey,
         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,
@@ -89,7 +90,6 @@ fn test_vote_authorize_and_withdraw() {
         vote_account_pubkey,
         new_authorized_pubkey: withdraw_authority.pubkey(),
         vote_authorize: VoteAuthorize::Withdrawer,
-        memo: None,
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
@@ -107,7 +107,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);
@@ -120,7 +119,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,11 +1,10 @@
 [package]
 name = "solana-client"
-version = "1.6.7"
+version = "1.5.14"
 description = "Solana Client"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-client"
 license = "Apache-2.0"
 edition = "2018"
 
@@ -15,32 +14,31 @@ 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.6.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.7" }
-solana-faucet = { path = "../faucet", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.6.7" }
+solana-account-decoder = { path = "../account-decoder", version = "1.5.14" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-net-utils = { path = "../net-utils", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-transaction-status = { path = "../transaction-status", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.14" }
 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.6.7" }
+jsonrpc-core = "15.0.0"
+jsonrpc-http-server = "15.0.0"
+solana-logger = { path = "../logger", version = "1.5.14" }
 
 [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)]

client/src/client_error.rs

@@ -1,12 +1,9 @@
-use {
-    crate::rpc_request,
-    solana_faucet::faucet::FaucetError,
-    solana_sdk::{
-        signature::SignerError, transaction::TransactionError, transport::TransportError,
-    },
-    std::io,
-    thiserror::Error,
+use crate::rpc_request;
+use solana_sdk::{
+    signature::SignerError, transaction::TransactionError, transport::TransportError,
 };
+use std::io;
+use thiserror::Error;
 
 pub use reqwest; // export `reqwest` for clients
 
@@ -24,8 +21,6 @@ pub enum ClientErrorKind {
     SigningError(#[from] SignerError),
     #[error(transparent)]
     TransactionError(#[from] TransactionError),
-    #[error(transparent)]
-    FaucetError(#[from] FaucetError),
     #[error("Custom: {0}")]
     Custom(String),
 }
@@ -49,7 +44,6 @@ impl From<ClientErrorKind> for TransportError {
             ClientErrorKind::RpcError(err) => Self::Custom(format!("{:?}", err)),
             ClientErrorKind::SerdeJson(err) => Self::Custom(format!("{:?}", err)),
             ClientErrorKind::SigningError(err) => Self::Custom(format!("{:?}", err)),
-            ClientErrorKind::FaucetError(err) => Self::Custom(format!("{:?}", err)),
             ClientErrorKind::Custom(err) => Self::Custom(format!("{:?}", err)),
         }
     }
@@ -166,13 +160,4 @@ impl From<TransactionError> for ClientError {
     }
 }
 
-impl From<FaucetError> for ClientError {
-    fn from(err: FaucetError) -> Self {
-        Self {
-            request: None,
-            kind: err.into(),
-        }
-    }
-}
-
 pub type Result<T> = std::result::Result<T, ClientError>;

client/src/http_sender.rs

@@ -1,27 +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, 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 {
@@ -30,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 }
     }
 }
 
@@ -58,26 +38,20 @@ 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
@@ -96,9 +70,7 @@ impl RpcSender for HttpSender {
                         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())
                         {
@@ -148,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

@@ -18,4 +18,3 @@ 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,8 +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" {
                     Signature::new(&[8; 64]).to_string()

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)]
@@ -48,31 +46,30 @@ pub fn get_account_with_commitment(
                 .value
                 .ok_or_else(|| Error::Client(format!("AccountNotFound: pubkey={}", nonce_pubkey)))
         })
-        .and_then(|a| account_identity_ok(&a).map(|()| a))
+        .and_then(|a| match account_identity_ok(&a) {
+            Ok(()) => Ok(a),
+            Err(e) => Err(e),
+        })
 }
 
-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)]

client/src/rpc_client.rs

@@ -1,47 +1,50 @@
-use {
-    crate::{
-        client_error::{ClientError, ClientErrorKind, Result as ClientResult},
-        http_sender::HttpSender,
-        mock_sender::{MockSender, Mocks},
-        rpc_config::RpcAccountInfoConfig,
-        rpc_config::*,
-        rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
-        rpc_response::*,
-        rpc_sender::RpcSender,
+use crate::{
+    client_error::{ClientError, ClientErrorKind, Result as ClientResult},
+    http_sender::HttpSender,
+    mock_sender::{MockSender, Mocks},
+    rpc_config::RpcAccountInfoConfig,
+    rpc_config::{
+        RpcGetConfirmedSignaturesForAddress2Config, RpcLargestAccountsConfig,
+        RpcProgramAccountsConfig, RpcSendTransactionConfig, RpcSimulateTransactionConfig,
+        RpcTokenAccountsFilter,
     },
-    bincode::serialize,
-    indicatif::{ProgressBar, ProgressStyle},
-    log::*,
-    serde_json::{json, Value},
-    solana_account_decoder::{
-        parse_token::{TokenAccountType, UiTokenAccount, UiTokenAmount},
-        UiAccount, UiAccountData, UiAccountEncoding,
-    },
-    solana_sdk::{
-        account::Account,
-        clock::{Epoch, Slot, UnixTimestamp, DEFAULT_MS_PER_SLOT, MAX_HASH_AGE_IN_SECONDS},
-        commitment_config::{CommitmentConfig, CommitmentLevel},
-        epoch_info::EpochInfo,
-        epoch_schedule::EpochSchedule,
-        fee_calculator::{FeeCalculator, FeeRateGovernor},
-        hash::Hash,
-        pubkey::Pubkey,
-        signature::Signature,
-        transaction::{self, uses_durable_nonce, Transaction},
-    },
-    solana_transaction_status::{
-        EncodedConfirmedBlock, EncodedConfirmedTransaction, TransactionStatus, UiConfirmedBlock,
-        UiTransactionEncoding,
-    },
-    solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY,
-    std::{
-        cmp::min,
-        net::SocketAddr,
-        str::FromStr,
-        sync::RwLock,
-        thread::sleep,
-        time::{Duration, Instant},
+    rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
+    rpc_response::*,
+    rpc_sender::RpcSender,
+};
+use bincode::serialize;
+use indicatif::{ProgressBar, ProgressStyle};
+use log::*;
+use serde_json::{json, Value};
+use solana_account_decoder::{
+    parse_token::{TokenAccountType, UiTokenAccount, UiTokenAmount},
+    UiAccount, UiAccountData, UiAccountEncoding,
+};
+use solana_sdk::{
+    account::Account,
+    clock::{
+        Slot, UnixTimestamp, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT,
+        MAX_HASH_AGE_IN_SECONDS,
     },
+    commitment_config::{CommitmentConfig, CommitmentLevel},
+    epoch_info::EpochInfo,
+    epoch_schedule::EpochSchedule,
+    fee_calculator::{FeeCalculator, FeeRateGovernor},
+    hash::Hash,
+    pubkey::Pubkey,
+    signature::Signature,
+    transaction::{self, uses_durable_nonce, Transaction},
+};
+use solana_transaction_status::{
+    EncodedConfirmedBlock, EncodedConfirmedTransaction, TransactionStatus, UiTransactionEncoding,
+};
+use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
+use std::{
+    cmp::min,
+    net::SocketAddr,
+    sync::RwLock,
+    thread::sleep,
+    time::{Duration, Instant},
 };
 
 pub struct RpcClient {
@@ -123,13 +126,6 @@ impl RpcClient {
         Self::new(get_rpc_request_str(addr, false))
     }
 
-    pub fn new_socket_with_commitment(
-        addr: SocketAddr,
-        commitment_config: CommitmentConfig,
-    ) -> Self {
-        Self::new_with_commitment(get_rpc_request_str(addr, false), commitment_config)
-    }
-
     pub fn new_socket_with_timeout(addr: SocketAddr, timeout: Duration) -> Self {
         let url = get_rpc_request_str(addr, false);
         Self::new_with_timeout(url, timeout)
@@ -404,53 +400,6 @@ impl RpcClient {
         )
     }
 
-    pub fn get_slot_leaders(&self, start_slot: Slot, limit: u64) -> ClientResult<Vec<Pubkey>> {
-        self.send(RpcRequest::GetSlotLeaders, json!([start_slot, limit]))
-            .and_then(|slot_leaders: Vec<String>| {
-                slot_leaders
-                    .iter()
-                    .map(|slot_leader| {
-                        Pubkey::from_str(slot_leader).map_err(|err| {
-                            ClientErrorKind::Custom(format!(
-                                "pubkey deserialization failed: {}",
-                                err
-                            ))
-                            .into()
-                        })
-                    })
-                    .collect()
-            })
-    }
-
-    /// Get block production for the current epoch
-    pub fn get_block_production(&self) -> RpcResult<RpcBlockProduction> {
-        self.send(RpcRequest::GetBlockProduction, Value::Null)
-    }
-
-    pub fn get_block_production_with_config(
-        &self,
-        config: RpcBlockProductionConfig,
-    ) -> RpcResult<RpcBlockProduction> {
-        self.send(RpcRequest::GetBlockProduction, json!(config))
-    }
-
-    pub fn get_stake_activation(
-        &self,
-        stake_account: Pubkey,
-        epoch: Option<Epoch>,
-    ) -> ClientResult<RpcStakeActivation> {
-        self.send(
-            RpcRequest::GetStakeActivation,
-            json!([
-                stake_account.to_string(),
-                RpcEpochConfig {
-                    epoch,
-                    commitment: Some(self.commitment_config),
-                }
-            ]),
-        )
-    }
-
     pub fn supply(&self) -> RpcResult<RpcSupply> {
         self.supply_with_commitment(self.commitment_config)
     }
@@ -465,17 +414,10 @@ impl RpcClient {
         )
     }
 
-    #[deprecated(since = "1.5.19", note = "Please use RpcClient::supply() instead")]
-    #[allow(deprecated)]
     pub fn total_supply(&self) -> ClientResult<u64> {
         self.total_supply_with_commitment(self.commitment_config)
     }
 
-    #[deprecated(
-        since = "1.5.19",
-        note = "Please use RpcClient::supply_with_commitment() instead"
-    )]
-    #[allow(deprecated)]
     pub fn total_supply_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
@@ -507,17 +449,10 @@ impl RpcClient {
         &self,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<RpcVoteAccountStatus> {
-        self.get_vote_accounts_with_config(RpcGetVoteAccountsConfig {
-            commitment: Some(self.maybe_map_commitment(commitment_config)?),
-            ..RpcGetVoteAccountsConfig::default()
-        })
-    }
-
-    pub fn get_vote_accounts_with_config(
-        &self,
-        config: RpcGetVoteAccountsConfig,
-    ) -> ClientResult<RpcVoteAccountStatus> {
-        self.send(RpcRequest::GetVoteAccounts, json!([config]))
+        self.send(
+            RpcRequest::GetVoteAccounts,
+            json!([self.maybe_map_commitment(commitment_config)?]),
+        )
     }
 
     pub fn wait_for_max_stake(
@@ -568,14 +503,6 @@ impl RpcClient {
         self.send(RpcRequest::GetConfirmedBlock, json!([slot, encoding]))
     }
 
-    pub fn get_confirmed_block_with_config(
-        &self,
-        slot: Slot,
-        config: RpcConfirmedBlockConfig,
-    ) -> ClientResult<UiConfirmedBlock> {
-        self.send(RpcRequest::GetConfirmedBlock, json!([slot, config]))
-    }
-
     pub fn get_confirmed_blocks(
         &self,
         start_slot: Slot,
@@ -587,24 +514,6 @@ impl RpcClient {
         )
     }
 
-    pub fn get_confirmed_blocks_with_commitment(
-        &self,
-        start_slot: Slot,
-        end_slot: Option<Slot>,
-        commitment_config: CommitmentConfig,
-    ) -> ClientResult<Vec<Slot>> {
-        let json = if end_slot.is_some() {
-            json!([
-                start_slot,
-                end_slot,
-                self.maybe_map_commitment(commitment_config)?
-            ])
-        } else {
-            json!([start_slot, self.maybe_map_commitment(commitment_config)?])
-        };
-        self.send(RpcRequest::GetConfirmedBlocks, json)
-    }
-
     pub fn get_confirmed_blocks_with_limit(
         &self,
         start_slot: Slot,
@@ -616,27 +525,6 @@ impl RpcClient {
         )
     }
 
-    pub fn get_confirmed_blocks_with_limit_and_commitment(
-        &self,
-        start_slot: Slot,
-        limit: usize,
-        commitment_config: CommitmentConfig,
-    ) -> ClientResult<Vec<Slot>> {
-        self.send(
-            RpcRequest::GetConfirmedBlocksWithLimit,
-            json!([
-                start_slot,
-                limit,
-                self.maybe_map_commitment(commitment_config)?
-            ]),
-        )
-    }
-
-    #[deprecated(
-        since = "1.5.19",
-        note = "Please use RpcClient::get_confirmed_signatures_for_address2() instead"
-    )]
-    #[allow(deprecated)]
     pub fn get_confirmed_signatures_for_address(
         &self,
         address: &Pubkey,
@@ -678,7 +566,6 @@ impl RpcClient {
             before: config.before.map(|signature| signature.to_string()),
             until: config.until.map(|signature| signature.to_string()),
             limit: config.limit,
-            commitment: config.commitment,
         };
 
         let result: Vec<RpcConfirmedTransactionStatusWithSignature> = self.send(
@@ -700,17 +587,6 @@ impl RpcClient {
         )
     }
 
-    pub fn get_confirmed_transaction_with_config(
-        &self,
-        signature: &Signature,
-        config: RpcConfirmedTransactionConfig,
-    ) -> ClientResult<EncodedConfirmedTransaction> {
-        self.send(
-            RpcRequest::GetConfirmedTransaction,
-            json!([signature.to_string(), config]),
-        )
-    }
-
     pub fn get_block_time(&self, slot: Slot) -> ClientResult<UnixTimestamp> {
         let request = RpcRequest::GetBlockTime;
         let response = self.sender.send(request, json!([slot]));
@@ -754,34 +630,16 @@ impl RpcClient {
         slot: Option<Slot>,
         commitment_config: CommitmentConfig,
     ) -> ClientResult<Option<RpcLeaderSchedule>> {
-        self.get_leader_schedule_with_config(
-            slot,
-            RpcLeaderScheduleConfig {
-                commitment: Some(self.maybe_map_commitment(commitment_config)?),
-                ..RpcLeaderScheduleConfig::default()
-            },
+        self.send(
+            RpcRequest::GetLeaderSchedule,
+            json!([slot, self.maybe_map_commitment(commitment_config)?]),
         )
     }
 
-    pub fn get_leader_schedule_with_config(
-        &self,
-        slot: Option<Slot>,
-        config: RpcLeaderScheduleConfig,
-    ) -> ClientResult<Option<RpcLeaderSchedule>> {
-        self.send(RpcRequest::GetLeaderSchedule, json!([slot, config]))
-    }
-
     pub fn get_epoch_schedule(&self) -> ClientResult<EpochSchedule> {
         self.send(RpcRequest::GetEpochSchedule, Value::Null)
     }
 
-    pub fn get_recent_performance_samples(
-        &self,
-        limit: Option<usize>,
-    ) -> ClientResult<Vec<RpcPerfSample>> {
-        self.send(RpcRequest::GetRecentPerformanceSamples, json!([limit]))
-    }
-
     pub fn get_identity(&self) -> ClientResult<Pubkey> {
         let rpc_identity: RpcIdentity = self.send(RpcRequest::GetIdentity, Value::Null)?;
 
@@ -801,27 +659,6 @@ impl RpcClient {
         self.send(RpcRequest::GetInflationRate, Value::Null)
     }
 
-    pub fn get_inflation_reward(
-        &self,
-        addresses: &[Pubkey],
-        epoch: Option<Epoch>,
-    ) -> ClientResult<Vec<Option<RpcInflationReward>>> {
-        let addresses: Vec<_> = addresses
-            .iter()
-            .map(|address| address.to_string())
-            .collect();
-        self.send(
-            RpcRequest::GetInflationReward,
-            json!([
-                addresses,
-                RpcEpochConfig {
-                    epoch,
-                    commitment: Some(self.commitment_config),
-                }
-            ]),
-        )
-    }
-
     pub fn get_version(&self) -> ClientResult<RpcVersionInfo> {
         self.send(RpcRequest::GetVersion, Value::Null)
     }
@@ -928,14 +765,6 @@ impl RpcClient {
             })?
     }
 
-    pub fn get_max_retransmit_slot(&self) -> ClientResult<Slot> {
-        self.send(RpcRequest::GetMaxRetransmitSlot, Value::Null)
-    }
-
-    pub fn get_max_shred_insert_slot(&self) -> ClientResult<Slot> {
-        self.send(RpcRequest::GetMaxShredInsertSlot, Value::Null)
-    }
-
     pub fn get_multiple_accounts(&self, pubkeys: &[Pubkey]) -> ClientResult<Vec<Option<Account>>> {
         Ok(self
             .get_multiple_accounts_with_commitment(pubkeys, self.commitment_config)?
@@ -1170,7 +999,9 @@ impl RpcClient {
             debug!("Got same blockhash ({:?}), will retry...", blockhash);
 
             // Retry ~twice during a slot
-            sleep(Duration::from_millis(DEFAULT_MS_PER_SLOT / 2));
+            sleep(Duration::from_millis(
+                500 * DEFAULT_TICKS_PER_SLOT / DEFAULT_TICKS_PER_SECOND,
+            ));
             num_retries += 1;
         }
         Err(RpcError::ForUser(format!(
@@ -1381,64 +1212,6 @@ impl RpcClient {
         )
     }
 
-    pub fn request_airdrop(&self, pubkey: &Pubkey, lamports: u64) -> ClientResult<Signature> {
-        self.request_airdrop_with_config(
-            pubkey,
-            lamports,
-            RpcRequestAirdropConfig {
-                commitment: Some(self.commitment_config),
-                ..RpcRequestAirdropConfig::default()
-            },
-        )
-    }
-
-    pub fn request_airdrop_with_blockhash(
-        &self,
-        pubkey: &Pubkey,
-        lamports: u64,
-        recent_blockhash: &Hash,
-    ) -> ClientResult<Signature> {
-        self.request_airdrop_with_config(
-            pubkey,
-            lamports,
-            RpcRequestAirdropConfig {
-                commitment: Some(self.commitment_config),
-                recent_blockhash: Some(recent_blockhash.to_string()),
-            },
-        )
-    }
-
-    pub fn request_airdrop_with_config(
-        &self,
-        pubkey: &Pubkey,
-        lamports: u64,
-        config: RpcRequestAirdropConfig,
-    ) -> ClientResult<Signature> {
-        let commitment = config.commitment.unwrap_or_default();
-        let commitment = self.maybe_map_commitment(commitment)?;
-        let config = RpcRequestAirdropConfig {
-            commitment: Some(commitment),
-            ..config
-        };
-        self.send(
-            RpcRequest::RequestAirdrop,
-            json!([pubkey.to_string(), lamports, config]),
-        )
-        .and_then(|signature: String| {
-            Signature::from_str(&signature).map_err(|err| {
-                ClientErrorKind::Custom(format!("signature deserialization failed: {}", err)).into()
-            })
-        })
-        .map_err(|_| {
-            RpcError::ForUser(
-                "airdrop request failed. \
-                This can happen when the rate limit is reached."
-                    .to_string(),
-            )
-            .into()
-        })
-    }
-
     fn poll_balance_with_timeout_and_commitment(
         &self,
         pubkey: &Pubkey,
@@ -1640,24 +1413,6 @@ impl RpcClient {
         commitment: CommitmentConfig,
         config: RpcSendTransactionConfig,
     ) -> ClientResult<Signature> {
-        let recent_blockhash = if uses_durable_nonce(transaction).is_some() {
-            self.get_recent_blockhash_with_commitment(CommitmentConfig::processed())?
-                .value
-                .0
-        } else {
-            transaction.message.recent_blockhash
-        };
-        let signature = self.send_transaction_with_config(transaction, config)?;
-        self.confirm_transaction_with_spinner(&signature, &recent_blockhash, commitment)?;
-        Ok(signature)
-    }
-
-    pub fn confirm_transaction_with_spinner(
-        &self,
-        signature: &Signature,
-        recent_blockhash: &Hash,
-        commitment: CommitmentConfig,
-    ) -> ClientResult<()> {
         let desired_confirmations = if commitment.is_finalized() {
             MAX_LOCKOUT_HISTORY + 1
         } else {
@@ -1669,8 +1424,16 @@ impl RpcClient {
 
         progress_bar.set_message(&format!(
             "[{}/{}] Finalizing transaction {}",
-            confirmations, desired_confirmations, signature,
+            confirmations, desired_confirmations, transaction.signatures[0],
         ));
+        let recent_blockhash = if uses_durable_nonce(transaction).is_some() {
+            self.get_recent_blockhash_with_commitment(CommitmentConfig::processed())?
+                .value
+                .0
+        } else {
+            transaction.message.recent_blockhash
+        };
+        let signature = self.send_transaction_with_config(transaction, config)?;
         let (signature, status) = loop {
             // Get recent commitment in order to count confirmations for successful transactions
             let status = self
@@ -1717,7 +1480,7 @@ impl RpcClient {
             {
                 progress_bar.set_message("Transaction confirmed");
                 progress_bar.finish_and_clear();
-                return Ok(());
+                return Ok(signature);
             }
 
             progress_bar.set_message(&format!(
@@ -1740,6 +1503,10 @@ impl RpcClient {
         }
     }
 
+    pub fn validator_exit(&self) -> ClientResult<bool> {
+        self.send(RpcRequest::ValidatorExit, Value::Null)
+    }
+
     pub fn send<T>(&self, request: RpcRequest, params: Value) -> ClientResult<T>
     where
         T: serde::de::DeserializeOwned,
@@ -1759,7 +1526,6 @@ pub struct GetConfirmedSignaturesForAddress2Config {
     pub before: Option<Signature>,
     pub until: Option<Signature>,
     pub limit: Option<usize>,
-    pub commitment: Option<CommitmentConfig>,
 }
 
 fn new_spinner_progress_bar() -> ProgressBar {
@@ -1808,7 +1574,7 @@ mod tests {
     use super::*;
     use crate::{client_error::ClientErrorKind, mock_sender::PUBKEY};
     use assert_matches::assert_matches;
-    use jsonrpc_core::{futures::prelude::*, Error, IoHandler, Params};
+    use jsonrpc_core::{Error, IoHandler, Params};
     use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder};
     use serde_json::Number;
     use solana_sdk::{
@@ -1819,35 +1585,20 @@ mod tests {
 
     #[test]
     fn test_send() {
-        _test_send();
-    }
-
-    #[tokio::test(flavor = "current_thread")]
-    #[should_panic(expected = "can call blocking only when running on the multi-threaded runtime")]
-    async fn test_send_async_current_thread_should_panic() {
-        _test_send();
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_send_async_multi_thread() {
-        _test_send();
-    }
-
-    fn _test_send() {
         let (sender, receiver) = channel();
         thread::spawn(move || {
             let rpc_addr = "0.0.0.0:0".parse().unwrap();
             let mut io = IoHandler::default();
             // Successful request
             io.add_method("getBalance", |_params: Params| {
-                future::ok(Value::Number(Number::from(50)))
+                Ok(Value::Number(Number::from(50)))
             });
             // Failed request
             io.add_method("getRecentBlockhash", |params: Params| {
                 if params != Params::None {
-                    future::err(Error::invalid_request())
+                    Err(Error::invalid_request())
                 } else {
-                    future::ok(Value::String(
+                    Ok(Value::String(
                         "deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx".to_string(),
                     ))
                 }

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,
+    commitment_config::{CommitmentConfig, CommitmentLevel},
 };
+use solana_transaction_status::UiTransactionEncoding;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -33,62 +31,6 @@ pub struct RpcSimulateTransactionConfig {
     pub encoding: Option<UiTransactionEncoding>,
 }
 
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcRequestAirdropConfig {
-    pub recent_blockhash: Option<String>, // base-58 encoded blockhash
-    #[serde(flatten)]
-    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>,
-}
-
-#[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 {
@@ -106,7 +48,7 @@ pub struct RpcLargestAccountsConfig {
 
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct RpcEpochConfig {
+pub struct RpcStakeConfig {
     pub epoch: Option<Epoch>,
     #[serde(flatten)]
     pub commitment: Option<CommitmentConfig>,
@@ -165,101 +107,4 @@ 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>,
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum RpcEncodingConfigWrapper<T> {
-    Deprecated(Option<UiTransactionEncoding>),
-    Current(Option<T>),
-}
-
-impl<T: EncodingConfig + Default + Copy> RpcEncodingConfigWrapper<T> {
-    pub fn convert_to_current(&self) -> T {
-        match self {
-            RpcEncodingConfigWrapper::Deprecated(encoding) => T::new_with_encoding(encoding),
-            RpcEncodingConfigWrapper::Current(config) => config.unwrap_or_default(),
-        }
-    }
-}
-
-pub trait EncodingConfig {
-    fn new_with_encoding(encoding: &Option<UiTransactionEncoding>) -> Self;
-}
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcConfirmedBlockConfig {
-    pub encoding: Option<UiTransactionEncoding>,
-    pub transaction_details: Option<TransactionDetails>,
-    pub rewards: Option<bool>,
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-}
-
-impl EncodingConfig for RpcConfirmedBlockConfig {
-    fn new_with_encoding(encoding: &Option<UiTransactionEncoding>) -> Self {
-        Self {
-            encoding: *encoding,
-            ..Self::default()
-        }
-    }
-}
-
-impl RpcConfirmedBlockConfig {
-    pub fn rewards_only() -> Self {
-        Self {
-            transaction_details: Some(TransactionDetails::None),
-            ..Self::default()
-        }
-    }
-
-    pub fn rewards_with_commitment(commitment: Option<CommitmentConfig>) -> Self {
-        Self {
-            transaction_details: Some(TransactionDetails::None),
-            commitment,
-            ..Self::default()
-        }
-    }
-}
-
-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 RpcConfirmedTransactionConfig {
-    pub encoding: Option<UiTransactionEncoding>,
-    #[serde(flatten)]
-    pub commitment: Option<CommitmentConfig>,
-}
-
-impl EncodingConfig for RpcConfirmedTransactionConfig {
-    fn new_with_encoding(encoding: &Option<UiTransactionEncoding>) -> Self {
-        Self {
-            encoding: *encoding,
-            ..Self::default()
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum RpcConfirmedBlocksConfigWrapper {
-    EndSlotOnly(Option<Slot>),
-    CommitmentOnly(Option<CommitmentConfig>),
-}
-
-impl RpcConfirmedBlocksConfigWrapper {
-    pub fn unzip(&self) -> (Option<Slot>, Option<CommitmentConfig>) {
-        match &self {
-            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 {
-    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;

client/src/rpc_request.rs

@@ -1,29 +1,21 @@
-use {
-    crate::rpc_response::RpcSimulateTransactionResult,
-    serde_json::{json, Value},
-    solana_sdk::{clock::Slot, pubkey::Pubkey},
-    std::fmt,
-    thiserror::Error,
-};
+use crate::rpc_response::RpcSimulateTransactionResult;
+use serde_json::{json, Value};
+use solana_sdk::{clock::Slot, pubkey::Pubkey};
+use std::fmt;
+use thiserror::Error;
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
 pub enum RpcRequest {
     DeregisterNode,
+    ValidatorExit,
     GetAccountInfo,
     GetBalance,
-    GetBlockProduction,
     GetBlockTime,
     GetClusterNodes,
     GetConfirmedBlock,
     GetConfirmedBlocks,
     GetConfirmedBlocksWithLimit,
-
-    #[deprecated(
-        since = "1.5.19",
-        note = "Please use RpcRequest::GetConfirmedSignaturesForAddress2 instead"
-    )]
     GetConfirmedSignaturesForAddress,
-
     GetConfirmedSignaturesForAddress2,
     GetConfirmedTransaction,
     GetEpochInfo,
@@ -37,35 +29,26 @@ pub enum RpcRequest {
     GetIdentity,
     GetInflationGovernor,
     GetInflationRate,
-    GetInflationReward,
     GetLargestAccounts,
     GetLeaderSchedule,
-    GetMaxRetransmitSlot,
-    GetMaxShredInsertSlot,
     GetMinimumBalanceForRentExemption,
     GetMultipleAccounts,
     GetProgramAccounts,
     GetRecentBlockhash,
-    GetRecentPerformanceSamples,
     GetSnapshotSlot,
     GetSignatureStatuses,
     GetSlot,
     GetSlotLeader,
-    GetSlotLeaders,
     GetStorageTurn,
     GetStorageTurnRate,
     GetSlotsPerSegment,
-    GetStakeActivation,
     GetStoragePubkeysForSlot,
     GetSupply,
     GetTokenAccountBalance,
     GetTokenAccountsByDelegate,
     GetTokenAccountsByOwner,
     GetTokenSupply,
-
-    #[deprecated(since = "1.5.19", note = "Please use RpcRequest::GetSupply instead")]
     GetTotalSupply,
-
     GetTransactionCount,
     GetVersion,
     GetVoteAccounts,
@@ -77,14 +60,13 @@ pub enum RpcRequest {
     SignVote,
 }
 
-#[allow(deprecated)]
 impl fmt::Display for RpcRequest {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let method = match self {
             RpcRequest::DeregisterNode => "deregisterNode",
+            RpcRequest::ValidatorExit => "validatorExit",
             RpcRequest::GetAccountInfo => "getAccountInfo",
             RpcRequest::GetBalance => "getBalance",
-            RpcRequest::GetBlockProduction => "getBlockProduction",
             RpcRequest::GetBlockTime => "getBlockTime",
             RpcRequest::GetClusterNodes => "getClusterNodes",
             RpcRequest::GetConfirmedBlock => "getConfirmedBlock",
@@ -104,22 +86,16 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetIdentity => "getIdentity",
             RpcRequest::GetInflationGovernor => "getInflationGovernor",
             RpcRequest::GetInflationRate => "getInflationRate",
-            RpcRequest::GetInflationReward => "getInflationReward",
             RpcRequest::GetLargestAccounts => "getLargestAccounts",
             RpcRequest::GetLeaderSchedule => "getLeaderSchedule",
-            RpcRequest::GetMaxRetransmitSlot => "getMaxRetransmitSlot",
-            RpcRequest::GetMaxShredInsertSlot => "getMaxShredInsertSlot",
             RpcRequest::GetMinimumBalanceForRentExemption => "getMinimumBalanceForRentExemption",
             RpcRequest::GetMultipleAccounts => "getMultipleAccounts",
             RpcRequest::GetProgramAccounts => "getProgramAccounts",
             RpcRequest::GetRecentBlockhash => "getRecentBlockhash",
-            RpcRequest::GetRecentPerformanceSamples => "getRecentPerformanceSamples",
             RpcRequest::GetSnapshotSlot => "getSnapshotSlot",
             RpcRequest::GetSignatureStatuses => "getSignatureStatuses",
             RpcRequest::GetSlot => "getSlot",
             RpcRequest::GetSlotLeader => "getSlotLeader",
-            RpcRequest::GetSlotLeaders => "getSlotLeaders",
-            RpcRequest::GetStakeActivation => "getStakeActivation",
             RpcRequest::GetStorageTurn => "getStorageTurn",
             RpcRequest::GetStorageTurnRate => "getStorageTurnRate",
             RpcRequest::GetSlotsPerSegment => "getSlotsPerSegment",
@@ -152,7 +128,6 @@ pub const MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS2_LIMIT: usize = 1_000;
 pub const MAX_MULTIPLE_ACCOUNTS: usize = 100;
 pub const NUM_LARGEST_ACCOUNTS: usize = 20;
 pub const MAX_GET_PROGRAM_ACCOUNT_FILTERS: usize = 4;
-pub const MAX_GET_SLOT_LEADERS: usize = 5000;
 
 // Validators that are this number of slots behind are considered delinquent
 pub const DELINQUENT_VALIDATOR_SLOT_DISTANCE: u64 = 128;

client/src/rpc_response.rs

@@ -1,17 +1,13 @@
-use {
-    crate::client_error,
-    solana_account_decoder::{parse_token::UiTokenAmount, UiAccount},
-    solana_sdk::{
-        clock::{Epoch, Slot, UnixTimestamp},
-        fee_calculator::{FeeCalculator, FeeRateGovernor},
-        inflation::Inflation,
-        transaction::{Result, TransactionError},
-    },
-    solana_transaction_status::{
-        ConfirmedTransactionStatusWithSignature, TransactionConfirmationStatus,
-    },
-    std::{collections::HashMap, fmt, net::SocketAddr},
+use crate::client_error;
+use solana_account_decoder::{parse_token::UiTokenAmount, UiAccount};
+use solana_sdk::{
+    clock::{Epoch, Slot, UnixTimestamp},
+    fee_calculator::{FeeCalculator, FeeRateGovernor},
+    inflation::Inflation,
+    transaction::{Result, TransactionError},
 };
+use solana_transaction_status::ConfirmedTransactionStatusWithSignature;
+use std::{collections::HashMap, fmt, net::SocketAddr};
 
 pub type RpcResult<T> = client_error::Result<Response<T>>;
 
@@ -105,63 +101,13 @@ pub struct SlotInfo {
     pub root: Slot,
 }
 
-#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct SlotTransactionStats {
-    pub num_transaction_entries: u64,
-    pub num_successful_transactions: u64,
-    pub num_failed_transactions: u64,
-    pub max_transactions_per_entry: u64,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase", tag = "type")]
 pub enum SlotUpdate {
-    FirstShredReceived {
-        slot: Slot,
-        timestamp: u64,
-    },
-    Completed {
-        slot: Slot,
-        timestamp: u64,
-    },
-    CreatedBank {
-        slot: Slot,
-        parent: Slot,
-        timestamp: u64,
-    },
-    Frozen {
-        slot: Slot,
-        timestamp: u64,
-        stats: SlotTransactionStats,
-    },
-    Dead {
-        slot: Slot,
-        timestamp: u64,
-        err: String,
-    },
-    OptimisticConfirmation {
-        slot: Slot,
-        timestamp: u64,
-    },
-    Root {
-        slot: Slot,
-        timestamp: u64,
-    },
-}
-
-impl SlotUpdate {
-    pub fn slot(&self) -> Slot {
-        match self {
-            Self::FirstShredReceived { slot, .. } => *slot,
-            Self::Completed { slot, .. } => *slot,
-            Self::CreatedBank { slot, .. } => *slot,
-            Self::Frozen { slot, .. } => *slot,
-            Self::Dead { slot, .. } => *slot,
-            Self::OptimisticConfirmation { slot, .. } => *slot,
-            Self::Root { slot, .. } => *slot,
-        }
-    }
+    OptimisticConfirmation { slot: Slot, timestamp: u64 },
+    FirstShredReceived { slot: Slot, timestamp: u64 },
+    Frozen { slot: Slot, timestamp: u64 },
+    Root { slot: Slot, timestamp: u64 },
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -211,21 +157,6 @@ pub struct RpcContactInfo {
 /// Map of leader base58 identity pubkeys to the slot indices relative to the first epoch slot
 pub type RpcLeaderSchedule = HashMap<String, Vec<usize>>;
 
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcBlockProductionRange {
-    pub first_slot: Slot,
-    pub last_slot: Slot,
-}
-
-#[derive(Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcBlockProduction {
-    /// Map of leader base58 identity pubkeys to a tuple of `(number of leader slots, number of blocks produced)`
-    pub by_identity: HashMap<String, (usize, usize)>,
-    pub range: RpcBlockProductionRange,
-}
-
 #[derive(Serialize, Deserialize, Clone)]
 #[serde(rename_all = "kebab-case")]
 pub struct RpcVersionInfo {
@@ -269,10 +200,10 @@ pub struct RpcVoteAccountStatus {
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcVoteAccountInfo {
-    /// Vote account address, as base-58 encoded string
+    /// Vote account pubkey as base-58 encoded string
     pub vote_pubkey: String,
 
-    /// The validator identity, as base-58 encoded string
+    /// The pubkey of the node that votes using this account
     pub node_pubkey: String,
 
     /// The current stake, in lamports, delegated to this vote account
@@ -332,7 +263,7 @@ pub struct RpcSupply {
     pub non_circulating_accounts: Vec<String>,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub enum StakeActivationState {
     Activating,
@@ -341,7 +272,7 @@ pub enum StakeActivationState {
     Inactive,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcStakeActivation {
     pub state: StakeActivationState,
@@ -365,7 +296,6 @@ pub struct RpcConfirmedTransactionStatusWithSignature {
     pub err: Option<TransactionError>,
     pub memo: Option<String>,
     pub block_time: Option<UnixTimestamp>,
-    pub confirmation_status: Option<TransactionConfirmationStatus>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -377,15 +307,6 @@ pub struct RpcPerfSample {
     pub sample_period_secs: u16,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcInflationReward {
-    pub epoch: Epoch,
-    pub effective_slot: Slot,
-    pub amount: u64,       // lamports
-    pub post_balance: u64, // lamports
-}
-
 impl From<ConfirmedTransactionStatusWithSignature> for RpcConfirmedTransactionStatusWithSignature {
     fn from(value: ConfirmedTransactionStatusWithSignature) -> Self {
         let ConfirmedTransactionStatusWithSignature {
@@ -401,7 +322,6 @@ impl From<ConfirmedTransactionStatusWithSignature> for RpcConfirmedTransactionSt
             err,
             memo,
             block_time,
-            confirmation_status: None,
         }
     }
 }

client/src/thin_client.rs

@@ -3,38 +3,36 @@
 //! messages to the network directly. The binary encoding of its messages are
 //! unstable and may change in future releases.
 
-use {
-    crate::{rpc_client::RpcClient, rpc_config::RpcProgramAccountsConfig, rpc_response::Response},
-    bincode::{serialize_into, serialized_size},
-    log::*,
-    solana_sdk::{
-        account::Account,
-        client::{AsyncClient, Client, SyncClient},
-        clock::{Slot, MAX_PROCESSING_AGE},
-        commitment_config::CommitmentConfig,
-        epoch_info::EpochInfo,
-        fee_calculator::{FeeCalculator, FeeRateGovernor},
-        hash::Hash,
-        instruction::Instruction,
-        message::Message,
-        packet::PACKET_DATA_SIZE,
-        pubkey::Pubkey,
-        signature::{Keypair, Signature, Signer},
-        signers::Signers,
-        system_instruction,
-        timing::duration_as_ms,
-        transaction::{self, Transaction},
-        transport::Result as TransportResult,
-    },
-    std::{
-        io,
-        net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
-        sync::{
-            atomic::{AtomicBool, AtomicUsize, Ordering},
-            RwLock,
-        },
-        time::{Duration, Instant},
+use crate::{rpc_client::RpcClient, rpc_config::RpcProgramAccountsConfig, rpc_response::Response};
+use bincode::{serialize_into, serialized_size};
+use log::*;
+use solana_sdk::{
+    account::Account,
+    client::{AsyncClient, Client, SyncClient},
+    clock::{Slot, MAX_PROCESSING_AGE},
+    commitment_config::CommitmentConfig,
+    epoch_info::EpochInfo,
+    fee_calculator::{FeeCalculator, FeeRateGovernor},
+    hash::Hash,
+    instruction::Instruction,
+    message::Message,
+    packet::PACKET_DATA_SIZE,
+    pubkey::Pubkey,
+    signature::{Keypair, Signature, Signer},
+    signers::Signers,
+    system_instruction,
+    timing::duration_as_ms,
+    transaction::{self, Transaction},
+    transport::Result as TransportResult,
+};
+use std::{
+    io,
+    net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        RwLock,
     },
+    time::{Duration, Instant},
 };
 
 struct ClientOptimizer {
@@ -169,8 +167,8 @@ impl ThinClient {
         let rpc_clients: Vec<_> = rpc_addrs.into_iter().map(RpcClient::new_socket).collect();
         let optimizer = ClientOptimizer::new(rpc_clients.len());
         Self {
-            transactions_socket,
             tpu_addrs,
+            transactions_socket,
             rpc_clients,
             optimizer,
         }
@@ -311,6 +309,10 @@ impl ThinClient {
             .map_err(|e| e.into())
     }
 
+    pub fn validator_exit(&self) -> TransportResult<bool> {
+        self.rpc_client().validator_exit().map_err(|e| e.into())
+    }
+
     pub fn get_num_blocks_since_signature_confirmation(
         &mut self,
         sig: &Signature,

client/src/tpu_client.rs

@@ -1,393 +0,0 @@
-use crate::{
-    pubsub_client::{PubsubClient, PubsubClientError, PubsubClientSubscription},
-    rpc_client::RpcClient,
-    rpc_response::SlotUpdate,
-};
-use bincode::serialize;
-use log::*;
-use solana_sdk::{clock::Slot, pubkey::Pubkey, transaction::Transaction};
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    net::{SocketAddr, UdpSocket},
-    str::FromStr,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, RwLock,
-    },
-    thread::JoinHandle,
-    time::{Duration, Instant},
-};
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum TpuSenderError {
-    #[error("Pubsub error: {0:?}")]
-    PubsubError(#[from] PubsubClientError),
-    #[error("RPC error: {0:?}")]
-    RpcError(#[from] crate::client_error::ClientError),
-    #[error("IO error: {0:?}")]
-    IoError(#[from] std::io::Error),
-}
-
-type Result<T> = std::result::Result<T, TpuSenderError>;
-
-/// Default number of slots used to build TPU socket fanout set
-pub const DEFAULT_FANOUT_SLOTS: u64 = 12;
-
-/// Maximum number of slots used to build TPU socket fanout set
-pub const MAX_FANOUT_SLOTS: u64 = 100;
-
-/// Config params for `TpuClient`
-#[derive(Clone, Debug)]
-pub struct TpuClientConfig {
-    /// The range of upcoming slots to include when determining which
-    /// leaders to send transactions to (min: 1, max: 100)
-    pub fanout_slots: u64,
-}
-
-impl Default for TpuClientConfig {
-    fn default() -> Self {
-        Self {
-            fanout_slots: DEFAULT_FANOUT_SLOTS,
-        }
-    }
-}
-
-/// Client which sends transactions directly to the current leader's TPU port over UDP.
-/// The client uses RPC to determine the current leader and fetch node contact info
-pub struct TpuClient {
-    send_socket: UdpSocket,
-    fanout_slots: u64,
-    leader_tpu_service: LeaderTpuService,
-    exit: Arc<AtomicBool>,
-}
-
-impl TpuClient {
-    /// Serializes and sends a transaction to the current leader's TPU port
-    pub fn send_transaction(&self, transaction: &Transaction) -> bool {
-        let wire_transaction = serialize(transaction).expect("serialization should succeed");
-        self.send_wire_transaction(&wire_transaction)
-    }
-
-    /// Sends a transaction to the current leader's TPU port
-    pub fn send_wire_transaction(&self, wire_transaction: &[u8]) -> bool {
-        let mut sent = false;
-        for tpu_address in self
-            .leader_tpu_service
-            .leader_tpu_sockets(self.fanout_slots)
-        {
-            if self
-                .send_socket
-                .send_to(wire_transaction, tpu_address)
-                .is_ok()
-            {
-                sent = true;
-            }
-        }
-        sent
-    }
-
-    /// Create a new client that disconnects when dropped
-    pub fn new(
-        rpc_client: Arc<RpcClient>,
-        websocket_url: &str,
-        config: TpuClientConfig,
-    ) -> Result<Self> {
-        let exit = Arc::new(AtomicBool::new(false));
-        let leader_tpu_service = LeaderTpuService::new(rpc_client, websocket_url, exit.clone())?;
-
-        Ok(Self {
-            send_socket: UdpSocket::bind("0.0.0.0:0").unwrap(),
-            fanout_slots: config.fanout_slots.min(MAX_FANOUT_SLOTS).max(1),
-            leader_tpu_service,
-            exit,
-        })
-    }
-}
-
-impl Drop for TpuClient {
-    fn drop(&mut self) {
-        self.exit.store(true, Ordering::Relaxed);
-        self.leader_tpu_service.join();
-    }
-}
-
-struct LeaderTpuCache {
-    first_slot: Slot,
-    leaders: Vec<Pubkey>,
-    leader_tpu_map: HashMap<Pubkey, SocketAddr>,
-}
-
-impl LeaderTpuCache {
-    fn new(rpc_client: &RpcClient, first_slot: Slot) -> Self {
-        let leaders = Self::fetch_slot_leaders(rpc_client, first_slot).unwrap_or_default();
-        let leader_tpu_map = Self::fetch_cluster_tpu_sockets(&rpc_client).unwrap_or_default();
-        Self {
-            first_slot,
-            leaders,
-            leader_tpu_map,
-        }
-    }
-
-    // Last slot that has a cached leader pubkey
-    fn last_slot(&self) -> Slot {
-        self.first_slot + self.leaders.len().saturating_sub(1) as u64
-    }
-
-    // Get the TPU sockets for the current leader and upcoming leaders according to fanout size
-    fn get_leader_sockets(&self, current_slot: Slot, fanout_slots: u64) -> Vec<SocketAddr> {
-        let mut leader_set = HashSet::new();
-        let mut leader_sockets = Vec::new();
-        for leader_slot in current_slot..current_slot + fanout_slots {
-            if let Some(leader) = self.get_slot_leader(leader_slot) {
-                if let Some(tpu_socket) = self.leader_tpu_map.get(leader) {
-                    if leader_set.insert(*leader) {
-                        leader_sockets.push(*tpu_socket);
-                    }
-                }
-            }
-        }
-        leader_sockets
-    }
-
-    fn get_slot_leader(&self, slot: Slot) -> Option<&Pubkey> {
-        if slot >= self.first_slot {
-            let index = slot - self.first_slot;
-            self.leaders.get(index as usize)
-        } else {
-            None
-        }
-    }
-
-    fn fetch_cluster_tpu_sockets(rpc_client: &RpcClient) -> Result<HashMap<Pubkey, SocketAddr>> {
-        let cluster_contact_info = rpc_client.get_cluster_nodes()?;
-        Ok(cluster_contact_info
-            .into_iter()
-            .filter_map(|contact_info| {
-                Some((
-                    Pubkey::from_str(&contact_info.pubkey).ok()?,
-                    contact_info.tpu?,
-                ))
-            })
-            .collect())
-    }
-
-    fn fetch_slot_leaders(rpc_client: &RpcClient, start_slot: Slot) -> Result<Vec<Pubkey>> {
-        Ok(rpc_client.get_slot_leaders(start_slot, 2 * MAX_FANOUT_SLOTS)?)
-    }
-}
-
-// 48 chosen because it's unlikely that 12 leaders in a row will miss their slots
-const MAX_SLOT_SKIP_DISTANCE: u64 = 48;
-
-#[derive(Clone, Debug)]
-struct RecentLeaderSlots(Arc<RwLock<VecDeque<Slot>>>);
-impl RecentLeaderSlots {
-    fn new(current_slot: Slot) -> Self {
-        let mut recent_slots = VecDeque::new();
-        recent_slots.push_back(current_slot);
-        Self(Arc::new(RwLock::new(recent_slots)))
-    }
-
-    fn record_slot(&self, current_slot: Slot) {
-        let mut recent_slots = self.0.write().unwrap();
-        recent_slots.push_back(current_slot);
-        // 12 recent slots should be large enough to avoid a misbehaving
-        // validator from affecting the median recent slot
-        while recent_slots.len() > 12 {
-            recent_slots.pop_front();
-        }
-    }
-
-    // Estimate the current slot from recent slot notifications.
-    fn estimated_current_slot(&self) -> Slot {
-        let mut recent_slots: Vec<Slot> = self.0.read().unwrap().iter().cloned().collect();
-        assert!(!recent_slots.is_empty());
-        recent_slots.sort_unstable();
-
-        // Validators can broadcast invalid blocks that are far in the future
-        // so check if the current slot is in line with the recent progression.
-        let max_index = recent_slots.len() - 1;
-        let median_index = max_index / 2;
-        let median_recent_slot = recent_slots[median_index];
-        let expected_current_slot = median_recent_slot + (max_index - median_index) as u64;
-        let max_reasonable_current_slot = expected_current_slot + MAX_SLOT_SKIP_DISTANCE;
-
-        // Return the highest slot that doesn't exceed what we believe is a
-        // reasonable slot.
-        recent_slots
-            .into_iter()
-            .rev()
-            .find(|slot| *slot <= max_reasonable_current_slot)
-            .unwrap()
-    }
-}
-
-#[cfg(test)]
-impl From<Vec<Slot>> for RecentLeaderSlots {
-    fn from(recent_slots: Vec<Slot>) -> Self {
-        assert!(!recent_slots.is_empty());
-        Self(Arc::new(RwLock::new(recent_slots.into_iter().collect())))
-    }
-}
-
-/// Service that tracks upcoming leaders and maintains an up-to-date mapping
-/// of leader id to TPU socket address.
-struct LeaderTpuService {
-    recent_slots: RecentLeaderSlots,
-    leader_tpu_cache: Arc<RwLock<LeaderTpuCache>>,
-    subscription: Option<PubsubClientSubscription<SlotUpdate>>,
-    t_leader_tpu_service: Option<JoinHandle<()>>,
-}
-
-impl LeaderTpuService {
-    fn new(rpc_client: Arc<RpcClient>, websocket_url: &str, exit: Arc<AtomicBool>) -> Result<Self> {
-        let start_slot = rpc_client.get_max_shred_insert_slot()?;
-
-        let recent_slots = RecentLeaderSlots::new(start_slot);
-        let leader_tpu_cache = Arc::new(RwLock::new(LeaderTpuCache::new(&rpc_client, start_slot)));
-
-        let subscription = if !websocket_url.is_empty() {
-            let recent_slots = recent_slots.clone();
-            Some(PubsubClient::slot_updates_subscribe(
-                websocket_url,
-                move |update| {
-                    let current_slot = match update {
-                        // This update indicates that a full slot was received by the connected
-                        // node so we can stop sending transactions to the leader for that slot
-                        SlotUpdate::Completed { slot, .. } => slot.saturating_add(1),
-                        // This update indicates that we have just received the first shred from
-                        // the leader for this slot and they are probably still accepting transactions.
-                        SlotUpdate::FirstShredReceived { slot, .. } => slot,
-                        _ => return,
-                    };
-
-                    recent_slots.record_slot(current_slot);
-                },
-            )?)
-        } else {
-            None
-        };
-
-        let t_leader_tpu_service = Some({
-            let recent_slots = recent_slots.clone();
-            let leader_tpu_cache = leader_tpu_cache.clone();
-            std::thread::Builder::new()
-                .name("ldr-tpu-srv".to_string())
-                .spawn(move || Self::run(rpc_client, recent_slots, leader_tpu_cache, exit))
-                .unwrap()
-        });
-
-        Ok(LeaderTpuService {
-            recent_slots,
-            leader_tpu_cache,
-            subscription,
-            t_leader_tpu_service,
-        })
-    }
-
-    fn join(&mut self) {
-        if let Some(mut subscription) = self.subscription.take() {
-            let _ = subscription.send_unsubscribe();
-            let _ = subscription.shutdown();
-        }
-        if let Some(t_handle) = self.t_leader_tpu_service.take() {
-            t_handle.join().unwrap();
-        }
-    }
-
-    fn leader_tpu_sockets(&self, fanout_slots: u64) -> Vec<SocketAddr> {
-        let current_slot = self.recent_slots.estimated_current_slot();
-        self.leader_tpu_cache
-            .read()
-            .unwrap()
-            .get_leader_sockets(current_slot, fanout_slots)
-    }
-
-    fn run(
-        rpc_client: Arc<RpcClient>,
-        recent_slots: RecentLeaderSlots,
-        leader_tpu_cache: Arc<RwLock<LeaderTpuCache>>,
-        exit: Arc<AtomicBool>,
-    ) {
-        let mut last_cluster_refresh = Instant::now();
-        let mut sleep_ms = 1000;
-        loop {
-            if exit.load(Ordering::Relaxed) {
-                break;
-            }
-
-            // Refresh cluster TPU ports every 5min in case validators restart with new port configuration
-            // or new validators come online
-            if last_cluster_refresh.elapsed() > Duration::from_secs(5 * 60) {
-                if let Ok(leader_tpu_map) = LeaderTpuCache::fetch_cluster_tpu_sockets(&rpc_client) {
-                    leader_tpu_cache.write().unwrap().leader_tpu_map = leader_tpu_map;
-                    last_cluster_refresh = Instant::now();
-                } else {
-                    sleep_ms = 100;
-                    continue;
-                }
-            }
-
-            // Sleep a few slots before checking if leader cache needs to be refreshed again
-            std::thread::sleep(Duration::from_millis(sleep_ms));
-
-            let current_slot = recent_slots.estimated_current_slot();
-            if current_slot
-                >= leader_tpu_cache
-                    .read()
-                    .unwrap()
-                    .last_slot()
-                    .saturating_sub(MAX_FANOUT_SLOTS)
-            {
-                if let Ok(slot_leaders) =
-                    LeaderTpuCache::fetch_slot_leaders(&rpc_client, current_slot)
-                {
-                    let mut leader_tpu_cache = leader_tpu_cache.write().unwrap();
-                    leader_tpu_cache.first_slot = current_slot;
-                    leader_tpu_cache.leaders = slot_leaders;
-                } else {
-                    sleep_ms = 100;
-                    continue;
-                }
-            }
-
-            sleep_ms = 1000;
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn assert_slot(recent_slots: RecentLeaderSlots, expected_slot: Slot) {
-        assert_eq!(recent_slots.estimated_current_slot(), expected_slot);
-    }
-
-    #[test]
-    fn test_recent_leader_slots() {
-        assert_slot(RecentLeaderSlots::new(0), 0);
-
-        let mut recent_slots: Vec<Slot> = (1..=12).collect();
-        assert_slot(RecentLeaderSlots::from(recent_slots.clone()), 12);
-
-        recent_slots.reverse();
-        assert_slot(RecentLeaderSlots::from(recent_slots), 12);
-
-        assert_slot(
-            RecentLeaderSlots::from(vec![0, 1 + MAX_SLOT_SKIP_DISTANCE]),
-            1 + MAX_SLOT_SKIP_DISTANCE,
-        );
-        assert_slot(
-            RecentLeaderSlots::from(vec![0, 2 + MAX_SLOT_SKIP_DISTANCE]),
-            0,
-        );
-
-        assert_slot(RecentLeaderSlots::from(vec![1]), 1);
-        assert_slot(RecentLeaderSlots::from(vec![1, 100]), 1);
-        assert_slot(RecentLeaderSlots::from(vec![1, 2, 100]), 2);
-        assert_slot(RecentLeaderSlots::from(vec![1, 2, 3, 100]), 3);
-        assert_slot(RecentLeaderSlots::from(vec![1, 2, 3, 99, 100]), 3);
-    }
-}

core/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "solana-core"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.6.7"
+version = "1.5.14"
+documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-core"
 readme = "../README.md"
 repository = "https://github.com/solana-labs/solana"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
@@ -17,25 +17,23 @@ codecov = { repository = "solana-labs/solana", branch = "master", service = "git
 ahash = "0.6.1"
 base64 = "0.12.3"
 bincode = "1.3.1"
-blake3 = "0.3.7"
 bv = { version = "0.11.1", features = ["serde"] }
 bs58 = "0.3.1"
 byteorder = "1.3.4"
 chrono = { version = "0.4.11", features = ["serde"] }
 core_affinity = "0.5.10"
 crossbeam-channel = "0.4"
-ed25519-dalek = "=1.0.1"
+ed25519-dalek = "=1.0.0-pre.4"
 fs_extra = "1.2.0"
 flate2 = "1.0"
 indexmap = { version = "1.5", features = ["rayon"] }
 itertools = "0.9.0"
-jsonrpc-core = "17.0.0"
-jsonrpc-core-client = { version = "17.0.0", features = ["ipc", "ws"] }
-jsonrpc-derive = "17.0.0"
-jsonrpc-http-server = "17.0.0"
-jsonrpc-pubsub = "17.0.0"
-jsonrpc-ws-server = "17.0.0"
-libc = "0.2.81"
+jsonrpc-core = "15.0.0"
+jsonrpc-core-client = { version = "15.0.0", features = ["ws"] }
+jsonrpc-derive = "15.0.0"
+jsonrpc-http-server = "15.0.0"
+jsonrpc-pubsub = "15.0.0"
+jsonrpc-ws-server = "15.0.0"
 log = "0.4.11"
 lru = "0.6.1"
 miow = "0.2.2"
@@ -43,54 +41,57 @@ net2 = "0.2.37"
 num-traits = "0.2"
 rand = "0.7.0"
 rand_chacha = "0.2.2"
-rand_core = "0.6.2"
 raptorq = "1.4.2"
-rayon = "1.5.0"
+rayon = "1.4.1"
 regex = "1.3.9"
 retain_mut = "0.1.2"
-serde = "1.0.122"
+rustversion = "1.0.4"
+serde = "1.0.118"
 serde_bytes = "0.11"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "=1.6.7" }
-solana-banks-server = { path = "../banks-server", version = "=1.6.7" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.7" }
-solana-client = { path = "../client", version = "=1.6.7" }
-solana-faucet = { path = "../faucet", version = "=1.6.7" }
-solana-ledger = { path = "../ledger", version = "=1.6.7" }
-solana-logger = { path = "../logger", version = "=1.6.7" }
-solana-merkle-tree = { path = "../merkle-tree", version = "=1.6.7" }
-solana-metrics = { path = "../metrics", version = "=1.6.7" }
-solana-measure = { path = "../measure", version = "=1.6.7" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.7" }
-solana-perf = { path = "../perf", version = "=1.6.7" }
-solana-program-test = { path = "../program-test", version = "=1.6.7" }
-solana-runtime = { path = "../runtime", version = "=1.6.7" }
-solana-sdk = { path = "../sdk", version = "=1.6.7" }
-solana-frozen-abi = { path = "../frozen-abi", version = "=1.6.7" }
-solana-frozen-abi-macro = { path = "../frozen-abi/macro", version = "=1.6.7" }
-solana-stake-program = { path = "../programs/stake", version = "=1.6.7" }
-solana-storage-bigtable = { path = "../storage-bigtable", version = "=1.6.7" }
-solana-streamer = { path = "../streamer", version = "=1.6.7" }
-solana-sys-tuner = { path = "../sys-tuner", version = "=1.6.7" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.6.7" }
-solana-version = { path = "../version", version = "=1.6.7" }
-solana-vote-program = { path = "../programs/vote", version = "=1.6.7" }
+solana-account-decoder = { path = "../account-decoder", version = "1.5.14" }
+solana-banks-server = { path = "../banks-server", version = "1.5.14" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.14" }
+solana-client = { path = "../client", version = "1.5.14" }
+solana-faucet = { path = "../faucet", version = "1.5.14" }
+solana-ledger = { path = "../ledger", version = "1.5.14" }
+solana-logger = { path = "../logger", version = "1.5.14" }
+solana-merkle-tree = { path = "../merkle-tree", version = "1.5.14" }
+solana-metrics = { path = "../metrics", version = "1.5.14" }
+solana-measure = { path = "../measure", version = "1.5.14" }
+solana-net-utils = { path = "../net-utils", version = "1.5.14" }
+solana-perf = { path = "../perf", version = "1.5.14" }
+solana-program-test = { path = "../program-test", version = "1.5.14" }
+solana-runtime = { path = "../runtime", version = "1.5.14" }
+solana-sdk = { path = "../sdk", version = "1.5.14" }
+solana-frozen-abi = { path = "../frozen-abi", version = "1.5.14" }
+solana-frozen-abi-macro = { path = "../frozen-abi/macro", version = "1.5.14" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.14" }
+solana-storage-bigtable = { path = "../storage-bigtable", version = "1.5.14" }
+solana-streamer = { path = "../streamer", version = "1.5.14" }
+solana-sys-tuner = { path = "../sys-tuner", version = "1.5.14" }
+solana-transaction-status = { path = "../transaction-status", version = "1.5.14" }
+solana-version = { path = "../version", version = "1.5.14" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.14" }
 spl-token-v2-0 = { package = "spl-token", version = "=3.1.0", features = ["no-entrypoint"] }
 tempfile = "3.1.0"
 thiserror = "1.0"
-tokio = { version = "1", features = ["full"] }
-tokio_02 = { version = "0.2", package = "tokio", features = ["full"] }
-tokio-util = { version = "0.3", features = ["codec"] } # This crate needs to stay in sync with tokio_02, until that dependency can be removed
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "=1.6.7" }
+tokio = { version = "0.2", features = ["full"] }
+tokio_01 = { version = "0.1", package = "tokio" }
+tokio_01_bytes = { version = "0.4.7", package = "bytes" }
+tokio_fs_01 = { version = "0.1", package = "tokio-fs" }
+tokio_io_01 = { version = "0.1", package = "tokio-io" }
+tokio_codec_01 = { version = "0.1", package = "tokio-codec" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.5.14" }
 trees = "0.2.1"
 
 [dev-dependencies]
 matches = "0.1.6"
 num_cpus = "1.13.0"
-reqwest = { version = "0.11.2", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
 serial_test = "0.4.0"
-symlink = "0.1.0"
+serial_test_derive = "0.4.0"
 systemstat = "0.1.5"
 
 [build-dependencies]

core/benches/banking_stage.rs

@@ -7,7 +7,7 @@ use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
 use rayon::prelude::*;
-use solana_core::banking_stage::{create_test_recorder, BankingStage, BankingStageStats};
+use solana_core::banking_stage::{create_test_recorder, BankingStage};
 use solana_core::cluster_info::ClusterInfo;
 use solana_core::cluster_info::Node;
 use solana_core::poh_recorder::WorkingBankEntry;
@@ -66,8 +66,6 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
         let (exit, poh_recorder, poh_service, _signal_receiver) =
             create_test_recorder(&bank, &blockstore, None);
 
-        let recorder = poh_recorder.lock().unwrap().recorder();
-
         let tx = test_tx();
         let len = 4096;
         let chunk_size = 1024;
@@ -83,14 +81,12 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
         bencher.iter(move || {
             let _ignored = BankingStage::consume_buffered_packets(
                 &my_pubkey,
-                std::u128::MAX,
                 &poh_recorder,
                 &mut packets,
                 None,
                 &s,
                 None::<Box<dyn Fn()>>,
-                &BankingStageStats::default(),
-                &recorder,
+                None,
             );
         });
 
@@ -158,9 +154,6 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
 
     let (verified_sender, verified_receiver) = unbounded();
     let (vote_sender, vote_receiver) = unbounded();
-    let mut bank = Bank::new(&genesis_config);
-    // Allow arbitrary transaction processing time for the purposes of this bench
-    bank.ns_per_slot = std::u128::MAX;
     let bank = Arc::new(Bank::new(&genesis_config));
 
     debug!("threads: {} txs: {}", num_threads, txes);
@@ -302,7 +295,7 @@ fn simulate_process_entries(
         hash: next_hash(&bank.last_blockhash(), 1, &tx_vector),
         transactions: tx_vector,
     };
-    process_entries(&bank, &mut [entry], randomize_txs, None, None).unwrap();
+    process_entries(&bank, &[entry], randomize_txs, None, None).unwrap();
 }
 
 #[allow(clippy::same_item_push)]

core/benches/crds_shards.rs

@@ -3,34 +3,30 @@
 extern crate test;
 
 use rand::{thread_rng, Rng};
-use solana_core::{
-    crds::{Crds, VersionedCrdsValue},
-    crds_shards::CrdsShards,
-    crds_value::CrdsValue,
-};
+use solana_core::contact_info::ContactInfo;
+use solana_core::crds::VersionedCrdsValue;
+use solana_core::crds_shards::CrdsShards;
+use solana_core::crds_value::{CrdsData, CrdsValue};
+use solana_sdk::pubkey;
 use solana_sdk::timing::timestamp;
-use std::iter::repeat_with;
 use test::Bencher;
 
 const CRDS_SHARDS_BITS: u32 = 8;
 
-fn new_test_crds_value<R: Rng>(rng: &mut R) -> VersionedCrdsValue {
-    let value = CrdsValue::new_rand(rng, None);
-    let label = value.label();
-    let mut crds = Crds::default();
-    crds.insert(value, timestamp()).unwrap();
-    crds.remove(&label).unwrap()
+fn new_test_crds_value() -> VersionedCrdsValue {
+    let data = CrdsData::ContactInfo(ContactInfo::new_localhost(&pubkey::new_rand(), timestamp()));
+    VersionedCrdsValue::new(timestamp(), CrdsValue::new_unsigned(data))
 }
 
 fn bench_crds_shards_find(bencher: &mut Bencher, num_values: usize, mask_bits: u32) {
-    let mut rng = thread_rng();
-    let values: Vec<_> = repeat_with(|| new_test_crds_value(&mut rng))
+    let values: Vec<VersionedCrdsValue> = std::iter::repeat_with(new_test_crds_value)
         .take(num_values)
         .collect();
     let mut shards = CrdsShards::new(CRDS_SHARDS_BITS);
     for (index, value) in values.iter().enumerate() {
         assert!(shards.insert(index, value));
     }
+    let mut rng = thread_rng();
     bencher.iter(|| {
         let mask = rng.gen();
         let _hits = shards.find(mask, mask_bits).count();

core/benches/retransmit_stage.rs

@@ -81,7 +81,8 @@ fn bench_retransmitter(bencher: &mut Bencher) {
     let keypair = Arc::new(Keypair::new());
     let slot = 0;
     let parent = 0;
-    let shredder = Shredder::new(slot, parent, keypair, 0, 0).unwrap();
+    let shredder =
+        Shredder::new(slot, parent, 0.0, keypair, 0, 0).expect("Failed to create entry shredder");
     let mut data_shreds = shredder.entries_to_shreds(&entries, true, 0).0;
 
     let num_packets = data_shreds.len();

core/benches/shredder.rs

@@ -8,8 +8,8 @@ use raptorq::{Decoder, Encoder};
 use solana_ledger::entry::{create_ticks, Entry};
 use solana_ledger::shred::{
     max_entries_per_n_shred, max_ticks_per_n_shreds, ProcessShredsStats, Shred, Shredder,
-    MAX_DATA_SHREDS_PER_FEC_BLOCK, SHRED_PAYLOAD_SIZE, SIZE_OF_DATA_SHRED_IGNORED_TAIL,
-    SIZE_OF_DATA_SHRED_PAYLOAD,
+    MAX_DATA_SHREDS_PER_FEC_BLOCK, RECOMMENDED_FEC_RATE, SHRED_PAYLOAD_SIZE,
+    SIZE_OF_DATA_SHRED_IGNORED_TAIL, SIZE_OF_DATA_SHRED_PAYLOAD,
 };
 use solana_perf::test_tx;
 use solana_sdk::hash::Hash;
@@ -39,15 +39,10 @@ fn make_shreds(num_shreds: usize) -> Vec<Shred> {
         Some(shred_size),
     );
     let entries = make_large_unchained_entries(txs_per_entry, num_entries);
-    let shredder = Shredder::new(1, 0, Arc::new(Keypair::new()), 0, 0).unwrap();
+    let shredder =
+        Shredder::new(1, 0, RECOMMENDED_FEC_RATE, Arc::new(Keypair::new()), 0, 0).unwrap();
     let data_shreds = shredder
-        .entries_to_data_shreds(
-            &entries,
-            true, // is_last_in_slot
-            0,    // next_shred_index
-            0,    // fec_set_offset
-            &mut ProcessShredsStats::default(),
-        )
+        .entries_to_data_shreds(&entries, true, 0, &mut ProcessShredsStats::default())
         .0;
     assert!(data_shreds.len() >= num_shreds);
     data_shreds
@@ -74,7 +69,7 @@ fn bench_shredder_ticks(bencher: &mut Bencher) {
     let num_ticks = max_ticks_per_n_shreds(1, Some(SIZE_OF_DATA_SHRED_PAYLOAD)) * num_shreds as u64;
     let entries = create_ticks(num_ticks, 0, Hash::default());
     bencher.iter(|| {
-        let shredder = Shredder::new(1, 0, kp.clone(), 0, 0).unwrap();
+        let shredder = Shredder::new(1, 0, RECOMMENDED_FEC_RATE, kp.clone(), 0, 0).unwrap();
         shredder.entries_to_shreds(&entries, true, 0);
     })
 }
@@ -93,7 +88,7 @@ fn bench_shredder_large_entries(bencher: &mut Bencher) {
     let entries = make_large_unchained_entries(txs_per_entry, num_entries);
     // 1Mb
     bencher.iter(|| {
-        let shredder = Shredder::new(1, 0, kp.clone(), 0, 0).unwrap();
+        let shredder = Shredder::new(1, 0, RECOMMENDED_FEC_RATE, kp.clone(), 0, 0).unwrap();
         shredder.entries_to_shreds(&entries, true, 0);
     })
 }
@@ -106,7 +101,7 @@ fn bench_deshredder(bencher: &mut Bencher) {
     let num_shreds = ((10000 * 1000) + (shred_size - 1)) / shred_size;
     let num_ticks = max_ticks_per_n_shreds(1, Some(shred_size)) * num_shreds as u64;
     let entries = create_ticks(num_ticks, 0, Hash::default());
-    let shredder = Shredder::new(1, 0, kp, 0, 0).unwrap();
+    let shredder = Shredder::new(1, 0, RECOMMENDED_FEC_RATE, kp, 0, 0).unwrap();
     let data_shreds = shredder.entries_to_shreds(&entries, true, 0).0;
     bencher.iter(|| {
         let raw = &mut Shredder::deshred(&data_shreds).unwrap();
@@ -132,8 +127,11 @@ fn bench_shredder_coding(bencher: &mut Bencher) {
     let data_shreds = make_shreds(symbol_count);
     bencher.iter(|| {
         Shredder::generate_coding_shreds(
+            0,
+            RECOMMENDED_FEC_RATE,
             &data_shreds[..symbol_count],
-            true, // is_last_in_slot
+            0,
+            symbol_count,
         )
         .len();
     })
@@ -144,16 +142,20 @@ fn bench_shredder_decoding(bencher: &mut Bencher) {
     let symbol_count = MAX_DATA_SHREDS_PER_FEC_BLOCK as usize;
     let data_shreds = make_shreds(symbol_count);
     let coding_shreds = Shredder::generate_coding_shreds(
+        0,
+        RECOMMENDED_FEC_RATE,
         &data_shreds[..symbol_count],
-        true, // is_last_in_slot
+        0,
+        symbol_count,
     );
     bencher.iter(|| {
         Shredder::try_recovery(
             coding_shreds[..].to_vec(),
             symbol_count,
             symbol_count,
-            0, // first index
-            1, // slot
+            0,
+            0,
+            1,
         )
         .unwrap();
     })

core/src/bigtable_upload_service.rs

@@ -5,7 +5,7 @@ use std::{
     sync::{Arc, RwLock},
     thread::{self, Builder, JoinHandle},
 };
-use tokio::runtime::Runtime;
+use tokio::runtime;
 
 // Delay uploading the largest confirmed root for this many slots.  This is done in an attempt to
 // ensure that the `CacheBlockTimeService` has had enough time to add the block time for the root
@@ -21,7 +21,7 @@ pub struct BigTableUploadService {
 
 impl BigTableUploadService {
     pub fn new(
-        runtime: Arc<Runtime>,
+        runtime_handle: runtime::Handle,
         bigtable_ledger_storage: solana_storage_bigtable::LedgerStorage,
         blockstore: Arc<Blockstore>,
         block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
@@ -32,7 +32,7 @@ impl BigTableUploadService {
             .name("bigtable-upload".to_string())
             .spawn(move || {
                 Self::run(
-                    runtime,
+                    runtime_handle,
                     bigtable_ledger_storage,
                     blockstore,
                     block_commitment_cache,
@@ -45,7 +45,7 @@ impl BigTableUploadService {
     }
 
     fn run(
-        runtime: Arc<Runtime>,
+        runtime: runtime::Handle,
         bigtable_ledger_storage: solana_storage_bigtable::LedgerStorage,
         blockstore: Arc<Blockstore>,
         block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,

core/src/broadcast_stage.rs

@@ -373,7 +373,7 @@ pub fn get_broadcast_peers(
 /// # Remarks
 pub fn broadcast_shreds(
     s: &UdpSocket,
-    shreds: &[Shred],
+    shreds: &Arc<Vec<Shred>>,
     peers_and_stakes: &[(u64, usize)],
     peers: &[ContactInfo],
     last_datapoint_submit: &Arc<AtomicU64>,
@@ -447,7 +447,7 @@ pub mod test {
         entry::create_ticks,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
         get_tmp_ledger_path,
-        shred::{max_ticks_per_n_shreds, ProcessShredsStats, Shredder},
+        shred::{max_ticks_per_n_shreds, ProcessShredsStats, Shredder, RECOMMENDED_FEC_RATE},
     };
     use solana_runtime::bank::Bank;
     use solana_sdk::{
@@ -472,14 +472,12 @@ pub mod test {
     ) {
         let num_entries = max_ticks_per_n_shreds(num, None);
         let (data_shreds, _) = make_slot_entries(slot, 0, num_entries);
-        let keypair = Keypair::new();
-        let coding_shreds = Shredder::data_shreds_to_coding_shreds(
-            &keypair,
-            &data_shreds[0..],
-            true, // is_last_in_slot
-            &mut ProcessShredsStats::default(),
-        )
-        .unwrap();
+        let keypair = Arc::new(Keypair::new());
+        let shredder = Shredder::new(slot, 0, RECOMMENDED_FEC_RATE, keypair, 0, 0)
+            .expect("Expected to create a new shredder");
+
+        let coding_shreds = shredder
+            .data_shreds_to_coding_shreds(&data_shreds[0..], &mut ProcessShredsStats::default());
         (
             data_shreds.clone(),
             coding_shreds.clone(),
@@ -669,6 +667,8 @@ pub mod test {
                 }
             }
 
+            sleep(Duration::from_millis(2000));
+
             trace!(
                 "[broadcast_ledger] max_tick_height: {}, start_tick_height: {}, ticks_per_slot: {}",
                 max_tick_height,
@@ -676,17 +676,10 @@ pub mod test {
                 ticks_per_slot,
             );
 
-            let mut entries = vec![];
-            for _ in 0..10 {
-                entries = broadcast_service
-                    .blockstore
-                    .get_slot_entries(slot, 0)
-                    .expect("Expect entries to be present");
-                if entries.len() >= max_tick_height as usize {
-                    break;
-                }
-                sleep(Duration::from_millis(1000));
-            }
+            let blockstore = broadcast_service.blockstore;
+            let entries = blockstore
+                .get_slot_entries(slot, 0)
+                .expect("Expect entries to be present");
             assert_eq!(entries.len(), max_tick_height as usize);
 
             drop(entry_sender);

core/src/broadcast_stage/broadcast_fake_shreds_run.rs

@@ -1,6 +1,6 @@
 use super::*;
 use solana_ledger::entry::Entry;
-use solana_ledger::shred::Shredder;
+use solana_ledger::shred::{Shredder, RECOMMENDED_FEC_RATE};
 use solana_sdk::hash::Hash;
 use solana_sdk::signature::Keypair;
 
@@ -47,6 +47,7 @@ impl BroadcastRun for BroadcastFakeShredsRun {
         let shredder = Shredder::new(
             bank.slot(),
             bank.parent().unwrap().slot(),
+            RECOMMENDED_FEC_RATE,
             self.keypair.clone(),
             (bank.tick_height() % bank.ticks_per_slot()) as u8,
             self.shred_version,