Bump version to 1.5.13

(cherry picked from commit 658951e680)

Co-authored-by: behzad nouri <behzadnouri@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==]"
     }
 }

.buildkite/hooks/pre-command

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

.mergify.yml

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

.travis.yml

@@ -38,7 +38,6 @@ jobs:
         - readlink -f .
       script:
         - source ci/env.sh
-        - rustup set profile default
         - ci/publish-tarball.sh
       deploy:
         - provider: s3
@@ -61,12 +60,6 @@ jobs:
     - <<: *release-artifacts
       name: "Windows release artifacts"
       os: windows
-      install:
-        - choco install openssl
-        - export OPENSSL_DIR="C:\Program Files\OpenSSL-Win64"
-        - source ci/rust-version.sh
-        - PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH"
-        - readlink -f .
     #  Linux release artifacts are still built by ci/buildkite-secondary.yml
     #- <<: *release-artifacts
     #  name: "Linux release artifacts"
@@ -80,7 +73,7 @@ jobs:
 
       language: node_js
       node_js:
-        - "lts/*"
+        - "node"
 
       cache:
         directories:

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "accounts-cluster-bench",
     "bench-exchange",
     "bench-streamer",
     "bench-tps",
@@ -21,7 +20,6 @@ members = [
     "perf",
     "validator",
     "genesis",
-    "genesis-utils",
     "gossip",
     "install",
     "keygen",
@@ -32,6 +30,7 @@ members = [
     "log-analyzer",
     "merkle-root-bench",
     "merkle-tree",
+    "stake-o-matic",
     "storage-bigtable",
     "storage-proto",
     "streamer",
@@ -39,17 +38,21 @@ members = [
     "metrics",
     "net-shaper",
     "notifier",
-    "poh",
     "poh-bench",
     "program-test",
+    "programs/secp256k1",
     "programs/bpf_loader",
+    "programs/budget",
     "programs/config",
     "programs/exchange",
-    "programs/secp256k1",
+    "programs/failure",
+    "programs/noop",
+    "programs/ownable",
     "programs/stake",
+    "programs/vest",
     "programs/vote",
     "remote-wallet",
-    "rpc",
+    "ramp-tps",
     "runtime",
     "runtime/store-tool",
     "sdk",
@@ -57,6 +60,7 @@ members = [
     "sdk/cargo-test-bpf",
     "scripts",
     "stake-accounts",
+    "stake-monitor",
     "sys-tuner",
     "tokens",
     "transaction-status",
@@ -72,11 +76,3 @@ members = [
 exclude = [
     "programs/bpf",
 ]
-
-# TODO: Remove once the "simd-accel" feature from the reed-solomon-erasure
-# dependency is supported on Apple M1. v2 of the feature resolver is needed to
-# specify arch-specific features.
-resolver = "2"
-
-[profile.dev]
-split-debuginfo = "unpacked"

README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/IKyzQ6T.png" width="250" />
+    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
   </a>
 </p>
 
@@ -19,7 +19,7 @@ $ source $HOME/.cargo/env
 $ rustup component add rustfmt
 ```
 
-Please make sure you are always using the latest stable rust version by running:
+Please sure you are always using the latest stable rust version by running:
 
 ```bash
 $ rustup update
@@ -32,12 +32,6 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make
 ```
 
-On Mac M1s, make sure you set up your terminal & homebrew [to use](https://5balloons.info/correct-way-to-install-and-use-homebrew-on-m1-macs/) Rosetta. You can install it with:
-
-```bash
-$ softwareupdate --install-rosetta
-```
-
 ## **2. Download the source code.**
 
 ```bash
@@ -51,6 +45,11 @@ $ cd solana
 $ cargo build
 ```
 
+## **4. Run a minimal local cluster.**
+```bash
+$ ./run.sh
+```
+
 # Testing
 
 **Run the test suite:**
@@ -108,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,169 +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 report shall follow the process outlined within this document
-* Valid exploits can be eligible even if they are not successfully executed on the cluster
-* Multiple submissions for the same class of exploit are still eligible for compensation, though may be compensated at a lower rate, however these will be assessed on a case-by-case basis
-* Participants must complete KYC and sign the participation agreement here when the registrations are open https://solana.com/validator-registration. Security exploits will still be assessed and open for submission at all times. This needs only be done prior to distribution of tokens.
-
-Payment of Bug Bounties:
-* Payments for eligible bug reports are distributed monthly.
-* Bounties for all bug reports submitted in a given month are paid out in the middle of the
-following month.
-* The SOL/USD conversion rate used for payments is the market price at the end of
-  the last day of the month for the month in which the bug was submitted.
-* The reference for this price is the Closing Price given by Coingecko.com on
-  that date given here:
-  https://www.coingecko.com/en/coins/solana/historical_data/usd#panel
-* For example, for all bugs submitted in March 2021, the SOL/USD price for bug
-  payouts is the Close price on 2021-03-31 of $19.49.  This applies to all bugs
-  submitted in March 2021, to be paid in mid-April 2021.
-* Bug bounties are paid out in
-[stake accounts](https://solana.com/staking) with a
-[lockup](https://docs.solana.com/staking/stake-accounts#lockups)
-expiring 12 months from the last day of the month in which the bug was submitted.
-
-<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.7.18"
+version = "1.5.13"
 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,14 @@ bs58 = "0.3.1"
 bv = "0.11.1"
 Inflector = "0.11.4"
 lazy_static = "1.4.0"
-serde = "1.0.122"
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-config-program = { path = "../programs/config", version = "=1.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
-solana-vote-program = { path = "../programs/vote", version = "=1.7.18" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.2.0", features = ["no-entrypoint"] }
+solana-config-program = { path = "../programs/config", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.13" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.13" }
+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,
@@ -28,7 +25,6 @@ use {
 
 pub type StringAmount = String;
 pub type StringDecimals = String;
-pub const MAX_BASE58_BYTES: usize = 128;
 
 /// A duplicate representation of an Account for pretty JSON serialization
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -49,7 +45,7 @@ pub enum UiAccountData {
     Binary(String, UiAccountEncoding),
 }
 
-#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub enum UiAccountEncoding {
     Binary, // Legacy. Retained for RPC backwards compatibility
@@ -61,73 +57,58 @@ pub enum UiAccountEncoding {
 }
 
 impl UiAccount {
-    fn encode_bs58<T: ReadableAccount>(
-        account: &T,
-        data_slice_config: Option<UiDataSliceConfig>,
-    ) -> String {
-        if account.data().len() <= MAX_BASE58_BYTES {
-            bs58::encode(slice_data(account.data(), data_slice_config)).into_string()
-        } else {
-            "error: data too large for bs58 encoding".to_string()
-        }
-    }
-
-    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 => {
-                let data = Self::encode_bs58(account, data_slice_config);
-                UiAccountData::LegacyBinary(data)
-            }
-            UiAccountEncoding::Base58 => {
-                let data = Self::encode_bs58(account, data_slice_config);
-                UiAccountData::Binary(data, encoding)
-            }
+            UiAccountEncoding::Binary => UiAccountData::LegacyBinary(
+                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(),
+                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(),
@@ -147,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,
+        })
     }
 }
 
@@ -179,7 +160,7 @@ impl Default for UiFeeCalculator {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UiDataSliceConfig {
     pub offset: usize,
@@ -203,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() {
@@ -237,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,
@@ -250,9 +230,7 @@ mod test {
             UiAccountData::Binary(_, UiAccountEncoding::Base64Zstd)
         ));
 
-        let decoded_account = encoded_account.decode::<Account>().unwrap();
-        assert_eq!(decoded_account.data(), &vec![0; 1024]);
-        let decoded_account = encoded_account.decode::<AccountSharedData>().unwrap();
-        assert_eq!(decoded_account.data(), &vec![0; 1024]);
+        let decoded_account = encoded_account.decode().unwrap();
+        assert_eq!(decoded_account.data, vec![0; 1024]);
     }
 }

account-decoder/src/parse_account_data.rs

@@ -9,14 +9,14 @@ use crate::{
 };
 use inflector::Inflector;
 use serde_json::Value;
-use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, stake, system_program, sysvar};
+use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, system_program, sysvar};
 use std::collections::HashMap;
 use thiserror::Error;
 
 lazy_static! {
     static ref BPF_UPGRADEABLE_LOADER_PROGRAM_ID: Pubkey = solana_sdk::bpf_loader_upgradeable::id();
     static ref CONFIG_PROGRAM_ID: Pubkey = solana_config_program::id();
-    static ref STAKE_PROGRAM_ID: Pubkey = stake::program::id();
+    static ref STAKE_PROGRAM_ID: Pubkey = solana_stake_program::id();
     static ref SYSTEM_PROGRAM_ID: Pubkey = system_program::id();
     static ref SYSVAR_PROGRAM_ID: Pubkey = sysvar::id();
     static ref TOKEN_PROGRAM_ID: Pubkey = spl_token_id_v2_0();

account-decoder/src/parse_config.rs

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

account-decoder/src/parse_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_stake.rs

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

account-decoder/src/parse_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

@@ -14,23 +14,23 @@ use std::str::FromStr;
 // A helper function to convert spl_token_v2_0::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
 pub fn spl_token_id_v2_0() -> Pubkey {
-    Pubkey::new_from_array(spl_token_v2_0::id().to_bytes())
+    Pubkey::from_str(&spl_token_v2_0::id().to_string()).unwrap()
 }
 
 // A helper function to convert spl_token_v2_0::native_mint::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
 pub fn spl_token_v2_0_native_mint() -> Pubkey {
-    Pubkey::new_from_array(spl_token_v2_0::native_mint::id().to_bytes())
+    Pubkey::from_str(&spl_token_v2_0::native_mint::id().to_string()).unwrap()
 }
 
 // A helper function to convert a solana_sdk::pubkey::Pubkey to spl_sdk::pubkey::Pubkey
 pub fn spl_token_v2_0_pubkey(pubkey: &Pubkey) -> SplTokenPubkey {
-    SplTokenPubkey::new_from_array(pubkey.to_bytes())
+    SplTokenPubkey::from_str(&pubkey.to_string()).unwrap()
 }
 
 // A helper function to convert a spl_sdk::pubkey::Pubkey to solana_sdk::pubkey::Pubkey
 pub fn pubkey_from_spl_token_v2_0(pubkey: &SplTokenPubkey) -> Pubkey {
-    Pubkey::new_from_array(pubkey.to_bytes())
+    Pubkey::from_str(&pubkey.to_string()).unwrap()
 }
 
 pub fn parse_token(
@@ -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.7.18"
+version = "1.5.13"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -10,12 +10,12 @@ publish = false
 
 [dependencies]
 log = "0.4.11"
-rayon = "1.5.0"
-solana-logger = { path = "../logger", version = "=1.7.18" }
-solana-runtime = { path = "../runtime", version = "=1.7.18" }
-solana-measure = { path = "../measure", version = "=1.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
-solana-version = { path = "../version", version = "=1.7.18" }
+rayon = "1.4.0"
+solana-logger = { path = "../logger", version = "1.5.13" }
+solana-runtime = { path = "../runtime", version = "1.5.13" }
+solana-measure = { path = "../measure", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+solana-version = { path = "../version", version = "1.5.13" }
 rand = "0.7.0"
 clap = "2.33.1"
 crossbeam-channel = "0.4"

accounts-bench/src/main.rs

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

accounts-cluster-bench/.gitignore

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

accounts-cluster-bench/Cargo.toml

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

accounts-cluster-bench/src/main.rs

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

banking-bench/Cargo.toml

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

banking-bench/src/main.rs

@@ -4,8 +4,13 @@ use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
 use rayon::prelude::*;
-use solana_core::banking_stage::BankingStage;
-use solana_gossip::{cluster_info::ClusterInfo, cluster_info::Node};
+use solana_core::{
+    banking_stage::{create_test_recorder, BankingStage},
+    cluster_info::ClusterInfo,
+    cluster_info::Node,
+    poh_recorder::PohRecorder,
+    poh_recorder::WorkingBankEntry,
+};
 use solana_ledger::{
     blockstore::Blockstore,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
@@ -13,7 +18,6 @@ use solana_ledger::{
 };
 use solana_measure::measure::Measure;
 use solana_perf::packet::to_packets_chunked;
-use solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry};
 use solana_runtime::{
     accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
 };
@@ -25,7 +29,6 @@ use solana_sdk::{
     timing::{duration_as_us, timestamp},
     transaction::Transaction,
 };
-use solana_streamer::socket::SocketAddrSpace;
 use std::{
     sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex},
     thread::sleep,
@@ -75,7 +78,7 @@ fn make_accounts_txs(
         .into_par_iter()
         .map(|_| {
             let mut new = dummy.clone();
-            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
+            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
             if !same_payer {
                 new.message.account_keys[0] = solana_sdk::pubkey::new_rand();
             }
@@ -166,7 +169,6 @@ fn main() {
 
     let (verified_sender, verified_receiver) = unbounded();
     let (vote_sender, vote_receiver) = unbounded();
-    let (tpu_vote_sender, tpu_vote_receiver) = unbounded();
     let (replay_vote_sender, _replay_vote_receiver) = unbounded();
     let bank0 = Bank::new(&genesis_config);
     let mut bank_forks = BankForks::new(bank0);
@@ -187,7 +189,7 @@ fn main() {
             genesis_config.hash(),
         );
         // Ignore any pesky duplicate signature errors in the case we are using single-payer
-        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
+        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
         fund.signatures = vec![Signature::new(&sig[0..64])];
         let x = bank.process_transaction(&fund);
         x.unwrap();
@@ -197,7 +199,7 @@ fn main() {
     if !skip_sanity {
         //sanity check, make sure all the transactions can execute sequentially
         transactions.iter().for_each(|tx| {
-            let res = bank.process_transaction(tx);
+            let res = bank.process_transaction(&tx);
             assert!(res.is_ok(), "sanity test transactions error: {:?}", res);
         });
         bank.clear_signatures();
@@ -217,17 +219,12 @@ fn main() {
         );
         let (exit, poh_recorder, poh_service, signal_receiver) =
             create_test_recorder(&bank, &blockstore, None);
-        let cluster_info = ClusterInfo::new(
-            Node::new_localhost().info,
-            Arc::new(Keypair::new()),
-            SocketAddrSpace::Unspecified,
-        );
+        let cluster_info = ClusterInfo::new_with_invalid_keypair(Node::new_localhost().info);
         let cluster_info = Arc::new(cluster_info);
         let banking_stage = BankingStage::new(
             &cluster_info,
             &poh_recorder,
             verified_receiver,
-            tpu_vote_receiver,
             vote_receiver,
             None,
             replay_vote_sender,
@@ -358,7 +355,7 @@ fn main() {
             if bank.slot() > 0 && bank.slot() % 16 == 0 {
                 for tx in transactions.iter_mut() {
                     tx.message.recent_blockhash = bank.last_blockhash();
-                    let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
+                    let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
                     tx.signatures[0] = Signature::new(&sig[0..64]);
                 }
                 verified = to_packets_chunked(&transactions.clone(), packets_per_chunk);
@@ -383,7 +380,6 @@ fn main() {
         );
 
         drop(verified_sender);
-        drop(tpu_vote_sender);
         drop(vote_sender);
         exit.store(true, Ordering::Relaxed);
         banking_stage.join().unwrap();

banks-client/Cargo.toml

@@ -1,30 +1,29 @@
 [package]
 name = "solana-banks-client"
-version = "1.7.18"
+version = "1.5.13"
 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]
 bincode = "1.3.1"
-borsh = "0.9.0"
-borsh-derive = "0.9.0"
+borsh = "0.8.1"
+borsh-derive = "0.8.1"
 futures = "0.3"
 mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.7.18" }
-solana-program = { path = "../sdk/program", version = "=1.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
-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.13" }
+solana-program = { path = "../sdk/program", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+tarpc = { version = "0.23.0", features = ["full"] }
+tokio = { version = "0.3.5", features = ["full"] }
+tokio-serde = { version = "0.6", features = ["bincode"] }
 
 [dev-dependencies]
-solana-runtime = { path = "../runtime", version = "=1.7.18" }
-solana-banks-server = { path = "../banks-server", version = "=1.7.18" }
+solana-runtime = { path = "../runtime", version = "1.5.13" }
+solana-banks-server = { path = "../banks-server", version = "1.5.13" }
 
 [lib]
 crate-type = ["lib"]

banks-client/src/lib.rs

@@ -10,14 +10,8 @@ use futures::{future::join_all, Future, FutureExt};
 pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
 use solana_banks_interface::{BanksRequest, BanksResponse};
 use solana_program::{
-    clock::Clock,
-    clock::Slot,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    program_pack::Pack,
-    pubkey::Pubkey,
-    rent::Rent,
-    sysvar::{self, Sysvar},
+    clock::Slot, fee_calculator::FeeCalculator, hash::Hash, program_pack::Pack, pubkey::Pubkey,
+    rent::Rent, sysvar,
 };
 use solana_sdk::{
     account::{from_account, Account},
@@ -69,7 +63,7 @@ impl BanksClient {
         &mut self,
         ctx: Context,
         commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, u64)>> + '_ {
+    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
         self.inner
             .get_fees_with_commitment_and_context(ctx, commitment)
     }
@@ -91,14 +85,6 @@ impl BanksClient {
         self.inner.get_slot_with_context(ctx, commitment)
     }
 
-    pub fn get_block_height_with_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.inner.get_block_height_with_context(ctx, commitment)
-    }
-
     pub fn process_transaction_with_commitment_and_context(
         &mut self,
         ctx: Context,
@@ -129,39 +115,24 @@ impl BanksClient {
         self.send_transaction_with_context(context::current(), transaction)
     }
 
-    /// Return the cluster clock
-    pub fn get_clock(&mut self) -> impl Future<Output = io::Result<Clock>> + '_ {
-        self.get_account(sysvar::clock::id()).map(|result| {
-            let clock_sysvar = result?
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Clock sysvar not present"))?;
-            from_account::<Clock, _>(&clock_sysvar).ok_or_else(|| {
-                io::Error::new(io::ErrorKind::Other, "Failed to deserialize Clock sysvar")
-            })
-        })
-    }
-
     /// Return the fee parameters associated with a recent, rooted blockhash. The cluster
     /// will use the transaction's blockhash to look up these same fee parameters and
     /// use them to calculate the transaction fee.
     pub fn get_fees(
         &mut self,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, u64)>> + '_ {
+    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
         self.get_fees_with_commitment_and_context(context::current(), CommitmentLevel::default())
     }
 
-    /// Return the cluster Sysvar
-    pub fn get_sysvar<T: Sysvar>(&mut self) -> impl Future<Output = io::Result<T>> + '_ {
-        self.get_account(T::id()).map(|result| {
-            let sysvar = result?
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Sysvar not present"))?;
-            from_account::<T, _>(&sysvar)
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Failed to deserialize sysvar"))
-        })
-    }
-
     /// Return the cluster rent
     pub fn get_rent(&mut self) -> impl Future<Output = io::Result<Rent>> + '_ {
-        self.get_sysvar::<Rent>()
+        self.get_account(sysvar::rent::id()).map(|result| {
+            let rent_sysvar = result?
+                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Rent sysvar not present"))?;
+            from_account::<Rent>(&rent_sysvar).ok_or_else(|| {
+                io::Error::new(io::ErrorKind::Other, "Failed to deserialize Rent sysvar")
+            })
+        })
     }
 
     /// Return a recent, rooted blockhash from the server. The cluster will only accept
@@ -221,18 +192,12 @@ impl BanksClient {
         self.process_transactions_with_commitment(transactions, CommitmentLevel::default())
     }
 
-    /// Return the most recent rooted slot. All transactions at or below this slot
-    /// are said to be finalized. The cluster will not fork to a higher slot.
+    /// Return the most recent rooted slot height. All transactions at or below this height
+    /// are said to be finalized. The cluster will not fork to a higher slot height.
     pub fn get_root_slot(&mut self) -> impl Future<Output = io::Result<Slot>> + '_ {
         self.get_slot_with_context(context::current(), CommitmentLevel::default())
     }
 
-    /// Return the most recent rooted block height. All transactions at or below this height
-    /// are said to be finalized. The cluster will not fork to a higher block height.
-    pub fn get_root_block_height(&mut self) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.get_block_height_with_context(context::current(), CommitmentLevel::default())
-    }
-
     /// Return the account at the given address at the slot corresponding to the given
     /// commitment level. If the account is not found, None is returned.
     pub fn get_account_with_commitment(
@@ -412,13 +377,13 @@ mod tests {
 
         let mint_pubkey = &genesis.mint_keypair.pubkey();
         let bob_pubkey = solana_sdk::pubkey::new_rand();
-        let instruction = system_instruction::transfer(mint_pubkey, &bob_pubkey, 1);
-        let message = Message::new(&[instruction], Some(mint_pubkey));
+        let instruction = system_instruction::transfer(&mint_pubkey, &bob_pubkey, 1);
+        let message = Message::new(&[instruction], Some(&mint_pubkey));
 
         Runtime::new()?.block_on(async {
             let client_transport = start_local_server(bank_forks, block_commitment_cache).await;
             let mut banks_client = start_client(client_transport).await?;
-            let (_, recent_blockhash, last_valid_block_height) = banks_client.get_fees().await?;
+            let (_, recent_blockhash, last_valid_slot) = banks_client.get_fees().await?;
             let transaction = Transaction::new(&[&genesis.mint_keypair], message, recent_blockhash);
             let signature = transaction.signatures[0];
             banks_client.send_transaction(transaction).await?;
@@ -426,8 +391,8 @@ mod tests {
             let mut status = banks_client.get_transaction_status(signature).await?;
 
             while status.is_none() {
-                let root_block_height = banks_client.get_root_block_height().await?;
-                if root_block_height > last_valid_block_height {
+                let root_slot = banks_client.get_root_slot().await?;
+                if root_slot > last_valid_slot {
                     break;
                 }
                 sleep(Duration::from_millis(100)).await;

banks-interface/Cargo.toml

@@ -1,22 +1,21 @@
 [package]
 name = "solana-banks-interface"
-version = "1.7.18"
+version = "1.5.13"
 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.7.18" }
-tarpc = { version = "0.24.1", features = ["full"] }
+serde = { version = "1.0.118", features = ["derive"] }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+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-interface/src/lib.rs

@@ -34,7 +34,6 @@ pub trait Banks {
     async fn get_transaction_status_with_context(signature: Signature)
         -> Option<TransactionStatus>;
     async fn get_slot_with_context(commitment: CommitmentLevel) -> Slot;
-    async fn get_block_height_with_context(commitment: CommitmentLevel) -> u64;
     async fn process_transaction_with_commitment_and_context(
         transaction: Transaction,
         commitment: CommitmentLevel,

banks-server/Cargo.toml

@@ -1,12 +1,11 @@
 [package]
 name = "solana-banks-server"
-version = "1.7.18"
+version = "1.5.13"
 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.7.18" }
-solana-runtime = { path = "../runtime", version = "=1.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
-solana-metrics = { path = "../metrics", version = "=1.7.18" }
-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.13" }
+solana-runtime = { path = "../runtime", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+solana-metrics = { path = "../metrics", version = "1.5.13" }
+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

@@ -113,7 +113,7 @@ impl BanksServer {
         self,
         signature: &Signature,
         blockhash: &Hash,
-        last_valid_block_height: u64,
+        last_valid_slot: Slot,
         commitment: CommitmentLevel,
     ) -> Option<transaction::Result<()>> {
         let mut status = self
@@ -122,7 +122,7 @@ impl BanksServer {
         while status.is_none() {
             sleep(Duration::from_millis(200)).await;
             let bank = self.bank(commitment);
-            if bank.block_height() > last_valid_block_height {
+            if bank.slot() > last_valid_slot {
                 break;
             }
             status = bank.get_signature_status_with_blockhash(signature, blockhash);
@@ -131,13 +131,10 @@ impl BanksServer {
     }
 }
 
-fn verify_transaction(
-    transaction: &Transaction,
-    libsecp256k1_0_5_upgrade_enabled: bool,
-) -> transaction::Result<()> {
+fn verify_transaction(transaction: &Transaction) -> transaction::Result<()> {
     if let Err(err) = transaction.verify() {
         Err(err)
-    } else if let Err(err) = transaction.verify_precompiles(libsecp256k1_0_5_upgrade_enabled) {
+    } else if let Err(err) = transaction.verify_precompiles() {
         Err(err)
     } else {
         Ok(())
@@ -148,19 +145,16 @@ fn verify_transaction(
 impl Banks for BanksServer {
     async fn send_transaction_with_context(self, _: Context, transaction: Transaction) {
         let blockhash = &transaction.message.recent_blockhash;
-        let last_valid_block_height = self
+        let last_valid_slot = self
             .bank_forks
             .read()
             .unwrap()
             .root_bank()
-            .get_blockhash_last_valid_block_height(blockhash)
+            .get_blockhash_last_valid_slot(&blockhash)
             .unwrap();
         let signature = transaction.signatures.get(0).cloned().unwrap_or_default();
-        let info = TransactionInfo::new(
-            signature,
-            serialize(&transaction).unwrap(),
-            last_valid_block_height,
-        );
+        let info =
+            TransactionInfo::new(signature, serialize(&transaction).unwrap(), last_valid_slot);
         self.transaction_sender.send(info).unwrap();
     }
 
@@ -168,13 +162,11 @@ impl Banks for BanksServer {
         self,
         _: Context,
         commitment: CommitmentLevel,
-    ) -> (FeeCalculator, Hash, u64) {
+    ) -> (FeeCalculator, Hash, Slot) {
         let bank = self.bank(commitment);
         let (blockhash, fee_calculator) = bank.last_blockhash_with_fee_calculator();
-        let last_valid_block_height = bank
-            .get_blockhash_last_valid_block_height(&blockhash)
-            .unwrap();
-        (fee_calculator, blockhash, last_valid_block_height)
+        let last_valid_slot = bank.get_blockhash_last_valid_slot(&blockhash).unwrap();
+        (fee_calculator, blockhash, last_valid_slot)
     }
 
     async fn get_transaction_status_with_context(
@@ -217,39 +209,29 @@ impl Banks for BanksServer {
         self.slot(commitment)
     }
 
-    async fn get_block_height_with_context(self, _: Context, commitment: CommitmentLevel) -> u64 {
-        self.bank(commitment).block_height()
-    }
-
     async fn process_transaction_with_commitment_and_context(
         self,
         _: Context,
         transaction: Transaction,
         commitment: CommitmentLevel,
     ) -> Option<transaction::Result<()>> {
-        if let Err(err) = verify_transaction(
-            &transaction,
-            self.bank(commitment).libsecp256k1_0_5_upgrade_enabled(),
-        ) {
+        if let Err(err) = verify_transaction(&transaction) {
             return Some(Err(err));
         }
 
         let blockhash = &transaction.message.recent_blockhash;
-        let last_valid_block_height = self
+        let last_valid_slot = self
             .bank_forks
             .read()
             .unwrap()
             .root_bank()
-            .get_blockhash_last_valid_block_height(blockhash)
+            .get_blockhash_last_valid_slot(blockhash)
             .unwrap();
         let signature = transaction.signatures.get(0).cloned().unwrap_or_default();
-        let info = TransactionInfo::new(
-            signature,
-            serialize(&transaction).unwrap(),
-            last_valid_block_height,
-        );
+        let info =
+            TransactionInfo::new(signature, serialize(&transaction).unwrap(), last_valid_slot);
         self.transaction_sender.send(info).unwrap();
-        self.poll_signature_status(&signature, blockhash, last_valid_block_height, commitment)
+        self.poll_signature_status(&signature, blockhash, last_valid_slot, commitment)
             .await
     }
 
@@ -260,7 +242,7 @@ impl Banks for BanksServer {
         commitment: CommitmentLevel,
     ) -> Option<Account> {
         let bank = self.bank(commitment);
-        bank.get_account(&address).map(Account::from)
+        bank.get_account(&address)
     }
 }
 

banks-server/src/rpc_banks_service.rs

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

banks-server/src/send_transaction_service.rs

@@ -2,7 +2,7 @@
 use log::*;
 use solana_metrics::{datapoint_warn, inc_new_counter_info};
 use solana_runtime::{bank::Bank, bank_forks::BankForks};
-use solana_sdk::signature::Signature;
+use solana_sdk::{clock::Slot, signature::Signature};
 use std::{
     collections::HashMap,
     net::{SocketAddr, UdpSocket},
@@ -24,19 +24,15 @@ pub struct SendTransactionService {
 pub struct TransactionInfo {
     pub signature: Signature,
     pub wire_transaction: Vec<u8>,
-    pub last_valid_block_height: u64,
+    pub last_valid_slot: Slot,
 }
 
 impl TransactionInfo {
-    pub fn new(
-        signature: Signature,
-        wire_transaction: Vec<u8>,
-        last_valid_block_height: u64,
-    ) -> Self {
+    pub fn new(signature: Signature, wire_transaction: Vec<u8>, last_valid_slot: Slot) -> Self {
         Self {
             signature,
             wire_transaction,
-            last_valid_block_height,
+            last_valid_slot,
         }
     }
 }
@@ -128,7 +124,7 @@ impl SendTransactionService {
                 result.rooted += 1;
                 inc_new_counter_info!("send_transaction_service-rooted", 1);
                 false
-            } else if transaction_info.last_valid_block_height < root_bank.block_height() {
+            } else if transaction_info.last_valid_slot < root_bank.slot() {
                 info!("Dropping expired transaction: {}", signature);
                 result.expired += 1;
                 inc_new_counter_info!("send_transaction_service-expired", 1);
@@ -142,8 +138,8 @@ impl SendTransactionService {
                         result.retried += 1;
                         inc_new_counter_info!("send_transaction_service-retry", 1);
                         Self::send_transaction(
-                            send_socket,
-                            tpu_address,
+                            &send_socket,
+                            &tpu_address,
                             &transaction_info.wire_transaction,
                         );
                         true

bench-exchange/Cargo.toml

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

bench-exchange/src/bench.rs

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

bench-exchange/src/main.rs

@@ -5,9 +5,8 @@ pub mod order_book;
 
 use crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config};
 use log::*;
-use solana_gossip::gossip_service::{discover_cluster, get_multi_client};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
 use solana_sdk::signature::Signer;
-use solana_streamer::socket::SocketAddrSpace;
 
 fn main() {
     solana_logger::setup();
@@ -56,12 +55,11 @@ fn main() {
         );
     } else {
         info!("Connecting to the cluster");
-        let nodes = discover_cluster(&entrypoint_addr, num_nodes, SocketAddrSpace::Unspecified)
-            .unwrap_or_else(|_| {
-                panic!("Failed to discover nodes");
-            });
+        let nodes = discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
+            panic!("Failed to discover nodes");
+        });
 
-        let (client, num_clients) = get_multi_client(&nodes, &SocketAddrSpace::Unspecified);
+        let (client, num_clients) = get_multi_client(&nodes);
 
         info!("{} nodes found", num_clients);
         if num_clients < num_nodes {

bench-exchange/tests/bench_exchange.rs

@@ -1,22 +1,19 @@
 use log::*;
 use solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
 use solana_core::validator::ValidatorConfig;
-use solana_exchange_program::{
-    exchange_processor::process_instruction, id, solana_exchange_program,
-};
+use solana_exchange_program::exchange_processor::process_instruction;
+use solana_exchange_program::id;
+use solana_exchange_program::solana_exchange_program;
 use solana_faucet::faucet::run_local_faucet_with_port;
-use solana_gossip::gossip_service::{discover_cluster, get_multi_client};
-use solana_local_cluster::{
-    local_cluster::{ClusterConfig, LocalCluster},
-    validator_configs::make_identical_validator_configs,
-};
-use solana_runtime::{bank::Bank, bank_client::BankClient};
-use solana_sdk::{
-    genesis_config::create_genesis_config,
-    signature::{Keypair, Signer},
-};
-use solana_streamer::socket::SocketAddrSpace;
-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]
@@ -44,19 +41,13 @@ fn test_exchange_local_cluster() {
     } = config;
     let accounts_in_groups = batch_size * account_groups;
 
-    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,
-            ),
-            native_instruction_processors: [solana_exchange_program!()].to_vec(),
-            ..ClusterConfig::default()
-        },
-        SocketAddrSpace::Unspecified,
-    );
+    let cluster = LocalCluster::new(&mut ClusterConfig {
+        node_stakes: vec![100_000; NUM_NODES],
+        cluster_lamports: 100_000_000_000_000,
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
+        native_instruction_processors: [solana_exchange_program!()].to_vec(),
+        ..ClusterConfig::default()
+    });
 
     let faucet_keypair = Keypair::new();
     cluster.transfer(
@@ -73,17 +64,13 @@ fn test_exchange_local_cluster() {
         .expect("faucet_addr");
 
     info!("Connecting to the cluster");
-    let nodes = discover_cluster(
-        &cluster.entry_point_info.gossip,
-        NUM_NODES,
-        SocketAddrSpace::Unspecified,
-    )
-    .unwrap_or_else(|err| {
-        error!("Failed to discover {} nodes: {:?}", NUM_NODES, err);
-        exit(1);
-    });
+    let nodes =
+        discover_cluster(&cluster.entry_point_info.gossip, NUM_NODES).unwrap_or_else(|err| {
+            error!("Failed to discover {} nodes: {:?}", NUM_NODES, err);
+            exit(1);
+        });
 
-    let (client, num_clients) = get_multi_client(&nodes, &SocketAddrSpace::Unspecified);
+    let (client, num_clients) = get_multi_client(&nodes);
 
     info!("clients: {}", num_clients);
     assert!(num_clients >= NUM_NODES);

bench-streamer/Cargo.toml

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

bench-streamer/src/main.rs

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

bench-tps/Cargo.toml

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

bench-tps/src/bench.rs

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

bench-tps/src/main.rs

@@ -2,12 +2,11 @@
 use log::*;
 use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs};
 use solana_bench_tps::cli;
+use solana_core::gossip_service::{discover_cluster, get_client, get_multi_client};
 use solana_genesis::Base64Account;
-use solana_gossip::gossip_service::{discover_cluster, get_client, get_multi_client};
 use solana_sdk::fee_calculator::FeeRateGovernor;
 use solana_sdk::signature::{Keypair, Signer};
 use solana_sdk::system_program;
-use solana_streamer::socket::SocketAddrSpace;
 use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc};
 
 /// Number of signatures for all transactions in ~1 week at ~100K TPS
@@ -40,7 +39,7 @@ fn main() {
     let keypair_count = *tx_count * keypair_multiplier;
     if *write_to_client_file {
         info!("Generating {} keypairs", keypair_count);
-        let (keypairs, _) = generate_keypairs(id, keypair_count as u64);
+        let (keypairs, _) = generate_keypairs(&id, keypair_count as u64);
         let num_accounts = keypairs.len() as u64;
         let max_fee =
             FeeRateGovernor::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
@@ -69,14 +68,13 @@ fn main() {
     }
 
     info!("Connecting to the cluster");
-    let nodes = discover_cluster(entrypoint_addr, *num_nodes, SocketAddrSpace::Unspecified)
-        .unwrap_or_else(|err| {
-            eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
-            exit(1);
-        });
+    let nodes = discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
+        eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
+        exit(1);
+    });
 
     let client = if *multi_client {
-        let (client, num_clients) = get_multi_client(&nodes, &SocketAddrSpace::Unspecified);
+        let (client, num_clients) = get_multi_client(&nodes);
         if nodes.len() < num_clients {
             eprintln!(
                 "Error: Insufficient nodes discovered.  Expecting {} or more",
@@ -90,7 +88,7 @@ fn main() {
         let mut target_client = None;
         for node in nodes {
             if node.id == *target_node {
-                target_client = Some(Arc::new(get_client(&[node], &SocketAddrSpace::Unspecified)));
+                target_client = Some(Arc::new(get_client(&[node])));
                 break;
             }
         }
@@ -99,7 +97,7 @@ fn main() {
             exit(1);
         })
     } else {
-        Arc::new(get_client(&nodes, &SocketAddrSpace::Unspecified))
+        Arc::new(get_client(&nodes))
     };
 
     let keypairs = if *read_from_client_file {
@@ -137,7 +135,7 @@ fn main() {
         generate_and_fund_keypairs(
             client.clone(),
             Some(*faucet_addr),
-            id,
+            &id,
             keypair_count,
             *num_lamports_per_account,
         )

bench-tps/tests/bench_tps.rs

@@ -1,42 +1,28 @@
 #![allow(clippy::integer_arithmetic)]
-use serial_test::serial;
-use solana_bench_tps::{
-    bench::{do_bench_tps, generate_and_fund_keypairs},
-    cli::Config,
-};
+use serial_test_derive::serial;
+use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs};
+use solana_bench_tps::cli::Config;
 use solana_client::thin_client::create_client;
+use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
 use solana_core::validator::ValidatorConfig;
 use solana_faucet::faucet::run_local_faucet_with_port;
-use solana_gossip::cluster_info::VALIDATOR_PORT_RANGE;
-use solana_local_cluster::{
-    local_cluster::{ClusterConfig, LocalCluster},
-    validator_configs::make_identical_validator_configs,
-};
+use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_sdk::signature::{Keypair, Signer};
-use solana_streamer::socket::SocketAddrSpace;
-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![];
 
     solana_logger::setup();
     const NUM_NODES: usize = 1;
-    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,
-            ),
-            native_instruction_processors,
-            ..ClusterConfig::default()
-        },
-        SocketAddrSpace::Unspecified,
-    );
+    let cluster = LocalCluster::new(&mut ClusterConfig {
+        node_stakes: vec![999_990; NUM_NODES],
+        cluster_lamports: 200_000_000,
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
+        native_instruction_processors,
+        ..ClusterConfig::default()
+    });
 
     let faucet_keypair = Keypair::new();
     cluster.transfer(

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/buildkite-pipeline.sh

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

ci/buildkite-secondary.yml

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

ci/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
   #
@@ -28,29 +30,18 @@ cargo_audit_ignores=(
   # Blocked on multiple crates updating `time` to >= 0.2.23
   --ignore RUSTSEC-2020-0071
 
+  # difference is unmaintained
+  #
+  # Blocked on predicates v1.0.6 removing its dependency on `difference`
+  --ignore RUSTSEC-2020-0095
+
+  # hyper is upgraded on master/v1.6 but not for v1.5
+  --ignore RUSTSEC-2021-0020
+
   # 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
 
-  # hyper: Lenient `hyper` header parsing of `Content-Length` could allow request smuggling
-  #
-  # Blocked on jsonrpc removing dependency on unmaintained `websocket`
-  # https://github.com/paritytech/jsonrpc/issues/605
-  --ignore RUSTSEC-2021-0078
-
-  # hyper: Integer overflow in `hyper`'s parsing of the `Transfer-Encoding` header leads to data loss
-  #
-  # Blocked on jsonrpc removing dependency on unmaintained `websocket`
-  # https://github.com/paritytech/jsonrpc/issues/605
-  --ignore RUSTSEC-2021-0079
-
-  # chrono: Potential segfault in `localtime_r` invocations
-  #
-  # Blocked due to no safe upgrade
-  # https://github.com/chronotope/chrono/issues/499
-  --ignore RUSTSEC-2020-0159
-
 )
-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.52.1
+FROM solanalabs/rust:1.49.0
 ARG date
 
 RUN set -x \

ci/docker-rust/Dockerfile

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

ci/env.sh

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

ci/localnet-sanity.sh

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

ci/order-crates-for-publishing.py

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

ci/publish-bpf-sdk.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")/.."
+eval "$(ci/channel-info.sh)"
+
+if [[ -n "$CI_TAG" ]]; then
+  CHANNEL_OR_TAG=$CI_TAG
+else
+  CHANNEL_OR_TAG=$CHANNEL
+fi
+
+(
+  set -x
+  sdk/bpf/scripts/package.sh
+  [[ -f bpf-sdk.tar.bz2 ]]
+)
+
+source ci/upload-ci-artifact.sh
+echo --- AWS S3 Store
+if [[ -z $CHANNEL_OR_TAG ]]; then
+  echo Skipped
+else
+  upload-s3-artifact "/solana/bpf-sdk.tar.bz2" "s3://solana-sdk/$CHANNEL_OR_TAG/bpf-sdk.tar.bz2"
+fi
+
+exit 0

ci/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-local.sh

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

ci/run-sanity.sh

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

ci/rust-version.sh

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

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

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

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

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

ci/test-bench.sh

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

ci/test-checks.sh

@@ -14,7 +14,7 @@ scripts/increment-cargo-version.sh check
 
 # Disallow uncommitted Cargo.lock changes
 (
-  _ scripts/cargo-for-all-lock-files.sh tree >/dev/null
+  _ scripts/cargo-for-all-lock-files.sh tree
   set +e
   if ! _ git diff --exit-code; then
     echo -e "\nError: Uncommitted Cargo.lock changes" 1>&2
@@ -35,10 +35,8 @@ echo --- build environment
   "$cargo" stable clippy --version --verbose
   "$cargo" nightly clippy --version --verbose
 
-  # audit is done only with "$cargo stable"
+  # audit is done only with stable
   "$cargo" stable audit --version
-
-  grcov --version
 )
 
 export RUST_BACKTRACE=1
@@ -47,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=$?
@@ -58,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
@@ -67,8 +65,7 @@ _ ci/order-crates-for-publishing.py
 
 # -Z... is needed because of clippy bug: https://github.com/rust-lang/rust-clippy/issues/4612
 # run nightly clippy for `sdk/` as there's a moderate amount of nightly-only code there
-_ "$cargo" nightly clippy -Zunstable-options --workspace --all-targets -- \
-  --deny=warnings --deny=clippy::integer_arithmetic --allow=clippy::inconsistent_struct_constructor
+_ "$cargo" nightly clippy -Zunstable-options --workspace --all-targets -- --deny=warnings --deny=clippy::integer_arithmetic
 
 _ "$cargo" stable fmt --all -- --check
 
@@ -82,6 +79,7 @@ _ ci/do-audit.sh
       cd "$project"
       _ "$cargo" nightly clippy -- --deny=warnings --allow=clippy::missing_safety_doc
       _ "$cargo" stable fmt -- --check
+      _ "$cargo" nightly test
     )
   done
 }

ci/test-downstream-builds.sh

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

ci/test-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-bpf.sh

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

ci/test-stable.sh

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

clap-utils/Cargo.toml

@@ -1,28 +1,23 @@
 [package]
 name = "solana-clap-utils"
-version = "1.7.18"
+version = "1.5.13"
 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.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
 thiserror = "1.0.21"
-tiny-bip39 = "0.8.1"
-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,24 +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,
 };
-
-// Sentinel value used to indicate to write to screen instead of file
-pub const STDOUT_OUTFILE_TOKEN: &str = "-";
+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>>
@@ -60,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, true).ok()
+            keypair_from_seed_phrase(name, skip_validation, true).ok()
         } else {
             read_keypair_file(value).ok()
         }
@@ -75,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, true).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
@@ -96,26 +71,6 @@ where
         .map_err(|err| format!("{}", err))
 }
 
-// Return an error if a `SignerSourceKind::Prompt` cannot be parsed
-pub fn is_prompt_signer_source<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + Display,
-{
-    if string.as_ref() == ASK_KEYWORD {
-        return Ok(());
-    }
-    match parse_signer_source(string.as_ref())
-        .map_err(|err| format!("{}", err))?
-        .kind
-    {
-        SignerSourceKind::Prompt => Ok(()),
-        _ => Err(format!(
-            "Unable to parse input as `prompt:` URI scheme or `ASK` keyword: {}",
-            string
-        )),
-    }
-}
-
 // Return an error if string cannot be parsed as pubkey string or keypair file location
 pub fn is_pubkey_or_keypair<T>(string: T) -> Result<(), String>
 where
@@ -130,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(()),
     }
 }
@@ -215,8 +167,8 @@ where
 pub fn normalize_to_url_if_moniker<T: AsRef<str>>(url_or_moniker: T) -> String {
     match url_or_moniker.as_ref() {
         "m" | "mainnet-beta" => "https://api.mainnet-beta.solana.com",
-        "t" | "testnet" => "https://api.testnet.solana.com",
-        "d" | "devnet" => "https://api.devnet.solana.com",
+        "t" | "testnet" => "https://testnet.solana.com",
+        "d" | "devnet" => "https://devnet.solana.com",
         "l" | "localhost" => "http://localhost:8899",
         url => url,
     }

clap-utils/src/keypair.rs

@@ -1,44 +1,33 @@
-use {
-    crate::{
-        input_parsers::{pubkeys_sigs_of, STDOUT_OUTFILE_TOKEN},
-        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,
-            keypair_from_seed_and_derivation_path, keypair_from_seed_phrase_and_passphrase,
-            read_keypair, read_keypair_file, Keypair, NullSigner, Presigner, Signature, Signer,
-        },
-    },
-    std::{
-        cell::RefCell,
-        convert::TryFrom,
-        error,
-        io::{stdin, stdout, Write},
-        ops::Deref,
-        process::exit,
-        str::FromStr,
-        sync::Arc,
-    },
-    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>,
@@ -78,62 +67,14 @@ 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()
-    }
 }
 
-#[derive(Debug, Default)]
 pub struct DefaultSigner {
     pub arg_name: String,
     pub path: String,
-    is_path_checked: RefCell<bool>,
 }
 
 impl DefaultSigner {
-    pub fn new<AN: AsRef<str>, P: AsRef<str>>(arg_name: AN, path: P) -> Self {
-        let arg_name = arg_name.as_ref().to_string();
-        let path = path.as_ref().to_string();
-        Self {
-            arg_name,
-            path,
-            ..Self::default()
-        }
-    }
-
-    fn path(&self) -> Result<&str, Box<dyn std::error::Error>> {
-        if !self.is_path_checked.borrow().deref() {
-            parse_signer_source(&self.path)
-                .and_then(|s| {
-                    if let SignerSourceKind::Filepath(path) = &s.kind {
-                        std::fs::metadata(path).map(|_| ()).map_err(|e| e.into())
-                    } else {
-                        Ok(())
-                    }
-                })
-                .map_err(|_| {
-                    std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        format!(
-                        "No default signer found, run \"solana-keygen new -o {}\" to create a new one",
-                        self.path
-                    ),
-                    )
-                })?;
-            *self.is_path_checked.borrow_mut() = true;
-        }
-        Ok(&self.path)
-    }
-
     pub fn generate_unique_signers(
         &self,
         bulk_signers: Vec<Option<Box<dyn Signer>>>,
@@ -148,9 +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 {
@@ -163,160 +106,29 @@ impl DefaultSigner {
         matches: &ArgMatches,
         wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
     ) -> Result<Box<dyn Signer>, Box<dyn std::error::Error>> {
-        signer_from_path(matches, self.path()?, &self.arg_name, wallet_manager)
-    }
-
-    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,
-        )
+        signer_from_path(matches, &self.path, &self.arg_name, wallet_manager)
     }
 }
 
-pub(crate) struct SignerSource {
-    pub kind: SignerSourceKind,
-    pub derivation_path: Option<DerivationPath>,
-    pub legacy: bool,
-}
-
-impl SignerSource {
-    fn new(kind: SignerSourceKind) -> Self {
-        Self {
-            kind,
-            derivation_path: None,
-            legacy: false,
-        }
-    }
-
-    fn new_legacy(kind: SignerSourceKind) -> Self {
-        Self {
-            kind,
-            derivation_path: None,
-            legacy: true,
-        }
-    }
-}
-
-const SIGNER_SOURCE_PROMPT: &str = "prompt";
-const SIGNER_SOURCE_FILEPATH: &str = "file";
-const SIGNER_SOURCE_USB: &str = "usb";
-const SIGNER_SOURCE_STDIN: &str = "stdin";
-const SIGNER_SOURCE_PUBKEY: &str = "pubkey";
-
-pub(crate) enum SignerSourceKind {
-    Prompt,
+pub enum KeypairUrl {
+    Ask,
     Filepath(String),
-    Usb(RemoteWalletLocator),
+    Usb(String),
     Stdin,
     Pubkey(Pubkey),
 }
 
-impl AsRef<str> for SignerSourceKind {
-    fn as_ref(&self) -> &str {
-        match self {
-            Self::Prompt => SIGNER_SOURCE_PROMPT,
-            Self::Filepath(_) => SIGNER_SOURCE_FILEPATH,
-            Self::Usb(_) => SIGNER_SOURCE_USB,
-            Self::Stdin => SIGNER_SOURCE_STDIN,
-            Self::Pubkey(_) => SIGNER_SOURCE_PUBKEY,
-        }
-    }
-}
-
-impl std::fmt::Debug for SignerSourceKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let s: &str = self.as_ref();
-        write!(f, "{}", s)
-    }
-}
-
-#[derive(Debug, Error)]
-pub(crate) enum SignerSourceError {
-    #[error("unrecognized signer source")]
-    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();
-    let source = {
-        #[cfg(target_family = "windows")]
-        {
-            // trim matched single-quotes since cmd.exe won't
-            let mut source = source;
-            while let Some(trimmed) = source.strip_prefix('\'') {
-                source = if let Some(trimmed) = trimmed.strip_suffix('\'') {
-                    trimmed
-                } else {
-                    break;
-                }
-            }
-            source.replace("\\", "/")
-        }
-        #[cfg(not(target_family = "windows"))]
-        {
-            source.to_string()
-        }
-    };
-    match uriparse::URIReference::try_from(source.as_str()) {
-        Err(_) => Err(SignerSourceError::UnrecognizedSource),
-        Ok(uri) => {
-            if let Some(scheme) = uri.scheme() {
-                let scheme = scheme.as_str().to_ascii_lowercase();
-                match scheme.as_str() {
-                    SIGNER_SOURCE_PROMPT => Ok(SignerSource {
-                        kind: SignerSourceKind::Prompt,
-                        derivation_path: DerivationPath::from_uri_any_query(&uri)?,
-                        legacy: false,
-                    }),
-                    SIGNER_SOURCE_FILEPATH => Ok(SignerSource::new(SignerSourceKind::Filepath(
-                        uri.path().to_string(),
-                    ))),
-                    SIGNER_SOURCE_USB => Ok(SignerSource {
-                        kind: SignerSourceKind::Usb(RemoteWalletLocator::new_from_uri(&uri)?),
-                        derivation_path: DerivationPath::from_uri_key_query(&uri)?,
-                        legacy: false,
-                    }),
-                    SIGNER_SOURCE_STDIN => Ok(SignerSource::new(SignerSourceKind::Stdin)),
-                    _ => {
-                        #[cfg(target_family = "windows")]
-                        // On Windows, an absolute path's drive letter will be parsed as the URI
-                        // scheme. Assume a filepath source in case of a single character shceme.
-                        if scheme.len() == 1 {
-                            return Ok(SignerSource::new(SignerSourceKind::Filepath(source)));
-                        }
-                        Err(SignerSourceError::UnrecognizedSource)
-                    }
-                }
-            } else {
-                match source.as_str() {
-                    STDOUT_OUTFILE_TOKEN => Ok(SignerSource::new(SignerSourceKind::Stdin)),
-                    ASK_KEYWORD => Ok(SignerSource::new_legacy(SignerSourceKind::Prompt)),
-                    _ => match Pubkey::from_str(source.as_str()) {
-                        Ok(pubkey) => Ok(SignerSource::new(SignerSourceKind::Pubkey(pubkey))),
-                        Err(_) => std::fs::metadata(source.as_str())
-                            .map(|_| SignerSource::new(SignerSourceKind::Filepath(source)))
-                            .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())
     }
 }
 
@@ -333,53 +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,
-        legacy,
-    } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Prompt => {
+    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,
-                legacy,
             )?))
         }
-        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),
@@ -387,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,
@@ -407,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(
@@ -432,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()),
     }
 }
@@ -445,51 +224,34 @@ 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,
-        legacy,
-    } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Prompt => {
+    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,
-                legacy,
-            )
-            .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
-                ),
+                format!("could not read keypair file \"{}\". Run \"solana-keygen new\" to create a keypair file: {}", path, e),
             )
             .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,
@@ -504,7 +266,7 @@ pub fn resolve_signer_from_path(
     }
 }
 
-// Keyword used to indicate that the user should be prompted for a keypair seed phrase
+// Keyword used to indicate that the user should be asked for a keypair seed phrase
 pub const ASK_KEYWORD: &str = "ASK";
 
 pub const SKIP_SEED_PHRASE_VALIDATION_ARG: ArgConstant<'static> = ArgConstant {
@@ -515,7 +277,7 @@ pub const SKIP_SEED_PHRASE_VALIDATION_ARG: ArgConstant<'static> = ArgConstant {
 
 /// Prompts user for a passphrase and then asks for confirmirmation to check for mistakes
 pub fn prompt_passphrase(prompt: &str) -> Result<String, Box<dyn error::Error>> {
-    let passphrase = prompt_password_stderr(prompt)?;
+    let passphrase = prompt_password_stderr(&prompt)?;
     if !passphrase.is_empty() {
         let confirmed = rpassword::prompt_password_stderr("Enter same passphrase again: ")?;
         if confirmed != passphrase {
@@ -525,56 +287,6 @@ pub fn prompt_passphrase(prompt: &str) -> Result<String, Box<dyn error::Error>>
     Ok(passphrase)
 }
 
-/// Parses a path into a SignerSource and returns a Keypair for supporting SignerSourceKinds
-pub fn keypair_from_path(
-    matches: &ArgMatches,
-    path: &str,
-    keypair_name: &str,
-    confirm_pubkey: bool,
-) -> Result<Keypair, Box<dyn error::Error>> {
-    let SignerSource {
-        kind,
-        derivation_path,
-        legacy,
-    } = parse_signer_source(path)?;
-    match kind {
-        SignerSourceKind::Prompt => {
-            let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-            Ok(keypair_from_seed_phrase(
-                keypair_name,
-                skip_validation,
-                confirm_pubkey,
-                derivation_path,
-                legacy,
-            )?)
-        }
-        SignerSourceKind::Filepath(path) => match read_keypair_file(&path) {
-            Err(e) => Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "could not read keypair file \"{}\". \
-                    Run \"solana-keygen new\" to create a keypair file: {}",
-                    path, e
-                ),
-            )
-            .into()),
-            Ok(file) => Ok(file),
-        },
-        SignerSourceKind::Stdin => {
-            let mut stdin = std::io::stdin();
-            Ok(read_keypair(&mut stdin)?)
-        }
-        _ => Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            format!(
-                "signer of type `{:?}` does not support Keypair output",
-                kind
-            ),
-        )
-        .into()),
-    }
-}
-
 /// Reads user input from stdin to retrieve a seed phrase and passphrase for keypair derivation
 /// Optionally skips validation of seed phrase
 /// Optionally confirms recovered public key
@@ -582,8 +294,6 @@ pub fn keypair_from_seed_phrase(
     keypair_name: &str,
     skip_validation: bool,
     confirm_pubkey: bool,
-    derivation_path: Option<DerivationPath>,
-    legacy: bool,
 ) -> Result<Keypair, Box<dyn error::Error>> {
     let seed_phrase = prompt_password_stderr(&format!("[{}] seed phrase: ", keypair_name))?;
     let seed_phrase = seed_phrase.trim();
@@ -594,12 +304,7 @@ pub fn keypair_from_seed_phrase(
 
     let keypair = if skip_validation {
         let passphrase = prompt_passphrase(&passphrase_prompt)?;
-        if legacy {
-            keypair_from_seed_phrase_and_passphrase(seed_phrase, &passphrase)?
-        } else {
-            let seed = generate_seed_from_seed_phrase_and_passphrase(seed_phrase, &passphrase);
-            keypair_from_seed_and_derivation_path(&seed, derivation_path)?
-        }
+        keypair_from_seed_phrase_and_passphrase(&seed_phrase, &passphrase)?
     } else {
         let sanitized = sanitize_seed_phrase(seed_phrase);
         let parse_language_fn = || {
@@ -622,11 +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);
-        if legacy {
-            keypair_from_seed(seed.as_bytes())?
-        } else {
-            keypair_from_seed_and_derivation_path(seed.as_bytes(), derivation_path)?
-        }
+        keypair_from_seed(seed.as_bytes())?
     };
 
     if confirm_pubkey {
@@ -654,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() {
@@ -666,153 +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(STDOUT_OUTFILE_TOKEN).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Stdin,
-                derivation_path: None,
-                legacy: false,
-            }
-        ));
-        let stdin = "stdin:".to_string();
-        assert!(matches!(
-            parse_signer_source(&stdin).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Stdin,
-                derivation_path: None,
-                legacy: false,
-            }
-        ));
-        assert!(matches!(
-            parse_signer_source(ASK_KEYWORD).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Prompt,
-                derivation_path: None,
-                legacy: true,
-            }
-        ));
-        let pubkey = Pubkey::new_unique();
-        assert!(
-            matches!(parse_signer_source(&pubkey.to_string()).unwrap(), SignerSource {
-                kind: SignerSourceKind::Pubkey(p),
-                derivation_path: None,
-                legacy: false,
-            }
-            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,
-                legacy: false,
-            } if p == absolute_path_str)
-        );
-        assert!(
-            matches!(parse_signer_source(&relative_path_str).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-                legacy: false,
-            } if p == relative_path_str)
-        );
-
-        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,
-                legacy: false,
-            } 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,
-                legacy: false,
-            } 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 prompt = "prompt:".to_string();
-        assert!(matches!(
-            parse_signer_source(&prompt).unwrap(),
-            SignerSource {
-                kind: SignerSourceKind::Prompt,
-                derivation_path: None,
-                legacy: false,
-            }
-        ));
-        assert!(
-            matches!(parse_signer_source(&format!("file:{}", absolute_path_str)).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-                legacy: false,
-            } if p == absolute_path_str)
-        );
-        assert!(
-            matches!(parse_signer_source(&format!("file:{}", relative_path_str)).unwrap(), SignerSource {
-                kind: SignerSourceKind::Filepath(p),
-                derivation_path: None,
-                legacy: false,
-            } if p == relative_path_str)
-        );
-    }
 }

clap-utils/src/lib.rs

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

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.7.18"
+version = "1.5.13"
 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()
     }
@@ -107,24 +106,24 @@ mod test {
     #[test]
     fn compute_websocket_url() {
         assert_eq!(
-            Config::compute_websocket_url("http://api.devnet.solana.com"),
-            "ws://api.devnet.solana.com/".to_string()
+            Config::compute_websocket_url(&"http://devnet.solana.com"),
+            "ws://devnet.solana.com/".to_string()
         );
 
         assert_eq!(
-            Config::compute_websocket_url("https://api.devnet.solana.com"),
-            "wss://api.devnet.solana.com/".to_string()
+            Config::compute_websocket_url(&"https://devnet.solana.com"),
+            "wss://devnet.solana.com/".to_string()
         );
 
         assert_eq!(
-            Config::compute_websocket_url("http://example.com:8899"),
+            Config::compute_websocket_url(&"http://example.com:8899"),
             "ws://example.com:8900/".to_string()
         );
         assert_eq!(
-            Config::compute_websocket_url("https://example.com:1234"),
+            Config::compute_websocket_url(&"https://example.com:1234"),
             "wss://example.com:1235/".to_string()
         );
 
-        assert_eq!(Config::compute_websocket_url("garbage"), String::new());
+        assert_eq!(Config::compute_websocket_url(&"garbage"), String::new());
     }
 }

cli-config/src/lib.rs

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

cli-output/Cargo.toml

@@ -3,30 +3,27 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-output"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.7.18"
+version = "1.5.13"
 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"] }
-clap = "2.33.0"
-console = "0.14.1"
+console = "0.11.3"
 humantime = "2.0.1"
 Inflector = "0.11.4"
 indicatif = "0.15.0"
-serde = "1.0.122"
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "=1.7.18" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.7.18" }
-solana-client = { path = "../client", version = "=1.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.7.18" }
-solana-vote-program = { path = "../programs/vote", version = "=1.7.18" }
-spl-memo = { version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "1.5.13" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.13" }
+solana-client = { path = "../client", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.13" }
+solana-transaction-status = { path = "../transaction-status", version = "1.5.13" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.13" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

cli-output/src/display.rs

@@ -4,12 +4,10 @@ use {
     console::style,
     indicatif::{ProgressBar, ProgressStyle},
     solana_sdk::{
-        clock::UnixTimestamp, hash::Hash, message::Message, native_token::lamports_to_sol,
-        program_utils::limited_deserialize, pubkey::Pubkey, stake, transaction::Transaction,
+        clock::UnixTimestamp, hash::Hash, native_token::lamports_to_sol,
+        program_utils::limited_deserialize, transaction::Transaction,
     },
     solana_transaction_status::UiTransactionStatusMeta,
-    spl_memo::id as spl_memo_id,
-    spl_memo::v1::id as spl_memo_v1_id,
     std::{collections::HashMap, fmt, io},
 };
 
@@ -30,11 +28,6 @@ impl Default for BuildBalanceMessageConfig {
     }
 }
 
-fn is_memo_program(k: &Pubkey) -> bool {
-    let k_str = k.to_string();
-    (k_str == spl_memo_v1_id().to_string()) || (k_str == spl_memo_id().to_string())
-}
-
 pub fn build_balance_message_with_config(
     lamports: u64,
     config: &BuildBalanceMessageConfig,
@@ -132,31 +125,6 @@ pub fn println_signers(
     println!();
 }
 
-fn format_account_mode(message: &Message, index: usize) -> String {
-    format!(
-        "{}r{}{}", // accounts are always readable...
-        if message.is_signer(index) {
-            "s" // stands for signer
-        } else {
-            "-"
-        },
-        if message.is_writable(index, /*demote_program_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() {
@@ -244,9 +197,10 @@ pub fn write_transaction<W: io::Write>(
                 writeln!(w, "{}  {:?}", prefix, vote_instruction)?;
                 raw = false;
             }
-        } else if program_pubkey == stake::program::id() {
-            if let Ok(stake_instruction) =
-                limited_deserialize::<stake::instruction::StakeInstruction>(&instruction.data)
+        } else if program_pubkey == solana_stake_program::id() {
+            if let Ok(stake_instruction) = limited_deserialize::<
+                solana_stake_program::stake_instruction::StakeInstruction,
+            >(&instruction.data)
             {
                 writeln!(w, "{}  {:?}", prefix, stake_instruction)?;
                 raw = false;
@@ -259,11 +213,6 @@ pub fn write_transaction<W: io::Write>(
                 writeln!(w, "{}  {:?}", prefix, system_instruction)?;
                 raw = false;
             }
-        } else if is_memo_program(&program_pubkey) {
-            if let Ok(s) = std::str::from_utf8(&instruction.data) {
-                writeln!(w, "{}  Data: \"{}\"", prefix, s)?;
-                raw = false;
-            }
         }
 
         if raw {
@@ -321,38 +270,7 @@ pub fn write_transaction<W: io::Write>(
             if !log_messages.is_empty() {
                 writeln!(w, "{}Log Messages:", prefix,)?;
                 for log_message in log_messages {
-                    writeln!(w, "{}  {}", prefix, log_message)?;
-                }
-            }
-        }
-
-        if let Some(rewards) = &transaction_status.rewards {
-            if !rewards.is_empty() {
-                writeln!(w, "{}Rewards:", prefix,)?;
-                writeln!(
-                    w,
-                    "{}  {:<44}  {:^15}  {:<15}  {:<20}",
-                    prefix, "Address", "Type", "Amount", "New Balance"
-                )?;
-                for reward in rewards {
-                    let sign = if reward.lamports < 0 { "-" } else { "" };
-                    writeln!(
-                        w,
-                        "{}  {:<44}  {:^15}  {:<15}  {}",
-                        prefix,
-                        reward.pubkey,
-                        if let Some(reward_type) = reward.reward_type {
-                            format!("{}", reward_type)
-                        } else {
-                            "-".to_string()
-                        },
-                        format!(
-                            "{}◎{:<14.9}",
-                            sign,
-                            lamports_to_sol(reward.lamports.abs() as u64)
-                        ),
-                        format!("◎{:<18.9}", lamports_to_sol(reward.post_balance),)
-                    )?;
+                    writeln!(w, "{}  {}", prefix, log_message,)?;
                 }
             }
         }

cli/Cargo.toml

@@ -3,11 +3,10 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.7.18"
+version = "1.5.13"
 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"
@@ -16,8 +15,7 @@ chrono = { version = "0.4.11", features = ["serde"] }
 clap = "2.33.1"
 criterion-stats = "0.3.0"
 ctrlc = { version = "3.1.5", features = ["termination"] }
-console = "0.14.1"
-const_format = "0.2.14"
+console = "0.11.3"
 dirs-next = "2.0.0"
 log = "0.4.11"
 Inflector = "0.11.4"
@@ -25,35 +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"] }
-semver = "1.0.4"
-serde = "1.0.122"
+reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+serde = "1.0.118"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "=1.7.18" }
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "=1.7.18" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.7.18" }
-solana-cli-config = { path = "../cli-config", version = "=1.7.18" }
-solana-cli-output = { path = "../cli-output", version = "=1.7.18" }
-solana-client = { path = "../client", version = "=1.7.18" }
-solana-config-program = { path = "../programs/config", version = "=1.7.18" }
-solana-faucet = { path = "../faucet", version = "=1.7.18" }
-solana-logger = { path = "../logger", version = "=1.7.18" }
-solana-net-utils = { path = "../net-utils", version = "=1.7.18" }
-solana_rbpf = "=0.2.11"
-solana-remote-wallet = { path = "../remote-wallet", version = "=1.7.18" }
-solana-sdk = { path = "../sdk", version = "=1.7.18" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.7.18" }
-solana-version = { path = "../version", version = "=1.7.18" }
-solana-vote-program = { path = "../programs/vote", version = "=1.7.18" }
-spl-memo = { version = "=3.0.1", features = ["no-entrypoint"] }
+solana-account-decoder = { path = "../account-decoder", version = "1.5.13" }
+solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.5.13" }
+solana-clap-utils = { path = "../clap-utils", version = "1.5.13" }
+solana-cli-config = { path = "../cli-config", version = "1.5.13" }
+solana-cli-output = { path = "../cli-output", version = "1.5.13" }
+solana-client = { path = "../client", version = "1.5.13" }
+solana-config-program = { path = "../programs/config", version = "1.5.13" }
+solana-faucet = { path = "../faucet", version = "1.5.13" }
+solana-logger = { path = "../logger", version = "1.5.13" }
+solana-net-utils = { path = "../net-utils", version = "1.5.13" }
+solana_rbpf = "=0.2.5"
+solana-remote-wallet = { path = "../remote-wallet", version = "1.5.13" }
+solana-sdk = { path = "../sdk", version = "1.5.13" }
+solana-stake-program = { path = "../programs/stake", version = "1.5.13" }
+solana-transaction-status = { path = "../transaction-status", version = "1.5.13" }
+solana-version = { path = "../version", version = "1.5.13" }
+solana-vote-program = { path = "../programs/vote", version = "1.5.13" }
 thiserror = "1.0.21"
-tiny-bip39 = "0.8.1"
+tiny-bip39 = "0.7.0"
 url = "2.1.1"
 
 [dev-dependencies]
-solana-core = { path = "../core", version = "=1.7.18" }
-solana-streamer = { path = "../streamer", version = "=1.7.18" }
+solana-core = { path = "../core", version = "1.5.13" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/checks.rs

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

cli/src/clap_app.rs

@@ -1,202 +0,0 @@
-use crate::{
-    cli::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*, stake::*,
-    validator_info::*, vote::*, wallet::*,
-};
-use clap::{App, AppSettings, Arg, ArgGroup, SubCommand};
-use solana_clap_utils::{self, input_validators::*, keypair::*};
-use solana_cli_config::CONFIG_FILE;
-
-pub fn get_clap_app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, 'v> {
-    App::new(name)
-        .about(about)
-        .version(version)
-        .setting(AppSettings::SubcommandRequiredElseHelp)
-        .arg({
-            let arg = Arg::with_name("config_file")
-                .short("C")
-                .long("config")
-                .value_name("FILEPATH")
-                .takes_value(true)
-                .global(true)
-                .help("Configuration file to use");
-            if let Some(ref config_file) = *CONFIG_FILE {
-                arg.default_value(config_file)
-            } else {
-                arg
-            }
-        })
-        .arg(
-            Arg::with_name("json_rpc_url")
-                .short("u")
-                .long("url")
-                .value_name("URL_OR_MONIKER")
-                .takes_value(true)
-                .global(true)
-                .validator(is_url_or_moniker)
-                .help(
-                    "URL for Solana's JSON RPC or moniker (or their first letter): \
-                       [mainnet-beta, testnet, devnet, localhost]",
-                ),
-        )
-        .arg(
-            Arg::with_name("websocket_url")
-                .long("ws")
-                .value_name("URL")
-                .takes_value(true)
-                .global(true)
-                .validator(is_url)
-                .help("WebSocket URL for the solana cluster"),
-        )
-        .arg(
-            Arg::with_name("keypair")
-                .short("k")
-                .long("keypair")
-                .value_name("KEYPAIR")
-                .global(true)
-                .takes_value(true)
-                .help("Filepath or URL to a keypair"),
-        )
-        .arg(
-            Arg::with_name("commitment")
-                .long("commitment")
-                .takes_value(true)
-                .possible_values(&[
-                    "processed",
-                    "confirmed",
-                    "finalized",
-                    "recent", // Deprecated as of v1.5.5
-                    "single", // Deprecated as of v1.5.5
-                    "singleGossip", // Deprecated as of v1.5.5
-                    "root", // Deprecated as of v1.5.5
-                    "max", // Deprecated as of v1.5.5
-                ])
-                .value_name("COMMITMENT_LEVEL")
-                .hide_possible_values(true)
-                .global(true)
-                .help("Return information at the selected commitment level [possible values: processed, confirmed, finalized]"),
-        )
-        .arg(
-            Arg::with_name("verbose")
-                .long("verbose")
-                .short("v")
-                .global(true)
-                .help("Show additional information"),
-        )
-        .arg(
-            Arg::with_name("no_address_labels")
-                .long("no-address-labels")
-                .global(true)
-                .help("Do not use address labels in the output"),
-        )
-        .arg(
-            Arg::with_name("output_format")
-                .long("output")
-                .value_name("FORMAT")
-                .global(true)
-                .takes_value(true)
-                .possible_values(&["json", "json-compact"])
-                .help("Return information in specified output format"),
-        )
-        .arg(
-            Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
-                .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
-                .global(true)
-                .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
-        )
-        .arg(
-            Arg::with_name("rpc_timeout")
-                .long("rpc-timeout")
-                .value_name("SECONDS")
-                .takes_value(true)
-                .default_value(DEFAULT_RPC_TIMEOUT_SECONDS)
-                .global(true)
-                .hidden(true)
-                .help("Timeout value for RPC requests"),
-        )
-        .arg(
-            Arg::with_name("confirm_transaction_initial_timeout")
-                .long("confirm-timeout")
-                .value_name("SECONDS")
-                .takes_value(true)
-                .default_value(DEFAULT_CONFIRM_TX_TIMEOUT_SECONDS)
-                .global(true)
-                .hidden(true)
-                .help("Timeout value for initial transaction status"),
-        )
-        .cluster_query_subcommands()
-        .feature_subcommands()
-        .inflation_subcommands()
-        .nonce_subcommands()
-        .program_subcommands()
-        .stake_subcommands()
-        .validator_info_subcommands()
-        .vote_subcommands()
-        .wallet_subcommands()
-        .subcommand(
-            SubCommand::with_name("config")
-                .about("Solana command-line tool configuration settings")
-                .aliases(&["get", "set"])
-                .setting(AppSettings::SubcommandRequiredElseHelp)
-                .subcommand(
-                    SubCommand::with_name("get")
-                        .about("Get current config settings")
-                        .arg(
-                            Arg::with_name("specific_setting")
-                                .index(1)
-                                .value_name("CONFIG_FIELD")
-                                .takes_value(true)
-                                .possible_values(&[
-                                    "json_rpc_url",
-                                    "websocket_url",
-                                    "keypair",
-                                    "commitment",
-                                ])
-                                .help("Return a specific config setting"),
-                        ),
-                )
-                .subcommand(
-                    SubCommand::with_name("set")
-                        .about("Set a config setting")
-                        .group(
-                            ArgGroup::with_name("config_settings")
-                                .args(&["json_rpc_url", "websocket_url", "keypair", "commitment"])
-                                .multiple(true)
-                                .required(true),
-                        ),
-                )
-                .subcommand(
-                    SubCommand::with_name("import-address-labels")
-                        .about("Import a list of address labels")
-                        .arg(
-                            Arg::with_name("filename")
-                                .index(1)
-                                .value_name("FILENAME")
-                                .takes_value(true)
-                                .help("YAML file of address labels"),
-                        ),
-                )
-                .subcommand(
-                    SubCommand::with_name("export-address-labels")
-                        .about("Export the current address labels")
-                        .arg(
-                            Arg::with_name("filename")
-                                .index(1)
-                                .value_name("FILENAME")
-                                .takes_value(true)
-                                .help("YAML file to receive the current address labels"),
-                        ),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("completion")
-            .about("Generate completion scripts for various shells")
-            .arg(
-                Arg::with_name("shell")
-                .long("shell")
-                .short("s")
-                .takes_value(true)
-                .possible_values(&["bash", "fish", "zsh", "powershell", "elvish"])
-                .default_value("bash")
-            )
-        )
-}

cli/src/cluster_query.rs

@@ -1,6 +1,7 @@
 use crate::{
     cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
+    stake::is_stake_program_v2_enabled,
 };
 use clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
 use console::{style, Emoji};
@@ -23,12 +24,10 @@ use solana_client::{
     pubsub_client::PubsubClient,
     rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient},
     rpc_config::{
-        RpcAccountInfoConfig, RpcBlockConfig, RpcGetVoteAccountsConfig, RpcLargestAccountsConfig,
-        RpcLargestAccountsFilter, RpcProgramAccountsConfig, RpcTransactionConfig,
-        RpcTransactionLogsConfig, RpcTransactionLogsFilter,
+        RpcAccountInfoConfig, RpcLargestAccountsConfig, RpcLargestAccountsFilter,
+        RpcProgramAccountsConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
     },
     rpc_filter,
-    rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE,
     rpc_response::SlotInfo,
 };
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
@@ -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,
-    stake::{self, state::StakeState},
     system_instruction, system_program,
     sysvar::{
         self,
-        slot_history::SlotHistory,
         stake_history::{self},
     },
     timing,
     transaction::Transaction,
 };
 use solana_transaction_status::UiTransactionEncoding;
-use solana_vote_program::vote_state::VoteState;
 use std::{
     collections::{BTreeMap, HashMap, VecDeque},
     fmt,
-    str::FromStr,
+    net::SocketAddr,
     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("❌ ", "");
@@ -122,7 +115,7 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .long("our-localhost")
                         .takes_value(false)
                         .value_name("PORT")
-                        .default_value(DEFAULT_RPC_PORT_STR)
+                        .default_value(&DEFAULT_RPC_PORT_STR)
                         .validator(is_port)
                         .help("Guess Identity pubkey and validator rpc node assuming local (possibly private) validator"),
                 )
@@ -176,7 +169,7 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                     .takes_value(true)
                     .value_name("EPOCH")
                     .validator(is_epoch)
-                    .help("Epoch to show leader schedule for. [default: current]")
+                    .help("Epoch to show leader schedule for. (default: current)")
             )
         )
         .subcommand(
@@ -350,57 +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)"),
-                )
-                .arg(
-                    Arg::with_name("keep_unstaked_delinquents")
-                        .long("keep-unstaked-delinquents")
-                        .takes_value(false)
-                        .help("Don't discard unstaked, delinquent validators")
-                )
-                .arg(
-                    Arg::with_name("delinquent_slot_distance")
-                        .long("delinquent-slot-distance")
-                        .takes_value(true)
-                        .value_name("SLOT_DISTANCE")
-                        .validator(is_slot)
-                        .help(
-                            concatcp!(
-                                "Minimum slot distance from the tip to consider a validator delinquent. [default: ",
-                                DELINQUENT_VALIDATOR_SLOT_DISTANCE,
-                                "]",
-                        ))
                 ),
         )
         .subcommand(
@@ -454,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")
@@ -634,33 +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 keep_unstaked_delinquents = matches.is_present("keep_unstaked_delinquents");
-    let delinquent_slot_distance = value_of(matches, "delinquent_slot_distance");
-
-    let sort_order = match value_t_or_exit!(matches, "sort", String).as_str() {
-        "delinquent" => CliValidatorsSortOrder::Delinquent,
-        "commission" => CliValidatorsSortOrder::Commission,
-        "credits" => CliValidatorsSortOrder::EpochCredits,
-        "identity" => CliValidatorsSortOrder::Identity,
-        "last-vote" => CliValidatorsSortOrder::LastVote,
-        "root" => CliValidatorsSortOrder::Root,
-        "skip-rate" => CliValidatorsSortOrder::SkipRate,
-        "stake" => CliValidatorsSortOrder::Stake,
-        "vote-account" => CliValidatorsSortOrder::VoteAccount,
-        _ => unreachable!(),
-    };
 
     Ok(CliCommandInfo {
-        command: CliCommand::ShowValidators {
-            use_lamports_unit,
-            sort_order,
-            reverse_sort,
-            number_validators,
-            keep_unstaked_delinquents,
-            delinquent_slot_distance,
-        },
+        command: CliCommand::ShowValidators { use_lamports_unit },
         signers: vec![],
     })
 }
@@ -829,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
@@ -849,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!(
@@ -904,7 +790,7 @@ pub fn process_catchup(
                         "gaining"
                     },
                     slots_per_second,
-                    average_time_remaining
+                    time_remaining
                 )
             },
         ));
@@ -915,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;
     }
 }
 
@@ -961,19 +846,18 @@ pub fn process_fees(
                 *recent_blockhash,
                 fee_calculator.lamports_per_signature,
                 None,
-                None,
             )
         } else {
             CliFees::none()
         }
     } else {
-        let result = rpc_client.get_fees_with_commitment(config.commitment)?;
+        let result = rpc_client.get_recent_blockhash_with_commitment(config.commitment)?;
+        let (recent_blockhash, fee_calculator, last_valid_slot) = result.value;
         CliFees::some(
             result.context.slot,
-            result.value.blockhash,
-            result.value.fee_calculator.lamports_per_signature,
-            None,
-            Some(result.value.last_valid_block_height),
+            recent_blockhash,
+            fee_calculator.lamports_per_signature,
+            Some(last_valid_slot),
         )
     };
     Ok(config.output_format.formatted_string(&fees))
@@ -1051,16 +935,8 @@ pub fn process_get_block(
         rpc_client.get_slot_with_commitment(CommitmentConfig::finalized())?
     };
 
-    let encoded_confirmed_block = rpc_client
-        .get_block_with_config(
-            slot,
-            RpcBlockConfig {
-                encoding: Some(UiTransactionEncoding::Base64),
-                commitment: Some(CommitmentConfig::confirmed()),
-                ..RpcBlockConfig::default()
-            },
-        )?
-        .into();
+    let encoded_confirmed_block =
+        rpc_client.get_confirmed_block_with_encoding(slot, UiTransactionEncoding::Base64)?;
     let cli_block = CliBlock {
         encoded_confirmed_block,
         slot,
@@ -1089,27 +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 start_block_time = rpc_client
-        .get_block_time(epoch_info.absolute_slot - epoch_info.slot_index)
-        .ok();
-    let current_block_time = rpc_client.get_block_time(epoch_info.absolute_slot).ok();
-    let epoch_info = CliEpochInfo {
-        epoch_info,
-        average_slot_time_ms,
-        start_block_time,
-        current_block_time,
-    };
+    let epoch_info: CliEpochInfo = rpc_client.get_epoch_info()?.into();
     Ok(config.output_format.formatted_string(&epoch_info))
 }
 
@@ -1124,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 block_height = rpc_client.get_block_height()?;
-    Ok(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> {
@@ -1152,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,
@@ -1164,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_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;
@@ -1343,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 {
@@ -1480,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;
@@ -1685,14 +1517,40 @@ pub fn process_live_slots(config: &CliConfig) -> ProcessResult {
 pub fn process_show_gossip(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
     let cluster_nodes = rpc_client.get_cluster_nodes()?;
 
-    let nodes: Vec<_> = cluster_nodes
+    fn format_port(addr: Option<SocketAddr>) -> String {
+        addr.map(|addr| addr.port().to_string())
+            .unwrap_or_else(|| "none".to_string())
+    }
+
+    let s: Vec<_> = cluster_nodes
         .into_iter()
-        .map(|node| CliGossipNode::new(node, &config.address_labels))
+        .map(|node| {
+            format!(
+                "{:15} | {:44} | {:6} | {:5} | {:21} | {}",
+                node.gossip
+                    .map(|addr| addr.ip().to_string())
+                    .unwrap_or_else(|| "none".to_string()),
+                format_labeled_address(&node.pubkey, &config.address_labels),
+                format_port(node.gossip),
+                format_port(node.tpu),
+                node.rpc
+                    .map(|addr| addr.to_string())
+                    .unwrap_or_else(|| "none".to_string()),
+                node.version.unwrap_or_else(|| "unknown".to_string()),
+            )
+        })
         .collect();
 
-    Ok(config
-        .output_format
-        .formatted_string(&CliGossipNodes(nodes)))
+    Ok(format!(
+        "IP Address      | Node identifier                              \
+         | Gossip | TPU   | RPC Address           | Version\n\
+         ----------------+----------------------------------------------+\
+         --------+-------+-----------------------+----------------\n\
+         {}\n\
+         Nodes: {}",
+        s.join("\n"),
+        s.len(),
+    ))
 }
 
 pub fn process_show_stakes(
@@ -1702,16 +1560,17 @@ 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...");
 
     let mut program_accounts_config = RpcProgramAccountsConfig {
+        filters: None,
         account_config: RpcAccountInfoConfig {
             encoding: Some(solana_account_decoder::UiAccountEncoding::Base64),
             ..RpcAccountInfoConfig::default()
         },
-        ..RpcProgramAccountsConfig::default()
     };
 
     if let Some(vote_account_pubkeys) = vote_account_pubkeys {
@@ -1721,7 +1580,7 @@ pub fn process_show_stakes(
                 // Filter by `StakeState::Stake(_, _)`
                 rpc_filter::RpcFilterType::Memcmp(rpc_filter::Memcmp {
                     offset: 0,
-                    bytes: rpc_filter::MemcmpEncodedBytes::Base58(
+                    bytes: rpc_filter::MemcmpEncodedBytes::Binary(
                         bs58::encode([2, 0, 0, 0]).into_string(),
                     ),
                     encoding: Some(rpc_filter::MemcmpEncoding::Binary),
@@ -1729,7 +1588,7 @@ pub fn process_show_stakes(
                 // Filter by `Delegation::voter_pubkey`, which begins at byte offset 124
                 rpc_filter::RpcFilterType::Memcmp(rpc_filter::Memcmp {
                     offset: 124,
-                    bytes: rpc_filter::MemcmpEncodedBytes::Base58(
+                    bytes: rpc_filter::MemcmpEncodedBytes::Binary(
                         vote_account_pubkeys[0].to_string(),
                     ),
                     encoding: Some(rpc_filter::MemcmpEncoding::Binary),
@@ -1738,7 +1597,7 @@ pub fn process_show_stakes(
         }
     }
     let all_stake_accounts = rpc_client
-        .get_program_accounts_with_config(&stake::program::id(), program_accounts_config)?;
+        .get_program_accounts_with_config(&solana_stake_program::id(), program_accounts_config)?;
     let stake_history_account = rpc_client.get_account(&stake_history::id())?;
     let clock_account = rpc_client.get_account(&sysvar::clock::id())?;
     let clock: Clock = from_account(&clock_account).ok_or_else(|| {
@@ -1749,6 +1608,8 @@ pub fn process_show_stakes(
     let stake_history = from_account(&stake_history_account).ok_or_else(|| {
         CliError::RpcRequestError("Failed to deserialize stake history".to_string())
     })?;
+    // At v1.6, this check can be removed and simply passed as `true`
+    let stake_program_v2_enabled = is_stake_program_v2_enabled(rpc_client)?;
 
     let mut stake_accounts: Vec<CliKeyedStakeState> = vec![];
     for (stake_pubkey, stake_account) in all_stake_accounts {
@@ -1764,6 +1625,7 @@ pub fn process_show_stakes(
                                 use_lamports_unit,
                                 &stake_history,
                                 &clock,
+                                stake_program_v2_enabled,
                             ),
                         });
                     }
@@ -1782,6 +1644,7 @@ pub fn process_show_stakes(
                                 use_lamports_unit,
                                 &stake_history,
                                 &clock,
+                                stake_program_v2_enabled,
                             ),
                         });
                     }
@@ -1809,42 +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,
-    keep_unstaked_delinquents: bool,
-    delinquent_slot_distance: Option<Slot>,
 ) -> ProcessResult {
-    let progress_bar = new_spinner_progress_bar();
-    progress_bar.set_message("Fetching vote accounts...");
     let epoch_info = rpc_client.get_epoch_info()?;
-    let vote_accounts = rpc_client.get_vote_accounts_with_config(RpcGetVoteAccountsConfig {
-        keep_unstaked_delinquents: Some(keep_unstaked_delinquents),
-        delinquent_slot_distance,
-        ..RpcGetVoteAccountsConfig::default()
-    })?;
+    let vote_accounts = rpc_client.get_vote_accounts()?;
 
-    progress_bar.set_message("Fetching block production...");
-    let skip_rate: HashMap<_, _> = rpc_client
-        .get_block_production()
-        .ok()
-        .map(|result| {
-            result
-                .value
-                .by_identity
-                .into_iter()
-                .map(|(identity, (leader_slots, blocks_produced))| {
-                    (
-                        identity,
-                        100. * (leader_slots.saturating_sub(blocks_produced)) as f64
-                            / leader_slots as f64,
-                    )
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-
-    progress_bar.set_message("Fetching version information...");
     let mut node_version = HashMap::new();
     let unknown_version = "unknown".to_string();
     for contact_info in rpc_client.get_cluster_nodes()? {
@@ -1856,8 +1687,6 @@ pub fn process_show_validators(
         );
     }
 
-    progress_bar.finish_and_clear();
-
     let total_active_stake = vote_accounts
         .current
         .iter()
@@ -1872,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(
@@ -1883,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,
             )
         })
@@ -1921,43 +1750,12 @@ pub fn process_show_validators(
         entry.delinquent_active_stake += validator.activated_stake;
     }
 
-    let validators: Vec<_> = current_validators
-        .into_iter()
-        .chain(delinquent_validators.into_iter())
-        .collect();
-
-    let (average_skip_rate, average_stake_weighted_skip_rate) = {
-        let mut skip_rate_len = 0;
-        let mut skip_rate_sum = 0.;
-        let mut skip_rate_weighted_sum = 0.;
-        for validator in validators.iter() {
-            if let Some(skip_rate) = validator.skip_rate {
-                skip_rate_sum += skip_rate;
-                skip_rate_len += 1;
-                skip_rate_weighted_sum += skip_rate * validator.activated_stake as f64;
-            }
-        }
-
-        if skip_rate_len > 0 && total_active_stake > 0 {
-            (
-                skip_rate_sum / skip_rate_len as f64,
-                skip_rate_weighted_sum / total_active_stake as f64,
-            )
-        } else {
-            (100., 100.) // Impossible?
-        }
-    };
-
     let cli_validators = CliValidators {
         total_active_stake,
         total_current_stake,
         total_delinquent_stake,
-        validators,
-        average_skip_rate,
-        average_stake_weighted_skip_rate,
-        validators_sort_order,
-        validators_reverse_sort,
-        number_validators,
+        current_validators,
+        delinquent_validators,
         stake_by_version,
         use_lamports_unit,
     };
@@ -1973,13 +1771,12 @@ pub fn process_transaction_history(
     limit: usize,
     show_transactions: bool,
 ) -> ProcessResult {
-    let results = rpc_client.get_signatures_for_address_with_config(
+    let results = rpc_client.get_confirmed_signatures_for_address2_with_config(
         address,
         GetConfirmedSignaturesForAddress2Config {
             before,
             until,
             limit: Some(limit),
-            commitment: Some(CommitmentConfig::confirmed()),
         },
     )?;
 
@@ -1996,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()),
             );
@@ -2012,13 +1805,9 @@ pub fn process_transaction_history(
 
         if show_transactions {
             if let Ok(signature) = result.signature.parse::<Signature>() {
-                match rpc_client.get_transaction_with_config(
-                    &signature,
-                    RpcTransactionConfig {
-                        encoding: Some(UiTransactionEncoding::Base64),
-                        commitment: Some(CommitmentConfig::confirmed()),
-                    },
-                ) {
+                match rpc_client
+                    .get_confirmed_transaction(&signature, UiTransactionEncoding::Base64)
+                {
                     Ok(confirmed_transaction) => {
                         println_transaction(
                             &confirmed_transaction
@@ -2071,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,
@@ -2141,7 +1889,7 @@ pub fn process_calculate_rent(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{clap_app::get_clap_app, cli::parse_command};
+    use crate::cli::{app, parse_command};
     use solana_sdk::signature::{write_keypair, Keypair};
     use std::str::FromStr;
     use tempfile::NamedTempFile;
@@ -2153,11 +1901,14 @@ mod tests {
 
     #[test]
     fn test_parse_command() {
-        let test_commands = get_clap_app("test", "desc", "version");
+        let test_commands = app("test", "desc", "version");
         let default_keypair = Keypair::new();
         let (default_keypair_file, mut tmp_file) = make_tmp_file();
         write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
-        let default_signer = DefaultSigner::new("", &default_keypair_file);
+        let default_signer = DefaultSigner {
+            path: default_keypair_file,
+            arg_name: String::new(),
+        };
 
         let test_cluster_version = test_commands
             .clone()

cli/src/feature.rs

@@ -10,7 +10,6 @@ use solana_cli_output::{QuietDisplay, VerboseDisplay};
 use solana_client::{client_error::ClientError, rpc_client::RpcClient};
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
-    account::Account,
     clock::Slot,
     feature::{self, Feature},
     feature_set::FEATURE_NAMES,
@@ -18,12 +17,7 @@ use solana_sdk::{
     pubkey::Pubkey,
     transaction::Transaction,
 };
-use std::{
-    cmp::Ordering,
-    collections::{HashMap, HashSet},
-    fmt,
-    sync::Arc,
-};
+use std::{collections::HashMap, fmt, sync::Arc};
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum ForceActivation {
@@ -227,103 +221,44 @@ pub fn process_feature_subcommand(
     }
 }
 
-#[derive(Debug, Default)]
-struct WorkingFeatureSetStatsEntry {
-    stake: u64,
-    rpc_nodes_count: u32,
-    software_versions: HashSet<Option<semver::Version>>,
-}
-type WorkingFeatureSetStats = HashMap<u32, WorkingFeatureSetStatsEntry>;
-
-#[derive(Debug, Default)]
-struct FeatureSetStatsEntry {
-    stake_percent: f64,
-    rpc_nodes_percent: f32,
-    software_versions: Vec<Option<semver::Version>>,
-}
-type FeatureSetStats = HashMap<u32, FeatureSetStatsEntry>;
-
-fn feature_set_stats(rpc_client: &RpcClient) -> Result<FeatureSetStats, ClientError> {
+fn active_stake_by_feature_set(rpc_client: &RpcClient) -> Result<HashMap<u32, f64>, ClientError> {
     // Validator identity -> feature set
-    let feature_sets = rpc_client
+    let feature_set_map = rpc_client
         .get_cluster_nodes()?
         .into_iter()
-        .map(|contact_info| {
-            (
-                contact_info.pubkey,
-                contact_info.feature_set,
-                contact_info.rpc.is_some(),
-                contact_info
-                    .version
-                    .and_then(|v| semver::Version::parse(&v).ok()),
-            )
-        })
-        .collect::<Vec<_>>();
+        .map(|contact_info| (contact_info.pubkey, contact_info.feature_set))
+        .collect::<HashMap<_, _>>();
 
     let vote_accounts = rpc_client.get_vote_accounts()?;
 
-    let mut total_active_stake: u64 = vote_accounts
-        .delinquent
+    let total_active_stake: u64 = vote_accounts
+        .current
         .iter()
+        .chain(vote_accounts.delinquent.iter())
         .map(|vote_account| vote_account.activated_stake)
         .sum();
 
-    let vote_stakes = vote_accounts
-        .current
-        .into_iter()
-        .map(|vote_account| {
-            total_active_stake += vote_account.activated_stake;
-            (vote_account.node_pubkey, vote_account.activated_stake)
-        })
-        .collect::<HashMap<_, _>>();
-
-    let mut feature_set_stats: WorkingFeatureSetStats = HashMap::new();
-    let mut total_rpc_nodes = 0;
-    for (node_id, feature_set, is_rpc, version) in feature_sets {
-        let feature_set = feature_set.unwrap_or(0);
-        let feature_set_entry = feature_set_stats.entry(feature_set).or_default();
-
-        feature_set_entry.software_versions.insert(version);
-
-        if let Some(vote_stake) = vote_stakes.get(&node_id) {
-            feature_set_entry.stake += *vote_stake;
-        }
-
-        if is_rpc {
-            feature_set_entry.rpc_nodes_count += 1;
-            total_rpc_nodes += 1;
+    // Sum all active stake by feature set
+    let mut active_stake_by_feature_set: HashMap<u32, u64> = HashMap::new();
+    for vote_account in vote_accounts.current {
+        if let Some(Some(feature_set)) = feature_set_map.get(&vote_account.node_pubkey) {
+            *active_stake_by_feature_set.entry(*feature_set).or_default() +=
+                vote_account.activated_stake;
+        } else {
+            *active_stake_by_feature_set
+                .entry(0 /* "unknown" */)
+                .or_default() += vote_account.activated_stake;
         }
     }
 
-    Ok(feature_set_stats
+    Ok(active_stake_by_feature_set
         .into_iter()
-        .filter_map(
-            |(
+        .map(|(feature_set, active_stake)| {
+            (
                 feature_set,
-                WorkingFeatureSetStatsEntry {
-                    stake,
-                    rpc_nodes_count,
-                    software_versions,
-                },
-            )| {
-                let stake_percent = (stake as f64 / total_active_stake as f64) * 100.;
-                let rpc_nodes_percent = (rpc_nodes_count as f32 / total_rpc_nodes as f32) * 100.;
-                let mut software_versions = software_versions.into_iter().collect::<Vec<_>>();
-                software_versions.sort();
-                if stake_percent >= 0.001 || rpc_nodes_percent >= 0.001 {
-                    Some((
-                        feature_set,
-                        FeatureSetStatsEntry {
-                            stake_percent,
-                            rpc_nodes_percent,
-                            software_versions,
-                        },
-                    ))
-                } else {
-                    None
-                }
-            },
-        )
+                active_stake as f64 * 100. / total_active_stake as f64,
+            )
+        })
         .collect())
 }
 
@@ -331,189 +266,50 @@ fn feature_set_stats(rpc_client: &RpcClient) -> Result<FeatureSetStats, ClientEr
 fn feature_activation_allowed(rpc_client: &RpcClient, quiet: bool) -> Result<bool, ClientError> {
     let my_feature_set = solana_version::Version::default().feature_set;
 
-    let feature_set_stats = feature_set_stats(rpc_client)?;
+    let active_stake_by_feature_set = active_stake_by_feature_set(rpc_client)?;
 
-    let (stake_allowed, rpc_allowed) = feature_set_stats
+    let feature_activation_allowed = active_stake_by_feature_set
         .get(&my_feature_set)
-        .map(
-            |FeatureSetStatsEntry {
-                 stake_percent,
-                 rpc_nodes_percent,
-                 ..
-             }| (*stake_percent >= 95., *rpc_nodes_percent >= 95.),
-        )
-        .unwrap_or((false, false));
+        .map(|percentage| *percentage >= 95.)
+        .unwrap_or(false);
 
-    if !stake_allowed && !rpc_allowed && !quiet {
-        if feature_set_stats.get(&my_feature_set).is_none() {
+    if !feature_activation_allowed && !quiet {
+        if active_stake_by_feature_set.get(&my_feature_set).is_none() {
             println!(
                 "{}",
                 style("To activate features the tool and cluster feature sets must match, select a tool version that matches the cluster")
                     .bold());
         } else {
-            if !stake_allowed {
-                print!(
-                    "\n{}",
-                    style("To activate features the stake must be >= 95%")
-                        .bold()
-                        .red()
-                );
-            }
-            if !rpc_allowed {
-                print!(
-                    "\n{}",
-                    style("To activate features the RPC nodes must be >= 95%")
-                        .bold()
-                        .red()
-                );
-            }
-        }
-        println!(
-            "\n\n{}",
-            style(format!("Tool Feature Set: {}", my_feature_set)).bold()
-        );
-
-        let mut feature_set_stats = feature_set_stats.into_iter().collect::<Vec<_>>();
-        feature_set_stats.sort_by(|l, r| {
-            match l.1.software_versions[0]
-                .cmp(&r.1.software_versions[0])
-                .reverse()
-            {
-                Ordering::Equal => {
-                    match l
-                        .1
-                        .stake_percent
-                        .partial_cmp(&r.1.stake_percent)
-                        .unwrap()
-                        .reverse()
-                    {
-                        Ordering::Equal => {
-                            l.1.rpc_nodes_percent
-                                .partial_cmp(&r.1.rpc_nodes_percent)
-                                .unwrap()
-                                .reverse()
-                        }
-                        o => o,
-                    }
-                }
-                o => o,
-            }
-        });
-
-        let software_versions_title = "Software Version";
-        let feature_set_title = "Feature Set";
-        let stake_percent_title = "Stake";
-        let rpc_percent_title = "RPC";
-        let mut stats_output = Vec::new();
-        let mut max_software_versions_len = software_versions_title.len();
-        let mut max_feature_set_len = feature_set_title.len();
-        let mut max_stake_percent_len = stake_percent_title.len();
-        let mut max_rpc_percent_len = rpc_percent_title.len();
-        for (
-            feature_set,
-            FeatureSetStatsEntry {
-                stake_percent,
-                rpc_nodes_percent,
-                software_versions,
-            },
-        ) in feature_set_stats.into_iter()
-        {
-            let me = feature_set == my_feature_set;
-            let feature_set = if feature_set == 0 {
-                "unknown".to_string()
-            } else {
-                feature_set.to_string()
-            };
-            let stake_percent = format!("{:.2}%", stake_percent);
-            let rpc_percent = format!("{:.2}%", rpc_nodes_percent);
-
-            let mut has_unknown = false;
-            let mut software_versions = software_versions
-                .iter()
-                .filter_map(|v| {
-                    if v.is_none() {
-                        has_unknown = true;
-                    }
-                    v.as_ref()
-                })
-                .map(ToString::to_string)
-                .collect::<Vec<_>>();
-            if has_unknown {
-                software_versions.push("unknown".to_string());
-            }
-            let software_versions = software_versions.join(", ");
-            max_software_versions_len = max_software_versions_len.max(software_versions.len());
-
-            max_feature_set_len = max_feature_set_len.max(feature_set.len());
-            max_stake_percent_len = max_stake_percent_len.max(stake_percent.len());
-            max_rpc_percent_len = max_rpc_percent_len.max(rpc_percent.len());
-
-            stats_output.push((
-                software_versions,
-                feature_set,
-                stake_percent,
-                rpc_percent,
-                me,
-            ));
+            println!(
+                "{}",
+                style("To activate features the stake must be >= 95%").bold()
+            );
         }
         println!(
             "{}",
-            style(format!(
-                "{1:<0$}  {3:<2$}  {5:<4$}  {7:<6$}",
-                max_software_versions_len,
-                software_versions_title,
-                max_feature_set_len,
-                feature_set_title,
-                max_stake_percent_len,
-                stake_percent_title,
-                max_rpc_percent_len,
-                rpc_percent_title,
-            ))
-            .bold(),
+            style(format!("Tool Feature Set: {}", my_feature_set)).bold()
         );
-        for (software_versions, feature_set, stake_percent, rpc_percent, me) in stats_output {
-            println!(
-                "{1:<0$}  {3:>2$}  {5:>4$} {7:>6$}  {8}",
-                max_software_versions_len,
-                software_versions,
-                max_feature_set_len,
-                feature_set,
-                max_stake_percent_len,
-                stake_percent,
-                max_rpc_percent_len,
-                rpc_percent,
-                if me { "<-- me" } else { "" },
-            );
+        println!("{}", style("Cluster Feature Sets and Stakes:").bold());
+        for (feature_set, percentage) in active_stake_by_feature_set.iter() {
+            if *feature_set == 0 {
+                println!("  unknown    - {:.2}%", percentage);
+            } else {
+                println!(
+                    "  {:<10} - {:.2}% {}",
+                    feature_set,
+                    percentage,
+                    if *feature_set == my_feature_set {
+                        " <-- me"
+                    } else {
+                        ""
+                    }
+                );
+            }
         }
         println!();
     }
 
-    Ok(stake_allowed && rpc_allowed)
-}
-
-fn status_from_account(account: Account) -> Option<CliFeatureStatus> {
-    feature::from_account(&account).map(|feature| match feature.activated_at {
-        None => CliFeatureStatus::Pending,
-        Some(activation_slot) => CliFeatureStatus::Active(activation_slot),
-    })
-}
-
-fn get_feature_status(
-    rpc_client: &RpcClient,
-    feature_id: &Pubkey,
-) -> Result<Option<CliFeatureStatus>, Box<dyn std::error::Error>> {
-    rpc_client
-        .get_account(feature_id)
-        .map(status_from_account)
-        .map_err(|e| e.into())
-}
-
-pub fn get_feature_is_active(
-    rpc_client: &RpcClient,
-    feature_id: &Pubkey,
-) -> Result<bool, Box<dyn std::error::Error>> {
-    get_feature_status(rpc_client, feature_id)
-        .map(|status| matches!(status, Some(CliFeatureStatus::Active(_))))
+    Ok(feature_activation_allowed)
 }
 
 fn process_status(
@@ -531,7 +327,11 @@ fn process_status(
         let feature_id = &feature_ids[i];
         let feature_name = FEATURE_NAMES.get(feature_id).unwrap();
         if let Some(account) = account {
-            if let Some(feature_status) = status_from_account(account) {
+            if let Some(feature) = feature::from_account(&account) {
+                let feature_status = match feature.activated_at {
+                    None => CliFeatureStatus::Pending,
+                    Some(activation_slot) => CliFeatureStatus::Active(activation_slot),
+                };
                 features.push(CliFeature {
                     id: feature_id.to_string(),
                     description: feature_name.to_string(),

cli/src/inflation.rs

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

@@ -10,6 +10,7 @@ macro_rules! ACCOUNT_STRING {
     };
 }
 
+#[macro_use]
 macro_rules! pubkey {
     ($arg:expr, $help:expr) => {
         $arg.takes_value(true)
@@ -18,23 +19,18 @@ macro_rules! pubkey {
     };
 }
 
-#[macro_use]
-extern crate const_format;
-
 extern crate serde_derive;
 
 pub mod checks;
-pub mod clap_app;
 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;
 pub mod validator_info;
 pub mod vote;
-pub mod wallet;

cli/src/main.rs

@@ -1,15 +1,18 @@
-use clap::{crate_description, crate_name, value_t_or_exit, ArgMatches};
+use clap::{
+    crate_description, crate_name, value_t_or_exit, AppSettings, Arg, ArgGroup, ArgMatches,
+    SubCommand,
+};
 use console::style;
 use solana_clap_utils::{
-    input_validators::normalize_to_url_if_moniker,
-    keypair::{CliSigners, DefaultSigner},
+    input_validators::{is_url, is_url_or_moniker, normalize_to_url_if_moniker},
+    keypair::{CliSigners, DefaultSigner, SKIP_SEED_PHRASE_VALIDATION_ARG},
     DisplayError,
 };
-use solana_cli::{
-    clap_app::get_clap_app,
-    cli::{parse_command, process_command, CliCommandInfo, CliConfig, SettingType},
+use solana_cli::cli::{
+    app, parse_command, process_command, CliCommandInfo, CliConfig, SettingType,
+    DEFAULT_RPC_TIMEOUT_SECONDS,
 };
-use solana_cli_config::Config;
+use solana_cli_config::{Config, CONFIG_FILE};
 use solana_cli_output::{display::println_name_value, OutputFormat};
 use solana_client::rpc_config::RpcSendTransactionConfig;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
@@ -164,11 +167,6 @@ pub fn parse_args<'a>(
     let rpc_timeout = value_t_or_exit!(matches, "rpc_timeout", u64);
     let rpc_timeout = Duration::from_secs(rpc_timeout);
 
-    let confirm_transaction_initial_timeout =
-        value_t_or_exit!(matches, "confirm_transaction_initial_timeout", u64);
-    let confirm_transaction_initial_timeout =
-        Duration::from_secs(confirm_transaction_initial_timeout);
-
     let (_, websocket_url) = CliConfig::compute_websocket_url_setting(
         matches.value_of("websocket_url").unwrap_or(""),
         &config.websocket_url,
@@ -181,12 +179,15 @@ pub fn parse_args<'a>(
         &config.keypair_path,
     );
 
-    let default_signer = DefaultSigner::new(default_signer_arg_name, &default_signer_path);
+    let default_signer = DefaultSigner {
+        arg_name: default_signer_arg_name,
+        path: default_signer_path.clone(),
+    };
 
     let CliCommandInfo {
         command,
         mut signers,
-    } = parse_command(matches, &default_signer, &mut wallet_manager)?;
+    } = parse_command(&matches, &default_signer, &mut wallet_manager)?;
 
     if signers.is_empty() {
         if let Ok(signer_info) =
@@ -197,7 +198,18 @@ pub fn parse_args<'a>(
     }
 
     let verbose = matches.is_present("verbose");
-    let output_format = OutputFormat::from_matches(matches, "output_format", verbose);
+    let output_format = matches
+        .value_of("output_format")
+        .map(|value| match value {
+            "json" => OutputFormat::Json,
+            "json-compact" => OutputFormat::JsonCompact,
+            _ => unreachable!(),
+        })
+        .unwrap_or(if verbose {
+            OutputFormat::DisplayVerbose
+        } else {
+            OutputFormat::Display
+        });
 
     let (_, commitment) = CliConfig::compute_commitment_config(
         matches.value_of("commitment").unwrap_or(""),
@@ -226,7 +238,6 @@ pub fn parse_args<'a>(
                 preflight_commitment: Some(commitment.commitment),
                 ..RpcSendTransactionConfig::default()
             },
-            confirm_transaction_initial_timeout,
             address_labels,
         },
         signers,
@@ -235,21 +246,178 @@ pub fn parse_args<'a>(
 
 fn main() -> Result<(), Box<dyn error::Error>> {
     solana_logger::setup_with_default("off");
-    let matches = get_clap_app(
+    let matches = app(
         crate_name!(),
         crate_description!(),
         solana_version::version!(),
     )
+    .arg({
+        let arg = Arg::with_name("config_file")
+            .short("C")
+            .long("config")
+            .value_name("FILEPATH")
+            .takes_value(true)
+            .global(true)
+            .help("Configuration file to use");
+        if let Some(ref config_file) = *CONFIG_FILE {
+            arg.default_value(&config_file)
+        } else {
+            arg
+        }
+    })
+    .arg(
+        Arg::with_name("json_rpc_url")
+            .short("u")
+            .long("url")
+            .value_name("URL_OR_MONIKER")
+            .takes_value(true)
+            .global(true)
+            .validator(is_url_or_moniker)
+            .help(
+                "URL for Solana's JSON RPC or moniker (or their first letter): \
+                   [mainnet-beta, testnet, devnet, localhost]",
+            ),
+    )
+    .arg(
+        Arg::with_name("websocket_url")
+            .long("ws")
+            .value_name("URL")
+            .takes_value(true)
+            .global(true)
+            .validator(is_url)
+            .help("WebSocket URL for the solana cluster"),
+    )
+    .arg(
+        Arg::with_name("keypair")
+            .short("k")
+            .long("keypair")
+            .value_name("KEYPAIR")
+            .global(true)
+            .takes_value(true)
+            .help("Filepath or URL to a keypair"),
+    )
+    .arg(
+        Arg::with_name("commitment")
+            .long("commitment")
+            .takes_value(true)
+            .possible_values(&[
+                "processed",
+                "confirmed",
+                "finalized",
+                "recent", // Deprecated as of v1.5.5
+                "single", // Deprecated as of v1.5.5
+                "singleGossip", // Deprecated as of v1.5.5
+                "root", // Deprecated as of v1.5.5
+                "max", // Deprecated as of v1.5.5
+            ])
+            .value_name("COMMITMENT_LEVEL")
+            .hide_possible_values(true)
+            .global(true)
+            .help("Return information at the selected commitment level [possible values: processed, confirmed, finalized]"),
+    )
+    .arg(
+        Arg::with_name("verbose")
+            .long("verbose")
+            .short("v")
+            .global(true)
+            .help("Show additional information"),
+    )
+    .arg(
+        Arg::with_name("no_address_labels")
+            .long("no-address-labels")
+            .global(true)
+            .help("Do not use address labels in the output"),
+    )
+    .arg(
+        Arg::with_name("output_format")
+            .long("output")
+            .value_name("FORMAT")
+            .global(true)
+            .takes_value(true)
+            .possible_values(&["json", "json-compact"])
+            .help("Return information in specified output format"),
+    )
+    .arg(
+        Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
+            .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
+            .global(true)
+            .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
+    )
+    .arg(
+        Arg::with_name("rpc_timeout")
+            .long("rpc-timeout")
+            .value_name("SECONDS")
+            .takes_value(true)
+            .default_value(DEFAULT_RPC_TIMEOUT_SECONDS)
+            .global(true)
+            .hidden(true)
+            .help("Timeout value for RPC requests"),
+    )
+    .subcommand(
+        SubCommand::with_name("config")
+            .about("Solana command-line tool configuration settings")
+            .aliases(&["get", "set"])
+            .setting(AppSettings::SubcommandRequiredElseHelp)
+            .subcommand(
+                SubCommand::with_name("get")
+                    .about("Get current config settings")
+                    .arg(
+                        Arg::with_name("specific_setting")
+                            .index(1)
+                            .value_name("CONFIG_FIELD")
+                            .takes_value(true)
+                            .possible_values(&[
+                                "json_rpc_url",
+                                "websocket_url",
+                                "keypair",
+                                "commitment",
+                            ])
+                            .help("Return a specific config setting"),
+                    ),
+            )
+            .subcommand(
+                SubCommand::with_name("set")
+                    .about("Set a config setting")
+                    .group(
+                        ArgGroup::with_name("config_settings")
+                            .args(&["json_rpc_url", "websocket_url", "keypair", "commitment"])
+                            .multiple(true)
+                            .required(true),
+                    ),
+            )
+            .subcommand(
+                SubCommand::with_name("import-address-labels")
+                    .about("Import a list of address labels")
+                    .arg(
+                        Arg::with_name("filename")
+                            .index(1)
+                            .value_name("FILENAME")
+                            .takes_value(true)
+                            .help("YAML file of address labels"),
+                    ),
+            )
+            .subcommand(
+                SubCommand::with_name("export-address-labels")
+                    .about("Export the current address labels")
+                    .arg(
+                        Arg::with_name("filename")
+                            .index(1)
+                            .value_name("FILENAME")
+                            .takes_value(true)
+                            .help("YAML file to receive the current address labels"),
+                    ),
+            ),
+    )
     .get_matches();
 
     do_main(&matches).map_err(|err| DisplayError::new_as_boxed(err).into())
 }
 
 fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
-    if parse_settings(matches)? {
+    if parse_settings(&matches)? {
         let mut wallet_manager = None;
 
-        let (mut config, signers) = parse_args(matches, &mut wallet_manager)?;
+        let (mut config, signers) = parse_args(&matches, &mut wallet_manager)?;
         config.signers = signers.iter().map(|s| s.as_ref()).collect();
         let result = process_command(&config)?;
         println!("{}", result);

cli/src/memo.rs

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

cli/src/nonce.rs

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

cli/src/send_tpu.rs

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

cli/src/spend_utils.rs

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

cli/src/validator_info.rs

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

cli/src/vote.rs

@@ -4,16 +4,13 @@ use crate::{
         log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
         ProcessResult,
     },
-    memo::WithMemo,
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
-    stake::check_current_authority,
 };
 use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
 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;
@@ -56,15 +53,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Keypair of validator that will vote with this account"),
                 )
-                .arg(
-                    pubkey!(Arg::with_name("authorized_withdrawer")
-                        .index(3)
-                        .value_name("WITHDRAWER_PUBKEY")
-                        .takes_value(true)
-                        .required(true)
-                        .long("authorized-withdrawer"),
-                        "Public key of the authorized withdrawer")
-                )
                 .arg(
                     Arg::with_name("commission")
                         .long("commission")
@@ -80,12 +68,10 @@ impl VoteSubCommands for App<'_, '_> {
                         "Public key of the authorized voter [default: validator identity pubkey]. "),
                 )
                 .arg(
-                    Arg::with_name("allow_unsafe_authorized_withdrawer")
-                        .long("allow-unsafe-authorized-withdrawer")
-                        .takes_value(false)
-                        .help("Allow an authorized withdrawer pubkey to be identical to the validator identity \
-                               account pubkey or vote account pubkey, which is normally an unsafe \
-                               configuration and should be avoided."),
+                    pubkey!(Arg::with_name("authorized_withdrawer")
+                        .long("authorized-withdrawer")
+                        .value_name("WITHDRAWER_PUBKEY"),
+                        "Public key of the authorized withdrawer [default: validator identity pubkey]. "),
                 )
                 .arg(
                     Arg::with_name("seed")
@@ -93,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")
@@ -120,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")
@@ -147,66 +131,7 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("AUTHORIZED_PUBKEY")
                         .required(true),
                         "New authorized withdrawer. "),
-                )
-                .arg(memo_arg())
-        )
-        .subcommand(
-            SubCommand::with_name("vote-authorize-voter-checked")
-                .about("Authorize a new vote signing keypair for the given vote account, \
-                    checking the new authority as a signer")
-                .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
-                        .index(1)
-                        .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account in which to set the authorized voter. "),
-                )
-                .arg(
-                    Arg::with_name("authorized")
-                        .index(2)
-                        .value_name("AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("Current authorized vote signer."),
-                )
-                .arg(
-                    Arg::with_name("new_authorized")
-                        .index(3)
-                        .value_name("NEW_AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("New authorized vote signer."),
-                )
-                .arg(memo_arg())
-        )
-        .subcommand(
-            SubCommand::with_name("vote-authorize-withdrawer-checked")
-                .about("Authorize a new withdraw signing keypair for the given vote account, \
-                    checking the new authority as a signer")
-                .arg(
-                    pubkey!(Arg::with_name("vote_account_pubkey")
-                        .index(1)
-                        .value_name("VOTE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Vote account in which to set the authorized withdrawer. "),
-                )
-                .arg(
-                    Arg::with_name("authorized")
-                        .index(2)
-                        .value_name("AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("Current authorized withdrawer."),
-                )
-                .arg(
-                    Arg::with_name("new_authorized")
-                        .index(3)
-                        .value_name("NEW_AUTHORIZED_KEYPAIR")
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("New authorized withdrawer."),
-                )
-                .arg(memo_arg())
+                ),
         )
         .subcommand(
             SubCommand::with_name("vote-update-validator")
@@ -236,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")
@@ -266,7 +190,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer keypair"),
                 )
-                .arg(memo_arg())
         )
         .subcommand(
             SubCommand::with_name("vote-account")
@@ -284,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(
@@ -336,7 +243,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .validator(is_valid_signer)
                         .help("Authorized withdrawer [default: cli config keypair]"),
                 )
-                .arg(memo_arg())
         )
     }
 }
@@ -352,27 +258,7 @@ pub fn parse_create_vote_account(
         signer_of(matches, "identity_account", wallet_manager)?;
     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)?.unwrap();
-    let allow_unsafe = matches.is_present("allow_unsafe_authorized_withdrawer");
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
-
-    if !allow_unsafe {
-        if authorized_withdrawer == vote_account_pubkey.unwrap() {
-            return Err(CliError::BadParameter(
-                "Authorized withdrawer pubkey is identical to vote \
-                                               account pubkey, an unsafe configuration"
-                    .to_owned(),
-            ));
-        }
-        if authorized_withdrawer == identity_pubkey.unwrap() {
-            return Err(CliError::BadParameter(
-                "Authorized withdrawer pubkey is identical to identity \
-                                               account pubkey, an unsafe configuration"
-                    .to_owned(),
-            ));
-        }
-    }
+    let authorized_withdrawer = pubkey_of_signer(matches, "authorized_withdrawer", wallet_manager)?;
 
     let payer_provided = None;
     let signer_info = default_signer.generate_unique_signers(
@@ -389,7 +275,6 @@ pub fn parse_create_vote_account(
             authorized_voter,
             authorized_withdrawer,
             commission,
-            memo,
         },
         signers: signer_info.signers,
     })
@@ -400,39 +285,25 @@ pub fn parse_vote_authorize(
     default_signer: &DefaultSigner,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
     vote_authorize: VoteAuthorize,
-    checked: bool,
 ) -> Result<CliCommandInfo, CliError> {
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
-    let (authorized, authorized_pubkey) = signer_of(matches, "authorized", wallet_manager)?;
+    let new_authorized_pubkey =
+        pubkey_of_signer(matches, "new_authorized_pubkey", wallet_manager)?.unwrap();
+    let (authorized, _) = signer_of(matches, "authorized", wallet_manager)?;
 
     let payer_provided = None;
-    let mut signers = vec![payer_provided, authorized];
-
-    let new_authorized_pubkey = if checked {
-        let (new_authorized_signer, new_authorized_pubkey) =
-            signer_of(matches, "new_authorized", wallet_manager)?;
-        signers.push(new_authorized_signer);
-        new_authorized_pubkey.unwrap()
-    } else {
-        pubkey_of_signer(matches, "new_authorized_pubkey", wallet_manager)?.unwrap()
-    };
-
-    let signer_info = default_signer.generate_unique_signers(signers, matches, wallet_manager)?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
+    let signer_info = default_signer.generate_unique_signers(
+        vec![payer_provided, authorized],
+        matches,
+        wallet_manager,
+    )?;
 
     Ok(CliCommandInfo {
         command: CliCommand::VoteAuthorize {
             vote_account_pubkey,
             new_authorized_pubkey,
             vote_authorize,
-            memo,
-            authorized: signer_info.index_of(authorized_pubkey).unwrap(),
-            new_authorized: if checked {
-                signer_info.index_of(Some(new_authorized_pubkey))
-            } else {
-                None
-            },
         },
         signers: signer_info.signers,
     })
@@ -456,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,
     })
@@ -486,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,
     })
@@ -506,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![],
     })
@@ -541,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 {
@@ -549,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,
     })
@@ -562,14 +421,13 @@ pub fn process_create_vote_account(
     seed: &Option<String>,
     identity_account: SignerIndex,
     authorized_voter: &Option<Pubkey>,
-    authorized_withdrawer: Pubkey,
+    authorized_withdrawer: &Option<Pubkey>,
     commission: u8,
-    memo: Option<&String>,
 ) -> ProcessResult {
     let vote_account = config.signers[vote_account];
     let vote_account_pubkey = vote_account.pubkey();
     let vote_account_address = if let Some(seed) = seed {
-        Pubkey::create_with_seed(&vote_account_pubkey, seed, &solana_vote_program::id())?
+        Pubkey::create_with_seed(&vote_account_pubkey, &seed, &solana_vote_program::id())?
     } else {
         vote_account_pubkey
     };
@@ -594,7 +452,7 @@ pub fn process_create_vote_account(
         let vote_init = VoteInit {
             node_pubkey: identity_pubkey,
             authorized_voter: authorized_voter.unwrap_or(identity_pubkey),
-            authorized_withdrawer,
+            authorized_withdrawer: authorized_withdrawer.unwrap_or(identity_pubkey),
             commission,
         };
 
@@ -607,7 +465,6 @@ pub fn process_create_vote_account(
                 &vote_init,
                 lamports,
             )
-            .with_memo(memo)
         } else {
             vote_instruction::create_account(
                 &config.signers[0].pubkey(),
@@ -615,7 +472,6 @@ pub fn process_create_vote_account(
                 &vote_init,
                 lamports,
             )
-            .with_memo(memo)
         };
         Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
@@ -650,7 +506,7 @@ pub fn process_create_vote_account(
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<SystemError>(result, config)
+    log_instruction_custom_error::<SystemError>(result, &config)
 }
 
 pub fn process_vote_authorize(
@@ -659,54 +515,26 @@ pub fn process_vote_authorize(
     vote_account_pubkey: &Pubkey,
     new_authorized_pubkey: &Pubkey,
     vote_authorize: VoteAuthorize,
-    authorized: SignerIndex,
-    new_authorized: Option<SignerIndex>,
-    memo: Option<&String>,
 ) -> ProcessResult {
-    let authorized = config.signers[authorized];
-    let new_authorized_signer = new_authorized.map(|index| config.signers[index]);
+    // If the `authorized_account` is also the fee payer, `config.signers` will only have one
+    // keypair in it
+    let authorized = if config.signers.len() == 2 {
+        config.signers[1]
+    } else {
+        config.signers[0]
+    };
 
     check_unique_pubkeys(
         (&authorized.pubkey(), "authorized_account".to_string()),
         (new_authorized_pubkey, "new_authorized_pubkey".to_string()),
     )?;
-
-    let (_, vote_state) = get_vote_account(rpc_client, vote_account_pubkey, config.commitment)?;
-    match vote_authorize {
-        VoteAuthorize::Voter => {
-            let current_authorized_voter = vote_state
-                .authorized_voters()
-                .last()
-                .ok_or_else(|| {
-                    CliError::RpcRequestError(
-                        "Invalid vote account state; no authorized voters found".to_string(),
-                    )
-                })?
-                .1;
-            check_current_authority(current_authorized_voter, &authorized.pubkey())?
-        }
-        VoteAuthorize::Withdrawer => {
-            check_current_authority(&vote_state.authorized_withdrawer, &authorized.pubkey())?
-        }
-    }
-
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let vote_ix = if new_authorized_signer.is_some() {
-        vote_instruction::authorize_checked(
-            vote_account_pubkey,   // vote account to update
-            &authorized.pubkey(),  // current authorized
-            new_authorized_pubkey, // new vote signer/withdrawer
-            vote_authorize,        // vote or withdraw
-        )
-    } else {
-        vote_instruction::authorize(
-            vote_account_pubkey,   // vote account to update
-            &authorized.pubkey(),  // current authorized
-            new_authorized_pubkey, // new vote signer/withdrawer
-            vote_authorize,        // vote or withdraw
-        )
-    };
-    let ixs = vec![vote_ix].with_memo(memo);
+    let ixs = vec![vote_instruction::authorize(
+        vote_account_pubkey,   // vote account to update
+        &authorized.pubkey(),  // current authorized
+        new_authorized_pubkey, // new vote signer/withdrawer
+        vote_authorize,        // vote or withdraw
+    )];
 
     let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
@@ -719,7 +547,7 @@ pub fn process_vote_authorize(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 pub fn process_vote_update_validator(
@@ -728,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];
@@ -742,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);
@@ -756,7 +582,7 @@ pub fn process_vote_update_validator(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 pub fn process_vote_update_commission(
@@ -765,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()?;
@@ -773,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);
@@ -787,7 +611,7 @@ pub fn process_vote_update_commission(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 fn get_vote_account(
@@ -823,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)?;
@@ -849,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,
@@ -885,12 +706,11 @@ pub fn process_withdraw_from_vote_account(
     withdraw_authority: SignerIndex,
     withdraw_amount: SpendAmount,
     destination_account_pubkey: &Pubkey,
-    memo: Option<&String>,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
     let withdraw_authority = config.signers[withdraw_authority];
 
-    let current_balance = rpc_client.get_balance(vote_account_pubkey)?;
+    let current_balance = rpc_client.get_balance(&vote_account_pubkey)?;
     let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(VoteState::size_of())?;
 
     let lamports = match withdraw_amount {
@@ -906,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(
@@ -925,13 +744,13 @@ pub fn process_withdraw_from_vote_account(
         config.commitment,
     )?;
     let result = rpc_client.send_and_confirm_transaction_with_spinner(&transaction);
-    log_instruction_custom_error::<VoteError>(result, config)
+    log_instruction_custom_error::<VoteError>(result, &config)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{clap_app::get_clap_app, cli::parse_command};
+    use crate::cli::{app, parse_command};
     use solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer};
     use tempfile::NamedTempFile;
 
@@ -942,7 +761,7 @@ mod tests {
 
     #[test]
     fn test_parse_command() {
-        let test_commands = get_clap_app("test", "desc", "version");
+        let test_commands = app("test", "desc", "version");
         let keypair = Keypair::new();
         let pubkey = keypair.pubkey();
         let pubkey_string = pubkey.to_string();
@@ -953,7 +772,10 @@ mod tests {
         let default_keypair = Keypair::new();
         let (default_keypair_file, mut tmp_file) = make_tmp_file();
         write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
-        let default_signer = DefaultSigner::new("", &default_keypair_file);
+        let default_signer = DefaultSigner {
+            path: default_keypair_file.clone(),
+            arg_name: String::new(),
+        };
 
         let test_authorize_voter = test_commands.clone().get_matches_from(vec![
             "test",
@@ -968,10 +790,7 @@ mod tests {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
                     new_authorized_pubkey: pubkey2,
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 0,
-                    new_authorized: None,
+                    vote_authorize: VoteAuthorize::Voter
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -994,10 +813,7 @@ mod tests {
                 command: CliCommand::VoteAuthorize {
                     vote_account_pubkey: pubkey,
                     new_authorized_pubkey: pubkey2,
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 1,
-                    new_authorized: None,
+                    vote_authorize: VoteAuthorize::Voter
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1006,84 +822,18 @@ mod tests {
             }
         );
 
-        let (voter_keypair_file, mut tmp_file) = make_tmp_file();
-        let voter_keypair = Keypair::new();
-        write_keypair(&voter_keypair, tmp_file.as_file_mut()).unwrap();
-
-        let test_authorize_voter = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-authorize-voter-checked",
-            &pubkey_string,
-            &default_keypair_file,
-            &voter_keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_authorize_voter, &default_signer, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::VoteAuthorize {
-                    vote_account_pubkey: pubkey,
-                    new_authorized_pubkey: voter_keypair.pubkey(),
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 0,
-                    new_authorized: Some(1),
-                },
-                signers: vec![
-                    read_keypair_file(&default_keypair_file).unwrap().into(),
-                    read_keypair_file(&voter_keypair_file).unwrap().into()
-                ],
-            }
-        );
-
-        let test_authorize_voter = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-authorize-voter-checked",
-            &pubkey_string,
-            &authorized_keypair_file,
-            &voter_keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_authorize_voter, &default_signer, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::VoteAuthorize {
-                    vote_account_pubkey: pubkey,
-                    new_authorized_pubkey: voter_keypair.pubkey(),
-                    vote_authorize: VoteAuthorize::Voter,
-                    memo: None,
-                    authorized: 1,
-                    new_authorized: Some(2),
-                },
-                signers: vec![
-                    read_keypair_file(&default_keypair_file).unwrap().into(),
-                    read_keypair_file(&authorized_keypair_file).unwrap().into(),
-                    read_keypair_file(&voter_keypair_file).unwrap().into(),
-                ],
-            }
-        );
-
-        let test_authorize_voter = test_commands.clone().get_matches_from(vec![
-            "test",
-            "vote-authorize-voter-checked",
-            &pubkey_string,
-            &authorized_keypair_file,
-            &pubkey2_string,
-        ]);
-        assert!(parse_command(&test_authorize_voter, &default_signer, &mut None).is_err());
-
         let (keypair_file, mut tmp_file) = make_tmp_file();
         let keypair = Keypair::new();
         write_keypair(&keypair, tmp_file.as_file_mut()).unwrap();
         // Test CreateVoteAccount SubCommand
         let (identity_keypair_file, mut tmp_file) = make_tmp_file();
         let identity_keypair = Keypair::new();
-        let authorized_withdrawer = Keypair::new().pubkey();
         write_keypair(&identity_keypair, tmp_file.as_file_mut()).unwrap();
         let test_create_vote_account = test_commands.clone().get_matches_from(vec![
             "test",
             "create-vote-account",
             &keypair_file,
             &identity_keypair_file,
-            &authorized_withdrawer.to_string(),
             "--commission",
             "10",
         ]);
@@ -1095,9 +845,8 @@ mod tests {
                     seed: None,
                     identity_account: 2,
                     authorized_voter: None,
-                    authorized_withdrawer,
+                    authorized_withdrawer: None,
                     commission: 10,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1116,7 +865,6 @@ mod tests {
             "create-vote-account",
             &keypair_file,
             &identity_keypair_file,
-            &authorized_withdrawer.to_string(),
         ]);
         assert_eq!(
             parse_command(&test_create_vote_account2, &default_signer, &mut None).unwrap(),
@@ -1126,9 +874,8 @@ mod tests {
                     seed: None,
                     identity_account: 2,
                     authorized_voter: None,
-                    authorized_withdrawer,
+                    authorized_withdrawer: None,
                     commission: 100,
-                    memo: None,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1149,7 +896,6 @@ mod tests {
             "create-vote-account",
             &keypair_file,
             &identity_keypair_file,
-            &authorized_withdrawer.to_string(),
             "--authorized-voter",
             &authed.to_string(),
         ]);
@@ -1161,9 +907,8 @@ mod tests {
                     seed: None,
                     identity_account: 2,
                     authorized_voter: Some(authed),
-                    authorized_withdrawer,
-                    commission: 100,
-                    memo: None,
+                    authorized_withdrawer: None,
+                    commission: 100
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1176,14 +921,14 @@ mod tests {
         let (keypair_file, mut tmp_file) = make_tmp_file();
         let keypair = Keypair::new();
         write_keypair(&keypair, tmp_file.as_file_mut()).unwrap();
-        // succeed even though withdrawer unsafe (because forcefully allowed)
+        // test init with an authed withdrawer
         let test_create_vote_account4 = test_commands.clone().get_matches_from(vec![
             "test",
             "create-vote-account",
             &keypair_file,
             &identity_keypair_file,
-            &identity_keypair_file,
-            "--allow-unsafe-authorized-withdrawer",
+            "--authorized-withdrawer",
+            &authed.to_string(),
         ]);
         assert_eq!(
             parse_command(&test_create_vote_account4, &default_signer, &mut None).unwrap(),
@@ -1193,9 +938,8 @@ mod tests {
                     seed: None,
                     identity_account: 2,
                     authorized_voter: None,
-                    authorized_withdrawer: identity_keypair.pubkey(),
-                    commission: 100,
-                    memo: None,
+                    authorized_withdrawer: Some(authed),
+                    commission: 100
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -1219,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(),
@@ -1243,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(),
@@ -1268,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()],
             }
@@ -1290,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()],
             }
@@ -1317,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/src/wallet.rs

@@ -1,744 +0,0 @@
-use crate::{
-    cli::{
-        log_instruction_custom_error, request_and_confirm_airdrop, CliCommand, CliCommandInfo,
-        CliConfig, CliError, ProcessResult,
-    },
-    memo::WithMemo,
-    nonce::check_nonce_account,
-    spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
-};
-use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
-use solana_account_decoder::{UiAccount, UiAccountEncoding};
-use solana_clap_utils::{
-    fee_payer::*,
-    input_parsers::*,
-    input_validators::*,
-    keypair::{DefaultSigner, SignerIndex},
-    memo::*,
-    nonce::*,
-    offline::*,
-};
-use solana_cli_output::{
-    display::build_balance_message, return_signers_with_config, CliAccount,
-    CliSignatureVerificationStatus, CliTransaction, CliTransactionConfirmation, OutputFormat,
-    ReturnSignersConfig,
-};
-use solana_client::{
-    blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
-    rpc_config::RpcTransactionConfig, rpc_response::RpcKeyedAccount,
-};
-use solana_remote_wallet::remote_wallet::RemoteWalletManager;
-use solana_sdk::{
-    commitment_config::CommitmentConfig,
-    message::Message,
-    pubkey::Pubkey,
-    signature::Signature,
-    stake,
-    system_instruction::{self, SystemError},
-    system_program,
-    transaction::Transaction,
-};
-use solana_transaction_status::{EncodedTransaction, UiTransactionEncoding};
-use std::{fmt::Write as FmtWrite, fs::File, io::Write, sync::Arc};
-
-pub trait WalletSubCommands {
-    fn wallet_subcommands(self) -> Self;
-}
-
-impl WalletSubCommands for App<'_, '_> {
-    fn wallet_subcommands(self) -> Self {
-        self.subcommand(
-            SubCommand::with_name("account")
-                .about("Show the contents of an account")
-                .alias("account")
-                .arg(
-                    pubkey!(Arg::with_name("account_pubkey")
-                        .index(1)
-                        .value_name("ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Account key URI. ")
-                )
-                .arg(
-                    Arg::with_name("output_file")
-                        .long("output-file")
-                        .short("o")
-                        .value_name("FILEPATH")
-                        .takes_value(true)
-                        .help("Write the account data to this file"),
-                )
-                .arg(
-                    Arg::with_name("lamports")
-                        .long("lamports")
-                        .takes_value(false)
-                        .help("Display balance in lamports instead of SOL"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("address")
-                .about("Get your public key")
-                .arg(
-                    Arg::with_name("confirm_key")
-                        .long("confirm-key")
-                        .takes_value(false)
-                        .help("Confirm key on device; only relevant if using remote wallet"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("airdrop")
-                .about("Request SOL from a faucet")
-                .arg(
-                    Arg::with_name("amount")
-                        .index(1)
-                        .value_name("AMOUNT")
-                        .takes_value(true)
-                        .validator(is_amount)
-                        .required(true)
-                        .help("The airdrop amount to request, in SOL"),
-                )
-                .arg(
-                    pubkey!(Arg::with_name("to")
-                        .index(2)
-                        .value_name("RECIPIENT_ADDRESS"),
-                        "The account address of airdrop recipient. "),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("balance")
-                .about("Get your balance")
-                .arg(
-                    pubkey!(Arg::with_name("pubkey")
-                        .index(1)
-                        .value_name("ACCOUNT_ADDRESS"),
-                        "The account address of the balance to check. ")
-                )
-                .arg(
-                    Arg::with_name("lamports")
-                        .long("lamports")
-                        .takes_value(false)
-                        .help("Display balance in lamports instead of SOL"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("confirm")
-                .about("Confirm transaction by signature")
-                .arg(
-                    Arg::with_name("signature")
-                        .index(1)
-                        .value_name("TRANSACTION_SIGNATURE")
-                        .takes_value(true)
-                        .required(true)
-                        .help("The transaction signature to confirm"),
-                )
-                .after_help(// Formatted specifically for the manually-indented heredoc string
-                   "Note: This will show more detailed information for finalized transactions with verbose mode (-v/--verbose).\
-                  \n\
-                  \nAccount modes:\
-                  \n  |srwx|\
-                  \n    s: signed\
-                  \n    r: readable (always true)\
-                  \n    w: writable\
-                  \n    x: program account (inner instructions excluded)\
-                   "
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("create-address-with-seed")
-                .about("Generate a derived account address with a seed")
-                .arg(
-                    Arg::with_name("seed")
-                        .index(1)
-                        .value_name("SEED_STRING")
-                        .takes_value(true)
-                        .required(true)
-                        .validator(is_derived_address_seed)
-                        .help("The seed.  Must not take more than 32 bytes to encode as utf-8"),
-                )
-                .arg(
-                    Arg::with_name("program_id")
-                        .index(2)
-                        .value_name("PROGRAM_ID")
-                        .takes_value(true)
-                        .required(true)
-                        .help(
-                            "The program_id that the address will ultimately be used for, \n\
-                             or one of NONCE, STAKE, and VOTE keywords",
-                        ),
-                )
-                .arg(
-                    pubkey!(Arg::with_name("from")
-                        .long("from")
-                        .value_name("FROM_PUBKEY")
-                        .required(false),
-                        "From (base) key, [default: cli config keypair]. "),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("decode-transaction")
-                .about("Decode a serialized transaction")
-                .arg(
-                    Arg::with_name("transaction")
-                        .index(1)
-                        .value_name("TRANSACTION")
-                        .takes_value(true)
-                        .required(true)
-                        .help("transaction to decode"),
-                )
-                .arg(
-                    Arg::with_name("encoding")
-                        .index(2)
-                        .value_name("ENCODING")
-                        .possible_values(&["base58", "base64"]) // Subset of `UiTransactionEncoding` enum
-                        .default_value("base58")
-                        .takes_value(true)
-                        .required(true)
-                        .help("transaction encoding"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("resolve-signer")
-                .about("Checks that a signer is valid, and returns its specific path; useful for signers that may be specified generally, eg. usb://ledger")
-                .arg(
-                    Arg::with_name("signer")
-                        .index(1)
-                        .value_name("SIGNER_KEYPAIR")
-                        .takes_value(true)
-                        .required(true)
-                        .validator(is_valid_signer)
-                        .help("The signer path to resolve")
-                )
-        )
-        .subcommand(
-            SubCommand::with_name("transfer")
-                .about("Transfer funds between system accounts")
-                .alias("pay")
-                .arg(
-                    pubkey!(Arg::with_name("to")
-                        .index(1)
-                        .value_name("RECIPIENT_ADDRESS")
-                        .required(true),
-                        "The account address of recipient. "),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .index(2)
-                        .value_name("AMOUNT")
-                        .takes_value(true)
-                        .validator(is_amount_or_all)
-                        .required(true)
-                        .help("The amount to send, in SOL; accepts keyword ALL"),
-                )
-                .arg(
-                    pubkey!(Arg::with_name("from")
-                        .long("from")
-                        .value_name("FROM_ADDRESS"),
-                        "Source account of funds (if different from client local account). "),
-                )
-                .arg(
-                    Arg::with_name("no_wait")
-                        .long("no-wait")
-                        .takes_value(false)
-                        .help("Return signature immediately after submitting the transaction, instead of waiting for confirmations"),
-                )
-                .arg(
-                    Arg::with_name("derived_address_seed")
-                        .long("derived-address-seed")
-                        .takes_value(true)
-                        .value_name("SEED_STRING")
-                        .requires("derived_address_program_id")
-                        .validator(is_derived_address_seed)
-                        .hidden(true)
-                )
-                .arg(
-                    Arg::with_name("derived_address_program_id")
-                        .long("derived-address-program-id")
-                        .takes_value(true)
-                        .value_name("PROGRAM_ID")
-                        .requires("derived_address_seed")
-                        .hidden(true)
-                )
-                .arg(
-                    Arg::with_name("allow_unfunded_recipient")
-                        .long("allow-unfunded-recipient")
-                        .takes_value(false)
-                        .help("Complete the transfer even if the recipient address is not funded")
-                )
-                .offline_args()
-                .nonce_args(false)
-                .arg(memo_arg())
-                .arg(fee_payer_arg()),
-        )
-    }
-}
-
-fn resolve_derived_address_program_id(matches: &ArgMatches<'_>, arg_name: &str) -> Option<Pubkey> {
-    matches.value_of(arg_name).and_then(|v| match v {
-        "NONCE" => Some(system_program::id()),
-        "STAKE" => Some(stake::program::id()),
-        "VOTE" => Some(solana_vote_program::id()),
-        _ => pubkey_of(matches, arg_name),
-    })
-}
-
-pub fn parse_account(
-    matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let account_pubkey = pubkey_of_signer(matches, "account_pubkey", wallet_manager)?.unwrap();
-    let output_file = matches.value_of("output_file");
-    let use_lamports_unit = matches.is_present("lamports");
-    Ok(CliCommandInfo {
-        command: CliCommand::ShowAccount {
-            pubkey: account_pubkey,
-            output_file: output_file.map(ToString::to_string),
-            use_lamports_unit,
-        },
-        signers: vec![],
-    })
-}
-
-pub fn parse_airdrop(
-    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let pubkey = pubkey_of_signer(matches, "to", wallet_manager)?;
-    let signers = if pubkey.is_some() {
-        vec![]
-    } else {
-        vec![default_signer.signer_from_path(matches, wallet_manager)?]
-    };
-    let lamports = lamports_of_sol(matches, "amount").unwrap();
-    Ok(CliCommandInfo {
-        command: CliCommand::Airdrop { pubkey, lamports },
-        signers,
-    })
-}
-
-pub fn parse_balance(
-    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let pubkey = pubkey_of_signer(matches, "pubkey", wallet_manager)?;
-    let signers = if pubkey.is_some() {
-        vec![]
-    } else {
-        vec![default_signer.signer_from_path(matches, wallet_manager)?]
-    };
-    Ok(CliCommandInfo {
-        command: CliCommand::Balance {
-            pubkey,
-            use_lamports_unit: matches.is_present("lamports"),
-        },
-        signers,
-    })
-}
-
-pub fn parse_decode_transaction(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let blob = value_t_or_exit!(matches, "transaction", String);
-    let encoding = match matches.value_of("encoding").unwrap() {
-        "base58" => UiTransactionEncoding::Base58,
-        "base64" => UiTransactionEncoding::Base64,
-        _ => unreachable!(),
-    };
-
-    let encoded_transaction = EncodedTransaction::Binary(blob, encoding);
-    if let Some(transaction) = encoded_transaction.decode() {
-        Ok(CliCommandInfo {
-            command: CliCommand::DecodeTransaction(transaction),
-            signers: vec![],
-        })
-    } else {
-        Err(CliError::BadParameter(
-            "Unable to decode transaction".to_string(),
-        ))
-    }
-}
-
-pub fn parse_create_address_with_seed(
-    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let from_pubkey = pubkey_of_signer(matches, "from", wallet_manager)?;
-    let signers = if from_pubkey.is_some() {
-        vec![]
-    } else {
-        vec![default_signer.signer_from_path(matches, wallet_manager)?]
-    };
-
-    let program_id = resolve_derived_address_program_id(matches, "program_id").unwrap();
-
-    let seed = matches.value_of("seed").unwrap().to_string();
-
-    Ok(CliCommandInfo {
-        command: CliCommand::CreateAddressWithSeed {
-            from_pubkey,
-            seed,
-            program_id,
-        },
-        signers,
-    })
-}
-
-pub fn parse_transfer(
-    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let amount = SpendAmount::new_from_matches(matches, "amount");
-    let to = pubkey_of_signer(matches, "to", wallet_manager)?.unwrap();
-    let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-    let dump_transaction_message = matches.is_present(DUMP_TRANSACTION_MESSAGE.name);
-    let no_wait = matches.is_present("no_wait");
-    let blockhash_query = BlockhashQuery::new_from_matches(matches);
-    let nonce_account = pubkey_of_signer(matches, NONCE_ARG.name, wallet_manager)?;
-    let (nonce_authority, nonce_authority_pubkey) =
-        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
-    let memo = matches.value_of(MEMO_ARG.name).map(String::from);
-    let (fee_payer, fee_payer_pubkey) = signer_of(matches, FEE_PAYER_ARG.name, wallet_manager)?;
-    let (from, from_pubkey) = signer_of(matches, "from", wallet_manager)?;
-    let allow_unfunded_recipient = matches.is_present("allow_unfunded_recipient");
-
-    let mut bulk_signers = vec![fee_payer, from];
-    if nonce_account.is_some() {
-        bulk_signers.push(nonce_authority);
-    }
-
-    let signer_info =
-        default_signer.generate_unique_signers(bulk_signers, matches, wallet_manager)?;
-
-    let derived_address_seed = matches
-        .value_of("derived_address_seed")
-        .map(|s| s.to_string());
-    let derived_address_program_id =
-        resolve_derived_address_program_id(matches, "derived_address_program_id");
-
-    Ok(CliCommandInfo {
-        command: CliCommand::Transfer {
-            amount,
-            to,
-            sign_only,
-            dump_transaction_message,
-            allow_unfunded_recipient,
-            no_wait,
-            blockhash_query,
-            nonce_account,
-            nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
-            memo,
-            fee_payer: signer_info.index_of(fee_payer_pubkey).unwrap(),
-            from: signer_info.index_of(from_pubkey).unwrap(),
-            derived_address_seed,
-            derived_address_program_id,
-        },
-        signers: signer_info.signers,
-    })
-}
-
-pub fn process_show_account(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    account_pubkey: &Pubkey,
-    output_file: &Option<String>,
-    use_lamports_unit: bool,
-) -> ProcessResult {
-    let account = rpc_client.get_account(account_pubkey)?;
-    let data = account.data.clone();
-    let cli_account = CliAccount {
-        keyed_account: RpcKeyedAccount {
-            pubkey: account_pubkey.to_string(),
-            account: UiAccount::encode(
-                account_pubkey,
-                &account,
-                UiAccountEncoding::Base64,
-                None,
-                None,
-            ),
-        },
-        use_lamports_unit,
-    };
-
-    let mut account_string = config.output_format.formatted_string(&cli_account);
-
-    if config.output_format == OutputFormat::Display
-        || config.output_format == OutputFormat::DisplayVerbose
-    {
-        if let Some(output_file) = output_file {
-            let mut f = File::create(output_file)?;
-            f.write_all(&data)?;
-            writeln!(&mut account_string)?;
-            writeln!(&mut account_string, "Wrote account data to {}", output_file)?;
-        } else if !data.is_empty() {
-            use pretty_hex::*;
-            writeln!(&mut account_string, "{:?}", data.hex_dump())?;
-        }
-    }
-
-    Ok(account_string)
-}
-
-pub fn process_airdrop(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    pubkey: &Option<Pubkey>,
-    lamports: u64,
-) -> ProcessResult {
-    let pubkey = if let Some(pubkey) = pubkey {
-        *pubkey
-    } else {
-        config.pubkey()?
-    };
-    println!(
-        "Requesting airdrop of {}",
-        build_balance_message(lamports, false, true),
-    );
-
-    let pre_balance = rpc_client.get_balance(&pubkey)?;
-
-    let result = request_and_confirm_airdrop(rpc_client, config, &pubkey, lamports);
-    if let Ok(signature) = result {
-        let signature_cli_message = log_instruction_custom_error::<SystemError>(result, config)?;
-        println!("{}", signature_cli_message);
-
-        let current_balance = rpc_client.get_balance(&pubkey)?;
-
-        if current_balance < pre_balance.saturating_add(lamports) {
-            println!("Balance unchanged");
-            println!("Run `solana confirm -v {:?}` for more info", signature);
-            Ok("".to_string())
-        } else {
-            Ok(build_balance_message(current_balance, false, true))
-        }
-    } else {
-        log_instruction_custom_error::<SystemError>(result, config)
-    }
-}
-
-pub fn process_balance(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    pubkey: &Option<Pubkey>,
-    use_lamports_unit: bool,
-) -> ProcessResult {
-    let pubkey = if let Some(pubkey) = pubkey {
-        *pubkey
-    } else {
-        config.pubkey()?
-    };
-    let balance = rpc_client.get_balance(&pubkey)?;
-    Ok(build_balance_message(balance, use_lamports_unit, true))
-}
-
-pub fn process_confirm(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    signature: &Signature,
-) -> ProcessResult {
-    match rpc_client.get_signature_statuses_with_history(&[*signature]) {
-        Ok(status) => {
-            let cli_transaction = if let Some(transaction_status) = &status.value[0] {
-                let mut transaction = None;
-                let mut get_transaction_error = None;
-                if config.verbose {
-                    match rpc_client.get_transaction_with_config(
-                        signature,
-                        RpcTransactionConfig {
-                            encoding: Some(UiTransactionEncoding::Base64),
-                            commitment: Some(CommitmentConfig::confirmed()),
-                        },
-                    ) {
-                        Ok(confirmed_transaction) => {
-                            let decoded_transaction = confirmed_transaction
-                                .transaction
-                                .transaction
-                                .decode()
-                                .expect("Successful decode");
-                            let json_transaction = EncodedTransaction::encode(
-                                decoded_transaction.clone(),
-                                UiTransactionEncoding::Json,
-                            );
-
-                            transaction = Some(CliTransaction {
-                                transaction: json_transaction,
-                                meta: confirmed_transaction.transaction.meta,
-                                block_time: confirmed_transaction.block_time,
-                                slot: Some(confirmed_transaction.slot),
-                                decoded_transaction,
-                                prefix: "  ".to_string(),
-                                sigverify_status: vec![],
-                            });
-                        }
-                        Err(err) => {
-                            get_transaction_error = Some(format!("{:?}", err));
-                        }
-                    }
-                }
-                CliTransactionConfirmation {
-                    confirmation_status: Some(transaction_status.confirmation_status()),
-                    transaction,
-                    get_transaction_error,
-                    err: transaction_status.err.clone(),
-                }
-            } else {
-                CliTransactionConfirmation {
-                    confirmation_status: None,
-                    transaction: None,
-                    get_transaction_error: None,
-                    err: None,
-                }
-            };
-            Ok(config.output_format.formatted_string(&cli_transaction))
-        }
-        Err(err) => Err(CliError::RpcRequestError(format!("Unable to confirm: {}", err)).into()),
-    }
-}
-
-#[allow(clippy::unnecessary_wraps)]
-pub fn process_decode_transaction(config: &CliConfig, transaction: &Transaction) -> ProcessResult {
-    let sigverify_status = CliSignatureVerificationStatus::verify_transaction(transaction);
-    let decode_transaction = CliTransaction {
-        decoded_transaction: transaction.clone(),
-        transaction: EncodedTransaction::encode(transaction.clone(), UiTransactionEncoding::Json),
-        meta: None,
-        block_time: None,
-        slot: None,
-        prefix: "".to_string(),
-        sigverify_status,
-    };
-    Ok(config.output_format.formatted_string(&decode_transaction))
-}
-
-pub fn process_create_address_with_seed(
-    config: &CliConfig,
-    from_pubkey: Option<&Pubkey>,
-    seed: &str,
-    program_id: &Pubkey,
-) -> ProcessResult {
-    let from_pubkey = if let Some(pubkey) = from_pubkey {
-        *pubkey
-    } else {
-        config.pubkey()?
-    };
-    let address = Pubkey::create_with_seed(&from_pubkey, seed, program_id)?;
-    Ok(address.to_string())
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn process_transfer(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    amount: SpendAmount,
-    to: &Pubkey,
-    from: SignerIndex,
-    sign_only: bool,
-    dump_transaction_message: bool,
-    allow_unfunded_recipient: bool,
-    no_wait: bool,
-    blockhash_query: &BlockhashQuery,
-    nonce_account: Option<&Pubkey>,
-    nonce_authority: SignerIndex,
-    memo: Option<&String>,
-    fee_payer: SignerIndex,
-    derived_address_seed: Option<String>,
-    derived_address_program_id: Option<&Pubkey>,
-) -> ProcessResult {
-    let from = config.signers[from];
-    let mut from_pubkey = from.pubkey();
-
-    let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
-
-    if !sign_only && !allow_unfunded_recipient {
-        let recipient_balance = rpc_client
-            .get_balance_with_commitment(to, config.commitment)?
-            .value;
-        if recipient_balance == 0 {
-            return Err(format!(
-                "The recipient address ({}) is not funded. \
-                                Add `--allow-unfunded-recipient` to complete the transfer \
-                               ",
-                to
-            )
-            .into());
-        }
-    }
-
-    let nonce_authority = config.signers[nonce_authority];
-    let fee_payer = config.signers[fee_payer];
-
-    let derived_parts = derived_address_seed.zip(derived_address_program_id);
-    let with_seed = if let Some((seed, program_id)) = derived_parts {
-        let base_pubkey = from_pubkey;
-        from_pubkey = Pubkey::create_with_seed(&base_pubkey, &seed, program_id)?;
-        Some((base_pubkey, seed, program_id, from_pubkey))
-    } else {
-        None
-    };
-
-    let build_message = |lamports| {
-        let ixs = if let Some((base_pubkey, seed, program_id, from_pubkey)) = with_seed.as_ref() {
-            vec![system_instruction::transfer_with_seed(
-                from_pubkey,
-                base_pubkey,
-                seed.clone(),
-                program_id,
-                to,
-                lamports,
-            )]
-            .with_memo(memo)
-        } else {
-            vec![system_instruction::transfer(&from_pubkey, to, lamports)].with_memo(memo)
-        };
-
-        if let Some(nonce_account) = &nonce_account {
-            Message::new_with_nonce(
-                ixs,
-                Some(&fee_payer.pubkey()),
-                nonce_account,
-                &nonce_authority.pubkey(),
-            )
-        } else {
-            Message::new(&ixs, Some(&fee_payer.pubkey()))
-        }
-    };
-
-    let (message, _) = resolve_spend_tx_and_check_account_balances(
-        rpc_client,
-        sign_only,
-        amount,
-        &fee_calculator,
-        &from_pubkey,
-        &fee_payer.pubkey(),
-        build_message,
-        config.commitment,
-    )?;
-    let mut tx = Transaction::new_unsigned(message);
-
-    if sign_only {
-        tx.try_partial_sign(&config.signers, recent_blockhash)?;
-        return_signers_with_config(
-            &tx,
-            &config.output_format,
-            &ReturnSignersConfig {
-                dump_transaction_message,
-            },
-        )
-    } else {
-        if let Some(nonce_account) = &nonce_account {
-            let nonce_account = nonce_utils::get_account_with_commitment(
-                rpc_client,
-                nonce_account,
-                config.commitment,
-            )?;
-            check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
-        }
-
-        tx.try_sign(&config.signers, recent_blockhash)?;
-        let result = if no_wait {
-            rpc_client.send_transaction(&tx)
-        } else {
-            rpc_client.send_and_confirm_transaction_with_spinner(&tx)
-        };
-        log_instruction_custom_error::<SystemError>(result, config)
-    }
-}

cli/tests/fixtures/build.sh

@@ -5,4 +5,3 @@ cd "$(dirname "$0")"
 
 make -C ../../../programs/bpf/c/
 cp ../../../programs/bpf/c/out/noop.so .
-cat noop.so noop.so noop.so > noop_large.so

cli/tests/nonce.rs

@@ -18,46 +18,48 @@ use solana_sdk::{
     signature::{keypair_from_seed, Keypair, Signer},
     system_program,
 };
-use solana_streamer::socket::SocketAddrSpace;
 
 #[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), SocketAddrSpace::Unspecified);
-
-    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), SocketAddrSpace::Unspecified);
-
-    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), SocketAddrSpace::Unspecified);
-
-    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();
@@ -69,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());
@@ -105,7 +108,6 @@ fn full_battery_tests(
         nonce_account: 1,
         seed,
         nonce_authority: optional_authority,
-        memo: None,
         amount: SpendAmount::Some(1000),
     };
 
@@ -139,7 +141,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: index,
-        memo: None,
     };
     process_command(&config_payer).unwrap();
 
@@ -157,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,
     };
@@ -178,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();
@@ -187,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();
 
@@ -196,7 +194,6 @@ fn full_battery_tests(
     config_payer.command = CliCommand::NewNonce {
         nonce_account,
         nonce_authority: 1,
-        memo: None,
     };
     process_command(&config_payer).unwrap();
 
@@ -204,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,
     };
@@ -218,34 +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),
-        SocketAddrSpace::Unspecified,
-    );
 
     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());
@@ -269,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();
@@ -300,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,
@@ -326,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),
@@ -335,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,