Gossip log (#11555 ) (#11562 )

Co-authored-by: Carl <carl@solana.com> (cherry picked from commit 1b238dd63e) Co-authored-by: carllin <wumu727@gmail.com>
Move cluster slots update to separate thread (#11523 ) (#11558 )
2020-08-11 22:55:18 +00:00 · 2020-08-11 21:24:34 +00:00 · 2020-08-11 21:21:35 +00:00 · 2020-08-11 19:42:32 +00:00 · 2020-08-11 17:31:57 +00:00 · 2020-08-11 16:20:06 +00:00
1145 changed files with 47256 additions and 178200 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/.buildkite/env/secrets.ejson
+++ b/.buildkite/env/secrets.ejson
@@ -1,7 +1,12 @@
 {
    "_public_key": "ae29f4f7ad2fc92de70d470e411c8426d5d48db8817c9e3dae574b122192335f",
-    "_comment": "These credentials are encrypted and pose no risk",
    "environment": {
-      "CODECOV_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:3K68mE38LJ2RB98VWmjuNLFBNn1XTGR4:cR4r05/TOZQKmEZp1v4CSgUJtC6QJiOaL85QjXW0qZ061fMnsBA8AtAPMDoDq4WCGOZM1A==]"
+      "CODECOV_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:3K68mE38LJ2RB98VWmjuNLFBNn1XTGR4:cR4r05/TOZQKmEZp1v4CSgUJtC6QJiOaL85QjXW0qZ061fMnsBA8AtAPMDoDq4WCGOZM1A==]",
+      "CRATES_IO_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:GGRTYDjMXksevzR6kq4Jx+FaIQZz50RU:xkbwDxcgoCyU+aT2tiI9mymigrEl6YiOr3axe3aX70ELIBKbCdPGilXP/wixvKi94g2u]",
+      "GEOLOCATION_API_KEY": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:U2PZLi5MU3Ru/zK1SilianEeizcMvxml:AJKf2OAtDHmJh0KyXrBnNnistItZvVVP3cZ7ZLtrVupjmWN/PzmKwSsXeCNObWS+]",
+      "GITHUB_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:0NJNlpD/O19mvOakCGBYDhIDfySxWFSC:Dz4NXv9x6ncRQ1u9sVoWOcqmkg0sI09qmefghB0GXZgPcFGgn6T0mw7ynNnbUvjyH8dLruKHauk=]",
+      "INFLUX_DATABASE": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:SzwHIeOVpmbTcGQOGngoFgYumsLZJUGq:t7Rpk49njsWvoM+ztv5Uwuiz]",
+      "INFLUX_PASSWORD": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:/MUs+q7pdGrUjzwcq+6pgIFxur4hxdqu:am22z2E2dtmw1f1J1Mq5JLcUHZsrEjQAJ0pp21M4AZeJbNO6bVb44d9zSkHj7xdN6U+GNlCk+wU=]",
+      "INFLUX_USERNAME": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:XjghH20xGVWro9B+epGlJaJcW8Wze0Bi:ZIdOtXudTY5TqKseDU7gVvQXfmXV99Xh]"
    }
 }
--- a/.buildkite/hooks/post-command
+++ b/.buildkite/hooks/post-command
@@ -3,19 +3,16 @@
 #
 # Save target/ for the next CI build on this machine
 #
-if [[ -z $CARGO_TARGET_CACHE ]]; then
-  echo "+++ CARGO_TARGET_CACHE not defined" # pre-command should have defined it
-else
-  (
-    set -x
-    mkdir -p "$CARGO_TARGET_CACHE"
-    set -x
-    rsync -a --delete --link-dest="$PWD" target "$CARGO_TARGET_CACHE"
-    du -hs "$CARGO_TARGET_CACHE"
-    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$CARGO_TARGET_CACHE")
-    echo "--- ${cacheSizeInGB}GB: $CARGO_TARGET_CACHE"
-  )
-fi
+(
+  set -x
+  d=$HOME/cargo-target-cache/"$BUILDKITE_LABEL"
+  mkdir -p "$d"
+  set -x
+  rsync -a --delete --link-dest="$PWD" target "$d"
+  du -hs "$d"
+  read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$d")
+  echo "--- ${cacheSizeInGB}GB: $d"
+)

 #
 # Add job_stats data point
--- a/.buildkite/hooks/pre-command
+++ b/.buildkite/hooks/pre-command
@@ -11,29 +11,23 @@ export PS4="++"
 #
 # Restore target/ from the previous CI build on this machine
 #
-eval "$(ci/channel-info.sh)"
-export CARGO_TARGET_CACHE=$HOME/cargo-target-cache/"$CHANNEL"-"$BUILDKITE_LABEL"
 (
  set -x
+  d=$HOME/cargo-target-cache/"$BUILDKITE_LABEL"
  MAX_CACHE_SIZE=18 # gigabytes

-  if [[ -d $CARGO_TARGET_CACHE ]]; then
-    du -hs "$CARGO_TARGET_CACHE"
-    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$CARGO_TARGET_CACHE")
-    echo "--- ${cacheSizeInGB}GB: $CARGO_TARGET_CACHE"
+  if [[ -d $d ]]; then
+    du -hs "$d"
+    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$d")
+    echo "--- ${cacheSizeInGB}GB: $d"
    if [[ $cacheSizeInGB -gt $MAX_CACHE_SIZE ]]; then
-      echo "--- $CARGO_TARGET_CACHE is too large, removing it"
-      rm -rf "$CARGO_TARGET_CACHE"
+      echo "--- $d is too large, removing it"
+      rm -rf "$d"
    fi
  else
-    echo "--- $CARGO_TARGET_CACHE not present"
+    echo "--- $d not present"
  fi

-  mkdir -p "$CARGO_TARGET_CACHE"/target
-  rsync -a --delete --link-dest="$CARGO_TARGET_CACHE" "$CARGO_TARGET_CACHE"/target .
-
-  # Don't reuse BPF target build artifacts due to incremental build issues with
-  # `std:
-  #    "found possibly newer version of crate `std` which `xyz` depends on
-  rm -rf target/bpfel-unknown-unknown
+  mkdir -p "$d"/target
+  rsync -a --delete --link-dest="$d" "$d"/target .
 )
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -1,3 +1,11 @@
+only: pulls
+
+# Number of days of inactivity before a pull request becomes stale
+daysUntilStale: 7
+
+# Number of days of inactivity before a stale pull request is closed
+daysUntilClose: 7
+
 # Issues with these labels will never be considered stale
 exemptLabels:
  - security
@@ -6,34 +14,12 @@ exemptLabels:
 # Label to use when marking a pull request as stale
 staleLabel: stale

-pulls:
-  # Number of days of inactivity before a pull request becomes stale
-  daysUntilStale: 7
+# Comment to post when marking a pull request as stale. Set to `false` to disable
+markComment: >
+  This pull request has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs.

-  # Number of days of inactivity before a stale pull request is closed
-  daysUntilClose: 7
-  # Comment to post when marking a pull request as stale. Set to `false` to disable
-  markComment: >
-    This pull request has been automatically marked as stale because it has not had
-    recent activity. It will be closed if no further activity occurs.
-
-  # Comment to post when closing a stale pull request. Set to `false` to disable
-  closeComment: >
-    This stale pull request has been automatically closed.
-    Thank you for your contributions.
-
-issues:
-  # Number of days of inactivity before a issue becomes stale
-  daysUntilStale: 365
-
-  # Number of days of inactivity before a stale issue is closed
-  daysUntilClose: 7
-  # Comment to post when marking a issue as stale. Set to `false` to disable
-  markComment: >
-    This issue has been automatically marked as stale because it has not had
-    recent activity. It will be closed if no further activity occurs.
-
-  # Comment to post when closing a stale issue. Set to `false` to disable
-  closeComment: >
-    This stale issue has been automatically closed.
-    Thank you for your contributions.
+# Comment to post when closing a stale pull request. Set to `false` to disable
+closeComment: >
+  This stale pull request has been automatically closed.
+  Thank you for your contributions.
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,7 @@
+/docs/html/
+/docs/src/tests.ok
+/docs/src/cli/usage.md
+/docs/src/.gitbook/assets/*.svg
 /farf/
 /solana-release/
 /solana-release.tar.bz2
@@ -10,8 +14,6 @@

 /config/

-.cache
-
 # log files
 *.log
 log-*.txt
--- a/.mergify.yml
+++ b/.mergify.yml
@@ -50,6 +50,22 @@ pull_request_rules:
      label:
        add:
          - automerge
+  - name: v1.1 backport
+    conditions:
+      - label=v1.1
+    actions:
+      backport:
+        ignore_conflicts: true
+        branches:
+          - v1.1
+  - name: v1.2 backport
+    conditions:
+      - label=v1.2
+    actions:
+      backport:
+        ignore_conflicts: true
+        branches:
+          - v1.2
  - name: v1.3 backport
    conditions:
      - label=v1.3
@@ -58,27 +74,3 @@ pull_request_rules:
        ignore_conflicts: true
        branches:
          - v1.3
-  - name: v1.4 backport
-    conditions:
-      - label=v1.4
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.4
-  - name: v1.5 backport
-    conditions:
-      - label=v1.5
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.5
-  - name: v1.6 backport
-    conditions:
-      - label=v1.6
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.6
--- a/.travis.yml
+++ b/.travis.yml
@@ -34,8 +34,6 @@ jobs:
        - stable
      install:
        - source ci/rust-version.sh
-        - PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH"
-        - readlink -f .
      script:
        - source ci/env.sh
        - ci/publish-tarball.sh
@@ -126,8 +124,6 @@ jobs:
          - ~/.npm

      before_install:
-        - source ci/env.sh
-        - .travis/channel_restriction.sh edge beta || travis_terminate 0
        - .travis/affects.sh docs/ .travis || travis_terminate 0
        - cd docs/
        - source .travis/before_install.sh
--- a/.travis/channel_restriction.sh
+++ b/.travis/channel_restriction.sh
@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-#
-# Only proceed if we are on one of the channels passed in, or a tag build
-#
-
-set -ex
-
-[[ -n $CI_TAG ]] && exit 0
-
-eval "$(ci/channel-info.sh)"
-
-for acceptable_channel in "$@"; do
-  if [[ "$CHANNEL" == "$acceptable_channel" ]]; then
-    exit 0
-  fi
-done
-
-echo "Not running from one of the following channels: $*"
-exit 1
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -232,7 +232,7 @@ confused with 3-letter acronyms.
 Solana's architecture is described by docs generated from markdown files in
 the `docs/src/` directory, maintained by an *editor* (currently @garious). To
 add a design proposal, you'll need to include it in the
-[Accepted Design Proposals](https://docs.solana.com/proposals/accepted-design-proposals)
+[Accepted Design Proposals](https://docs.solana.com/proposals)
 section of the Solana docs.  Here's the full process:

 1. Propose a design by creating a PR that adds a markdown document to the
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,21 +5,17 @@ members = [
    "bench-tps",
    "accounts-bench",
    "banking-bench",
-    "banks-client",
-    "banks-interface",
-    "banks-server",
    "clap-utils",
    "cli-config",
-    "cli-output",
    "client",
    "core",
    "dos",
    "download-utils",
    "faucet",
-    "frozen-abi",
    "perf",
    "validator",
    "genesis",
+    "genesis-programs",
    "gossip",
    "install",
    "keygen",
@@ -28,19 +24,15 @@ members = [
    "local-cluster",
    "logger",
    "log-analyzer",
-    "merkle-root-bench",
    "merkle-tree",
    "stake-o-matic",
    "storage-bigtable",
-    "storage-proto",
    "streamer",
    "measure",
    "metrics",
    "net-shaper",
    "notifier",
    "poh-bench",
-    "program-test",
-    "programs/secp256k1",
    "programs/bpf_loader",
    "programs/budget",
    "programs/config",
@@ -54,10 +46,7 @@ members = [
    "remote-wallet",
    "ramp-tps",
    "runtime",
-    "runtime/store-tool",
    "sdk",
-    "sdk/cargo-build-bpf",
-    "sdk/cargo-test-bpf",
    "scripts",
    "stake-accounts",
    "stake-monitor",
@@ -68,6 +57,7 @@ members = [
    "upload-perf",
    "net-utils",
    "version",
+    "vote-signer",
    "cli",
    "rayon-threadlimit",
    "watchtower",
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ $ source $HOME/.cargo/env
 $ rustup component add rustfmt
 ```

-Please sure you are always using the latest stable rust version by running:
+If your rustc version is lower than 1.39.0, please update it:

 ```bash
 $ rustup update
@@ -29,7 +29,7 @@ On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, etc

 ```bash
 $ sudo apt-get update
-$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make
+$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```

 ## **2. Download the source code.**
@@ -59,11 +59,10 @@ $ cargo test
 ```

 ### Starting a local testnet
-Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/cluster/bench-tps).
+Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/bench-tps).

-### Accessing the remote development cluster
-* `devnet` - stable public cluster for development accessible via
-devnet.solana.com. Runs 24/7. Learn more about the [public clusters](https://docs.solana.com/clusters)
+### Accessing the remote testnet
+* `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7

 # Benchmarking

@@ -108,5 +107,3 @@ send us that patch!
 # Disclaimer

 All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
-
-Any content produced by Solana, or developer resources that Solana provides, are for educational and inspiration purposes only.  Solana does not encourage, induce or sanction the deployment of any such applications in violation of applicable laws or regulations.
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -107,15 +107,11 @@ Alternatively use the Github UI.
   1.  If the Cargo.toml version field is **0.12.3**, then the release tag must be **v0.12.3**
 1. Make sure the Target Branch field matches the branch you want to make a release on.
   1.  If you want to release v0.12.0, the target branch must be v0.12
-1. Fill the release notes.
-   1.  If this is the first release on the branch (e.g. v0.13.**0**), paste in [this
-   template](https://raw.githubusercontent.com/solana-labs/solana/master/.github/RELEASE_TEMPLATE.md).  Engineering Lead can provide summary contents for release notes if needed.
-   1. If this is a patch release, review all the commits since the previous release on this branch and add details as needed.
+1. If this is the first release on the branch (e.g. v0.13.**0**), paste in [this
+   template](https://raw.githubusercontent.com/solana-labs/solana/master/.github/RELEASE_TEMPLATE.md).  Engineering Lead can provide summary contents for release notes if needed.  If this is a patch release, review all the commits since the previous release on this branch and add details as needed.
 1. Click "Save Draft", then confirm the release notes look good and the tag name and branch are correct.
-1. Ensure all desired commits (usually backports) are landed on the branch by now.
-1. Ensure the release is marked **"This is a pre-release"**.  This flag will need to be be removed manually after confirming the the Linux binary artifacts appear at a later step.
-1. Go back into edit the release and click "Publish release" while being marked as a pre-release.
-1. Confirm there is new git tag with intended version number at the intended revision after running `git fetch` locally.
+1. Ensure the release is marked **"This is a pre-release"**.  This flag will then need to be be removed once the the Linux binary artifacts appear later.
+1. Go back into edit the release and click "Publish release" when ready.


 ### Update release branch with the next patch version
@@ -135,8 +131,7 @@ Alternatively use the Github UI.
 1. Open a PR against origin/vX.Y and then merge the PR after passing CI.

 ### Prepare for the next release
-1.  Go to [GitHub Releases](https://github.com/solana-labs/solana/releases) and create a new draft release for `X.Y.Z+1` with empty release notes.  This allows people to incrementally add new release notes until it's time for the next release
-    1. Also, point the branch field to the same branch and mark the relese as **"This is a pre-release"**.
+1.  Go to [GitHub Releases](https://github.com/solana-labs/solana/releases) and create a new draft release for `X.Y.Z+1` with empty release nodes.  This allows people to incrementally add new release notes until it's time for the next release
 1.  Go to the [Github Milestones](https://github.com/solana-labs/solana/milestones).  Create a new milestone for the `X.Y.Z+1`, move over
 unresolved issues still in the `X.Y.Z` milestone, then close the `X.Y.Z` milestone.

@@ -152,5 +147,5 @@ appearing.  To check for progress:
 [Crates.io](https://crates.io/crates/solana) should have an updated Solana version.  This can take 2-3 hours, and sometimes fails in the `solana-secondary` job.
 If this happens and the error is non-fatal, click "Retry" on the "publish crate" job

-### Update software on devnet.solana.com/testnet.solana.com/mainnet-beta.solana.com
+### Update software on devnet.solana.com/testnet.solama.com/mainnet-beta.solana.com
 See the documentation at https://github.com/solana-labs/cluster-ops/
--- a/account-decoder/Cargo.toml
+++ b/account-decoder/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "solana-account-decoder"
-version = "1.5.6"
+version = "1.3.2"
 description = "Solana account decoder"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -15,16 +15,15 @@ bs58 = "0.3.1"
 bv = "0.11.1"
 Inflector = "0.11.4"
 lazy_static = "1.4.0"
+solana-config-program = { path = "../programs/config", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-stake-program = { path = "../programs/stake", version = "1.3.2" }
+solana-vote-program = { path = "../programs/vote", version = "1.3.2" }
+spl-token-v1-0 = { package = "spl-token", version = "1.0.6", features = ["skip-no-mangle"] }
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-config-program = { path = "../programs/config", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.0.1", features = ["no-entrypoint"] }
 thiserror = "1.0"
-zstd = "0.5.1"

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
--- a/account-decoder/src/lib.rs
+++ b/account-decoder/src/lib.rs
@@ -4,7 +4,6 @@ extern crate lazy_static;
 extern crate serde_derive;

 pub mod parse_account_data;
-pub mod parse_bpf_loader;
 pub mod parse_config;
 pub mod parse_nonce;
 pub mod parse_stake;
@@ -13,14 +12,9 @@ pub mod parse_token;
 pub mod parse_vote;
 pub mod validator_info;

-use {
-    crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount},
-    solana_sdk::{account::Account, clock::Epoch, fee_calculator::FeeCalculator, pubkey::Pubkey},
-    std::{
-        io::{Read, Write},
-        str::FromStr,
-    },
-};
+use crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount};
+use solana_sdk::{account::Account, clock::Epoch, fee_calculator::FeeCalculator, pubkey::Pubkey};
+use std::str::FromStr;

 pub type StringAmount = String;

@@ -38,20 +32,17 @@ pub struct UiAccount {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", untagged)]
 pub enum UiAccountData {
-    LegacyBinary(String), // Legacy. Retained for RPC backwards compatibility
+    Binary(String),
    Json(ParsedAccount),
-    Binary(String, UiAccountEncoding),
+    Binary64(String),
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub enum UiAccountEncoding {
-    Binary, // Legacy. Retained for RPC backwards compatibility
-    Base58,
-    Base64,
+    Binary,
    JsonParsed,
-    #[serde(rename = "base64+zstd")]
-    Base64Zstd,
+    Binary64,
 }

 impl UiAccount {
@@ -63,37 +54,20 @@ impl UiAccount {
        data_slice_config: Option<UiDataSliceConfig>,
    ) -> Self {
        let data = match encoding {
-            UiAccountEncoding::Binary => UiAccountData::LegacyBinary(
+            UiAccountEncoding::Binary => UiAccountData::Binary(
                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)),
-                encoding,
-            ),
-            UiAccountEncoding::Base64Zstd => {
-                let mut encoder = zstd::stream::write::Encoder::new(Vec::new(), 0).unwrap();
-                match encoder
-                    .write_all(slice_data(&account.data, data_slice_config))
-                    .and_then(|()| encoder.finish())
-                {
-                    Ok(zstd_data) => UiAccountData::Binary(base64::encode(zstd_data), encoding),
-                    Err(_) => UiAccountData::Binary(
-                        base64::encode(slice_data(&account.data, data_slice_config)),
-                        UiAccountEncoding::Base64,
-                    ),
-                }
-            }
+            UiAccountEncoding::Binary64 => UiAccountData::Binary64(base64::encode(slice_data(
+                &account.data,
+                data_slice_config,
+            ))),
            UiAccountEncoding::JsonParsed => {
                if let Ok(parsed_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::Binary64(base64::encode(&account.data))
                }
            }
        };
@@ -109,22 +83,8 @@ impl UiAccount {
    pub fn decode(&self) -> Option<Account> {
        let data = match &self.data {
            UiAccountData::Json(_) => None,
-            UiAccountData::LegacyBinary(blob) => bs58::decode(blob).into_vec().ok(),
-            UiAccountData::Binary(blob, encoding) => match encoding {
-                UiAccountEncoding::Base58 => bs58::decode(blob).into_vec().ok(),
-                UiAccountEncoding::Base64 => base64::decode(blob).ok(),
-                UiAccountEncoding::Base64Zstd => base64::decode(blob)
-                    .ok()
-                    .map(|zstd_data| {
-                        let mut data = vec![];
-                        zstd::stream::read::Decoder::new(zstd_data.as_slice())
-                            .and_then(|mut reader| reader.read_to_end(&mut data))
-                            .map(|_| data)
-                            .ok()
-                    })
-                    .flatten(),
-                UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
-            },
+            UiAccountData::Binary(blob) => bs58::decode(blob).into_vec().ok(),
+            UiAccountData::Binary64(blob) => base64::decode(blob).ok(),
        }?;
        Some(Account {
            lamports: self.lamports,
@@ -210,25 +170,4 @@ mod test {
        });
        assert_eq!(slice_data(&data, slice_config), &[] as &[u8]);
    }
-
-    #[test]
-    fn test_base64_zstd() {
-        let encoded_account = UiAccount::encode(
-            &Pubkey::default(),
-            Account {
-                data: vec![0; 1024],
-                ..Account::default()
-            },
-            UiAccountEncoding::Base64Zstd,
-            None,
-            None,
-        );
-        assert!(matches!(
-            encoded_account.data,
-            UiAccountData::Binary(_, UiAccountEncoding::Base64Zstd)
-        ));
-
-        let decoded_account = encoded_account.decode().unwrap();
-        assert_eq!(decoded_account.data, vec![0; 1024]);
-    }
 }
--- a/account-decoder/src/parse_account_data.rs
+++ b/account-decoder/src/parse_account_data.rs
@@ -1,10 +1,9 @@
 use crate::{
-    parse_bpf_loader::parse_bpf_upgradeable_loader,
    parse_config::parse_config,
    parse_nonce::parse_nonce,
    parse_stake::parse_stake,
    parse_sysvar::parse_sysvar,
-    parse_token::{parse_token, spl_token_id_v2_0},
+    parse_token::{parse_token, spl_token_id_v1_0},
    parse_vote::parse_vote,
 };
 use inflector::Inflector;
@@ -14,19 +13,14 @@ use std::collections::HashMap;
 use thiserror::Error;

 lazy_static! {
-    static ref BPF_UPGRADEABLE_LOADER_PROGRAM_ID: Pubkey = solana_sdk::bpf_loader_upgradeable::id();
    static ref CONFIG_PROGRAM_ID: Pubkey = solana_config_program::id();
    static ref STAKE_PROGRAM_ID: Pubkey = solana_stake_program::id();
    static ref SYSTEM_PROGRAM_ID: Pubkey = system_program::id();
    static ref SYSVAR_PROGRAM_ID: Pubkey = sysvar::id();
-    static ref TOKEN_PROGRAM_ID: Pubkey = spl_token_id_v2_0();
+    static ref TOKEN_PROGRAM_ID: Pubkey = spl_token_id_v1_0();
    static ref VOTE_PROGRAM_ID: Pubkey = solana_vote_program::id();
    pub static ref PARSABLE_PROGRAM_IDS: HashMap<Pubkey, ParsableAccount> = {
        let mut m = HashMap::new();
-        m.insert(
-            *BPF_UPGRADEABLE_LOADER_PROGRAM_ID,
-            ParsableAccount::BpfUpgradeableLoader,
-        );
        m.insert(*CONFIG_PROGRAM_ID, ParsableAccount::Config);
        m.insert(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
        m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::SplToken);
@@ -66,7 +60,6 @@ pub struct ParsedAccount {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum ParsableAccount {
-    BpfUpgradeableLoader,
    Config,
    Nonce,
    SplToken,
@@ -88,12 +81,9 @@ pub fn parse_account_data(
 ) -> Result<ParsedAccount, ParseAccountError> {
    let program_name = PARSABLE_PROGRAM_IDS
        .get(program_id)
-        .ok_or(ParseAccountError::ProgramNotParsable)?;
+        .ok_or_else(|| ParseAccountError::ProgramNotParsable)?;
    let additional_data = additional_data.unwrap_or_default();
    let parsed_json = match program_name {
-        ParsableAccount::BpfUpgradeableLoader => {
-            serde_json::to_value(parse_bpf_upgradeable_loader(data)?)?
-        }
        ParsableAccount::Config => serde_json::to_value(parse_config(data, pubkey)?)?,
        ParsableAccount::Nonce => serde_json::to_value(parse_nonce(data)?)?,
        ParsableAccount::SplToken => {
@@ -121,14 +111,14 @@ mod test {

    #[test]
    fn test_parse_account_data() {
-        let account_pubkey = solana_sdk::pubkey::new_rand();
-        let other_program = solana_sdk::pubkey::new_rand();
+        let account_pubkey = Pubkey::new_rand();
+        let other_program = Pubkey::new_rand();
        let data = vec![0; 4];
        assert!(parse_account_data(&account_pubkey, &other_program, &data, None).is_err());

        let vote_state = VoteState::default();
        let mut vote_account_data: Vec<u8> = vec![0; VoteState::size_of()];
-        let versioned = VoteStateVersions::new_current(vote_state);
+        let versioned = VoteStateVersions::Current(Box::new(vote_state));
        VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
        let parsed = parse_account_data(
            &account_pubkey,
--- a/account-decoder/src/parse_bpf_loader.rs
+++ b/account-decoder/src/parse_bpf_loader.rs
@@ -1,181 +0,0 @@
-use crate::{
-    parse_account_data::{ParsableAccount, ParseAccountError},
-    UiAccountData, UiAccountEncoding,
-};
-use bincode::{deserialize, serialized_size};
-use solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey};
-
-pub fn parse_bpf_upgradeable_loader(
-    data: &[u8],
-) -> Result<BpfUpgradeableLoaderAccountType, ParseAccountError> {
-    let account_state: UpgradeableLoaderState = deserialize(data).map_err(|_| {
-        ParseAccountError::AccountNotParsable(ParsableAccount::BpfUpgradeableLoader)
-    })?;
-    let parsed_account = match account_state {
-        UpgradeableLoaderState::Uninitialized => BpfUpgradeableLoaderAccountType::Uninitialized,
-        UpgradeableLoaderState::Buffer { authority_address } => {
-            let offset = if authority_address.is_some() {
-                UpgradeableLoaderState::buffer_data_offset().unwrap()
-            } else {
-                // This case included for code completeness; in practice, a Buffer account will
-                // always have authority_address.is_some()
-                UpgradeableLoaderState::buffer_data_offset().unwrap()
-                    - serialized_size(&Pubkey::default()).unwrap() as usize
-            };
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: authority_address.map(|pubkey| pubkey.to_string()),
-                data: UiAccountData::Binary(
-                    base64::encode(&data[offset as usize..]),
-                    UiAccountEncoding::Base64,
-                ),
-            })
-        }
-        UpgradeableLoaderState::Program {
-            programdata_address,
-        } => BpfUpgradeableLoaderAccountType::Program(UiProgram {
-            program_data: programdata_address.to_string(),
-        }),
-        UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address,
-        } => {
-            let offset = if upgrade_authority_address.is_some() {
-                UpgradeableLoaderState::programdata_data_offset().unwrap()
-            } else {
-                UpgradeableLoaderState::programdata_data_offset().unwrap()
-                    - serialized_size(&Pubkey::default()).unwrap() as usize
-            };
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: upgrade_authority_address.map(|pubkey| pubkey.to_string()),
-                data: UiAccountData::Binary(
-                    base64::encode(&data[offset as usize..]),
-                    UiAccountEncoding::Base64,
-                ),
-            })
-        }
-    };
-    Ok(parsed_account)
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase", tag = "type", content = "info")]
-pub enum BpfUpgradeableLoaderAccountType {
-    Uninitialized,
-    Buffer(UiBuffer),
-    Program(UiProgram),
-    ProgramData(UiProgramData),
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiBuffer {
-    pub authority: Option<String>,
-    pub data: UiAccountData,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiProgram {
-    pub program_data: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiProgramData {
-    pub slot: u64,
-    pub authority: Option<String>,
-    pub data: UiAccountData,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use bincode::serialize;
-    use solana_sdk::pubkey::Pubkey;
-
-    #[test]
-    fn test_parse_bpf_upgradeable_loader_accounts() {
-        let bpf_loader_state = UpgradeableLoaderState::Uninitialized;
-        let account_data = serialize(&bpf_loader_state).unwrap();
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Uninitialized
-        );
-
-        let program = vec![7u8; 64]; // Arbitrary program data
-
-        let authority = Pubkey::new_unique();
-        let bpf_loader_state = UpgradeableLoaderState::Buffer {
-            authority_address: Some(authority),
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: Some(authority.to_string()),
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        // This case included for code completeness; in practice, a Buffer account will always have
-        // authority_address.is_some()
-        let bpf_loader_state = UpgradeableLoaderState::Buffer {
-            authority_address: None,
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: None,
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        let programdata_address = Pubkey::new_unique();
-        let bpf_loader_state = UpgradeableLoaderState::Program {
-            programdata_address,
-        };
-        let account_data = serialize(&bpf_loader_state).unwrap();
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Program(UiProgram {
-                program_data: programdata_address.to_string(),
-            })
-        );
-
-        let authority = Pubkey::new_unique();
-        let slot = 42;
-        let bpf_loader_state = UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address: Some(authority),
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: Some(authority.to_string()),
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        let bpf_loader_state = UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address: None,
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: None,
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-    }
-}
--- a/account-decoder/src/parse_config.rs
+++ b/account-decoder/src/parse_config.rs
@@ -117,7 +117,7 @@ mod test {
            }))
            .unwrap(),
        };
-        let info_pubkey = solana_sdk::pubkey::new_rand();
+        let info_pubkey = Pubkey::new_rand();
        let validator_info_config_account = create_config_account(
            vec![(validator_info::id(), false), (info_pubkey, true)],
            &validator_info,
--- a/account-decoder/src/parse_stake.rs
+++ b/account-decoder/src/parse_stake.rs
@@ -134,6 +134,7 @@ impl From<Delegation> for UiDelegation {
 mod test {
    use super::*;
    use bincode::serialize;
+    use solana_sdk::pubkey::Pubkey;

    #[test]
    fn test_parse_stake() {
@@ -144,8 +145,8 @@ mod test {
            StakeAccountType::Uninitialized
        );

-        let pubkey = solana_sdk::pubkey::new_rand();
-        let custodian = solana_sdk::pubkey::new_rand();
+        let pubkey = Pubkey::new_rand();
+        let custodian = Pubkey::new_rand();
        let authorized = Authorized::auto(&pubkey);
        let lockup = Lockup {
            unix_timestamp: 0,
@@ -179,7 +180,7 @@ mod test {
            })
        );

-        let voter_pubkey = solana_sdk::pubkey::new_rand();
+        let voter_pubkey = Pubkey::new_rand();
        let stake = Stake {
            delegation: Delegation {
                voter_pubkey,
--- a/account-decoder/src/parse_sysvar.rs
+++ b/account-decoder/src/parse_sysvar.rs
@@ -105,7 +105,6 @@ pub enum SysvarAccountType {
 pub struct UiClock {
    pub slot: Slot,
    pub epoch: Epoch,
-    pub epoch_start_timestamp: UnixTimestamp,
    pub leader_schedule_epoch: Epoch,
    pub unix_timestamp: UnixTimestamp,
 }
@@ -115,7 +114,6 @@ impl From<Clock> for UiClock {
        Self {
            slot: clock.slot,
            epoch: clock.epoch,
-            epoch_start_timestamp: clock.epoch_start_timestamp,
            leader_schedule_epoch: clock.leader_schedule_epoch,
            unix_timestamp: clock.unix_timestamp,
        }
@@ -214,13 +212,15 @@ pub struct UiStakeHistoryEntry {
 mod test {
    use super::*;
    use solana_sdk::{
-        account::create_account, fee_calculator::FeeCalculator, hash::Hash,
-        sysvar::recent_blockhashes::IterItem,
+        fee_calculator::FeeCalculator,
+        hash::Hash,
+        sysvar::{recent_blockhashes::IterItem, Sysvar},
    };
+    use std::iter::FromIterator;

    #[test]
    fn test_parse_sysvars() {
-        let clock_sysvar = create_account(&Clock::default(), 1);
+        let clock_sysvar = Clock::default().create_account(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(&epoch_schedule, 1);
+        let epoch_schedule_sysvar = epoch_schedule.create_account(1);
        assert_eq!(
            parse_sysvar(&epoch_schedule_sysvar.data, &sysvar::epoch_schedule::id()).unwrap(),
            SysvarAccountType::EpochSchedule(epoch_schedule),
        );

-        let fees_sysvar = create_account(&Fees::default(), 1);
+        let fees_sysvar = Fees::default().create_account(1);
        assert_eq!(
            parse_sysvar(&fees_sysvar.data, &sysvar::fees::id()).unwrap(),
            SysvarAccountType::Fees(UiFees::default()),
@@ -249,10 +249,9 @@ mod test {
        let fee_calculator = FeeCalculator {
            lamports_per_signature: 10,
        };
-        let recent_blockhashes: RecentBlockhashes = vec![IterItem(0, &hash, &fee_calculator)]
-            .into_iter()
-            .collect();
-        let recent_blockhashes_sysvar = create_account(&recent_blockhashes, 1);
+        let recent_blockhashes =
+            RecentBlockhashes::from_iter(vec![IterItem(0, &hash, &fee_calculator)].into_iter());
+        let recent_blockhashes_sysvar = recent_blockhashes.create_account(1);
        assert_eq!(
            parse_sysvar(
                &recent_blockhashes_sysvar.data,
@@ -270,13 +269,13 @@ mod test {
            exemption_threshold: 2.0,
            burn_percent: 5,
        };
-        let rent_sysvar = create_account(&rent, 1);
+        let rent_sysvar = rent.create_account(1);
        assert_eq!(
            parse_sysvar(&rent_sysvar.data, &sysvar::rent::id()).unwrap(),
            SysvarAccountType::Rent(rent.into()),
        );

-        let rewards_sysvar = create_account(&Rewards::default(), 1);
+        let rewards_sysvar = Rewards::default().create_account(1);
        assert_eq!(
            parse_sysvar(&rewards_sysvar.data, &sysvar::rewards::id()).unwrap(),
            SysvarAccountType::Rewards(UiRewards::default()),
@@ -284,7 +283,7 @@ mod test {

        let mut slot_hashes = SlotHashes::default();
        slot_hashes.add(1, hash);
-        let slot_hashes_sysvar = create_account(&slot_hashes, 1);
+        let slot_hashes_sysvar = slot_hashes.create_account(1);
        assert_eq!(
            parse_sysvar(&slot_hashes_sysvar.data, &sysvar::slot_hashes::id()).unwrap(),
            SysvarAccountType::SlotHashes(vec![UiSlotHashEntry {
@@ -295,7 +294,7 @@ mod test {

        let mut slot_history = SlotHistory::default();
        slot_history.add(42);
-        let slot_history_sysvar = create_account(&slot_history, 1);
+        let slot_history_sysvar = slot_history.create_account(1);
        assert_eq!(
            parse_sysvar(&slot_history_sysvar.data, &sysvar::slot_history::id()).unwrap(),
            SysvarAccountType::SlotHistory(UiSlotHistory {
@@ -311,7 +310,7 @@ mod test {
            deactivating: 3,
        };
        stake_history.add(1, stake_history_entry.clone());
-        let stake_history_sysvar = create_account(&stake_history, 1);
+        let stake_history_sysvar = stake_history.create_account(1);
        assert_eq!(
            parse_sysvar(&stake_history_sysvar.data, &sysvar::stake_history::id()).unwrap(),
            SysvarAccountType::StakeHistory(vec![UiStakeHistoryEntry {
@@ -320,7 +319,7 @@ mod test {
            }]),
        );

-        let bad_pubkey = solana_sdk::pubkey::new_rand();
+        let bad_pubkey = Pubkey::new_rand();
        assert!(parse_sysvar(&stake_history_sysvar.data, &bad_pubkey).is_err());

        let bad_data = vec![0; 4];
--- a/account-decoder/src/parse_token.rs
+++ b/account-decoder/src/parse_token.rs
@@ -3,42 +3,32 @@ use crate::{
    StringAmount,
 };
 use solana_sdk::pubkey::Pubkey;
-use spl_token_v2_0::{
-    solana_program::{
-        program_option::COption, program_pack::Pack, pubkey::Pubkey as SplTokenPubkey,
-    },
-    state::{Account, AccountState, Mint, Multisig},
+use spl_token_v1_0::{
+    option::COption,
+    solana_sdk::pubkey::Pubkey as SplTokenPubkey,
+    state::{unpack, Account, Mint, Multisig},
 };
-use std::str::FromStr;
+use std::{mem::size_of, str::FromStr};

-// A helper function to convert spl_token_v2_0::id() as spl_sdk::pubkey::Pubkey to
+// A helper function to convert spl_token_v1_0::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
-pub fn spl_token_id_v2_0() -> Pubkey {
-    Pubkey::from_str(&spl_token_v2_0::id().to_string()).unwrap()
+pub fn spl_token_id_v1_0() -> Pubkey {
+    Pubkey::from_str(&spl_token_v1_0::id().to_string()).unwrap()
 }

-// A helper function to convert spl_token_v2_0::native_mint::id() as spl_sdk::pubkey::Pubkey to
+// A helper function to convert spl_token_v1_0::native_mint::id() as spl_sdk::pubkey::Pubkey to
 // solana_sdk::pubkey::Pubkey
-pub fn spl_token_v2_0_native_mint() -> Pubkey {
-    Pubkey::from_str(&spl_token_v2_0::native_mint::id().to_string()).unwrap()
-}
-
-// A helper function to convert a solana_sdk::pubkey::Pubkey to spl_sdk::pubkey::Pubkey
-pub fn spl_token_v2_0_pubkey(pubkey: &Pubkey) -> SplTokenPubkey {
-    SplTokenPubkey::from_str(&pubkey.to_string()).unwrap()
-}
-
-// A helper function to convert a spl_sdk::pubkey::Pubkey to solana_sdk::pubkey::Pubkey
-pub fn pubkey_from_spl_token_v2_0(pubkey: &SplTokenPubkey) -> Pubkey {
-    Pubkey::from_str(&pubkey.to_string()).unwrap()
+pub fn spl_token_v1_0_native_mint() -> Pubkey {
+    Pubkey::from_str(&spl_token_v1_0::native_mint::id().to_string()).unwrap()
 }

 pub fn parse_token(
    data: &[u8],
    mint_decimals: Option<u8>,
 ) -> Result<TokenAccountType, ParseAccountError> {
-    if data.len() == Account::get_packed_len() {
-        let account = Account::unpack(data)
+    let mut data = data.to_vec();
+    if data.len() == size_of::<Account>() {
+        let account: Account = *unpack(&mut data)
            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
        let decimals = mint_decimals.ok_or_else(|| {
            ParseAccountError::AdditionalDataMissing(
@@ -53,12 +43,8 @@ pub fn parse_token(
                COption::Some(pubkey) => Some(pubkey.to_string()),
                COption::None => None,
            },
-            state: account.state.into(),
-            is_native: account.is_native(),
-            rent_exempt_reserve: match account.is_native {
-                COption::Some(reserve) => Some(token_amount_to_ui_amount(reserve, decimals)),
-                COption::None => None,
-            },
+            is_initialized: account.is_initialized,
+            is_native: account.is_native,
            delegated_amount: if account.delegate.is_none() {
                None
            } else {
@@ -67,29 +53,20 @@ pub fn parse_token(
                    decimals,
                ))
            },
-            close_authority: match account.close_authority {
-                COption::Some(pubkey) => Some(pubkey.to_string()),
-                COption::None => None,
-            },
        }))
-    } else if data.len() == Mint::get_packed_len() {
-        let mint = Mint::unpack(data)
+    } else if data.len() == size_of::<Mint>() {
+        let mint: Mint = *unpack(&mut data)
            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
        Ok(TokenAccountType::Mint(UiMint {
-            mint_authority: match mint.mint_authority {
+            owner: match mint.owner {
                COption::Some(pubkey) => Some(pubkey.to_string()),
                COption::None => None,
            },
-            supply: mint.supply.to_string(),
            decimals: mint.decimals,
            is_initialized: mint.is_initialized,
-            freeze_authority: match mint.freeze_authority {
-                COption::Some(pubkey) => Some(pubkey.to_string()),
-                COption::None => None,
-            },
        }))
-    } else if data.len() == Multisig::get_packed_len() {
-        let multisig = Multisig::unpack(data)
+    } else if data.len() == size_of::<Multisig>() {
+        let multisig: Multisig = *unpack(&mut data)
            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
        Ok(TokenAccountType::Multisig(UiMultisig {
            num_required_signers: multisig.m,
@@ -130,32 +107,10 @@ pub struct UiTokenAccount {
    pub token_amount: UiTokenAmount,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delegate: Option<String>,
-    pub state: UiAccountState,
+    pub is_initialized: bool,
    pub is_native: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub rent_exempt_reserve: Option<UiTokenAmount>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub delegated_amount: Option<UiTokenAmount>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub close_authority: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub enum UiAccountState {
-    Uninitialized,
-    Initialized,
-    Frozen,
-}
-
-impl From<AccountState> for UiAccountState {
-    fn from(state: AccountState) -> Self {
-        match state {
-            AccountState::Uninitialized => UiAccountState::Uninitialized,
-            AccountState::Initialized => UiAccountState::Initialized,
-            AccountState::Frozen => UiAccountState::Frozen,
-        }
-    }
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
@@ -166,31 +121,6 @@ pub struct UiTokenAmount {
    pub amount: StringAmount,
 }

-impl UiTokenAmount {
-    pub fn real_number_string(&self) -> String {
-        let decimals = self.decimals as usize;
-        if decimals > 0 {
-            let amount = u64::from_str(&self.amount).unwrap_or(0);
-
-            // Left-pad zeros to decimals + 1, so we at least have an integer zero
-            let mut s = format!("{:01$}", amount, decimals + 1);
-
-            // Add the decimal point (Sorry, "," locales!)
-            s.insert(s.len() - decimals, '.');
-            s
-        } else {
-            self.amount.clone()
-        }
-    }
-
-    pub fn real_number_string_trimmed(&self) -> String {
-        let s = self.real_number_string();
-        let zeros_trimmed = s.trim_end_matches('0');
-        let decimal_trimmed = zeros_trimmed.trim_end_matches('.');
-        decimal_trimmed.to_string()
-    }
-}
-
 pub fn token_amount_to_ui_amount(amount: u64, decimals: u8) -> UiTokenAmount {
    // Use `amount_to_ui_amount()` once spl_token is bumped to a version that supports it: https://github.com/solana-labs/solana-program-library/pull/211
    let amount_decimals = amount as f64 / 10_usize.pow(decimals as u32) as f64;
@@ -204,11 +134,9 @@ pub fn token_amount_to_ui_amount(amount: u64, decimals: u8) -> UiTokenAmount {
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct UiMint {
-    pub mint_authority: Option<String>,
-    pub supply: StringAmount,
+    pub owner: Option<String>,
    pub decimals: u8,
    pub is_initialized: bool,
-    pub freeze_authority: Option<String>,
 }

 #[derive(Debug, Serialize, Deserialize, PartialEq)]
@@ -221,7 +149,7 @@ pub struct UiMultisig {
 }

 pub fn get_token_account_mint(data: &[u8]) -> Option<Pubkey> {
-    if data.len() == Account::get_packed_len() {
+    if data.len() == size_of::<Account>() {
        Some(Pubkey::new(&data[0..32]))
    } else {
        None
@@ -231,21 +159,18 @@ pub fn get_token_account_mint(data: &[u8]) -> Option<Pubkey> {
 #[cfg(test)]
 mod test {
    use super::*;
+    use spl_token_v1_0::state::unpack_unchecked;

    #[test]
    fn test_parse_token() {
        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
        let owner_pubkey = SplTokenPubkey::new(&[3; 32]);
-        let mut account_data = vec![0; Account::get_packed_len()];
-        let mut account = Account::unpack_unchecked(&account_data).unwrap();
+        let mut account_data = [0; size_of::<Account>()];
+        let mut account: &mut Account = unpack_unchecked(&mut account_data).unwrap();
        account.mint = mint_pubkey;
        account.owner = owner_pubkey;
        account.amount = 42;
-        account.state = AccountState::Initialized;
-        account.is_native = COption::None;
-        account.close_authority = COption::Some(owner_pubkey);
-        Account::pack(account, &mut account_data).unwrap();
-
+        account.is_initialized = true;
        assert!(parse_token(&account_data, None).is_err());
        assert_eq!(
            parse_token(&account_data, Some(2)).unwrap(),
@@ -258,49 +183,39 @@ mod test {
                    amount: "42".to_string()
                },
                delegate: None,
-                state: UiAccountState::Initialized,
+                is_initialized: true,
                is_native: false,
-                rent_exempt_reserve: None,
                delegated_amount: None,
-                close_authority: Some(owner_pubkey.to_string()),
            }),
        );

-        let mut mint_data = vec![0; Mint::get_packed_len()];
-        let mut mint = Mint::unpack_unchecked(&mint_data).unwrap();
-        mint.mint_authority = COption::Some(owner_pubkey);
-        mint.supply = 42;
+        let mut mint_data = [0; size_of::<Mint>()];
+        let mut mint: &mut Mint = unpack_unchecked(&mut mint_data).unwrap();
+        mint.owner = COption::Some(owner_pubkey);
        mint.decimals = 3;
        mint.is_initialized = true;
-        mint.freeze_authority = COption::Some(owner_pubkey);
-        Mint::pack(mint, &mut mint_data).unwrap();
-
        assert_eq!(
            parse_token(&mint_data, None).unwrap(),
            TokenAccountType::Mint(UiMint {
-                mint_authority: Some(owner_pubkey.to_string()),
-                supply: 42.to_string(),
+                owner: Some(owner_pubkey.to_string()),
                decimals: 3,
                is_initialized: true,
-                freeze_authority: Some(owner_pubkey.to_string()),
            }),
        );

        let signer1 = SplTokenPubkey::new(&[1; 32]);
        let signer2 = SplTokenPubkey::new(&[2; 32]);
        let signer3 = SplTokenPubkey::new(&[3; 32]);
-        let mut multisig_data = vec![0; Multisig::get_packed_len()];
+        let mut multisig_data = [0; size_of::<Multisig>()];
+        let mut multisig: &mut Multisig = unpack_unchecked(&mut multisig_data).unwrap();
        let mut signers = [SplTokenPubkey::default(); 11];
        signers[0] = signer1;
        signers[1] = signer2;
        signers[2] = signer3;
-        let mut multisig = Multisig::unpack_unchecked(&multisig_data).unwrap();
        multisig.m = 2;
        multisig.n = 3;
        multisig.is_initialized = true;
        multisig.signers = signers;
-        Multisig::pack(multisig, &mut multisig_data).unwrap();
-
        assert_eq!(
            parse_token(&multisig_data, None).unwrap(),
            TokenAccountType::Multisig(UiMultisig {
@@ -322,10 +237,9 @@ mod test {
    #[test]
    fn test_get_token_account_mint() {
        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
-        let mut account_data = vec![0; Account::get_packed_len()];
-        let mut account = Account::unpack_unchecked(&account_data).unwrap();
+        let mut account_data = [0; size_of::<Account>()];
+        let mut account: &mut Account = unpack_unchecked(&mut account_data).unwrap();
        account.mint = mint_pubkey;
-        Account::pack(account, &mut account_data).unwrap();

        let expected_mint_pubkey = Pubkey::new(&[2; 32]);
        assert_eq!(
@@ -333,20 +247,4 @@ mod test {
            Some(expected_mint_pubkey)
        );
    }
-
-    #[test]
-    fn test_ui_token_amount_real_string() {
-        let token_amount = token_amount_to_ui_amount(1, 0);
-        assert_eq!(&token_amount.real_number_string(), "1");
-        assert_eq!(&token_amount.real_number_string_trimmed(), "1");
-        let token_amount = token_amount_to_ui_amount(1, 9);
-        assert_eq!(&token_amount.real_number_string(), "0.000000001");
-        assert_eq!(&token_amount.real_number_string_trimmed(), "0.000000001");
-        let token_amount = token_amount_to_ui_amount(1_000_000_000, 9);
-        assert_eq!(&token_amount.real_number_string(), "1.000000000");
-        assert_eq!(&token_amount.real_number_string_trimmed(), "1");
-        let token_amount = token_amount_to_ui_amount(1_234_567_890, 3);
-        assert_eq!(&token_amount.real_number_string(), "1234567.890");
-        assert_eq!(&token_amount.real_number_string_trimmed(), "1234567.89");
-    }
 }
--- a/account-decoder/src/parse_vote.rs
+++ b/account-decoder/src/parse_vote.rs
@@ -128,13 +128,11 @@ mod test {
    fn test_parse_vote() {
        let vote_state = VoteState::default();
        let mut vote_account_data: Vec<u8> = vec![0; VoteState::size_of()];
-        let versioned = VoteStateVersions::new_current(vote_state);
+        let versioned = VoteStateVersions::Current(Box::new(vote_state));
        VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
-        let expected_vote_state = UiVoteState {
-            node_pubkey: Pubkey::default().to_string(),
-            authorized_withdrawer: Pubkey::default().to_string(),
-            ..UiVoteState::default()
-        };
+        let mut expected_vote_state = UiVoteState::default();
+        expected_vote_state.node_pubkey = Pubkey::default().to_string();
+        expected_vote_state.authorized_withdrawer = Pubkey::default().to_string();
        assert_eq!(
            parse_vote(&vote_account_data).unwrap(),
            VoteAccountType::Vote(expected_vote_state)
--- a/accounts-bench/Cargo.toml
+++ b/accounts-bench/Cargo.toml
@@ -2,20 +2,18 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-accounts-bench"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-publish = false

 [dependencies]
-log = "0.4.11"
-rayon = "1.4.0"
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+log = "0.4.6"
+rayon = "1.3.1"
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-runtime = { path = "../runtime", version = "1.3.2" }
+solana-measure = { path = "../measure", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
 rand = "0.7.0"
 clap = "2.33.1"
 crossbeam-channel = "0.4"
--- a/accounts-bench/src/main.rs
+++ b/accounts-bench/src/main.rs
@@ -1,21 +1,20 @@
-#[macro_use]
-extern crate log;
-use clap::{crate_description, crate_name, value_t, App, Arg};
+use clap::{value_t, App, Arg};
 use rayon::prelude::*;
 use solana_measure::measure::Measure;
 use solana_runtime::{
-    accounts::{create_test_accounts, update_accounts_bench, Accounts},
+    accounts::{create_test_accounts, update_accounts, Accounts},
    accounts_index::Ancestors,
 };
-use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
-use std::{collections::HashSet, env, fs, path::PathBuf};
+use solana_sdk::pubkey::Pubkey;
+use std::fs;
+use std::path::PathBuf;

 fn main() {
    solana_logger::setup();

-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
+    let matches = App::new("crate")
+        .about("about")
+        .version("version")
        .arg(
            Arg::with_name("num_slots")
                .long("num_slots")
@@ -51,14 +50,11 @@ fn main() {
    let clean = matches.is_present("clean");
    println!("clean: {:?}", clean);

-    let path = PathBuf::from(env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_owned()))
-        .join("accounts-bench");
-    println!("cleaning file system: {:?}", path);
+    let path = PathBuf::from("farf/accounts-bench");
    if fs::remove_dir_all(path.clone()).is_err() {
        println!("Warning: Couldn't remove {:?}", path);
    }
-    let accounts =
-        Accounts::new_with_config(vec![path], &ClusterType::Testnet, HashSet::new(), false);
+    let accounts = Accounts::new(vec![path]);
    println!("Creating {} accounts", num_accounts);
    let mut create_time = Measure::start("create accounts");
    let pubkeys: Vec<_> = (0..num_slots)
@@ -87,54 +83,23 @@ fn main() {
        ancestors.insert(i as u64, i - 1);
        accounts.add_root(i as u64);
    }
-    let mut elapsed = vec![0; iterations];
-    let mut elapsed_store = vec![0; iterations];
    for x in 0..iterations {
        if clean {
            let mut time = Measure::start("clean");
-            accounts.accounts_db.clean_accounts(None);
+            accounts.accounts_db.clean_accounts();
            time.stop();
            println!("{}", time);
            for slot in 0..num_slots {
-                update_accounts_bench(&accounts, &pubkeys, ((x + 1) * num_slots + slot) as u64);
+                update_accounts(&accounts, &pubkeys, ((x + 1) * num_slots + slot) as u64);
                accounts.add_root((x * num_slots + slot) as u64);
            }
        } else {
            let mut pubkeys: Vec<Pubkey> = vec![];
            let mut time = Measure::start("hash");
-            let results = accounts
-                .accounts_db
-                .update_accounts_hash(0, &ancestors, true);
+            let hash = accounts.accounts_db.update_accounts_hash(0, &ancestors);
            time.stop();
-            let mut time_store = Measure::start("hash using store");
-            let results_store = accounts.accounts_db.update_accounts_hash_with_index_option(
-                true,
-                false,
-                solana_sdk::clock::Slot::default(),
-                &ancestors,
-                true,
-            );
-            time_store.stop();
-            if results != results_store {
-                error!("results different: \n{:?}\n{:?}", results, results_store);
-            }
-            println!(
-                "hash,{},{},{},{}%",
-                results.0,
-                time,
-                time_store,
-                (time_store.as_us() as f64 / time.as_us() as f64 * 100.0f64) as u32
-            );
+            println!("hash: {} {}", hash, time);
            create_test_accounts(&accounts, &mut pubkeys, 1, 0);
-            elapsed[x] = time.as_us();
-            elapsed_store[x] = time_store.as_us();
        }
    }
-
-    for x in elapsed {
-        info!("update_accounts_hash(us),{}", x);
-    }
-    for x in elapsed_store {
-        info!("calculate_accounts_hash_without_index(us),{}", x);
-    }
 }
--- a/banking-bench/Cargo.toml
+++ b/banking-bench/Cargo.toml
@@ -2,28 +2,27 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-publish = false

 [dependencies]
 clap = "2.33.1"
 crossbeam-channel = "0.4"
-log = "0.4.11"
+log = "0.4.6"
 rand = "0.7.0"
-rayon = "1.4.0"
-solana-core = { path = "../core", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-streamer = { path = "../streamer", version = "1.5.6" }
-solana-perf = { path = "../perf", version = "1.5.6" }
-solana-ledger = { path = "../ledger", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+rayon = "1.3.1"
+solana-core = { path = "../core", version = "1.3.2" }
+solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
+solana-streamer = { path = "../streamer", version = "1.3.2" }
+solana-perf = { path = "../perf", version = "1.3.2" }
+solana-ledger = { path = "../ledger", version = "1.3.2" }
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-runtime = { path = "../runtime", version = "1.3.2" }
+solana-measure = { path = "../measure", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-version = { path = "../version", version = "1.3.2" }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
--- a/banking-bench/src/main.rs
+++ b/banking-bench/src/main.rs
@@ -17,11 +17,10 @@ use solana_ledger::{
 };
 use solana_measure::measure::Measure;
 use solana_perf::packet::to_packets_chunked;
-use solana_runtime::{
-    accounts_background_service::ABSRequestSender, bank::Bank, bank_forks::BankForks,
-};
+use solana_runtime::{bank::Bank, bank_forks::BankForks};
 use solana_sdk::{
    hash::Hash,
+    pubkey::Pubkey,
    signature::Keypair,
    signature::Signature,
    system_transaction,
@@ -70,7 +69,7 @@ fn make_accounts_txs(
    hash: Hash,
    same_payer: bool,
 ) -> Vec<Transaction> {
-    let to_pubkey = solana_sdk::pubkey::new_rand();
+    let to_pubkey = Pubkey::new_rand();
    let payer_key = Keypair::new();
    let dummy = system_transaction::transfer(&payer_key, &to_pubkey, 1, hash);
    (0..total_num_transactions)
@@ -79,9 +78,9 @@ fn make_accounts_txs(
            let mut new = dummy.clone();
            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
            if !same_payer {
-                new.message.account_keys[0] = solana_sdk::pubkey::new_rand();
+                new.message.account_keys[0] = Pubkey::new_rand();
            }
-            new.message.account_keys[1] = solana_sdk::pubkey::new_rand();
+            new.message.account_keys[1] = Pubkey::new_rand();
            new.signatures = vec![Signature::new(&sig[0..64])];
            new
        })
@@ -242,7 +241,7 @@ fn main() {
        let base_tx_count = bank.transaction_count();
        let mut txs_processed = 0;
        let mut root = 1;
-        let collector = solana_sdk::pubkey::new_rand();
+        let collector = Pubkey::new_rand();
        let config = Config {
            packets_per_batch: packets_per_chunk,
            chunk_len,
@@ -325,7 +324,7 @@ fn main() {
                poh_recorder.lock().unwrap().set_bank(&bank);
                assert!(poh_recorder.lock().unwrap().bank().is_some());
                if bank.slot() > 32 {
-                    bank_forks.set_root(root, &ABSRequestSender::default(), None);
+                    bank_forks.set_root(root, &None, None);
                    root += 1;
                }
                debug!(
--- a/banks-client/Cargo.toml
+++ b/banks-client/Cargo.toml
@@ -1,30 +0,0 @@
-[package]
-name = "solana-banks-client"
-version = "1.5.6"
-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/"
-edition = "2018"
-
-[dependencies]
-bincode = "1.3.1"
-futures = "0.3"
-mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-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.5.6" }
-solana-banks-server = { path = "../banks-server", version = "1.5.6" }
-
-[lib]
-crate-type = ["lib"]
-name = "solana_banks_client"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/banks-client/src/lib.rs
+++ b/banks-client/src/lib.rs
@@ -1,380 +0,0 @@
-//! A client for the ledger state, from the perspective of an arbitrary validator.
-//!
-//! Use start_tcp_client() to create a client and then import BanksClientExt to
-//! access its methods. Additional "*_with_context" methods are also available,
-//! but they are undocumented, may change over time, and are generally more
-//! cumbersome to use.
-
-use futures::{future::join_all, Future, FutureExt};
-pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
-use solana_banks_interface::{BanksRequest, BanksResponse};
-use solana_sdk::{
-    account::{from_account, Account},
-    clock::Slot,
-    commitment_config::CommitmentLevel,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    pubkey::Pubkey,
-    rent::Rent,
-    signature::Signature,
-    sysvar,
-    transaction::{self, Transaction},
-    transport,
-};
-use std::io::{self, Error, ErrorKind};
-use tarpc::{
-    client::{self, channel::RequestDispatch, NewClient},
-    context::{self, Context},
-    rpc::{ClientMessage, Response},
-    serde_transport::tcp,
-    Transport,
-};
-use tokio::{net::ToSocketAddrs, time::Duration};
-use tokio_serde::formats::Bincode;
-
-// This exists only for backward compatibility
-pub trait BanksClientExt {}
-
-#[derive(Clone)]
-pub struct BanksClient {
-    inner: TarpcClient,
-}
-
-impl BanksClient {
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new<C>(
-        config: client::Config,
-        transport: C,
-    ) -> NewClient<TarpcClient, RequestDispatch<BanksRequest, BanksResponse, C>>
-    where
-        C: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>>,
-    {
-        TarpcClient::new(config, transport)
-    }
-
-    pub fn send_transaction_with_context(
-        &mut self,
-        ctx: Context,
-        transaction: Transaction,
-    ) -> impl Future<Output = io::Result<()>> + '_ {
-        self.inner.send_transaction_with_context(ctx, transaction)
-    }
-
-    pub fn get_fees_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
-        self.inner
-            .get_fees_with_commitment_and_context(ctx, commitment)
-    }
-
-    pub fn get_transaction_status_with_context(
-        &mut self,
-        ctx: Context,
-        signature: Signature,
-    ) -> impl Future<Output = io::Result<Option<TransactionStatus>>> + '_ {
-        self.inner
-            .get_transaction_status_with_context(ctx, signature)
-    }
-
-    pub fn get_slot_with_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.inner.get_slot_with_context(ctx, commitment)
-    }
-
-    pub fn process_transaction_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<transaction::Result<()>>>> + '_ {
-        self.inner
-            .process_transaction_with_commitment_and_context(ctx, transaction, commitment)
-    }
-
-    pub fn get_account_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.inner
-            .get_account_with_commitment_and_context(ctx, address, commitment)
-    }
-
-    /// Send a transaction and return immediately. The server will resend the
-    /// transaction until either it is accepted by the cluster or the transaction's
-    /// blockhash expires.
-    pub fn send_transaction(
-        &mut self,
-        transaction: Transaction,
-    ) -> impl Future<Output = io::Result<()>> + '_ {
-        self.send_transaction_with_context(context::current(), transaction)
-    }
-
-    /// Return the fee parameters associated with a recent, rooted blockhash. The cluster
-    /// will use the transaction's blockhash to look up these same fee parameters and
-    /// use them to calculate the transaction fee.
-    pub fn get_fees(
-        &mut self,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
-        self.get_fees_with_commitment_and_context(context::current(), CommitmentLevel::default())
-    }
-
-    /// Return the cluster rent
-    pub fn get_rent(&mut self) -> impl Future<Output = io::Result<Rent>> + '_ {
-        self.get_account(sysvar::rent::id()).map(|result| {
-            let rent_sysvar = result?
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Rent sysvar not present"))?;
-            from_account::<Rent>(&rent_sysvar).ok_or_else(|| {
-                io::Error::new(io::ErrorKind::Other, "Failed to deserialize Rent sysvar")
-            })
-        })
-    }
-
-    /// Return a recent, rooted blockhash from the server. The cluster will only accept
-    /// transactions with a blockhash that has not yet expired. Use the `get_fees`
-    /// method to get both a blockhash and the blockhash's last valid slot.
-    pub fn get_recent_blockhash(&mut self) -> impl Future<Output = io::Result<Hash>> + '_ {
-        self.get_fees().map(|result| Ok(result?.1))
-    }
-
-    /// Send a transaction and return after the transaction has been rejected or
-    /// reached the given level of commitment.
-    pub fn process_transaction_with_commitment(
-        &mut self,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        let mut ctx = context::current();
-        ctx.deadline += Duration::from_secs(50);
-        self.process_transaction_with_commitment_and_context(ctx, transaction, commitment)
-            .map(|result| match result? {
-                None => {
-                    Err(Error::new(ErrorKind::TimedOut, "invalid blockhash or fee-payer").into())
-                }
-                Some(transaction_result) => Ok(transaction_result?),
-            })
-    }
-
-    /// Send a transaction and return until the transaction has been finalized or rejected.
-    pub fn process_transaction(
-        &mut self,
-        transaction: Transaction,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        self.process_transaction_with_commitment(transaction, CommitmentLevel::default())
-    }
-
-    pub async fn process_transactions_with_commitment(
-        &mut self,
-        transactions: Vec<Transaction>,
-        commitment: CommitmentLevel,
-    ) -> transport::Result<()> {
-        let mut clients: Vec<_> = transactions.iter().map(|_| self.clone()).collect();
-        let futures = clients
-            .iter_mut()
-            .zip(transactions)
-            .map(|(client, transaction)| {
-                client.process_transaction_with_commitment(transaction, commitment)
-            });
-        let statuses = join_all(futures).await;
-        statuses.into_iter().collect() // Convert Vec<Result<_, _>> to Result<Vec<_>>
-    }
-
-    /// Send transactions and return until the transaction has been finalized or rejected.
-    pub fn process_transactions(
-        &mut self,
-        transactions: Vec<Transaction>,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        self.process_transactions_with_commitment(transactions, CommitmentLevel::default())
-    }
-
-    /// Return the most recent rooted slot height. All transactions at or below this height
-    /// are said to be finalized. The cluster will not fork to a higher slot height.
-    pub fn get_root_slot(&mut self) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.get_slot_with_context(context::current(), CommitmentLevel::default())
-    }
-
-    /// Return the account at the given address at the slot corresponding to the given
-    /// commitment level. If the account is not found, None is returned.
-    pub fn get_account_with_commitment(
-        &mut self,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.get_account_with_commitment_and_context(context::current(), address, commitment)
-    }
-
-    /// Return the account at the given address at the time of the most recent root slot.
-    /// If the account is not found, None is returned.
-    pub fn get_account(
-        &mut self,
-        address: Pubkey,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.get_account_with_commitment(address, CommitmentLevel::default())
-    }
-
-    /// Return the balance in lamports of an account at the given address at the slot
-    /// corresponding to the given commitment level.
-    pub fn get_balance_with_commitment(
-        &mut self,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<u64>> + '_ {
-        self.get_account_with_commitment_and_context(context::current(), address, commitment)
-            .map(|result| Ok(result?.map(|x| x.lamports).unwrap_or(0)))
-    }
-
-    /// Return the balance in lamports of an account at the given address at the time
-    /// of the most recent root slot.
-    pub fn get_balance(&mut self, address: Pubkey) -> impl Future<Output = io::Result<u64>> + '_ {
-        self.get_balance_with_commitment(address, CommitmentLevel::default())
-    }
-
-    /// Return the status of a transaction with a signature matching the transaction's first
-    /// signature. Return None if the transaction is not found, which may be because the
-    /// blockhash was expired or the fee-paying account had insufficient funds to pay the
-    /// transaction fee. Note that servers rarely store the full transaction history. This
-    /// method may return None if the transaction status has been discarded.
-    pub fn get_transaction_status(
-        &mut self,
-        signature: Signature,
-    ) -> impl Future<Output = io::Result<Option<TransactionStatus>>> + '_ {
-        self.get_transaction_status_with_context(context::current(), signature)
-    }
-
-    /// Same as get_transaction_status, but for multiple transactions.
-    pub async fn get_transaction_statuses(
-        &mut self,
-        signatures: Vec<Signature>,
-    ) -> io::Result<Vec<Option<TransactionStatus>>> {
-        // tarpc futures oddly hold a mutable reference back to the client so clone the client upfront
-        let mut clients_and_signatures: Vec<_> = signatures
-            .into_iter()
-            .map(|signature| (self.clone(), signature))
-            .collect();
-
-        let futs = clients_and_signatures
-            .iter_mut()
-            .map(|(client, signature)| client.get_transaction_status(*signature));
-
-        let statuses = join_all(futs).await;
-
-        // Convert Vec<Result<_, _>> to Result<Vec<_>>
-        statuses.into_iter().collect()
-    }
-}
-
-pub async fn start_client<C>(transport: C) -> io::Result<BanksClient>
-where
-    C: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>> + Send + 'static,
-{
-    Ok(BanksClient {
-        inner: TarpcClient::new(client::Config::default(), transport).spawn()?,
-    })
-}
-
-pub async fn start_tcp_client<T: ToSocketAddrs>(addr: T) -> io::Result<BanksClient> {
-    let transport = tcp::connect(addr, Bincode::default).await?;
-    Ok(BanksClient {
-        inner: TarpcClient::new(client::Config::default(), transport).spawn()?,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_banks_server::banks_server::start_local_server;
-    use solana_runtime::{
-        bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache,
-        genesis_utils::create_genesis_config,
-    };
-    use solana_sdk::{message::Message, signature::Signer, system_instruction};
-    use std::sync::{Arc, RwLock};
-    use tarpc::transport;
-    use tokio::{runtime::Runtime, time::sleep};
-
-    #[test]
-    fn test_banks_client_new() {
-        let (client_transport, _server_transport) = transport::channel::unbounded();
-        BanksClient::new(client::Config::default(), client_transport);
-    }
-
-    #[test]
-    fn test_banks_server_transfer_via_server() -> io::Result<()> {
-        // This test shows the preferred way to interact with BanksServer.
-        // It creates a runtime explicitly (no globals via tokio macros) and calls
-        // `runtime.block_on()` just once, to run all the async code.
-
-        let genesis = create_genesis_config(10);
-        let bank = Bank::new(&genesis.genesis_config);
-        let slot = bank.slot();
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
-        ));
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-
-        let bob_pubkey = solana_sdk::pubkey::new_rand();
-        let mint_pubkey = genesis.mint_keypair.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 = banks_client.get_recent_blockhash().await?;
-            let transaction = Transaction::new(&[&genesis.mint_keypair], message, recent_blockhash);
-            banks_client.process_transaction(transaction).await.unwrap();
-            assert_eq!(banks_client.get_balance(bob_pubkey).await?, 1);
-            Ok(())
-        })
-    }
-
-    #[test]
-    fn test_banks_server_transfer_via_client() -> io::Result<()> {
-        // The caller may not want to hold the connection open until the transaction
-        // is processed (or blockhash expires). In this test, we verify the
-        // server-side functionality is available to the client.
-
-        let genesis = create_genesis_config(10);
-        let bank = Bank::new(&genesis.genesis_config);
-        let slot = bank.slot();
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
-        ));
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-
-        let 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));
-
-        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_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?;
-
-            let mut status = banks_client.get_transaction_status(signature).await?;
-
-            while status.is_none() {
-                let root_slot = banks_client.get_root_slot().await?;
-                if root_slot > last_valid_slot {
-                    break;
-                }
-                sleep(Duration::from_millis(100)).await;
-                status = banks_client.get_transaction_status(signature).await?;
-            }
-            assert!(status.unwrap().err.is_none());
-            assert_eq!(banks_client.get_balance(bob_pubkey).await?, 1);
-            Ok(())
-        })
-    }
-}
--- a/banks-interface/Cargo.toml
+++ b/banks-interface/Cargo.toml
@@ -1,25 +0,0 @@
-[package]
-name = "solana-banks-interface"
-version = "1.5.6"
-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/"
-edition = "2018"
-
-[dependencies]
-mio = "0.7.6"
-serde = { version = "1.0.112", features = ["derive"] }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-tarpc = { version = "0.23.0", features = ["full"] }
-
-[dev-dependencies]
-tokio = { version = "0.3.5", features = ["full"] }
-
-[lib]
-crate-type = ["lib"]
-name = "solana_banks_interface"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/banks-interface/src/lib.rs
+++ b/banks-interface/src/lib.rs
@@ -1,57 +0,0 @@
-use serde::{Deserialize, Serialize};
-use solana_sdk::{
-    account::Account,
-    clock::Slot,
-    commitment_config::CommitmentLevel,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Signature,
-    transaction::{self, Transaction, TransactionError},
-};
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TransactionConfirmationStatus {
-    Processed,
-    Confirmed,
-    Finalized,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct TransactionStatus {
-    pub slot: Slot,
-    pub confirmations: Option<usize>, // None = rooted
-    pub err: Option<TransactionError>,
-    pub confirmation_status: Option<TransactionConfirmationStatus>,
-}
-
-#[tarpc::service]
-pub trait Banks {
-    async fn send_transaction_with_context(transaction: Transaction);
-    async fn get_fees_with_commitment_and_context(
-        commitment: CommitmentLevel,
-    ) -> (FeeCalculator, Hash, Slot);
-    async fn get_transaction_status_with_context(signature: Signature)
-        -> Option<TransactionStatus>;
-    async fn get_slot_with_context(commitment: CommitmentLevel) -> Slot;
-    async fn process_transaction_with_commitment_and_context(
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> Option<transaction::Result<()>>;
-    async fn get_account_with_commitment_and_context(
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> Option<Account>;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tarpc::{client, transport};
-
-    #[test]
-    fn test_banks_client_new() {
-        let (client_transport, _server_transport) = transport::channel::unbounded();
-        BanksClient::new(client::Config::default(), client_transport);
-    }
-}
--- a/banks-server/Cargo.toml
+++ b/banks-server/Cargo.toml
@@ -1,29 +0,0 @@
-[package]
-name = "solana-banks-server"
-version = "1.5.6"
-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/"
-edition = "2018"
-
-[dependencies]
-bincode = "1.3.1"
-futures = "0.3"
-log = "0.4.11"
-mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
-tarpc = { version = "0.23.0", features = ["full"] }
-tokio = { version = "0.3", features = ["full"] }
-tokio-serde = { version = "0.6", features = ["bincode"] }
-
-[lib]
-crate-type = ["lib"]
-name = "solana_banks_server"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/banks-server/src/banks_server.rs
+++ b/banks-server/src/banks_server.rs
@@ -1,298 +0,0 @@
-use crate::send_transaction_service::{SendTransactionService, TransactionInfo};
-use bincode::{deserialize, serialize};
-use futures::{
-    future,
-    prelude::stream::{self, StreamExt},
-};
-use solana_banks_interface::{
-    Banks, BanksRequest, BanksResponse, TransactionConfirmationStatus, TransactionStatus,
-};
-use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache};
-use solana_sdk::{
-    account::Account,
-    clock::Slot,
-    commitment_config::CommitmentLevel,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Signature,
-    transaction::{self, Transaction},
-};
-use std::{
-    io,
-    net::{Ipv4Addr, SocketAddr},
-    sync::{
-        mpsc::{channel, Receiver, Sender},
-        Arc, RwLock,
-    },
-    thread::Builder,
-    time::Duration,
-};
-use tarpc::{
-    context::Context,
-    rpc::{transport::channel::UnboundedChannel, ClientMessage, Response},
-    serde_transport::tcp,
-    server::{self, Channel, Handler},
-    transport,
-};
-use tokio::time::sleep;
-use tokio_serde::formats::Bincode;
-
-#[derive(Clone)]
-struct BanksServer {
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    transaction_sender: Sender<TransactionInfo>,
-}
-
-impl BanksServer {
-    /// Return a BanksServer that forwards transactions to the
-    /// given sender. If unit-testing, those transactions can go to
-    /// a bank in the given BankForks. Otherwise, the receiver should
-    /// forward them to a validator in the leader schedule.
-    fn new(
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-        transaction_sender: Sender<TransactionInfo>,
-    ) -> Self {
-        Self {
-            bank_forks,
-            block_commitment_cache,
-            transaction_sender,
-        }
-    }
-
-    fn run(bank_forks: Arc<RwLock<BankForks>>, transaction_receiver: Receiver<TransactionInfo>) {
-        while let Ok(info) = transaction_receiver.recv() {
-            let mut transaction_infos = vec![info];
-            while let Ok(info) = transaction_receiver.try_recv() {
-                transaction_infos.push(info);
-            }
-            let transactions: Vec<_> = transaction_infos
-                .into_iter()
-                .map(|info| deserialize(&info.wire_transaction).unwrap())
-                .collect();
-            let bank = bank_forks.read().unwrap().working_bank();
-            let _ = bank.process_transactions(&transactions);
-        }
-    }
-
-    /// Useful for unit-testing
-    fn new_loopback(
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    ) -> Self {
-        let (transaction_sender, transaction_receiver) = channel();
-        let bank = bank_forks.read().unwrap().working_bank();
-        let slot = bank.slot();
-        {
-            // ensure that the commitment cache and bank are synced
-            let mut w_block_commitment_cache = block_commitment_cache.write().unwrap();
-            w_block_commitment_cache.set_all_slots(slot, slot);
-        }
-        let server_bank_forks = bank_forks.clone();
-        Builder::new()
-            .name("solana-bank-forks-client".to_string())
-            .spawn(move || Self::run(server_bank_forks, transaction_receiver))
-            .unwrap();
-        Self::new(bank_forks, block_commitment_cache, transaction_sender)
-    }
-
-    fn slot(&self, commitment: CommitmentLevel) -> Slot {
-        self.block_commitment_cache
-            .read()
-            .unwrap()
-            .slot_with_commitment(commitment)
-    }
-
-    fn bank(&self, commitment: CommitmentLevel) -> Arc<Bank> {
-        self.bank_forks.read().unwrap()[self.slot(commitment)].clone()
-    }
-
-    async fn poll_signature_status(
-        self,
-        signature: &Signature,
-        blockhash: &Hash,
-        last_valid_slot: Slot,
-        commitment: CommitmentLevel,
-    ) -> Option<transaction::Result<()>> {
-        let mut status = self
-            .bank(commitment)
-            .get_signature_status_with_blockhash(signature, blockhash);
-        while status.is_none() {
-            sleep(Duration::from_millis(200)).await;
-            let bank = self.bank(commitment);
-            if bank.slot() > last_valid_slot {
-                break;
-            }
-            status = bank.get_signature_status_with_blockhash(signature, blockhash);
-        }
-        status
-    }
-}
-
-fn verify_transaction(transaction: &Transaction) -> transaction::Result<()> {
-    if let Err(err) = transaction.verify() {
-        Err(err)
-    } else if let Err(err) = transaction.verify_precompiles() {
-        Err(err)
-    } else {
-        Ok(())
-    }
-}
-
-#[tarpc::server]
-impl Banks for BanksServer {
-    async fn send_transaction_with_context(self, _: Context, transaction: Transaction) {
-        let blockhash = &transaction.message.recent_blockhash;
-        let last_valid_slot = self
-            .bank_forks
-            .read()
-            .unwrap()
-            .root_bank()
-            .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_slot);
-        self.transaction_sender.send(info).unwrap();
-    }
-
-    async fn get_fees_with_commitment_and_context(
-        self,
-        _: Context,
-        commitment: CommitmentLevel,
-    ) -> (FeeCalculator, Hash, Slot) {
-        let bank = self.bank(commitment);
-        let (blockhash, fee_calculator) = bank.last_blockhash_with_fee_calculator();
-        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(
-        self,
-        _: Context,
-        signature: Signature,
-    ) -> Option<TransactionStatus> {
-        let bank = self.bank(CommitmentLevel::Processed);
-        let (slot, status) = bank.get_signature_status_slot(&signature)?;
-        let r_block_commitment_cache = self.block_commitment_cache.read().unwrap();
-
-        let optimistically_confirmed_bank = self.bank(CommitmentLevel::Confirmed);
-        let optimistically_confirmed =
-            optimistically_confirmed_bank.get_signature_status_slot(&signature);
-
-        let confirmations = if r_block_commitment_cache.root() >= slot
-            && r_block_commitment_cache.highest_confirmed_root() >= slot
-        {
-            None
-        } else {
-            r_block_commitment_cache
-                .get_confirmation_count(slot)
-                .or(Some(0))
-        };
-        Some(TransactionStatus {
-            slot,
-            confirmations,
-            err: status.err(),
-            confirmation_status: if confirmations.is_none() {
-                Some(TransactionConfirmationStatus::Finalized)
-            } else if optimistically_confirmed.is_some() {
-                Some(TransactionConfirmationStatus::Confirmed)
-            } else {
-                Some(TransactionConfirmationStatus::Processed)
-            },
-        })
-    }
-
-    async fn get_slot_with_context(self, _: Context, commitment: CommitmentLevel) -> Slot {
-        self.slot(commitment)
-    }
-
-    async fn process_transaction_with_commitment_and_context(
-        self,
-        _: Context,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> Option<transaction::Result<()>> {
-        if let Err(err) = verify_transaction(&transaction) {
-            return Some(Err(err));
-        }
-
-        let blockhash = &transaction.message.recent_blockhash;
-        let last_valid_slot = self
-            .bank_forks
-            .read()
-            .unwrap()
-            .root_bank()
-            .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_slot);
-        self.transaction_sender.send(info).unwrap();
-        self.poll_signature_status(&signature, blockhash, last_valid_slot, commitment)
-            .await
-    }
-
-    async fn get_account_with_commitment_and_context(
-        self,
-        _: Context,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> Option<Account> {
-        let bank = self.bank(commitment);
-        bank.get_account(&address)
-    }
-}
-
-pub async fn start_local_server(
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-) -> UnboundedChannel<Response<BanksResponse>, ClientMessage<BanksRequest>> {
-    let banks_server = BanksServer::new_loopback(bank_forks, block_commitment_cache);
-    let (client_transport, server_transport) = transport::channel::unbounded();
-    let server = server::new(server::Config::default())
-        .incoming(stream::once(future::ready(server_transport)))
-        .respond_with(banks_server.serve());
-    tokio::spawn(server);
-    client_transport
-}
-
-pub async fn start_tcp_server(
-    listen_addr: SocketAddr,
-    tpu_addr: SocketAddr,
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-) -> io::Result<()> {
-    // Note: These settings are copied straight from the tarpc example.
-    let server = tcp::listen(listen_addr, Bincode::default)
-        .await?
-        // Ignore accept errors.
-        .filter_map(|r| future::ready(r.ok()))
-        .map(server::BaseChannel::with_defaults)
-        // Limit channels to 1 per IP.
-        .max_channels_per_key(1, |t| {
-            t.as_ref()
-                .peer_addr()
-                .map(|x| x.ip())
-                .unwrap_or_else(|_| Ipv4Addr::new(0, 0, 0, 0).into())
-        })
-        // serve is generated by the service attribute. It takes as input any type implementing
-        // the generated Banks trait.
-        .map(move |chan| {
-            let (sender, receiver) = channel();
-
-            SendTransactionService::new(tpu_addr, &bank_forks, receiver);
-
-            let server =
-                BanksServer::new(bank_forks.clone(), block_commitment_cache.clone(), sender);
-            chan.respond_with(server.serve()).execute()
-        })
-        // Max 10 channels.
-        .buffer_unordered(10)
-        .for_each(|_| async {});
-
-    server.await;
-    Ok(())
-}
--- a/banks-server/src/lib.rs
+++ b/banks-server/src/lib.rs
@@ -1,6 +0,0 @@
-pub mod banks_server;
-pub mod rpc_banks_service;
-pub mod send_transaction_service;
-
-#[macro_use]
-extern crate solana_metrics;
--- a/banks-server/src/rpc_banks_service.rs
+++ b/banks-server/src/rpc_banks_service.rs
@@ -1,116 +0,0 @@
-//! The `rpc_banks_service` module implements the Solana Banks RPC API.
-
-use crate::banks_server::start_tcp_server;
-use futures::{future::FutureExt, pin_mut, prelude::stream::StreamExt, select};
-use solana_runtime::{bank_forks::BankForks, commitment::BlockCommitmentCache};
-use std::{
-    net::SocketAddr,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, RwLock,
-    },
-    thread::{self, Builder, JoinHandle},
-};
-use tokio::{
-    runtime::Runtime,
-    time::{self, Duration},
-};
-
-pub struct RpcBanksService {
-    thread_hdl: JoinHandle<()>,
-}
-
-/// Run the TCP service until `exit` is set to true
-async fn start_abortable_tcp_server(
-    listen_addr: SocketAddr,
-    tpu_addr: SocketAddr,
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    exit: Arc<AtomicBool>,
-) {
-    let server = start_tcp_server(
-        listen_addr,
-        tpu_addr,
-        bank_forks.clone(),
-        block_commitment_cache.clone(),
-    )
-    .fuse();
-    let interval = time::interval(Duration::from_millis(100)).fuse();
-    pin_mut!(server, interval);
-    loop {
-        select! {
-            _ = server => {},
-            _ = interval.select_next_some() => {
-                if exit.load(Ordering::Relaxed) {
-                    break;
-                }
-            }
-        }
-    }
-}
-
-impl RpcBanksService {
-    fn run(
-        listen_addr: SocketAddr,
-        tpu_addr: SocketAddr,
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-        exit: Arc<AtomicBool>,
-    ) {
-        let server = start_abortable_tcp_server(
-            listen_addr,
-            tpu_addr,
-            bank_forks,
-            block_commitment_cache,
-            exit,
-        );
-        Runtime::new().unwrap().block_on(server);
-    }
-
-    pub fn new(
-        listen_addr: SocketAddr,
-        tpu_addr: SocketAddr,
-        bank_forks: &Arc<RwLock<BankForks>>,
-        block_commitment_cache: &Arc<RwLock<BlockCommitmentCache>>,
-        exit: &Arc<AtomicBool>,
-    ) -> Self {
-        let bank_forks = bank_forks.clone();
-        let block_commitment_cache = block_commitment_cache.clone();
-        let exit = exit.clone();
-        let thread_hdl = Builder::new()
-            .name("solana-rpc-banks".to_string())
-            .spawn(move || {
-                Self::run(
-                    listen_addr,
-                    tpu_addr,
-                    bank_forks,
-                    block_commitment_cache,
-                    exit,
-                )
-            })
-            .unwrap();
-
-        Self { thread_hdl }
-    }
-
-    pub fn join(self) -> thread::Result<()> {
-        self.thread_hdl.join()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_runtime::bank::Bank;
-
-    #[test]
-    fn test_rpc_banks_server_exit() {
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(Bank::default())));
-        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-        let exit = Arc::new(AtomicBool::new(false));
-        let addr = "127.0.0.1:0".parse().unwrap();
-        let service = RpcBanksService::new(addr, addr, &bank_forks, &block_commitment_cache, &exit);
-        exit.store(true, Ordering::Relaxed);
-        service.join().unwrap();
-    }
-}
--- a/bench-exchange/Cargo.toml
+++ b/bench-exchange/Cargo.toml
@@ -2,7 +2,7 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,28 +11,28 @@ publish = false
 [dependencies]
 clap = "2.33.1"
 itertools = "0.9.0"
-log = "0.4.11"
+log = "0.4.8"
 num-derive = "0.3"
 num-traits = "0.2"
 rand = "0.7.0"
-rayon = "1.4.0"
+rayon = "1.3.1"
 serde_json = "1.0.56"
 serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-core = { path = "../core", version = "1.5.6" }
-solana-genesis = { path = "../genesis", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
+solana-core = { path = "../core", version = "1.3.2" }
+solana-genesis = { path = "../genesis", version = "1.3.2" }
+solana-client = { path = "../client", version = "1.3.2" }
+solana-faucet = { path = "../faucet", version = "1.3.2" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.3.2" }
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-metrics = { path = "../metrics", version = "1.3.2" }
+solana-net-utils = { path = "../net-utils", version = "1.3.2" }
+solana-runtime = { path = "../runtime", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-version = { path = "../version", version = "1.3.2" }

 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.5.6" }
+solana-local-cluster = { path = "../local-cluster", version = "1.3.2" }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
--- a/bench-exchange/src/bench.rs
+++ b/bench-exchange/src/bench.rs
@@ -390,7 +390,7 @@ fn swapper<T>(
            while client
                .get_balance_with_commitment(
                    &trade_infos[trade_index].trade_account,
-                    CommitmentConfig::processed(),
+                    CommitmentConfig::recent(),
                )
                .unwrap_or(0)
                == 0
@@ -445,7 +445,7 @@ fn swapper<T>(
            account_group = (account_group + 1) % account_groups as usize;

            let (blockhash, _fee_calculator, _last_valid_slot) = client
-                .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                .expect("Failed to get blockhash");
            let to_swap_txs: Vec<_> = to_swap
                .par_iter()
@@ -571,7 +571,7 @@ fn trader<T>(
        account_group = (account_group + 1) % account_groups as usize;

        let (blockhash, _fee_calculator, _last_valid_slot) = client
-            .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+            .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
            .expect("Failed to get blockhash");

        trades.chunks(chunk_size).for_each(|chunk| {
@@ -658,7 +658,7 @@ where
 {
    for s in &tx.signatures {
        if let Ok(Some(r)) =
-            sync_client.get_signature_status_with_commitment(s, CommitmentConfig::processed())
+            sync_client.get_signature_status_with_commitment(s, CommitmentConfig::recent())
        {
            match r {
                Ok(_) => {
@@ -681,7 +681,7 @@ fn verify_funding_transfer<T: SyncClient + ?Sized>(
    if verify_transaction(client, tx) {
        for a in &tx.message().account_keys[1..] {
            if client
-                .get_balance_with_commitment(a, CommitmentConfig::processed())
+                .get_balance_with_commitment(a, CommitmentConfig::recent())
                .unwrap_or(0)
                >= amount
            {
@@ -764,7 +764,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                );

                let (blockhash, _fee_calculator, _last_valid_slot) = client
-                    .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                    .expect("blockhash");
                to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
                    tx.sign(&[*k], blockhash);
@@ -803,7 +803,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
        funded.append(&mut new_funded);
        funded.retain(|(k, b)| {
            client
-                .get_balance_with_commitment(&k.pubkey(), CommitmentConfig::processed())
+                .get_balance_with_commitment(&k.pubkey(), CommitmentConfig::recent())
                .unwrap_or(0)
                > lamports
                && *b > lamports
@@ -857,7 +857,7 @@ pub fn create_token_accounts<T: Client>(
            let mut retries = 0;
            while !to_create_txs.is_empty() {
                let (blockhash, _fee_calculator, _last_valid_slot) = client
-                    .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                    .expect("Failed to get blockhash");
                to_create_txs
                    .par_iter_mut()
@@ -903,7 +903,7 @@ pub fn create_token_accounts<T: Client>(
        let mut new_notfunded: Vec<(&Arc<Keypair>, &Keypair)> = vec![];
        for f in &notfunded {
            if client
-                .get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::processed())
+                .get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::recent())
                .unwrap_or(0)
                == 0
            {
@@ -968,7 +968,7 @@ pub fn airdrop_lamports<T: Client>(
    id: &Keypair,
    amount: u64,
 ) {
-    let balance = client.get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed());
+    let balance = client.get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent());
    let balance = balance.unwrap_or(0);
    if balance >= amount {
        return;
@@ -986,7 +986,7 @@ pub fn airdrop_lamports<T: Client>(
    let mut tries = 0;
    loop {
        let (blockhash, _fee_calculator, _last_valid_slot) = client
-            .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+            .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
            .expect("Failed to get blockhash");
        match request_airdrop_transaction(&faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {
            Ok(transaction) => {
@@ -995,14 +995,14 @@ pub fn airdrop_lamports<T: Client>(
                for _ in 0..30 {
                    if let Ok(Some(_)) = client.get_signature_status_with_commitment(
                        &signature,
-                        CommitmentConfig::processed(),
+                        CommitmentConfig::recent(),
                    ) {
                        break;
                    }
                    sleep(Duration::from_millis(100));
                }
                if client
-                    .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed())
+                    .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent())
                    .unwrap_or(0)
                    >= amount
                {
--- a/bench-exchange/src/cli.rs
+++ b/bench-exchange/src/cli.rs
@@ -163,8 +163,7 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
        )
 }

-#[allow(clippy::field_reassign_with_default)]
-pub fn extract_args(matches: &ArgMatches) -> Config {
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
    let mut args = Config::default();

    args.entrypoint_addr = solana_net_utils::parse_host_port(
--- a/bench-exchange/tests/bench_exchange.rs
+++ b/bench-exchange/tests/bench_exchange.rs
@@ -5,7 +5,7 @@ use solana_core::validator::ValidatorConfig;
 use solana_exchange_program::exchange_processor::process_instruction;
 use solana_exchange_program::id;
 use solana_exchange_program::solana_exchange_program;
-use solana_faucet::faucet::run_local_faucet_with_port;
+use solana_faucet::faucet::run_local_faucet;
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_runtime::bank::Bank;
 use solana_runtime::bank_client::BankClient;
@@ -22,17 +22,15 @@ fn test_exchange_local_cluster() {

    const NUM_NODES: usize = 1;

-    let config = Config {
-        identity: Keypair::new(),
-        duration: Duration::from_secs(1),
-        fund_amount: 100_000,
-        threads: 1,
-        transfer_delay: 20, // 15
-        batch_size: 100,    // 1000
-        chunk_size: 10,     // 200
-        account_groups: 1,  // 10
-        ..Config::default()
-    };
+    let mut config = Config::default();
+    config.identity = Keypair::new();
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 15
+    config.batch_size = 100; // 1000;
+    config.chunk_size = 10; // 200;
+    config.account_groups = 1; // 10;
    let Config {
        fund_amount,
        batch_size,
@@ -41,7 +39,7 @@ fn test_exchange_local_cluster() {
    } = config;
    let accounts_in_groups = batch_size * account_groups;

-    let cluster = LocalCluster::new(&mut ClusterConfig {
+    let cluster = LocalCluster::new(&ClusterConfig {
        node_stakes: vec![100_000; NUM_NODES],
        cluster_lamports: 100_000_000_000_000,
        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
@@ -57,11 +55,8 @@ fn test_exchange_local_cluster() {
    );

    let (addr_sender, addr_receiver) = channel();
-    run_local_faucet_with_port(faucet_keypair, addr_sender, Some(1_000_000_000_000), 0);
-    let faucet_addr = addr_receiver
-        .recv_timeout(Duration::from_secs(2))
-        .expect("run_local_faucet")
-        .expect("faucet_addr");
+    run_local_faucet(faucet_keypair, addr_sender, Some(1_000_000_000_000));
+    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();

    info!("Connecting to the cluster");
    let nodes =
@@ -91,21 +86,18 @@ fn test_exchange_bank_client() {
    solana_logger::setup();
    let (genesis_config, identity) = create_genesis_config(100_000_000_000_000);
    let mut bank = Bank::new(&genesis_config);
-    bank.add_builtin("exchange_program", id(), process_instruction);
+    bank.add_builtin_program("exchange_program", id(), process_instruction);
    let clients = vec![BankClient::new(bank)];

-    do_bench_exchange(
-        clients,
-        Config {
-            identity,
-            duration: Duration::from_secs(1),
-            fund_amount: 100_000,
-            threads: 1,
-            transfer_delay: 20, // 0;
-            batch_size: 100,    // 1500;
-            chunk_size: 10,     // 1500;
-            account_groups: 1,  // 50;
-            ..Config::default()
-        },
-    );
+    let mut config = Config::default();
+    config.identity = identity;
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 0;
+    config.batch_size = 100; // 1500;
+    config.chunk_size = 10; // 1500;
+    config.account_groups = 1; // 50;
+
+    do_bench_exchange(clients, config);
 }
--- a/bench-streamer/Cargo.toml
+++ b/bench-streamer/Cargo.toml
@@ -2,19 +2,18 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-publish = false

 [dependencies]
 clap = "2.33.1"
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-streamer = { path = "../streamer", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
+solana-streamer = { path = "../streamer", version = "1.3.2" }
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-net-utils = { path = "../net-utils", version = "1.3.2" }
+solana-version = { path = "../version", version = "1.3.2" }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
--- a/bench-streamer/src/main.rs
+++ b/bench-streamer/src/main.rs
@@ -27,7 +27,7 @@ fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
        let mut num = 0;
        for p in &msgs.packets {
            let a = p.meta.addr();
-            assert!(p.meta.size <= PACKET_DATA_SIZE);
+            assert!(p.meta.size < PACKET_DATA_SIZE);
            send.send_to(&p.data[..p.meta.size], &a).unwrap();
            num += 1;
        }
--- a/bench-tps/Cargo.toml
+++ b/bench-tps/Cargo.toml
@@ -2,36 +2,35 @@
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-publish = false

 [dependencies]
 bincode = "1.3.1"
 clap = "2.33.1"
-log = "0.4.11"
-rayon = "1.4.0"
+log = "0.4.8"
+rayon = "1.3.1"
 serde_json = "1.0.56"
 serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-core = { path = "../core", version = "1.5.6" }
-solana-genesis = { path = "../genesis", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-metrics = { path = "../metrics", version = "1.5.6" }
-solana-measure = { path = "../measure", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana-runtime = { path = "../runtime", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
+solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
+solana-core = { path = "../core", version = "1.3.2" }
+solana-genesis = { path = "../genesis", version = "1.3.2" }
+solana-client = { path = "../client", version = "1.3.2" }
+solana-faucet = { path = "../faucet", version = "1.3.2" }
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-metrics = { path = "../metrics", version = "1.3.2" }
+solana-measure = { path = "../measure", version = "1.3.2" }
+solana-net-utils = { path = "../net-utils", version = "1.3.2" }
+solana-runtime = { path = "../runtime", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-version = { path = "../version", version = "1.3.2" }

 [dev-dependencies]
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "1.5.6" }
+solana-local-cluster = { path = "../local-cluster", version = "1.3.2" }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
--- a/bench-tps/src/bench.rs
+++ b/bench-tps/src/bench.rs
@@ -48,7 +48,7 @@ pub type SharedTransactions = Arc<RwLock<VecDeque<Vec<(Transaction, u64)>>>>;

 fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
    loop {
-        match client.get_recent_blockhash_with_commitment(CommitmentConfig::processed()) {
+        match client.get_recent_blockhash_with_commitment(CommitmentConfig::recent()) {
            Ok((blockhash, fee_calculator, _last_valid_slot)) => {
                return (blockhash, fee_calculator)
            }
@@ -497,7 +497,7 @@ fn do_tx_transfers<T: Client>(

 fn verify_funding_transfer<T: Client>(client: &Arc<T>, tx: &Transaction, amount: u64) -> bool {
    for a in &tx.message().account_keys[1..] {
-        match client.get_balance_with_commitment(a, CommitmentConfig::processed()) {
+        match client.get_balance_with_commitment(a, CommitmentConfig::recent()) {
            Ok(balance) => return balance >= amount,
            Err(err) => error!("failed to get balance {:?}", err),
        }
@@ -762,7 +762,7 @@ pub fn airdrop_lamports<T: Client>(
        };

        let current_balance = client
-            .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed())
+            .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent())
            .unwrap_or_else(|e| {
                info!("airdrop error {}", e);
                starting_balance
@@ -938,12 +938,10 @@ mod tests {
        let bank = Bank::new(&genesis_config);
        let client = Arc::new(BankClient::new(bank));

-        let config = Config {
-            id,
-            tx_count: 10,
-            duration: Duration::from_secs(5),
-            ..Config::default()
-        };
+        let mut config = Config::default();
+        config.id = id;
+        config.tx_count = 10;
+        config.duration = Duration::from_secs(5);

        let keypair_count = config.tx_count * config.keypair_multiplier;
        let keypairs =
@@ -967,7 +965,7 @@ mod tests {
        for kp in &keypairs {
            assert_eq!(
                client
-                    .get_balance_with_commitment(&kp.pubkey(), CommitmentConfig::processed())
+                    .get_balance_with_commitment(&kp.pubkey(), CommitmentConfig::recent())
                    .unwrap(),
                lamports
            );
--- a/bench-tps/src/cli.rs
+++ b/bench-tps/src/cli.rs
@@ -196,7 +196,7 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
 /// * `matches` - command line arguments parsed by clap
 /// # Panics
 /// Panics if there is trouble parsing any of the arguments
-pub fn extract_args(matches: &ArgMatches) -> Config {
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
    let mut args = Config::default();

    if let Some(addr) = matches.value_of("entrypoint") {
--- a/bench-tps/tests/bench_tps.rs
+++ b/bench-tps/tests/bench_tps.rs
@@ -4,7 +4,7 @@ use solana_bench_tps::cli::Config;
 use solana_client::thin_client::create_client;
 use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
 use solana_core::validator::ValidatorConfig;
-use solana_faucet::faucet::run_local_faucet_with_port;
+use solana_faucet::faucet::run_local_faucet;
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_sdk::signature::{Keypair, Signer};
 use std::sync::{mpsc::channel, Arc};
@@ -15,7 +15,7 @@ fn test_bench_tps_local_cluster(config: Config) {

    solana_logger::setup();
    const NUM_NODES: usize = 1;
-    let cluster = LocalCluster::new(&mut ClusterConfig {
+    let cluster = LocalCluster::new(&ClusterConfig {
        node_stakes: vec![999_990; NUM_NODES],
        cluster_lamports: 200_000_000,
        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
@@ -36,11 +36,8 @@ fn test_bench_tps_local_cluster(config: Config) {
    ));

    let (addr_sender, addr_receiver) = channel();
-    run_local_faucet_with_port(faucet_keypair, addr_sender, None, 0);
-    let faucet_addr = addr_receiver
-        .recv_timeout(Duration::from_secs(2))
-        .expect("run_local_faucet")
-        .expect("faucet_addr");
+    run_local_faucet(faucet_keypair, addr_sender, None);
+    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();

    let lamports_per_account = 100;

@@ -63,9 +60,9 @@ fn test_bench_tps_local_cluster(config: Config) {
 #[test]
 #[serial]
 fn test_bench_tps_local_cluster_solana() {
-    test_bench_tps_local_cluster(Config {
-        tx_count: 100,
-        duration: Duration::from_secs(10),
-        ..Config::default()
-    });
+    let mut config = Config::default();
+    config.tx_count = 100;
+    config.duration = Duration::from_secs(10);
+
+    test_bench_tps_local_cluster(config);
 }
--- a/31
+++ b/31
@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-# shellcheck source=ci/rust-version.sh
-here=$(dirname "$0")
-
-source "${here}"/ci/rust-version.sh all
-
-toolchain=
-case "$1" in
-  stable)
-    # shellcheck disable=SC2054 # rust_stable is sourced from rust-version.sh
-    toolchain="$rust_stable"
-    shift
-    ;;
-  nightly)
-    # shellcheck disable=SC2054 # rust_nightly is sourced from rust-version.sh
-    toolchain="$rust_nightly"
-    shift
-    ;;
-  +*)
-    toolchain="${1#+}"
-    shift
-    ;;
-  *)
-    # shellcheck disable=SC2054 # rust_stable is sourced from rust-version.sh
-    toolchain="$rust_stable"
-    ;;
-esac
-
-set -x
-exec cargo "+${toolchain}" "${@}"
--- a/13
+++ b/13
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-here=$(dirname "$0")
-
-maybe_bpf_sdk="--bpf-sdk $here/sdk/bpf"
-for a in "$@"; do
-  if [[ $a = --bpf-sdk ]]; then
-    maybe_bpf_sdk=
-  fi
-done
-
-set -x
-exec "$here"/cargo run --manifest-path "$here"/sdk/cargo-build-bpf/Cargo.toml -- $maybe_bpf_sdk "$@"
--- a/14
+++ b/14
@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-here=$(dirname "$0")
-
-maybe_bpf_sdk="--bpf-sdk $here/sdk/bpf"
-for a in "$@"; do
-  if [[ $a = --bpf-sdk ]]; then
-    maybe_bpf_sdk=
-  fi
-done
-
-export CARGO_BUILD_BPF="$here"/cargo-build-bpf
-set -x
-exec "$here"/cargo run --manifest-path "$here"/sdk/cargo-test-bpf/Cargo.toml -- $maybe_bpf_sdk "$@"
--- a/ci/README.md
+++ b/ci/README.md
@@ -47,8 +47,6 @@ sudo ./setup-new-buildkite-agent/setup-buildkite.sh
 ```
 - Copy the pubkey contents from `~buildkite-agent/.ssh/id_ecdsa.pub` and
 add the pubkey as an authorized SSH key on github.
-  - In net/scripts/solana-user-authorized_keys.sh
-  - Bug mvines to add it to the "solana-grimes" github user
 - Edit `/etc/buildkite-agent/buildkite-agent.cfg` and/or `/etc/systemd/system/buildkite-agent@*` to the desired configuration of the agent(s)
 - Copy `ejson` keys from another CI node at `/opt/ejson/keys/`
 to the same location on the new node.
--- a/ci/buildkite-pipeline.sh
+++ b/ci/buildkite-pipeline.sh
@@ -175,30 +175,6 @@ EOF
      "Stable-perf skipped as no relevant files were modified"
  fi

-  # Downstream backwards compatibility
-  if affects \
-             .rs$ \
-             Cargo.lock$ \
-             Cargo.toml$ \
-             ^ci/rust-version.sh \
-             ^ci/test-stable-perf.sh \
-             ^ci/test-stable.sh \
-             ^ci/test-local-cluster.sh \
-             ^core/build.rs \
-             ^fetch-perf-libs.sh \
-             ^programs/ \
-             ^sdk/ \
-             ^scripts/build-downstream-projects.sh \
-      ; then
-    cat >> "$output_file" <<"EOF"
-  - command: "scripts/build-downstream-projects.sh"
-    name: "downstream-projects"
-    timeout_in_minutes: 30
-EOF
-  else
-    annotate --style info \
-      "downstream-projects skipped as no relevant files were modified"
-  fi
  # Benches...
  if affects \
             .rs$ \
@@ -263,7 +239,7 @@ if [[ $BUILDKITE_BRANCH =~ ^pull ]]; then
  annotate --style info --context pr-backlink \
    "Github Pull Request: https://github.com/solana-labs/solana/$BUILDKITE_BRANCH"

-  if [[ $GITHUB_USER = "dependabot[bot]" ]]; then
+  if [[ $GITHUB_USER = "dependabot-preview[bot]" ]]; then
    command_step dependabot "ci/dependabot-pr.sh" 5
    wait_step
  fi
--- a/ci/channel-info.sh
+++ b/ci/channel-info.sh
@@ -89,20 +89,12 @@ BETA_CHANNEL_LATEST_TAG=${beta_tag:+v$beta_tag}
 STABLE_CHANNEL_LATEST_TAG=${stable_tag:+v$stable_tag}


-if [[ -n $CI_BASE_BRANCH ]]; then
-  BRANCH="$CI_BASE_BRANCH"
-elif [[ -n $CI_BRANCH ]]; then
-  BRANCH="$CI_BRANCH"
-fi
-
-if [[ -z "$CHANNEL" ]]; then
-  if [[ $BRANCH = "$STABLE_CHANNEL" ]]; then
-    CHANNEL=stable
-  elif [[ $BRANCH = "$EDGE_CHANNEL" ]]; then
-    CHANNEL=edge
-  elif [[ $BRANCH = "$BETA_CHANNEL" ]]; then
-    CHANNEL=beta
-  fi
+if [[ $CI_BRANCH = "$STABLE_CHANNEL" ]]; then
+  CHANNEL=stable
+elif [[ $CI_BRANCH = "$EDGE_CHANNEL" ]]; then
+  CHANNEL=edge
+elif [[ $CI_BRANCH = "$BETA_CHANNEL" ]]; then
+  CHANNEL=beta
 fi

 echo EDGE_CHANNEL="$EDGE_CHANNEL"
--- a/ci/dependabot-updater.sh
+++ b/ci/dependabot-updater.sh
@@ -6,13 +6,13 @@ source ci/_

 commit_range="$(git merge-base HEAD origin/master)..HEAD"
 parsed_update_args="$(
-  git log "$commit_range" --author "dependabot\[bot\]" --oneline -n1 |
+  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
    grep -o '[Bb]ump.*$' |
    sed -r 's/[Bb]ump ([^ ]+) from ([^ ]+) to ([^ ]+)/-p \1:\2 --precise \3/'
 )"
 # relaxed_parsed_update_args is temporal measure...
 relaxed_parsed_update_args="$(
-  git log "$commit_range" --author "dependabot\[bot\]" --oneline -n1 |
+  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
    grep -o '[Bb]ump.*$' |
    sed -r 's/[Bb]ump ([^ ]+) from [^ ]+ to ([^ ]+)/-p \1 --precise \2/'
 )"
--- a/ci/docker-rust-nightly/Dockerfile
+++ b/ci/docker-rust-nightly/Dockerfile
@@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.49.0
+FROM solanalabs/rust:1.45.1
 ARG date

 RUN set -x \
--- a/ci/docker-rust-nightly/README.md
+++ b/ci/docker-rust-nightly/README.md
@@ -20,7 +20,7 @@ To update the pinned version:
   specific YYYY-MM-DD that is desired (default is today's build).
   Check https://rust-lang.github.io/rustup-components-history/ for build
   status
-1. Update `ci/rust-version.sh` to reflect the new nightly `YYYY-MM-DD`
+1. Update `ci/rust-version.sh` to reflect the new nightly `YYY-MM-DD`
 1. Run `SOLANA_ALLOCATE_TTY=1 SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-checks.sh`
   and `SOLANA_ALLOCATE_TTY=1 SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-coverage.sh [args]...`
   to confirm the new nightly image builds.  Fix any issues as needed
--- a/ci/docker-rust/Dockerfile
+++ b/ci/docker-rust/Dockerfile
@@ -1,6 +1,6 @@
 # Note: when the rust version is changed also modify
 # ci/rust-version.sh to pick up the new image tag
-FROM rust:1.49.0
+FROM rust:1.45.1

 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0
--- a/ci/localnet-sanity.sh
+++ b/ci/localnet-sanity.sh
@@ -80,7 +80,7 @@ nodes=(
  "multinode-demo/validator.sh \
    --enable-rpc-exit \
    --no-restart \
-    --dynamic-port-range 8050-8100 \
+    --dynamic-port-range 8050-8100
    --init-complete-file init-complete-node1.log \
    --rpc-port 18899"
 )
--- a/ci/nits.sh
+++ b/ci/nits.sh
@@ -19,7 +19,6 @@ declare prints=(
 # Parts of the tree that are expected to be print free
 declare print_free_tree=(
  ':core/src/**.rs'
-  ':^core/src/validator.rs'
  ':faucet/src/**.rs'
  ':ledger/src/**.rs'
  ':metrics/src/**.rs'
@@ -27,9 +26,6 @@ declare print_free_tree=(
  ':runtime/src/**.rs'
  ':sdk/bpf/rust/rust-utils/**.rs'
  ':sdk/**.rs'
-  ':^sdk/cargo-build-bpf/**.rs'
-  ':^sdk/program/src/program_option.rs'
-  ':^sdk/program/src/program_stubs.rs'
  ':programs/**.rs'
  ':^**bin**.rs'
  ':^**bench**.rs'
--- a/ci/order-crates-for-publishing.py
+++ b/ci/order-crates-for-publishing.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python2.7
 #
 # This script figures the order in which workspace crates must be published to
 # crates.io.  Along the way it also ensures there are no circular dependencies
@@ -45,27 +45,21 @@ def get_packages():
    sorted_dependency_graph = []
    max_iterations = pow(len(dependency_graph),2)
    while dependency_graph:
-        deleted_packages = []
        if max_iterations == 0:
            # One day be more helpful and find the actual cycle for the user...
            sys.exit('Error: Circular dependency suspected between these packages: \n {}\n'.format('\n '.join(dependency_graph.keys())))

        max_iterations -= 1
-
        for package, dependencies in dependency_graph.items():
-            if package in deleted_packages:
-                continue
            for dependency in dependencies:
                if dependency in dependency_graph:
                    break
            else:
-                deleted_packages.append(package)
+                del dependency_graph[package]
                sorted_dependency_graph.append((package, manifest_path[package]))

-        dependency_graph = {p: d for p, d in dependency_graph.items() if not p in deleted_packages }
-

    return sorted_dependency_graph

 for package, manifest in get_packages():
-    print(os.path.relpath(manifest))
+    print os.path.relpath(manifest)
--- a/ci/publish-bpf-sdk.sh
+++ b/ci/publish-bpf-sdk.sh
@@ -16,12 +16,21 @@ fi
  [[ -f bpf-sdk.tar.bz2 ]]
 )

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

 exit 0
--- a/ci/publish-crate.sh
+++ b/ci/publish-crate.sh
@@ -4,8 +4,6 @@ cd "$(dirname "$0")/.."
 source ci/semver_bash/semver.sh
 source ci/rust-version.sh stable

-cargo="$(readlink -f ./cargo)"
-
 # shellcheck disable=SC2086
 is_crate_version_uploaded() {
  name=$1
@@ -40,7 +38,7 @@ for Cargo_toml in $Cargo_tomls; do
  crate_name=$(grep -m 1 '^name = ' "$Cargo_toml" | cut -f 3 -d ' ' | tr -d \")

  if grep -q "^publish = false" "$Cargo_toml"; then
-    echo "$crate_name is marked as unpublishable"
+    echo "$crate_name is is marked as unpublishable"
    continue
  fi

@@ -68,11 +66,11 @@ for Cargo_toml in $Cargo_tomls; do
      (
        set -x
        rm -rf crate-test
-        "$cargo" stable init crate-test
+        cargo +"$rust_stable" init crate-test
        cd crate-test/
        echo "${crate_name} = \"${expectedCrateVersion}\"" >> Cargo.toml
        echo "[workspace]" >> Cargo.toml
-        "$cargo" stable check
+        cargo +"$rust_stable" check
      ) && really_uploaded=1
      if ((really_uploaded)); then
        break;
--- a/ci/publish-tarball.sh
+++ b/ci/publish-tarball.sh
@@ -91,15 +91,17 @@ echo --- Creating release tarball
  cp "${RELEASE_BASENAME}"/version.yml "${TARBALL_BASENAME}"-$TARGET.yml
 )

-# Maybe tarballs are platform agnostic, only publish them from the Linux build
+# Metrics tarball is platform agnostic, only publish it from Linux
 MAYBE_TARBALLS=
 if [[ "$CI_OS_NAME" = linux ]]; then
+  metrics/create-metrics-tarball.sh
  (
    set -x
    sdk/bpf/scripts/package.sh
    [[ -f bpf-sdk.tar.bz2 ]]
+
  )
-  MAYBE_TARBALLS="bpf-sdk.tar.bz2"
+  MAYBE_TARBALLS="bpf-sdk.tar.bz2 solana-metrics.tar.bz2"
 fi

 source ci/upload-ci-artifact.sh
@@ -113,10 +115,19 @@ for file in "${TARBALL_BASENAME}"-$TARGET.tar.bz2 "${TARBALL_BASENAME}"-$TARGET.

  if [[ -n $BUILDKITE ]]; then
    echo --- AWS S3 Store: "$file"
-    upload-s3-artifact "/solana/$file" s3://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
+    (
+      set -x
+      $DRYRUN docker run \
+        --rm \
+        --env AWS_ACCESS_KEY_ID \
+        --env AWS_SECRET_ACCESS_KEY \
+        --volume "$PWD:/solana" \
+        eremite/aws-cli:2018.12.18 \
+        /usr/bin/s3cmd --acl-public put /solana/"$file" s3://release.solana.com/"$CHANNEL_OR_TAG"/"$file"

-    echo Published to:
-    $DRYRUN ci/format-url.sh https://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
+      echo Published to:
+      $DRYRUN ci/format-url.sh http://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
+    )

    if [[ -n $TAG ]]; then
      ci/upload-github-release-asset.sh "$file"
@@ -138,22 +149,4 @@ for file in "${TARBALL_BASENAME}"-$TARGET.tar.bz2 "${TARBALL_BASENAME}"-$TARGET.
  fi
 done

-
-# Create install wrapper for release.solana.com
-if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
-  echo "Skipping publishing install wrapper"
-elif [[ -n $BUILDKITE ]]; then
-  cat > release.solana.com-install <<EOF
-SOLANA_RELEASE=$CHANNEL_OR_TAG
-SOLANA_INSTALL_INIT_ARGS=$CHANNEL_OR_TAG
-SOLANA_DOWNLOAD_ROOT=http://release.solana.com
-EOF
-  cat install/solana-install-init.sh >> release.solana.com-install
-
-  echo --- AWS S3 Store: "install"
-  $DRYRUN upload-s3-artifact "/solana/release.solana.com-install" "s3://release.solana.com/$CHANNEL_OR_TAG/install"
-  echo Published to:
-  $DRYRUN ci/format-url.sh https://release.solana.com/"$CHANNEL_OR_TAG"/install
-fi
-
 echo --- ok
--- a/ci/rust-version.sh
+++ b/ci/rust-version.sh
@@ -18,13 +18,13 @@
 if [[ -n $RUST_STABLE_VERSION ]]; then
  stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.49.0
+  stable_version=1.45.1
 fi

 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
  nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2021-01-23
+  nightly_version=2020-07-27
 fi


--- a/ci/setup-new-buildkite-agent/setup-buildkite.sh
+++ b/ci/setup-new-buildkite-agent/setup-buildkite.sh
@@ -76,7 +76,7 @@ RestartForceExitStatus=SIGPIPE
 TimeoutStartSec=10
 TimeoutStopSec=0
 KillMode=process
-LimitNOFILE=700000
+LimitNOFILE=65536

 [Install]
 WantedBy=multi-user.target
--- a/ci/setup-new-buildkite-agent/setup-limits.sh
+++ b/ci/setup-new-buildkite-agent/setup-limits.sh
@@ -8,5 +8,5 @@ source "$HERE"/utils.sh
 ensure_env || exit 1

 # Allow more files to be opened by a user
-echo "* - nofile 700000" > /etc/security/limits.d/90-solana-nofiles.conf
+sed -i 's/^\(# End of file\)/* soft nofile 65535\n\n\1/' /etc/security/limits.conf

--- a/ci/setup-new-buildkite-agent/setup-new-machine.sh
+++ b/ci/setup-new-buildkite-agent/setup-new-machine.sh
@@ -7,7 +7,6 @@ SOLANA_ROOT="$HERE"/../..
 source "$HERE"/utils.sh

 ensure_env || exit 1
-check_ssh_authorized_keys || exit 1

 set -ex

--- a/ci/setup-new-buildkite-agent/setup-ssh.sh
+++ b/ci/setup-new-buildkite-agent/setup-ssh.sh
@@ -6,11 +6,6 @@ HERE="$(dirname "$0")"
 source "$HERE"/utils.sh

 ensure_env || exit 1
-# This is a last ditch effort to prevent the caller from locking themselves
-# out of the machine. Exiting here will likely leave the system in some
-# half-configured state. To prevent this, duplicate the next line at the top
-# of the entrypoint script.
-check_ssh_authorized_keys || exit 1

 set -xe
 # Setup sshd
--- a/ci/setup-new-buildkite-agent/utils.sh
+++ b/ci/setup-new-buildkite-agent/utils.sh
@@ -14,33 +14,3 @@ ensure_env() {
  $RC
 }

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

 eval "$(ci/channel-info.sh)"
-
-cargo="$(readlink -f "./cargo")"
+source ci/rust-version.sh all

 set -o pipefail
 export RUST_BACKTRACE=1
@@ -23,44 +22,40 @@ fi
 BENCH_FILE=bench_output.log
 BENCH_ARTIFACT=current_bench_results.log

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

 # Ensure all dependencies are built
-_ "$cargo" nightly build --release
+_ cargo +$rust_nightly build --release

 # Remove "BENCH_FILE", if it exists so that the following commands can append
 rm -f "$BENCH_FILE"

 # Run sdk benches
-_ "$cargo" nightly bench --manifest-path sdk/Cargo.toml ${V:+--verbose} \
+_ cargo +$rust_nightly bench --manifest-path sdk/Cargo.toml ${V:+--verbose} \
  -- -Z unstable-options --format=json | tee -a "$BENCH_FILE"

 # Run runtime benches
-_ "$cargo" nightly bench --manifest-path runtime/Cargo.toml ${V:+--verbose} \
+_ cargo +$rust_nightly bench --manifest-path runtime/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} \
+_ cargo +$rust_nightly bench --manifest-path core/Cargo.toml ${V:+--verbose} \
  -- -Z unstable-options --format=json | tee -a "$BENCH_FILE"

 # Run bpf benches
-_ "$cargo" nightly bench --manifest-path programs/bpf/Cargo.toml ${V:+--verbose} --features=bpf_c \
+_ cargo +$rust_nightly bench --manifest-path programs/bpf/Cargo.toml ${V:+--verbose} --features=bpf_c \
  -- -Z unstable-options --format=json --nocapture | tee -a "$BENCH_FILE"

 # Run banking/accounts bench. Doesn't require nightly, but use since it is already built.
-_ "$cargo" nightly run --release --manifest-path banking-bench/Cargo.toml ${V:+--verbose} | tee -a "$BENCH_FILE"
-_ "$cargo" nightly run --release --manifest-path accounts-bench/Cargo.toml ${V:+--verbose} -- --num_accounts 10000 --num_slots 4 | tee -a "$BENCH_FILE"
+_ cargo +$rust_nightly run --release --manifest-path banking-bench/Cargo.toml ${V:+--verbose} | tee -a "$BENCH_FILE"
+_ cargo +$rust_nightly run --release --manifest-path accounts-bench/Cargo.toml ${V:+--verbose} -- --num_accounts 10000 --num_slots 4 | tee -a "$BENCH_FILE"

 # `solana-upload-perf` disabled as it can take over 30 minutes to complete for some
 # reason
 exit 0
-_ "$cargo" nightly run --release --package solana-upload-perf \
+_ cargo +$rust_nightly run --release --package solana-upload-perf \
  -- "$BENCH_FILE" "$TARGET_BRANCH" "$UPLOAD_METRICS" | tee "$BENCH_ARTIFACT"

 upload-ci-artifact "$BENCH_FILE"
--- a/ci/test-checks.sh
+++ b/ci/test-checks.sh
@@ -8,9 +8,6 @@ source ci/_
 source ci/rust-version.sh stable
 source ci/rust-version.sh nightly
 eval "$(ci/channel-info.sh)"
-cargo="$(readlink -f "./cargo")"
-
-scripts/increment-cargo-version.sh check

 echo --- build environment
 (
@@ -19,14 +16,14 @@ echo --- build environment
  rustup run "$rust_stable" rustc --version --verbose
  rustup run "$rust_nightly" rustc --version --verbose

-  "$cargo" stable --version --verbose
-  "$cargo" nightly --version --verbose
+  cargo +"$rust_stable" --version --verbose
+  cargo +"$rust_nightly" --version --verbose

-  "$cargo" stable clippy --version --verbose
-  "$cargo" nightly clippy --version --verbose
+  cargo +"$rust_stable" clippy --version --verbose
+  cargo +"$rust_nightly" clippy --version --verbose

  # audit is done only with stable
-  "$cargo" stable audit --version
+  cargo +"$rust_stable" audit --version
 )

 export RUST_BACKTRACE=1
@@ -44,62 +41,32 @@ if [[ $CI_BASE_BRANCH = "$EDGE_CHANNEL" ]]; then
    echo "$0:   [tree (for outdated Cargo.lock sync)|check (for compilation error)|update -p foo --precise x.y.z (for your Cargo.toml update)] ..." >&2
    exit "$check_status"
  fi
-
-  # Ensure nightly and --benches
-  _ 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

+# Ensure nightly and --benches
+_ scripts/cargo-for-all-lock-files.sh +"$rust_nightly" check --locked --all-targets
+
 _ ci/order-crates-for-publishing.py
-_ "$cargo" stable fmt --all -- --check
+_ cargo +"$rust_stable" fmt --all -- --check

 # -Z... is needed because of clippy bug: https://github.com/rust-lang/rust-clippy/issues/4612
 # run nightly clippy for `sdk/` as there's a moderate amount of nightly-only code there
-_ "$cargo" nightly clippy -Zunstable-options --workspace --all-targets -- --deny=warnings
+_ cargo +"$rust_nightly" clippy -Zunstable-options --workspace --all-targets -- --deny=warnings

-cargo_audit_ignores=(
-  # failure is officially deprecated/unmaintained
-  #
-  # Blocked on multiple upstream crates removing their `failure` dependency.
-  --ignore RUSTSEC-2020-0036
-
-  # `net2` crate has been deprecated; use `socket2` instead
-  #
-  # Blocked on https://github.com/paritytech/jsonrpc/issues/575
-  --ignore RUSTSEC-2020-0016
-
-  # stdweb is unmaintained
-  #
-  # Blocked on multiple upstream crates removing their `stdweb` dependency.
-  --ignore RUSTSEC-2020-0056
-
-  # Potential segfault in the time crate
-  #
-  # Blocked on multiple crates updating `time` to >= 0.2.23
-  --ignore RUSTSEC-2020-0071
-
-  # difference is unmaintained
-  #
-  # Blocked on predicates v1.0.6 removing its dependency on `difference`
-  --ignore RUSTSEC-2020-0095
-
-  # hyper is upgraded on master/v1.6 but not for v1.5
-  --ignore RUSTSEC-2021-0020
-
-)
-_ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit "${cargo_audit_ignores[@]}"
+_ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008

 {
  cd programs/bpf
-  _ "$cargo" stable audit
+  _ cargo +"$rust_stable" audit
  for project in rust/*/ ; do
    echo "+++ do_bpf_checks $project"
    (
      cd "$project"
-      _ "$cargo" stable fmt -- --check
-      _ "$cargo" nightly test
-      _ "$cargo" nightly clippy -- --deny=warnings --allow=clippy::missing_safety_doc
+      _ cargo +"$rust_stable" fmt -- --check
+      _ cargo +"$rust_nightly" test
+      _ cargo +"$rust_nightly" clippy -- --deny=warnings --allow=clippy::missing_safety_doc
    )
  done
 }
--- a/ci/test-sanity.sh
+++ b/ci/test-sanity.sh
@@ -8,16 +8,10 @@ source ci/_
 (
  echo --- git diff --check
  set -x
-
-  if [[ -n $CI_BASE_BRANCH ]]
-  then branch="$CI_BASE_BRANCH"
-  else branch="master"
-  fi
-
  # Look for failed mergify.io backports by searching leftover conflict markers
  # Also check for any trailing whitespaces!
-  git fetch origin "$branch"
-  git diff "$(git merge-base HEAD "origin/$branch")" --check --oneline
+  git fetch origin "$CI_BASE_BRANCH"
+  git diff "$(git merge-base HEAD "origin/$CI_BASE_BRANCH")..HEAD" --check --oneline
 )

 echo
--- a/ci/test-stable.sh
+++ b/ci/test-stable.sh
@@ -2,8 +2,6 @@
 set -e
 cd "$(dirname "$0")/.."

-cargo="$(readlink -f "./cargo")"
-
 source ci/_

 annotate() {
@@ -21,6 +19,9 @@ export RUST_BACKTRACE=1
 export RUSTFLAGS="-D warnings"
 source scripts/ulimit-n.sh

+# Clear cached json keypair files
+rm -rf "$HOME/.config/solana"
+
 # Clear the C dependency files, if dependency moves these files are not regenerated
 test -d target/debug/bpf && find target/debug/bpf -name '*.d' -delete
 test -d target/release/bpf && find target/release/bpf -name '*.d' -delete
@@ -36,19 +37,12 @@ NPROC=$((NPROC>14 ? 14 : NPROC))
 echo "Executing $testName"
 case $testName in
 test-stable)
-  _ "$cargo" stable test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
+  _ cargo +"$rust_stable" test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
  ;;
 test-stable-perf)
-  # solana-keygen required when building C programs
-  _ "$cargo" build --manifest-path=keygen/Cargo.toml
-  export PATH="$PWD/target/debug":$PATH
-
-  # BPF solana-sdk legacy compile test
-  ./cargo-build-bpf --manifest-path sdk/Cargo.toml
-
  # BPF program tests
  _ make -C programs/bpf/c tests
-  _ "$cargo" stable test \
+  _ cargo +"$rust_stable" test \
    --manifest-path programs/bpf/Cargo.toml \
    --no-default-features --features=bpf_c,bpf_rust -- --nocapture

@@ -68,13 +62,13 @@ test-stable-perf)
    export SOLANA_CUDA=1
  fi

-  _ "$cargo" stable build --bins ${V:+--verbose}
-  _ "$cargo" stable test --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
-  _ "$cargo" stable run --manifest-path poh-bench/Cargo.toml ${V:+--verbose} -- --hashes-per-tick 10
+  _ cargo +"$rust_stable" build --bins ${V:+--verbose}
+  _ cargo +"$rust_stable" test --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
+  _ cargo +"$rust_stable" run --manifest-path poh-bench/Cargo.toml ${V:+--verbose} -- --hashes-per-tick 10
  ;;
 test-local-cluster)
-  _ "$cargo" stable build --release --bins ${V:+--verbose}
-  _ "$cargo" stable test --release --package solana-local-cluster ${V:+--verbose} -- --nocapture --test-threads=1
+  _ cargo +"$rust_stable" build --release --bins ${V:+--verbose}
+  _ cargo +"$rust_stable" test --release --package solana-local-cluster ${V:+--verbose} -- --nocapture --test-threads=1
  exit 0
  ;;
 *)
--- a/ci/upload-ci-artifact.sh
+++ b/ci/upload-ci-artifact.sh
@@ -16,16 +16,3 @@ upload-ci-artifact() {
  fi
 }

-upload-s3-artifact() {
-  echo "--- artifact: $1 to $2"
-  (
-    set -x
-    docker run \
-      --rm \
-      --env AWS_ACCESS_KEY_ID \
-      --env AWS_SECRET_ACCESS_KEY \
-      --volume "$PWD:/solana" \
-      eremite/aws-cli:2018.12.18 \
-      /usr/bin/s3cmd --acl-public put "$1" "$2"
-  )
-}
--- a/clap-utils/Cargo.toml
+++ b/clap-utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "solana-clap-utils"
-version = "1.5.6"
+version = "1.3.2"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,9 +11,9 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-thiserror = "1.0.21"
+solana-remote-wallet = { path = "../remote-wallet", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+thiserror = "1.0.20"
 tiny-bip39 = "0.7.0"
 url = "2.1.0"
 chrono = "0.4"
--- a/clap-utils/src/commitment.rs
+++ b/clap-utils/src/commitment.rs
@@ -0,0 +1,22 @@
+use crate::ArgConstant;
+use clap::Arg;
+
+pub const COMMITMENT_ARG: ArgConstant<'static> = ArgConstant {
+    name: "commitment",
+    long: "commitment",
+    help: "Return information at the selected commitment level",
+};
+
+pub fn commitment_arg<'a, 'b>() -> Arg<'a, 'b> {
+    commitment_arg_with_default("recent")
+}
+
+pub fn commitment_arg_with_default<'a, 'b>(default_value: &'static str) -> Arg<'a, 'b> {
+    Arg::with_name(COMMITMENT_ARG.name)
+        .long(COMMITMENT_ARG.long)
+        .takes_value(true)
+        .possible_values(&["recent", "single", "root", "max"])
+        .default_value(default_value)
+        .value_name("COMMITMENT_LEVEL")
+        .help(COMMITMENT_ARG.help)
+}
--- a/clap-utils/src/fee_payer.rs
+++ b/clap-utils/src/fee_payer.rs
@@ -1,19 +0,0 @@
-use crate::{input_validators, ArgConstant};
-use clap::Arg;
-
-pub const FEE_PAYER_ARG: ArgConstant<'static> = ArgConstant {
-    name: "fee_payer",
-    long: "fee-payer",
-    help: "Specify the fee-payer account. This may be a keypair file, the ASK keyword \n\
-           or the pubkey of an offline signer, provided an appropriate --signer argument \n\
-           is also passed. Defaults to the client keypair.",
-};
-
-pub fn fee_payer_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(FEE_PAYER_ARG.name)
-        .long(FEE_PAYER_ARG.long)
-        .takes_value(true)
-        .value_name("KEYPAIR")
-        .validator(input_validators::is_valid_signer)
-        .help(FEE_PAYER_ARG.help)
-}
--- a/clap-utils/src/input_parsers.rs
+++ b/clap-utils/src/input_parsers.rs
@@ -8,7 +8,6 @@ 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},
@@ -167,26 +166,26 @@ pub fn resolve_signer(
    name: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<Option<String>, Box<dyn std::error::Error>> {
-    resolve_signer_from_path(
+    Ok(resolve_signer_from_path(
        matches,
        matches.value_of(name).unwrap(),
        name,
        wallet_manager,
-    )
+    )?)
 }

 pub fn lamports_of_sol(matches: &ArgMatches<'_>, name: &str) -> Option<u64> {
    value_of(matches, name).map(sol_to_lamports)
 }

-pub fn cluster_type_of(matches: &ArgMatches<'_>, name: &str) -> Option<ClusterType> {
-    value_of(matches, name)
-}
-
 pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentConfig> {
-    matches
-        .value_of(name)
-        .map(|value| CommitmentConfig::from_str(value).unwrap_or_default())
+    matches.value_of(name).map(|value| match value {
+        "max" => CommitmentConfig::max(),
+        "recent" => CommitmentConfig::recent(),
+        "root" => CommitmentConfig::root(),
+        "single" => CommitmentConfig::single(),
+        _ => CommitmentConfig::default(),
+    })
 }

 #[cfg(test)]
@@ -224,8 +223,8 @@ mod tests {
        assert_eq!(values_of(&matches, "multiple"), Some(vec![50, 39]));
        assert_eq!(values_of::<u64>(&matches, "single"), None);

-        let pubkey0 = solana_sdk::pubkey::new_rand();
-        let pubkey1 = solana_sdk::pubkey::new_rand();
+        let pubkey0 = Pubkey::new_rand();
+        let pubkey1 = Pubkey::new_rand();
        let matches = app().clone().get_matches_from(vec![
            "test",
            "--multiple",
@@ -247,7 +246,7 @@ mod tests {
        assert_eq!(value_of(&matches, "single"), Some(50));
        assert_eq!(value_of::<u64>(&matches, "multiple"), None);

-        let pubkey = solana_sdk::pubkey::new_rand();
+        let pubkey = Pubkey::new_rand();
        let matches = app()
            .clone()
            .get_matches_from(vec!["test", "--single", &pubkey.to_string()]);
@@ -327,8 +326,8 @@ mod tests {

    #[test]
    fn test_pubkeys_sigs_of() {
-        let key1 = solana_sdk::pubkey::new_rand();
-        let key2 = solana_sdk::pubkey::new_rand();
+        let key1 = Pubkey::new_rand();
+        let key2 = Pubkey::new_rand();
        let sig1 = Keypair::new().sign_message(&[0u8]);
        let sig2 = Keypair::new().sign_message(&[1u8]);
        let signer1 = format!("{}={}", key1, sig1);
--- a/clap-utils/src/input_validators.rs
+++ b/clap-utils/src/input_validators.rs
@@ -1,7 +1,7 @@
 use crate::keypair::{parse_keypair_path, KeypairUrl, ASK_KEYWORD};
 use chrono::DateTime;
 use solana_sdk::{
-    clock::{Epoch, Slot},
+    clock::Slot,
    hash::Hash,
    pubkey::Pubkey,
    signature::{read_keypair_file, Signature},
@@ -148,40 +148,6 @@ where
    }
 }

-pub fn is_url_or_moniker<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + Display,
-{
-    match url::Url::parse(&normalize_to_url_if_moniker(string.as_ref())) {
-        Ok(url) => {
-            if url.has_host() {
-                Ok(())
-            } else {
-                Err("no host provided".to_string())
-            }
-        }
-        Err(err) => Err(format!("{}", err)),
-    }
-}
-
-pub fn normalize_to_url_if_moniker<T: AsRef<str>>(url_or_moniker: T) -> String {
-    match url_or_moniker.as_ref() {
-        "m" | "mainnet-beta" => "https://api.mainnet-beta.solana.com",
-        "t" | "testnet" => "https://testnet.solana.com",
-        "d" | "devnet" => "https://devnet.solana.com",
-        "l" | "localhost" => "http://localhost:8899",
-        url => url,
-    }
-    .to_string()
-}
-
-pub fn is_epoch<T>(epoch: T) -> Result<(), String>
-where
-    T: AsRef<str> + Display,
-{
-    is_parsable_generic::<Epoch, _>(epoch)
-}
-
 pub fn is_slot<T>(slot: T) -> Result<(), String>
 where
    T: AsRef<str> + Display,
--- a/clap-utils/src/keypair.rs
+++ b/clap-utils/src/keypair.rs
@@ -11,7 +11,6 @@ use solana_remote_wallet::{
    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,
@@ -26,90 +25,6 @@ use std::{
    sync::Arc,
 };

-pub struct SignOnly {
-    pub blockhash: Hash,
-    pub present_signers: Vec<(Pubkey, Signature)>,
-    pub absent_signers: Vec<Pubkey>,
-    pub bad_signers: Vec<Pubkey>,
-}
-
-impl SignOnly {
-    pub fn has_all_signers(&self) -> bool {
-        self.absent_signers.is_empty() && self.bad_signers.is_empty()
-    }
-
-    pub fn presigner_of(&self, pubkey: &Pubkey) -> Option<Presigner> {
-        presigner_from_pubkey_sigs(pubkey, &self.present_signers)
-    }
-}
-pub type CliSigners = Vec<Box<dyn Signer>>;
-pub type SignerIndex = usize;
-pub struct CliSignerInfo {
-    pub signers: CliSigners,
-}
-
-impl CliSignerInfo {
-    pub fn index_of(&self, pubkey: Option<Pubkey>) -> Option<usize> {
-        if let Some(pubkey) = pubkey {
-            self.signers
-                .iter()
-                .position(|signer| signer.pubkey() == pubkey)
-        } else {
-            Some(0)
-        }
-    }
-    pub fn index_of_or_none(&self, pubkey: Option<Pubkey>) -> Option<usize> {
-        if let Some(pubkey) = pubkey {
-            self.signers
-                .iter()
-                .position(|signer| signer.pubkey() == pubkey)
-        } else {
-            None
-        }
-    }
-}
-
-pub struct DefaultSigner {
-    pub arg_name: String,
-    pub path: String,
-}
-
-impl DefaultSigner {
-    pub fn generate_unique_signers(
-        &self,
-        bulk_signers: Vec<Option<Box<dyn Signer>>>,
-        matches: &ArgMatches<'_>,
-        wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-    ) -> Result<CliSignerInfo, Box<dyn error::Error>> {
-        let mut unique_signers = vec![];
-
-        // Determine if the default signer is needed
-        if bulk_signers.iter().any(|signer| signer.is_none()) {
-            let default_signer = self.signer_from_path(matches, wallet_manager)?;
-            unique_signers.push(default_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 {
-            signers: unique_signers,
-        })
-    }
-
-    pub fn signer_from_path(
-        &self,
-        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 enum KeypairUrl {
    Ask,
    Filepath(String),
@@ -163,7 +78,7 @@ pub fn signer_from_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 find keypair file: {} error: {}", path, e),
            )
            .into()),
            Ok(file) => Ok(Box::new(file)),
@@ -234,7 +149,7 @@ pub fn resolve_signer_from_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 find keypair file: {} error: {}", path, e),
            )
            .into()),
            Ok(_) => Ok(Some(path.to_string())),
@@ -307,24 +222,7 @@ pub fn keypair_from_seed_phrase(
        keypair_from_seed_phrase_and_passphrase(&seed_phrase, &passphrase)?
    } else {
        let sanitized = sanitize_seed_phrase(seed_phrase);
-        let parse_language_fn = || {
-            for language in &[
-                Language::English,
-                Language::ChineseSimplified,
-                Language::ChineseTraditional,
-                Language::Japanese,
-                Language::Spanish,
-                Language::Korean,
-                Language::French,
-                Language::Italian,
-            ] {
-                if let Ok(mnemonic) = Mnemonic::from_phrase(&sanitized, *language) {
-                    return Ok(mnemonic);
-                }
-            }
-            Err("Can't get mnemonic from seed phrases")
-        };
-        let mnemonic = parse_language_fn()?;
+        let mnemonic = Mnemonic::from_phrase(&sanitized, Language::English)?;
        let passphrase = prompt_passphrase(&passphrase_prompt)?;
        let seed = Seed::new(&mnemonic, &passphrase);
        keypair_from_seed(seed.as_bytes())?
--- a/clap-utils/src/lib.rs
+++ b/clap-utils/src/lib.rs
@@ -23,9 +23,8 @@ impl std::fmt::Debug for DisplayError {
    }
 }

-pub mod fee_payer;
+pub mod commitment;
 pub mod input_parsers;
 pub mod input_validators;
 pub mod keypair;
-pub mod nonce;
 pub mod offline;
--- a/clap-utils/src/nonce.rs
+++ b/clap-utils/src/nonce.rs
@@ -1,50 +0,0 @@
-use crate::{input_validators::*, offline::BLOCKHASH_ARG, ArgConstant};
-use clap::{App, Arg};
-
-pub const NONCE_ARG: ArgConstant<'static> = ArgConstant {
-    name: "nonce",
-    long: "nonce",
-    help: "Provide the nonce account to use when creating a nonced \n\
-           transaction. Nonced transactions are useful when a transaction \n\
-           requires a lengthy signing process. Learn more about nonced \n\
-           transactions at https://docs.solana.com/offline-signing/durable-nonce",
-};
-
-pub const NONCE_AUTHORITY_ARG: ArgConstant<'static> = ArgConstant {
-    name: "nonce_authority",
-    long: "nonce-authority",
-    help: "Provide the nonce authority keypair to use when signing a nonced transaction",
-};
-
-fn nonce_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(NONCE_ARG.name)
-        .long(NONCE_ARG.long)
-        .takes_value(true)
-        .value_name("PUBKEY")
-        .requires(BLOCKHASH_ARG.name)
-        .validator(is_valid_pubkey)
-        .help(NONCE_ARG.help)
-}
-
-pub fn nonce_authority_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(NONCE_AUTHORITY_ARG.name)
-        .long(NONCE_AUTHORITY_ARG.long)
-        .takes_value(true)
-        .value_name("KEYPAIR")
-        .validator(is_valid_signer)
-        .help(NONCE_AUTHORITY_ARG.help)
-}
-
-pub trait NonceArgs {
-    fn nonce_args(self, global: bool) -> Self;
-}
-
-impl NonceArgs for App<'_, '_> {
-    fn nonce_args(self, global: bool) -> Self {
-        self.arg(nonce_arg().global(global)).arg(
-            nonce_authority_arg()
-                .requires(NONCE_ARG.name)
-                .global(global),
-        )
-    }
-}
--- a/clap-utils/src/offline.rs
+++ b/clap-utils/src/offline.rs
@@ -1,5 +1,4 @@
-use crate::{input_validators::*, ArgConstant};
-use clap::{App, Arg};
+use crate::ArgConstant;

 pub const BLOCKHASH_ARG: ArgConstant<'static> = ArgConstant {
    name: "blockhash",
@@ -18,61 +17,3 @@ pub const SIGNER_ARG: ArgConstant<'static> = ArgConstant {
    long: "signer",
    help: "Provide a public-key/signature pair for the transaction",
 };
-
-pub fn blockhash_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(BLOCKHASH_ARG.name)
-        .long(BLOCKHASH_ARG.long)
-        .takes_value(true)
-        .value_name("BLOCKHASH")
-        .validator(is_hash)
-        .help(BLOCKHASH_ARG.help)
-}
-
-pub fn sign_only_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(SIGN_ONLY_ARG.name)
-        .long(SIGN_ONLY_ARG.long)
-        .takes_value(false)
-        .requires(BLOCKHASH_ARG.name)
-        .help(SIGN_ONLY_ARG.help)
-}
-
-fn signer_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(SIGNER_ARG.name)
-        .long(SIGNER_ARG.long)
-        .takes_value(true)
-        .value_name("PUBKEY=SIGNATURE")
-        .validator(is_pubkey_sig)
-        .requires(BLOCKHASH_ARG.name)
-        .multiple(true)
-        .help(SIGNER_ARG.help)
-}
-
-pub trait ArgsConfig {
-    fn blockhash_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg
-    }
-    fn sign_only_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg
-    }
-    fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg
-    }
-}
-
-pub trait OfflineArgs {
-    fn offline_args(self) -> Self;
-    fn offline_args_config(self, config: &dyn ArgsConfig) -> Self;
-}
-
-impl OfflineArgs for App<'_, '_> {
-    fn offline_args_config(self, config: &dyn ArgsConfig) -> Self {
-        self.arg(config.blockhash_arg(blockhash_arg()))
-            .arg(config.sign_only_arg(sign_only_arg()))
-            .arg(config.signer_arg(signer_arg()))
-    }
-    fn offline_args(self) -> Self {
-        struct NullArgsConfig {}
-        impl ArgsConfig for NullArgsConfig {}
-        self.offline_args_config(&NullArgsConfig {})
-    }
-}
--- a/cli-config/Cargo.toml
+++ b/cli-config/Cargo.toml
@@ -3,13 +3,13 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-config"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"

 [dependencies]
-dirs-next = "2.0.0"
+dirs = "2.0.2"
 lazy_static = "1.4.0"
 serde = "1.0.112"
 serde_derive = "1.0.103"
--- a/cli-config/src/config.rs
+++ b/cli-config/src/config.rs
@@ -5,7 +5,7 @@ use url::Url;

 lazy_static! {
    pub static ref CONFIG_FILE: Option<String> = {
-        dirs_next::home_dir().map(|mut path| {
+        dirs::home_dir().map(|mut path| {
            path.extend(&[".config", "solana", "cli", "config.yml"]);
            path.to_str().unwrap().to_string()
        })
@@ -17,16 +17,15 @@ pub struct Config {
    pub json_rpc_url: String,
    pub websocket_url: String,
    pub keypair_path: String,
+
    #[serde(default)]
    pub address_labels: HashMap<String, String>,
-    #[serde(default)]
-    pub commitment: String,
 }

 impl Default for Config {
    fn default() -> Self {
        let keypair_path = {
-            let mut keypair_path = dirs_next::home_dir().expect("home directory");
+            let mut keypair_path = dirs::home_dir().expect("home directory");
            keypair_path.extend(&[".config", "solana", "id.json"]);
            keypair_path.to_str().unwrap().to_string()
        };
@@ -42,14 +41,11 @@ impl Default for Config {
            "System Program".to_string(),
        );

-        let commitment = "confirmed".to_string();
-
        Self {
            json_rpc_url,
            websocket_url,
            keypair_path,
            address_labels,
-            commitment,
        }
    }
 }
--- a/cli-output/Cargo.toml
+++ b/cli-output/Cargo.toml
@@ -1,29 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-cli-output"
-description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-
-[dependencies]
-chrono = { version = "0.4.11", features = ["serde"] }
-console = "0.11.3"
-humantime = "2.0.1"
-Inflector = "0.11.4"
-indicatif = "0.15.0"
-serde = "1.0.112"
-serde_derive = "1.0.103"
-serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-transaction-status = { path = "../transaction-status", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/cli-output/src/lib.rs
+++ b/cli-output/src/lib.rs
@@ -1,15 +0,0 @@
-mod cli_output;
-pub mod display;
-pub use cli_output::*;
-
-pub trait QuietDisplay: std::fmt::Display {
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        write!(w, "{}", self)
-    }
-}
-
-pub trait VerboseDisplay: std::fmt::Display {
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        write!(w, "{}", self)
-    }
-}
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.5.6"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -16,40 +16,40 @@ clap = "2.33.1"
 criterion-stats = "0.3.0"
 ctrlc = { version = "3.1.5", features = ["termination"] }
 console = "0.11.3"
-dirs-next = "2.0.0"
-log = "0.4.11"
+dirs = "2.0.2"
+log = "0.4.8"
 Inflector = "0.11.4"
 indicatif = "0.15.0"
 humantime = "2.0.1"
 num-traits = "0.2"
-pretty-hex = "0.2.1"
-reqwest = { version = "0.10.8", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+pretty-hex = "0.1.1"
+reqwest = { version = "0.10.6", default-features = false, features = ["blocking", "rustls-tls", "json"] }
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
-solana-account-decoder = { path = "../account-decoder", version = "1.5.6" }
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.5.6" }
-solana-clap-utils = { path = "../clap-utils", version = "1.5.6" }
-solana-cli-config = { path = "../cli-config", version = "1.5.6" }
-solana-cli-output = { path = "../cli-output", version = "1.5.6" }
-solana-client = { path = "../client", version = "1.5.6" }
-solana-config-program = { path = "../programs/config", version = "1.5.6" }
-solana-faucet = { path = "../faucet", version = "1.5.6" }
-solana-logger = { path = "../logger", version = "1.5.6" }
-solana-net-utils = { path = "../net-utils", version = "1.5.6" }
-solana_rbpf = "=0.2.4"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.5.6" }
-solana-sdk = { path = "../sdk", version = "1.5.6" }
-solana-stake-program = { path = "../programs/stake", version = "1.5.6" }
-solana-transaction-status = { path = "../transaction-status", version = "1.5.6" }
-solana-version = { path = "../version", version = "1.5.6" }
-solana-vote-program = { path = "../programs/vote", version = "1.5.6" }
-thiserror = "1.0.21"
-tiny-bip39 = "0.7.0"
+solana-account-decoder = { path = "../account-decoder", version = "1.3.2" }
+solana-budget-program = { path = "../programs/budget", version = "1.3.2" }
+solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
+solana-cli-config = { path = "../cli-config", version = "1.3.2" }
+solana-client = { path = "../client", version = "1.3.2" }
+solana-config-program = { path = "../programs/config", version = "1.3.2" }
+solana-faucet = { path = "../faucet", version = "1.3.2" }
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-net-utils = { path = "../net-utils", version = "1.3.2" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.3.2" }
+solana-runtime = { path = "../runtime", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-stake-program = { path = "../programs/stake", version = "1.3.2" }
+solana-transaction-status = { path = "../transaction-status", version = "1.3.2" }
+solana-version = { path = "../version", version = "1.3.2" }
+solana-vote-program = { path = "../programs/vote", version = "1.3.2" }
+solana-vote-signer = { path = "../vote-signer", version = "1.3.2" }
+thiserror = "1.0.20"
 url = "2.1.1"

 [dev-dependencies]
-solana-core = { path = "../core", version = "1.5.6" }
+solana-core = { path = "../core", version = "1.3.2" }
+solana-budget-program = { path = "../programs/budget", version = "1.3.2" }
 tempfile = "3.1.0"

 [[bin]]
--- a/cli/src/checks.rs
+++ b/cli/src/checks.rs
@@ -54,42 +54,12 @@ pub fn check_account_for_multiple_fees_with_commitment(
    fee_calculator: &FeeCalculator,
    messages: &[&Message],
    commitment: CommitmentConfig,
-) -> Result<(), CliError> {
-    check_account_for_spend_multiple_fees_with_commitment(
-        rpc_client,
-        account_pubkey,
-        0,
-        fee_calculator,
-        messages,
-        commitment,
-    )
-}
-
-pub fn check_account_for_spend_multiple_fees_with_commitment(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    balance: u64,
-    fee_calculator: &FeeCalculator,
-    messages: &[&Message],
-    commitment: CommitmentConfig,
 ) -> Result<(), CliError> {
    let fee = calculate_fee(fee_calculator, messages);
-    if !check_account_for_balance_with_commitment(
-        rpc_client,
-        account_pubkey,
-        balance + fee,
-        commitment,
-    )
-    .map_err(Into::<ClientError>::into)?
+    if !check_account_for_balance_with_commitment(rpc_client, account_pubkey, fee, commitment)
+        .map_err(Into::<ClientError>::into)?
    {
-        if balance > 0 {
-            return Err(CliError::InsufficientFundsForSpendAndFee(
-                lamports_to_sol(balance),
-                lamports_to_sol(fee),
-            ));
-        } else {
-            return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
-        }
+        return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
    }
    Ok(())
 }
@@ -161,7 +131,7 @@ mod tests {
            context: RpcResponseContext { slot: 1 },
            value: json!(account_balance),
        });
-        let pubkey = solana_sdk::pubkey::new_rand();
+        let pubkey = Pubkey::new_rand();
        let fee_calculator = FeeCalculator::new(1);

        let pubkey0 = Pubkey::new(&[0; 32]);
@@ -221,7 +191,7 @@ mod tests {
            context: RpcResponseContext { slot: 1 },
            value: json!(account_balance),
        });
-        let pubkey = solana_sdk::pubkey::new_rand();
+        let pubkey = Pubkey::new_rand();

        let mut mocks = HashMap::new();
        mocks.insert(RpcRequest::GetBalance, account_balance_response);
@@ -267,9 +237,9 @@ mod tests {

    #[test]
    fn test_check_unique_pubkeys() {
-        let pubkey0 = solana_sdk::pubkey::new_rand();
+        let pubkey0 = Pubkey::new_rand();
        let pubkey_clone = pubkey0;
-        let pubkey1 = solana_sdk::pubkey::new_rand();
+        let pubkey1 = Pubkey::new_rand();

        check_unique_pubkeys((&pubkey0, "foo".to_string()), (&pubkey1, "bar".to_string()))
            .expect("unexpected result");
--- a/cli/src/cli.rs
+++ b/cli/src/cli.rs
--- a/cli-output/src/cli_output.rs
+++ b/cli-output/src/cli_output.rs
--- a/cli/src/cluster_query.rs
+++ b/cli/src/cluster_query.rs
--- a/cli-output/src/display.rs
+++ b/cli-output/src/display.rs
@@ -1,78 +1,16 @@
-use {
-    crate::cli_output::CliSignatureVerificationStatus,
-    chrono::{DateTime, NaiveDateTime, SecondsFormat, Utc},
-    console::style,
-    indicatif::{ProgressBar, ProgressStyle},
-    solana_sdk::{
-        clock::UnixTimestamp, hash::Hash, native_token::lamports_to_sol,
-        program_utils::limited_deserialize, transaction::Transaction,
-    },
-    solana_transaction_status::UiTransactionStatusMeta,
-    std::{collections::HashMap, fmt, io},
+use crate::cli::SettingType;
+use console::style;
+use indicatif::{ProgressBar, ProgressStyle};
+use solana_sdk::{
+    hash::Hash, native_token::lamports_to_sol, program_utils::limited_deserialize,
+    transaction::Transaction,
 };
-
-#[derive(Clone, Debug)]
-pub struct BuildBalanceMessageConfig {
-    pub use_lamports_unit: bool,
-    pub show_unit: bool,
-    pub trim_trailing_zeros: bool,
-}
-
-impl Default for BuildBalanceMessageConfig {
-    fn default() -> Self {
-        Self {
-            use_lamports_unit: false,
-            show_unit: true,
-            trim_trailing_zeros: true,
-        }
-    }
-}
-
-pub fn build_balance_message_with_config(
-    lamports: u64,
-    config: &BuildBalanceMessageConfig,
-) -> String {
-    let value = if config.use_lamports_unit {
-        lamports.to_string()
-    } else {
-        let sol = lamports_to_sol(lamports);
-        let sol_str = format!("{:.9}", sol);
-        if config.trim_trailing_zeros {
-            sol_str
-                .trim_end_matches('0')
-                .trim_end_matches('.')
-                .to_string()
-        } else {
-            sol_str
-        }
-    };
-    let unit = if config.show_unit {
-        if config.use_lamports_unit {
-            let ess = if lamports == 1 { "" } else { "s" };
-            format!(" lamport{}", ess)
-        } else {
-            " SOL".to_string()
-        }
-    } else {
-        "".to_string()
-    };
-    format!("{}{}", value, unit)
-}
-
-pub fn build_balance_message(lamports: u64, use_lamports_unit: bool, show_unit: bool) -> String {
-    build_balance_message_with_config(
-        lamports,
-        &BuildBalanceMessageConfig {
-            use_lamports_unit,
-            show_unit,
-            ..BuildBalanceMessageConfig::default()
-        },
-    )
-}
+use solana_transaction_status::UiTransactionStatusMeta;
+use std::{collections::HashMap, fmt, io};

 // Pretty print a "name value"
 pub fn println_name_value(name: &str, value: &str) {
-    let styled_value = if value.is_empty() {
+    let styled_value = if value == "" {
        style("(not set)").italic()
    } else {
        style(value)
@@ -80,8 +18,8 @@ pub fn println_name_value(name: &str, value: &str) {
    println!("{} {}", style(name).bold(), styled_value);
 }

-pub fn writeln_name_value(f: &mut dyn fmt::Write, name: &str, value: &str) -> fmt::Result {
-    let styled_value = if value.is_empty() {
+pub fn writeln_name_value(f: &mut fmt::Formatter, name: &str, value: &str) -> fmt::Result {
+    let styled_value = if value == "" {
        style("(not set)").italic()
    } else {
        style(value)
@@ -102,6 +40,21 @@ pub fn format_labeled_address(pubkey: &str, address_labels: &HashMap<String, Str
    }
 }

+pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) {
+    let description = match setting_type {
+        SettingType::Explicit => "",
+        SettingType::Computed => "(computed)",
+        SettingType::SystemDefault => "(default)",
+    };
+
+    println!(
+        "{} {} {}",
+        style(name).bold(),
+        style(value),
+        style(description).italic(),
+    );
+}
+
 pub fn println_signers(
    blockhash: &Hash,
    signers: &[String],
@@ -130,7 +83,6 @@ pub fn write_transaction<W: io::Write>(
    transaction: &Transaction,
    transaction_status: &Option<UiTransactionStatusMeta>,
    prefix: &str,
-    sigverify_status: Option<&[CliSignatureVerificationStatus]>,
 ) -> io::Result<()> {
    let message = &transaction.message;
    writeln!(
@@ -138,24 +90,11 @@ pub fn write_transaction<W: io::Write>(
        "{}Recent Blockhash: {:?}",
        prefix, message.recent_blockhash
    )?;
-    let sigverify_statuses = if let Some(sigverify_status) = sigverify_status {
-        sigverify_status
-            .iter()
-            .map(|s| format!(" ({})", s))
-            .collect()
-    } else {
-        vec!["".to_string(); transaction.signatures.len()]
-    };
-    for (signature_index, (signature, sigverify_status)) in transaction
-        .signatures
-        .iter()
-        .zip(&sigverify_statuses)
-        .enumerate()
-    {
+    for (signature_index, signature) in transaction.signatures.iter().enumerate() {
        writeln!(
            w,
-            "{}Signature {}: {:?}{}",
-            prefix, signature_index, signature, sigverify_status,
+            "{}Signature {}: {:?}",
+            prefix, signature_index, signature
        )?;
    }
    writeln!(w, "{}{:?}", prefix, message.header)?;
@@ -223,7 +162,7 @@ pub fn write_transaction<W: io::Write>(
        )?;
        writeln!(
            w,
-            "{}  Fee: ◎{}",
+            "{}  Fee: {} SOL",
            prefix,
            lamports_to_sol(transaction_status.fee)
        )?;
@@ -240,7 +179,7 @@ pub fn write_transaction<W: io::Write>(
            if pre == post {
                writeln!(
                    w,
-                    "{}  Account {} balance: ◎{}",
+                    "{}  Account {} balance: {} SOL",
                    prefix,
                    i,
                    lamports_to_sol(*pre)
@@ -248,7 +187,7 @@ pub fn write_transaction<W: io::Write>(
            } else {
                writeln!(
                    w,
-                    "{}  Account {} balance: ◎{} -> ◎{}",
+                    "{}  Account {} balance: {} SOL -> {} SOL",
                    prefix,
                    i,
                    lamports_to_sol(*pre),
@@ -256,15 +195,6 @@ pub fn write_transaction<W: io::Write>(
                )?;
            }
        }
-
-        if let Some(log_messages) = &transaction_status.log_messages {
-            if !log_messages.is_empty() {
-                writeln!(w, "{}Log Messages:", prefix,)?;
-                for log_message in log_messages {
-                    writeln!(w, "{}  {}", prefix, log_message,)?;
-                }
-            }
-        }
    } else {
        writeln!(w, "{}Status: Unavailable", prefix)?;
    }
@@ -276,18 +206,9 @@ pub fn println_transaction(
    transaction: &Transaction,
    transaction_status: &Option<UiTransactionStatusMeta>,
    prefix: &str,
-    sigverify_status: Option<&[CliSignatureVerificationStatus]>,
 ) {
    let mut w = Vec::new();
-    if write_transaction(
-        &mut w,
-        transaction,
-        transaction_status,
-        prefix,
-        sigverify_status,
-    )
-    .is_ok()
-    {
+    if write_transaction(&mut w, transaction, transaction_status, prefix).is_ok() {
        if let Ok(s) = String::from_utf8(w) {
            print!("{}", s);
        }
@@ -303,13 +224,6 @@ pub fn new_spinner_progress_bar() -> ProgressBar {
    progress_bar
 }

-pub fn unix_timestamp_to_string(unix_timestamp: UnixTimestamp) -> String {
-    match NaiveDateTime::from_timestamp_opt(unix_timestamp, 0) {
-        Some(ndt) => DateTime::<Utc>::from_utc(ndt, Utc).to_rfc3339_opts(SecondsFormat::Secs, true),
-        None => format!("UnixTimestamp {}", unix_timestamp),
-    }
-}
-
 #[cfg(test)]
 mod test {
    use super::*;
--- a/cli/src/feature.rs
+++ b/cli/src/feature.rs
@@ -1,415 +0,0 @@
-use crate::{
-    cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
-};
-use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
-use console::style;
-use serde::{Deserialize, Serialize};
-use solana_clap_utils::{input_parsers::*, input_validators::*, keypair::*};
-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::{
-    clock::Slot,
-    feature::{self, Feature},
-    feature_set::FEATURE_NAMES,
-    message::Message,
-    pubkey::Pubkey,
-    transaction::Transaction,
-};
-use std::{collections::HashMap, fmt, sync::Arc};
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum ForceActivation {
-    No,
-    Almost,
-    Yes,
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FeatureCliCommand {
-    Status {
-        features: Vec<Pubkey>,
-    },
-    Activate {
-        feature: Pubkey,
-        force: ForceActivation,
-    },
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", tag = "status", content = "sinceSlot")]
-pub enum CliFeatureStatus {
-    Inactive,
-    Pending,
-    Active(Slot),
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliFeature {
-    pub id: String,
-    pub description: String,
-    #[serde(flatten)]
-    pub status: CliFeatureStatus,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliFeatures {
-    pub features: Vec<CliFeature>,
-    pub feature_activation_allowed: bool,
-    #[serde(skip)]
-    pub inactive: bool,
-}
-
-impl fmt::Display for CliFeatures {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.features.len() > 1 {
-            writeln!(
-                f,
-                "{}",
-                style(format!(
-                    "{:<44} {:<28} {}",
-                    "Feature", "Status", "Description"
-                ))
-                .bold()
-            )?;
-        }
-        for feature in &self.features {
-            writeln!(
-                f,
-                "{:<44} {:<28} {}",
-                feature.id,
-                match feature.status {
-                    CliFeatureStatus::Inactive => style("inactive".to_string()).red(),
-                    CliFeatureStatus::Pending => style("activation pending".to_string()).yellow(),
-                    CliFeatureStatus::Active(activation_slot) =>
-                        style(format!("active since slot {}", activation_slot)).green(),
-                },
-                feature.description,
-            )?;
-        }
-        if self.inactive && !self.feature_activation_allowed {
-            writeln!(
-                f,
-                "{}",
-                style("\nFeature activation is not allowed at this time")
-                    .bold()
-                    .red()
-            )?;
-        }
-        Ok(())
-    }
-}
-
-impl QuietDisplay for CliFeatures {}
-impl VerboseDisplay for CliFeatures {}
-
-pub trait FeatureSubCommands {
-    fn feature_subcommands(self) -> Self;
-}
-
-impl FeatureSubCommands for App<'_, '_> {
-    fn feature_subcommands(self) -> Self {
-        self.subcommand(
-            SubCommand::with_name("feature")
-                .about("Runtime feature management")
-                .setting(AppSettings::SubcommandRequiredElseHelp)
-                .subcommand(
-                    SubCommand::with_name("status")
-                        .about("Query runtime feature status")
-                        .arg(
-                            Arg::with_name("features")
-                                .value_name("ADDRESS")
-                                .validator(is_valid_pubkey)
-                                .index(1)
-                                .multiple(true)
-                                .help("Feature status to query [default: all known features]"),
-                        ),
-                )
-                .subcommand(
-                    SubCommand::with_name("activate")
-                        .about("Activate a runtime feature")
-                        .arg(
-                            Arg::with_name("feature")
-                                .value_name("FEATURE_KEYPAIR")
-                                .validator(is_valid_signer)
-                                .index(1)
-                                .required(true)
-                                .help("The signer for the feature to activate"),
-                        )
-                        .arg(
-                            Arg::with_name("force")
-                                .long("yolo")
-                                .hidden(true)
-                                .multiple(true)
-                                .help("Override activation sanity checks. Don't use this flag"),
-                        ),
-                ),
-        )
-    }
-}
-
-fn known_feature(feature: &Pubkey) -> Result<(), CliError> {
-    if FEATURE_NAMES.contains_key(feature) {
-        Ok(())
-    } else {
-        Err(CliError::BadParameter(format!(
-            "Unknown feature: {}",
-            feature
-        )))
-    }
-}
-
-pub fn parse_feature_subcommand(
-    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let response = match matches.subcommand() {
-        ("activate", Some(matches)) => {
-            let (feature_signer, feature) = signer_of(matches, "feature", wallet_manager)?;
-            let mut signers = vec![default_signer.signer_from_path(matches, wallet_manager)?];
-
-            let force = match matches.occurrences_of("force") {
-                2 => ForceActivation::Yes,
-                1 => ForceActivation::Almost,
-                _ => ForceActivation::No,
-            };
-
-            signers.push(feature_signer.unwrap());
-            let feature = feature.unwrap();
-
-            known_feature(&feature)?;
-
-            CliCommandInfo {
-                command: CliCommand::Feature(FeatureCliCommand::Activate { feature, force }),
-                signers,
-            }
-        }
-        ("status", Some(matches)) => {
-            let mut features = if let Some(features) = pubkeys_of(matches, "features") {
-                for feature in &features {
-                    known_feature(feature)?;
-                }
-                features
-            } else {
-                FEATURE_NAMES.keys().cloned().collect()
-            };
-            features.sort();
-            CliCommandInfo {
-                command: CliCommand::Feature(FeatureCliCommand::Status { features }),
-                signers: vec![],
-            }
-        }
-        _ => unreachable!(),
-    };
-    Ok(response)
-}
-
-pub fn process_feature_subcommand(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    feature_subcommand: &FeatureCliCommand,
-) -> ProcessResult {
-    match feature_subcommand {
-        FeatureCliCommand::Status { features } => process_status(rpc_client, config, features),
-        FeatureCliCommand::Activate { feature, force } => {
-            process_activate(rpc_client, config, *feature, *force)
-        }
-    }
-}
-
-fn active_stake_by_feature_set(rpc_client: &RpcClient) -> Result<HashMap<u32, u64>, ClientError> {
-    // Validator identity -> feature set
-    let feature_set_map = rpc_client
-        .get_cluster_nodes()?
-        .into_iter()
-        .map(|contact_info| (contact_info.pubkey, contact_info.feature_set))
-        .collect::<HashMap<_, _>>();
-
-    let vote_accounts = rpc_client.get_vote_accounts()?;
-
-    let total_active_stake: u64 = vote_accounts
-        .current
-        .iter()
-        .chain(vote_accounts.delinquent.iter())
-        .map(|vote_account| vote_account.activated_stake)
-        .sum();
-
-    // Sum all active stake by feature set
-    let mut active_stake_by_feature_set = 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;
-        }
-    }
-
-    // Convert active stake to a percentage so the caller doesn't need `total_active_stake`
-    for (_, val) in active_stake_by_feature_set.iter_mut() {
-        *val = *val * 100 / total_active_stake;
-    }
-    Ok(active_stake_by_feature_set)
-}
-
-// Feature activation is only allowed when 95% of the active stake is on the current feature set
-fn feature_activation_allowed(rpc_client: &RpcClient, quiet: bool) -> Result<bool, ClientError> {
-    let my_feature_set = solana_version::Version::default().feature_set;
-
-    let active_stake_by_feature_set = active_stake_by_feature_set(rpc_client)?;
-
-    let feature_activation_allowed = active_stake_by_feature_set
-        .get(&my_feature_set)
-        .map(|percentage| *percentage >= 95)
-        .unwrap_or(false);
-
-    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 {
-            println!(
-                "{}",
-                style("To activate features the stake must be >= 95%").bold()
-            );
-        }
-        println!(
-            "{}",
-            style(format!("Tool Feture Set: {}", my_feature_set)).bold()
-        );
-        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 - {}%", percentage);
-            } else {
-                println!(
-                    "{} - {}% {}",
-                    feature_set,
-                    percentage,
-                    if *feature_set == my_feature_set {
-                        " <-- me"
-                    } else {
-                        ""
-                    }
-                );
-            }
-        }
-        println!();
-    }
-
-    Ok(feature_activation_allowed)
-}
-
-fn process_status(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    feature_ids: &[Pubkey],
-) -> ProcessResult {
-    let mut features: Vec<CliFeature> = vec![];
-    let mut inactive = false;
-    for (i, account) in rpc_client
-        .get_multiple_accounts(feature_ids)?
-        .into_iter()
-        .enumerate()
-    {
-        let feature_id = &feature_ids[i];
-        let feature_name = FEATURE_NAMES.get(feature_id).unwrap();
-        if let Some(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(),
-                    status: feature_status,
-                });
-                continue;
-            }
-        }
-        inactive = true;
-        features.push(CliFeature {
-            id: feature_id.to_string(),
-            description: feature_name.to_string(),
-            status: CliFeatureStatus::Inactive,
-        });
-    }
-
-    let feature_activation_allowed = feature_activation_allowed(rpc_client, features.len() <= 1)?;
-    let feature_set = CliFeatures {
-        features,
-        feature_activation_allowed,
-        inactive,
-    };
-    Ok(config.output_format.formatted_string(&feature_set))
-}
-
-fn process_activate(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    feature_id: Pubkey,
-    force: ForceActivation,
-) -> ProcessResult {
-    let account = rpc_client
-        .get_multiple_accounts(&[feature_id])?
-        .into_iter()
-        .next()
-        .unwrap();
-
-    if let Some(account) = account {
-        if feature::from_account(&account).is_some() {
-            return Err(format!("{} has already been activated", feature_id).into());
-        }
-    }
-
-    if !feature_activation_allowed(rpc_client, false)? {
-        match force {
-        ForceActivation::Almost =>
-            return Err("Add force argument once more to override the sanity check to force feature activation ".into()),
-        ForceActivation::Yes => println!("FEATURE ACTIVATION FORCED"),
-        ForceActivation::No =>
-            return Err("Feature activation is not allowed at this time".into()),
-        }
-    }
-
-    let rent = rpc_client.get_minimum_balance_for_rent_exemption(Feature::size_of())?;
-
-    let (blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let (message, _) = resolve_spend_tx_and_check_account_balance(
-        rpc_client,
-        false,
-        SpendAmount::Some(rent),
-        &fee_calculator,
-        &config.signers[0].pubkey(),
-        |lamports| {
-            Message::new(
-                &feature::activate_with_lamports(
-                    &feature_id,
-                    &config.signers[0].pubkey(),
-                    lamports,
-                ),
-                Some(&config.signers[0].pubkey()),
-            )
-        },
-        config.commitment,
-    )?;
-    let mut transaction = Transaction::new_unsigned(message);
-    transaction.try_sign(&config.signers, blockhash)?;
-
-    println!(
-        "Activating {} ({})",
-        FEATURE_NAMES.get(&feature_id).unwrap(),
-        feature_id
-    );
-    rpc_client.send_and_confirm_transaction_with_spinner(&transaction)?;
-    Ok("".to_string())
-}
--- a/cli/src/inflation.rs
+++ b/cli/src/inflation.rs
@@ -1,51 +0,0 @@
-use crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult};
-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 std::sync::Arc;
-
-#[derive(Debug, PartialEq)]
-pub enum InflationCliCommand {
-    Show,
-}
-
-pub trait InflationSubCommands {
-    fn inflation_subcommands(self) -> Self;
-}
-
-impl InflationSubCommands for App<'_, '_> {
-    fn inflation_subcommands(self) -> Self {
-        self.subcommand(SubCommand::with_name("inflation").about("Show inflation information"))
-    }
-}
-
-pub fn parse_inflation_subcommand(
-    _matches: &ArgMatches<'_>,
-    _default_signer: &DefaultSigner,
-    _wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    Ok(CliCommandInfo {
-        command: CliCommand::Inflation(InflationCliCommand::Show),
-        signers: vec![],
-    })
-}
-
-pub fn process_inflation_subcommand(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    inflation_subcommand: &InflationCliCommand,
-) -> ProcessResult {
-    assert_eq!(*inflation_subcommand, InflationCliCommand::Show);
-
-    let governor = rpc_client.get_inflation_governor()?;
-    let current_rate = rpc_client.get_inflation_rate()?;
-
-    let inflation = CliInflation {
-        governor,
-        current_rate,
-    };
-
-    Ok(config.output_format.formatted_string(&inflation))
-}
--- a/cli/src/lib.rs
+++ b/cli/src/lib.rs
@@ -18,16 +18,16 @@ macro_rules! pubkey {
    };
 }

+#[macro_use]
 extern crate serde_derive;

 pub mod checks;
 pub mod cli;
+pub mod cli_output;
 pub mod cluster_query;
-pub mod feature;
-pub mod inflation;
+pub mod display;
 pub mod nonce;
-pub mod program;
-pub mod send_tpu;
+pub mod offline;
 pub mod spend_utils;
 pub mod stake;
 pub mod test_utils;
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -3,36 +3,24 @@ use clap::{
    SubCommand,
 };
 use console::style;
+
 use solana_clap_utils::{
-    input_validators::{is_url, is_url_or_moniker, normalize_to_url_if_moniker},
-    keypair::{CliSigners, DefaultSigner, SKIP_SEED_PHRASE_VALIDATION_ARG},
-    DisplayError,
+    commitment::COMMITMENT_ARG, input_parsers::commitment_of, input_validators::is_url,
+    keypair::SKIP_SEED_PHRASE_VALIDATION_ARG, DisplayError,
 };
-use solana_cli::cli::{
-    app, parse_command, process_command, CliCommandInfo, CliConfig, SettingType,
-    DEFAULT_RPC_TIMEOUT_SECONDS,
+use solana_cli::{
+    cli::{
+        app, parse_command, process_command, CliCommandInfo, CliConfig, CliSigners,
+        DEFAULT_RPC_TIMEOUT_SECONDS,
+    },
+    cli_output::OutputFormat,
+    display::{println_name_value, println_name_value_or},
 };
 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;
 use std::{collections::HashMap, error, path::PathBuf, sync::Arc, time::Duration};

-pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) {
-    let description = match setting_type {
-        SettingType::Explicit => "",
-        SettingType::Computed => "(computed)",
-        SettingType::SystemDefault => "(default)",
-    };
-
-    println!(
-        "{} {} {}",
-        style(name).bold(),
-        style(value),
-        style(description).italic(),
-    );
-}
-
 fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error>> {
    let parse_args = match matches.subcommand() {
        ("config", Some(matches)) => {
@@ -60,19 +48,12 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    );
                    let (keypair_setting_type, keypair_path) =
                        CliConfig::compute_keypair_path_setting("", &config.keypair_path);
-                    let (commitment_setting_type, commitment) =
-                        CliConfig::compute_commitment_config("", &config.commitment);

                    if let Some(field) = subcommand_matches.value_of("specific_setting") {
                        let (field_name, value, setting_type) = match field {
                            "json_rpc_url" => ("RPC URL", json_rpc_url, url_setting_type),
                            "websocket_url" => ("WebSocket URL", websocket_url, ws_setting_type),
                            "keypair" => ("Key Path", keypair_path, keypair_setting_type),
-                            "commitment" => (
-                                "Commitment",
-                                commitment.commitment.to_string(),
-                                commitment_setting_type,
-                            ),
                            _ => unreachable!(),
                        };
                        println_name_value_or(&format!("{}:", field_name), &value, setting_type);
@@ -81,16 +62,11 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                        println_name_value_or("RPC URL:", &json_rpc_url, url_setting_type);
                        println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
                        println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
-                        println_name_value_or(
-                            "Commitment:",
-                            &commitment.commitment.to_string(),
-                            commitment_setting_type,
-                        );
                    }
                }
                ("set", Some(subcommand_matches)) => {
                    if let Some(url) = subcommand_matches.value_of("json_rpc_url") {
-                        config.json_rpc_url = normalize_to_url_if_moniker(url);
+                        config.json_rpc_url = url.to_string();
                        // Revert to a computed `websocket_url` value when `json_rpc_url` is
                        // changed
                        config.websocket_url = "".to_string();
@@ -101,9 +77,6 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    if let Some(keypair) = subcommand_matches.value_of("keypair") {
                        config.keypair_path = keypair.to_string();
                    }
-                    if let Some(commitment) = subcommand_matches.value_of("commitment") {
-                        config.commitment = commitment.to_string();
-                    }

                    config.save(config_file)?;

@@ -117,18 +90,11 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    );
                    let (keypair_setting_type, keypair_path) =
                        CliConfig::compute_keypair_path_setting("", &config.keypair_path);
-                    let (commitment_setting_type, commitment) =
-                        CliConfig::compute_commitment_config("", &config.commitment);

                    println_name_value("Config File:", config_file);
                    println_name_value_or("RPC URL:", &json_rpc_url, url_setting_type);
                    println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
                    println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
-                    println_name_value_or(
-                        "Commitment:",
-                        &commitment.commitment.to_string(),
-                        commitment_setting_type,
-                    );
                }
                ("import-address-labels", Some(subcommand_matches)) => {
                    let filename = value_t_or_exit!(subcommand_matches, "filename", PathBuf);
@@ -173,31 +139,14 @@ pub fn parse_args<'a>(
        matches.value_of("json_rpc_url").unwrap_or(""),
        &config.json_rpc_url,
    );
-    let default_signer_arg_name = "keypair".to_string();
    let (_, default_signer_path) = CliConfig::compute_keypair_path_setting(
-        matches.value_of(&default_signer_arg_name).unwrap_or(""),
+        matches.value_of("keypair").unwrap_or(""),
        &config.keypair_path,
    );

-    let default_signer = DefaultSigner {
-        arg_name: default_signer_arg_name,
-        path: default_signer_path.clone(),
-    };
+    let CliCommandInfo { command, signers } =
+        parse_command(&matches, &default_signer_path, &mut wallet_manager)?;

-    let CliCommandInfo {
-        command,
-        mut signers,
-    } = parse_command(&matches, &default_signer, &mut wallet_manager)?;
-
-    if signers.is_empty() {
-        if let Ok(signer_info) =
-            default_signer.generate_unique_signers(vec![None], matches, &mut wallet_manager)
-        {
-            signers.extend(signer_info.signers);
-        }
-    }
-
-    let verbose = matches.is_present("verbose");
    let output_format = matches
        .value_of("output_format")
        .map(|value| match value {
@@ -205,16 +154,13 @@ pub fn parse_args<'a>(
            "json-compact" => OutputFormat::JsonCompact,
            _ => unreachable!(),
        })
-        .unwrap_or(if verbose {
-            OutputFormat::DisplayVerbose
-        } else {
-            OutputFormat::Display
-        });
+        .unwrap_or(OutputFormat::Display);

-    let (_, commitment) = CliConfig::compute_commitment_config(
-        matches.value_of("commitment").unwrap_or(""),
-        &config.commitment,
-    );
+    let commitment = matches
+        .subcommand_name()
+        .and_then(|name| matches.subcommand_matches(name))
+        .and_then(|sub_matches| commitment_of(sub_matches, COMMITMENT_ARG.long))
+        .unwrap_or_default();

    let address_labels = if matches.is_present("no_address_labels") {
        HashMap::new()
@@ -231,13 +177,10 @@ pub fn parse_args<'a>(
            keypair_path: default_signer_path,
            rpc_client: None,
            rpc_timeout,
-            verbose,
+            verbose: matches.is_present("verbose"),
            output_format,
            commitment,
-            send_transaction_config: RpcSendTransactionConfig {
-                preflight_commitment: Some(commitment.commitment),
-                ..RpcSendTransactionConfig::default()
-            },
+            send_transaction_config: RpcSendTransactionConfig::default(),
            address_labels,
        },
        signers,
@@ -245,7 +188,7 @@ pub fn parse_args<'a>(
 }

 fn main() -> Result<(), Box<dyn error::Error>> {
-    solana_logger::setup_with_default("off");
+    solana_logger::setup();
    let matches = app(
        crate_name!(),
        crate_description!(),
@@ -269,14 +212,11 @@ fn main() -> Result<(), Box<dyn error::Error>> {
        Arg::with_name("json_rpc_url")
            .short("u")
            .long("url")
-            .value_name("URL_OR_MONIKER")
+            .value_name("URL")
            .takes_value(true)
            .global(true)
-            .validator(is_url_or_moniker)
-            .help(
-                "URL for Solana's JSON RPC or moniker (or their first letter): \
-                   [mainnet-beta, testnet, devnet, localhost]",
-            ),
+            .validator(is_url)
+            .help("JSON RPC URL for the solana cluster"),
    )
    .arg(
        Arg::with_name("websocket_url")
@@ -296,25 +236,6 @@ fn main() -> Result<(), Box<dyn error::Error>> {
            .takes_value(true)
            .help("Filepath or URL to a keypair"),
    )
-    .arg(
-        Arg::with_name("commitment")
-            .long("commitment")
-            .takes_value(true)
-            .possible_values(&[
-                "processed",
-                "confirmed",
-                "finalized",
-                "recent", // Deprecated as of v1.5.5
-                "single", // Deprecated as of v1.5.5
-                "singleGossip", // Deprecated as of v1.5.5
-                "root", // Deprecated as of v1.5.5
-                "max", // Deprecated as of v1.5.5
-            ])
-            .value_name("COMMITMENT_LEVEL")
-            .hide_possible_values(true)
-            .global(true)
-            .help("Return information at the selected commitment level [possible values: processed, confirmed, finalized]"),
-    )
    .arg(
        Arg::with_name("verbose")
            .long("verbose")
@@ -366,12 +287,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                            .index(1)
                            .value_name("CONFIG_FIELD")
                            .takes_value(true)
-                            .possible_values(&[
-                                "json_rpc_url",
-                                "websocket_url",
-                                "keypair",
-                                "commitment",
-                            ])
+                            .possible_values(&["json_rpc_url", "websocket_url", "keypair"])
                            .help("Return a specific config setting"),
                    ),
            )
@@ -380,7 +296,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                    .about("Set a config setting")
                    .group(
                        ArgGroup::with_name("config_settings")
-                            .args(&["json_rpc_url", "websocket_url", "keypair", "commitment"])
+                            .args(&["json_rpc_url", "websocket_url", "keypair"])
                            .multiple(true)
                            .required(true),
                    ),
--- a/cli/src/nonce.rs
+++ b/cli/src/nonce.rs
@@ -1,26 +1,29 @@
 use crate::{
    checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
    cli::{
-        log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
-        ProcessResult,
+        generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
+        CliConfig, CliError, ProcessResult, SignerIndex,
    },
+    cli_output::CliNonceAccount,
    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{
-    input_parsers::*,
-    input_validators::*,
-    keypair::{DefaultSigner, SignerIndex},
-    nonce::*,
+    input_parsers::*, input_validators::*, offline::BLOCKHASH_ARG, ArgConstant,
 };
-use solana_cli_output::CliNonceAccount;
-use solana_client::{nonce_utils::*, rpc_client::RpcClient};
+use solana_client::rpc_client::RpcClient;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
    account::Account,
+    account_utils::StateMut,
+    commitment_config::CommitmentConfig,
    hash::Hash,
    message::Message,
-    nonce::{self, State},
+    nonce::{
+        self,
+        state::{Data, Versions},
+        State,
+    },
    pubkey::Pubkey,
    system_instruction::{
        advance_nonce_account, authorize_nonce_account, create_nonce_account,
@@ -30,11 +33,64 @@ use solana_sdk::{
    transaction::Transaction,
 };
 use std::sync::Arc;
+use thiserror::Error;
+
+#[derive(Debug, Error, PartialEq)]
+pub enum CliNonceError {
+    #[error("invalid account owner")]
+    InvalidAccountOwner,
+    #[error("invalid account data")]
+    InvalidAccountData,
+    #[error("unexpected account data size")]
+    UnexpectedDataSize,
+    #[error("query hash does not match stored hash")]
+    InvalidHash,
+    #[error("query authority does not match account authority")]
+    InvalidAuthority,
+    #[error("invalid state for requested operation")]
+    InvalidStateForOperation,
+    #[error("client error: {0}")]
+    Client(String),
+}
+
+pub const NONCE_ARG: ArgConstant<'static> = ArgConstant {
+    name: "nonce",
+    long: "nonce",
+    help: "Provide the nonce account to use when creating a nonced \n\
+           transaction. Nonced transactions are useful when a transaction \n\
+           requires a lengthy signing process. Learn more about nonced \n\
+           transactions at https://docs.solana.com/offline-signing/durable-nonce",
+};
+
+pub const NONCE_AUTHORITY_ARG: ArgConstant<'static> = ArgConstant {
+    name: "nonce_authority",
+    long: "nonce-authority",
+    help: "Provide the nonce authority keypair to use when signing a nonced transaction",
+};

 pub trait NonceSubCommands {
    fn nonce_subcommands(self) -> Self;
 }

+pub fn nonce_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(NONCE_ARG.name)
+        .long(NONCE_ARG.long)
+        .takes_value(true)
+        .value_name("PUBKEY")
+        .requires(BLOCKHASH_ARG.name)
+        .validator(is_valid_pubkey)
+        .help(NONCE_ARG.help)
+}
+
+pub fn nonce_authority_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(NONCE_AUTHORITY_ARG.name)
+        .long(NONCE_AUTHORITY_ARG.long)
+        .takes_value(true)
+        .value_name("KEYPAIR")
+        .validator(is_valid_signer)
+        .help(NONCE_AUTHORITY_ARG.help)
+}
+
 impl NonceSubCommands for App<'_, '_> {
    fn nonce_subcommands(self) -> Self {
        self.subcommand(
@@ -164,9 +220,64 @@ impl NonceSubCommands for App<'_, '_> {
    }
 }

+pub fn get_account(
+    rpc_client: &RpcClient,
+    nonce_pubkey: &Pubkey,
+) -> Result<Account, CliNonceError> {
+    get_account_with_commitment(rpc_client, nonce_pubkey, CommitmentConfig::default())
+}
+
+pub fn get_account_with_commitment(
+    rpc_client: &RpcClient,
+    nonce_pubkey: &Pubkey,
+    commitment: CommitmentConfig,
+) -> Result<Account, CliNonceError> {
+    rpc_client
+        .get_account_with_commitment(nonce_pubkey, commitment)
+        .map_err(|e| CliNonceError::Client(format!("{}", e)))
+        .and_then(|result| {
+            result.value.ok_or_else(|| {
+                CliNonceError::Client(format!("AccountNotFound: pubkey={}", nonce_pubkey))
+            })
+        })
+        .and_then(|a| match account_identity_ok(&a) {
+            Ok(()) => Ok(a),
+            Err(e) => Err(e),
+        })
+}
+
+pub fn account_identity_ok(account: &Account) -> Result<(), CliNonceError> {
+    if account.owner != system_program::id() {
+        Err(CliNonceError::InvalidAccountOwner)
+    } else if account.data.is_empty() {
+        Err(CliNonceError::UnexpectedDataSize)
+    } else {
+        Ok(())
+    }
+}
+
+pub fn state_from_account(account: &Account) -> Result<State, CliNonceError> {
+    account_identity_ok(account)?;
+    StateMut::<Versions>::state(account)
+        .map_err(|_| CliNonceError::InvalidAccountData)
+        .map(|v| v.convert_to_current())
+}
+
+pub fn data_from_account(account: &Account) -> Result<Data, CliNonceError> {
+    account_identity_ok(account)?;
+    state_from_account(account).and_then(|ref s| data_from_state(s).map(|d| d.clone()))
+}
+
+pub fn data_from_state(state: &State) -> Result<&Data, CliNonceError> {
+    match state {
+        State::Uninitialized => Err(CliNonceError::InvalidStateForOperation),
+        State::Initialized(data) => Ok(data),
+    }
+}
+
 pub fn parse_authorize_nonce_account(
    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
+    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
    let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -175,9 +286,10 @@ pub fn parse_authorize_nonce_account(
        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;

    let payer_provided = None;
-    let signer_info = default_signer.generate_unique_signers(
+    let signer_info = generate_unique_signers(
        vec![payer_provided, nonce_authority],
        matches,
+        default_signer_path,
        wallet_manager,
    )?;

@@ -193,7 +305,7 @@ pub fn parse_authorize_nonce_account(

 pub fn parse_nonce_create_account(
    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
+    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
    let (nonce_account, nonce_account_pubkey) =
@@ -203,9 +315,10 @@ pub fn parse_nonce_create_account(
    let nonce_authority = pubkey_of_signer(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;

    let payer_provided = None;
-    let signer_info = default_signer.generate_unique_signers(
+    let signer_info = generate_unique_signers(
        vec![payer_provided, nonce_account],
        matches,
+        default_signer_path,
        wallet_manager,
    )?;

@@ -235,7 +348,7 @@ pub fn parse_get_nonce(

 pub fn parse_new_nonce(
    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
+    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
    let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -243,9 +356,10 @@ pub fn parse_new_nonce(
        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;

    let payer_provided = None;
-    let signer_info = default_signer.generate_unique_signers(
+    let signer_info = generate_unique_signers(
        vec![payer_provided, nonce_authority],
        matches,
+        default_signer_path,
        wallet_manager,
    )?;

@@ -277,7 +391,7 @@ pub fn parse_show_nonce_account(

 pub fn parse_withdraw_from_nonce_account(
    matches: &ArgMatches<'_>,
-    default_signer: &DefaultSigner,
+    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
    let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -288,9 +402,10 @@ pub fn parse_withdraw_from_nonce_account(
        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;

    let payer_provided = None;
-    let signer_info = default_signer.generate_unique_signers(
+    let signer_info = generate_unique_signers(
        vec![payer_provided, nonce_authority],
        matches,
+        default_signer_path,
        wallet_manager,
    )?;

@@ -314,14 +429,14 @@ pub fn check_nonce_account(
    match state_from_account(nonce_account)? {
        State::Initialized(ref data) => {
            if &data.blockhash != nonce_hash {
-                Err(Error::InvalidHash.into())
+                Err(CliNonceError::InvalidHash.into())
            } else if nonce_authority != &data.authority {
-                Err(Error::InvalidAuthority.into())
+                Err(CliNonceError::InvalidAuthority.into())
            } else {
                Ok(())
            }
        }
-        State::Uninitialized => Err(Error::InvalidStateForOperation.into()),
+        State::Uninitialized => Err(CliNonceError::InvalidStateForOperation.into()),
    }
 }

@@ -332,7 +447,9 @@ pub fn process_authorize_nonce_account(
    nonce_authority: SignerIndex,
    new_authority: &Pubkey,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;

    let nonce_authority = config.signers[nonce_authority];
    let ix = authorize_nonce_account(nonce_account, &nonce_authority.pubkey(), new_authority);
@@ -347,7 +464,11 @@ pub fn process_authorize_nonce_account(
        &tx.message,
        config.commitment,
    )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
    log_instruction_custom_error::<NonceError>(result, &config)
 }

@@ -394,7 +515,9 @@ pub fn process_create_nonce_account(
        Message::new(&ixs, Some(&config.signers[0].pubkey()))
    };

-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;

    let (message, lamports) = resolve_spend_tx_and_check_account_balance(
        rpc_client,
@@ -406,7 +529,9 @@ pub fn process_create_nonce_account(
        config.commitment,
    )?;

-    if let Ok(nonce_account) = get_account(rpc_client, &nonce_account_address) {
+    if let Ok(nonce_account) =
+        get_account_with_commitment(rpc_client, &nonce_account_address, config.commitment)
+    {
        let err_msg = if state_from_account(&nonce_account).is_ok() {
            format!("Nonce account {} already exists", nonce_account_address)
        } else {
@@ -429,7 +554,11 @@ pub fn process_create_nonce_account(

    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
    log_instruction_custom_error::<SystemError>(result, &config)
 }

@@ -457,17 +586,20 @@ pub fn process_new_nonce(
        (&nonce_account, "nonce_account_pubkey".to_string()),
    )?;

-    if let Err(err) = rpc_client.get_account(&nonce_account) {
-        return Err(CliError::BadParameter(format!(
-            "Unable to advance nonce account {}. error: {}",
-            nonce_account, err
-        ))
+    let nonce_account_check =
+        rpc_client.get_account_with_commitment(&nonce_account, config.commitment);
+    if nonce_account_check.is_err() || nonce_account_check.unwrap().value.is_none() {
+        return Err(CliError::BadParameter(
+            "Unable to create new nonce, no nonce account found".to_string(),
+        )
        .into());
    }

    let nonce_authority = config.signers[nonce_authority];
    let ix = advance_nonce_account(&nonce_account, &nonce_authority.pubkey());
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;
@@ -478,7 +610,11 @@ pub fn process_new_nonce(
        &tx.message,
        config.commitment,
    )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
    log_instruction_custom_error::<SystemError>(result, &config)
 }

@@ -520,7 +656,9 @@ pub fn process_withdraw_from_nonce_account(
    destination_account_pubkey: &Pubkey,
    lamports: u64,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;

    let nonce_authority = config.signers[nonce_authority];
    let ix = withdraw_nonce_account(
@@ -539,7 +677,11 @@ pub fn process_withdraw_from_nonce_account(
        &tx.message,
        config.commitment,
    )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
    log_instruction_custom_error::<NonceError>(result, &config)
 }

@@ -549,11 +691,9 @@ mod tests {
    use crate::cli::{app, parse_command};
    use solana_sdk::{
        account::Account,
-        account_utils::StateMut,
        fee_calculator::FeeCalculator,
        hash::hash,
-        nonce::{self, state::Versions, State},
-        nonce_account,
+        nonce::{self, State},
        signature::{read_keypair_file, write_keypair, Keypair, Signer},
        system_program,
    };
@@ -570,10 +710,6 @@ 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 {
-            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();
@@ -592,7 +728,12 @@ mod tests {
            &Pubkey::default().to_string(),
        ]);
        assert_eq!(
-            parse_command(&test_authorize_nonce_account, &default_signer, &mut None).unwrap(),
+            parse_command(
+                &test_authorize_nonce_account,
+                &default_keypair_file,
+                &mut None
+            )
+            .unwrap(),
            CliCommandInfo {
                command: CliCommand::AuthorizeNonceAccount {
                    nonce_account: nonce_account_pubkey,
@@ -613,7 +754,12 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(&test_authorize_nonce_account, &default_signer, &mut None).unwrap(),
+            parse_command(
+                &test_authorize_nonce_account,
+                &default_keypair_file,
+                &mut None
+            )
+            .unwrap(),
            CliCommandInfo {
                command: CliCommand::AuthorizeNonceAccount {
                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
@@ -635,7 +781,7 @@ mod tests {
            "50",
        ]);
        assert_eq!(
-            parse_command(&test_create_nonce_account, &default_signer, &mut None).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateNonceAccount {
                    nonce_account: 1,
@@ -660,7 +806,7 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(&test_create_nonce_account, &default_signer, &mut None).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateNonceAccount {
                    nonce_account: 1,
@@ -682,7 +828,7 @@ mod tests {
            &nonce_account_string,
        ]);
        assert_eq!(
-            parse_command(&test_get_nonce, &default_signer, &mut None).unwrap(),
+            parse_command(&test_get_nonce, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::GetNonce(nonce_account_keypair.pubkey()),
                signers: vec![],
@@ -696,7 +842,7 @@ mod tests {
                .get_matches_from(vec!["test", "new-nonce", &keypair_file]);
        let nonce_account = read_keypair_file(&keypair_file).unwrap();
        assert_eq!(
-            parse_command(&test_new_nonce, &default_signer, &mut None).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::NewNonce {
                    nonce_account: nonce_account.pubkey(),
@@ -716,7 +862,7 @@ mod tests {
        ]);
        let nonce_account = read_keypair_file(&keypair_file).unwrap();
        assert_eq!(
-            parse_command(&test_new_nonce, &default_signer, &mut None).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::NewNonce {
                    nonce_account: nonce_account.pubkey(),
@@ -736,7 +882,7 @@ mod tests {
            &nonce_account_string,
        ]);
        assert_eq!(
-            parse_command(&test_show_nonce_account, &default_signer, &mut None).unwrap(),
+            parse_command(&test_show_nonce_account, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::ShowNonceAccount {
                    nonce_account_pubkey: nonce_account_keypair.pubkey(),
@@ -757,7 +903,7 @@ mod tests {
        assert_eq!(
            parse_command(
                &test_withdraw_from_nonce_account,
-                &default_signer,
+                &default_keypair_file,
                &mut None
            )
            .unwrap(),
@@ -785,7 +931,7 @@ mod tests {
        assert_eq!(
            parse_command(
                &test_withdraw_from_nonce_account,
-                &default_signer,
+                &default_keypair_file,
                &mut None
            )
            .unwrap(),
@@ -807,7 +953,7 @@ mod tests {
    #[test]
    fn test_check_nonce_account() {
        let blockhash = Hash::default();
-        let nonce_pubkey = solana_sdk::pubkey::new_rand();
+        let nonce_pubkey = Pubkey::new_rand();
        let data = Versions::new_current(State::Initialized(nonce::state::Data {
            authority: nonce_pubkey,
            blockhash,
@@ -820,14 +966,14 @@ mod tests {
        if let CliError::InvalidNonce(err) =
            check_nonce_account(&invalid_owner.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
        {
-            assert_eq!(err, Error::InvalidAccountOwner,);
+            assert_eq!(err, CliNonceError::InvalidAccountOwner,);
        }

        let invalid_data = Account::new_data(1, &"invalid", &system_program::ID);
        if let CliError::InvalidNonce(err) =
            check_nonce_account(&invalid_data.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
        {
-            assert_eq!(err, Error::InvalidAccountData,);
+            assert_eq!(err, CliNonceError::InvalidAccountData,);
        }

        let data = Versions::new_current(State::Initialized(nonce::state::Data {
@@ -839,11 +985,11 @@ mod tests {
        if let CliError::InvalidNonce(err) =
            check_nonce_account(&invalid_hash.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
        {
-            assert_eq!(err, Error::InvalidHash,);
+            assert_eq!(err, CliNonceError::InvalidHash,);
        }

        let data = Versions::new_current(State::Initialized(nonce::state::Data {
-            authority: solana_sdk::pubkey::new_rand(),
+            authority: Pubkey::new_rand(),
            blockhash,
            fee_calculator: FeeCalculator::default(),
        }));
@@ -851,7 +997,7 @@ mod tests {
        if let CliError::InvalidNonce(err) =
            check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
        {
-            assert_eq!(err, Error::InvalidAuthority,);
+            assert_eq!(err, CliNonceError::InvalidAuthority,);
        }

        let data = Versions::new_current(State::Uninitialized);
@@ -859,32 +1005,32 @@ mod tests {
        if let CliError::InvalidNonce(err) =
            check_nonce_account(&invalid_state.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
        {
-            assert_eq!(err, Error::InvalidStateForOperation,);
+            assert_eq!(err, CliNonceError::InvalidStateForOperation,);
        }
    }

    #[test]
    fn test_account_identity_ok() {
-        let nonce_account = nonce_account::create_account(1).into_inner();
+        let nonce_account = nonce::create_account(1).into_inner();
        assert_eq!(account_identity_ok(&nonce_account), Ok(()));

        let system_account = Account::new(1, 0, &system_program::id());
        assert_eq!(
            account_identity_ok(&system_account),
-            Err(Error::UnexpectedDataSize),
+            Err(CliNonceError::UnexpectedDataSize),
        );

        let other_program = Pubkey::new(&[1u8; 32]);
        let other_account_no_data = Account::new(1, 0, &other_program);
        assert_eq!(
            account_identity_ok(&other_account_no_data),
-            Err(Error::InvalidAccountOwner),
+            Err(CliNonceError::InvalidAccountOwner),
        );
    }

    #[test]
    fn test_state_from_account() {
-        let mut nonce_account = nonce_account::create_account(1).into_inner();
+        let mut nonce_account = nonce::create_account(1).into_inner();
        assert_eq!(state_from_account(&nonce_account), Ok(State::Uninitialized));

        let data = nonce::state::Data {
@@ -903,21 +1049,21 @@ mod tests {
        let wrong_data_size_account = Account::new(1, 1, &system_program::id());
        assert_eq!(
            state_from_account(&wrong_data_size_account),
-            Err(Error::InvalidAccountData),
+            Err(CliNonceError::InvalidAccountData),
        );
    }

    #[test]
    fn test_data_from_helpers() {
-        let mut nonce_account = nonce_account::create_account(1).into_inner();
+        let mut nonce_account = nonce::create_account(1).into_inner();
        let state = state_from_account(&nonce_account).unwrap();
        assert_eq!(
            data_from_state(&state),
-            Err(Error::InvalidStateForOperation)
+            Err(CliNonceError::InvalidStateForOperation)
        );
        assert_eq!(
            data_from_account(&nonce_account),
-            Err(Error::InvalidStateForOperation)
+            Err(CliNonceError::InvalidStateForOperation)
        );

        let data = nonce::state::Data {
--- a/cli/src/offline/blockhash_query.rs
+++ b/cli/src/offline/blockhash_query.rs
@@ -1,13 +1,5 @@
-use crate::{nonce_utils, rpc_client::RpcClient};
-use clap::ArgMatches;
-use solana_clap_utils::{
-    input_parsers::{pubkey_of, value_of},
-    nonce::*,
-    offline::*,
-};
-use solana_sdk::{
-    commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey,
-};
+use super::*;
+use solana_sdk::commitment_config::CommitmentConfig;

 #[derive(Debug, PartialEq)]
 pub enum Source {
@@ -29,8 +21,8 @@ impl Source {
                Ok((res.0, res.1))
            }
            Self::NonceAccount(ref pubkey) => {
-                let data = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)
-                    .and_then(|ref a| nonce_utils::data_from_account(a))?;
+                let data = nonce::get_account_with_commitment(rpc_client, pubkey, commitment)
+                    .and_then(|ref a| nonce::data_from_account(a))?;
                Ok((data.blockhash, data.fee_calculator))
            }
        }
@@ -50,8 +42,8 @@ impl Source {
                Ok(res)
            }
            Self::NonceAccount(ref pubkey) => {
-                let res = nonce_utils::get_account_with_commitment(rpc_client, pubkey, commitment)?;
-                let res = nonce_utils::data_from_account(&res)?;
+                let res = nonce::get_account_with_commitment(rpc_client, pubkey, commitment)?;
+                let res = nonce::data_from_account(&res)?;
                Ok(Some(res)
                    .filter(|d| d.blockhash == *blockhash)
                    .map(|d| d.fee_calculator))
@@ -83,7 +75,7 @@ impl BlockhashQuery {
    pub fn new_from_matches(matches: &ArgMatches<'_>) -> Self {
        let blockhash = value_of(matches, BLOCKHASH_ARG.name);
        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        let nonce_account = pubkey_of(matches, NONCE_ARG.name);
+        let nonce_account = pubkey_of(matches, nonce::NONCE_ARG.name);
        BlockhashQuery::new(blockhash, sign_only, nonce_account)
    }

@@ -116,15 +108,17 @@ impl Default for BlockhashQuery {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::{
-        blockhash_query,
-        rpc_request::RpcRequest,
-        rpc_response::{Response, RpcFeeCalculator, RpcResponseContext},
-    };
+    use crate::{nonce::nonce_arg, offline::blockhash_query::BlockhashQuery};
    use clap::App;
    use serde_json::{self, json, Value};
    use solana_account_decoder::{UiAccount, UiAccountEncoding};
-    use solana_sdk::{account::Account, hash::hash, nonce, system_program};
+    use solana_client::{
+        rpc_request::RpcRequest,
+        rpc_response::{Response, RpcFeeCalculator, RpcResponseContext},
+    };
+    use solana_sdk::{
+        account::Account, fee_calculator::FeeCalculator, hash::hash, nonce, system_program,
+    };
    use std::collections::HashMap;

    #[test]
@@ -178,7 +172,7 @@ mod tests {
    #[test]
    fn test_blockhash_query_new_from_matches_ok() {
        let test_commands = App::new("blockhash_query_test")
-            .nonce_args(false)
+            .arg(nonce_arg())
            .offline_args();
        let blockhash = hash(&[1u8]);
        let blockhash_string = blockhash.to_string();
@@ -359,7 +353,7 @@ mod tests {
        let rpc_nonce_account = UiAccount::encode(
            &nonce_pubkey,
            nonce_account,
-            UiAccountEncoding::Base64,
+            UiAccountEncoding::Binary64,
            None,
            None,
        );
--- a/cli/src/offline/mod.rs
+++ b/cli/src/offline/mod.rs
@@ -0,0 +1,129 @@
+pub mod blockhash_query;
+
+use crate::nonce;
+use clap::{App, Arg, ArgMatches};
+use serde_json::Value;
+use solana_clap_utils::{
+    input_parsers::{pubkey_of, value_of},
+    input_validators::{is_hash, is_pubkey_sig},
+    keypair::presigner_from_pubkey_sigs,
+    offline::{BLOCKHASH_ARG, SIGNER_ARG, SIGN_ONLY_ARG},
+};
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::{
+    fee_calculator::FeeCalculator,
+    hash::Hash,
+    pubkey::Pubkey,
+    signature::{Presigner, Signature},
+};
+use std::str::FromStr;
+
+fn blockhash_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(BLOCKHASH_ARG.name)
+        .long(BLOCKHASH_ARG.long)
+        .takes_value(true)
+        .value_name("BLOCKHASH")
+        .validator(is_hash)
+        .help(BLOCKHASH_ARG.help)
+}
+
+fn sign_only_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(SIGN_ONLY_ARG.name)
+        .long(SIGN_ONLY_ARG.long)
+        .takes_value(false)
+        .requires(BLOCKHASH_ARG.name)
+        .help(SIGN_ONLY_ARG.help)
+}
+
+fn signer_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(SIGNER_ARG.name)
+        .long(SIGNER_ARG.long)
+        .takes_value(true)
+        .value_name("PUBKEY=SIGNATURE")
+        .validator(is_pubkey_sig)
+        .requires(BLOCKHASH_ARG.name)
+        .multiple(true)
+        .help(SIGNER_ARG.help)
+}
+
+pub trait OfflineArgs {
+    fn offline_args(self) -> Self;
+}
+
+impl OfflineArgs for App<'_, '_> {
+    fn offline_args(self) -> Self {
+        self.arg(blockhash_arg())
+            .arg(sign_only_arg())
+            .arg(signer_arg())
+    }
+}
+
+pub struct SignOnly {
+    pub blockhash: Hash,
+    pub present_signers: Vec<(Pubkey, Signature)>,
+    pub absent_signers: Vec<Pubkey>,
+    pub bad_signers: Vec<Pubkey>,
+}
+
+impl SignOnly {
+    pub fn has_all_signers(&self) -> bool {
+        self.absent_signers.is_empty() && self.bad_signers.is_empty()
+    }
+
+    pub fn presigner_of(&self, pubkey: &Pubkey) -> Option<Presigner> {
+        presigner_from_pubkey_sigs(pubkey, &self.present_signers)
+    }
+}
+
+pub fn parse_sign_only_reply_string(reply: &str) -> SignOnly {
+    let object: Value = serde_json::from_str(&reply).unwrap();
+    let blockhash_str = object.get("blockhash").unwrap().as_str().unwrap();
+    let blockhash = blockhash_str.parse::<Hash>().unwrap();
+    let mut present_signers: Vec<(Pubkey, Signature)> = Vec::new();
+    let signer_strings = object.get("signers");
+    if let Some(sig_strings) = signer_strings {
+        present_signers = sig_strings
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|signer_string| {
+                let mut signer = signer_string.as_str().unwrap().split('=');
+                let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
+                let sig = Signature::from_str(signer.next().unwrap()).unwrap();
+                (key, sig)
+            })
+            .collect();
+    }
+    let mut absent_signers: Vec<Pubkey> = Vec::new();
+    let signer_strings = object.get("absent");
+    if let Some(sig_strings) = signer_strings {
+        absent_signers = sig_strings
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|val| {
+                let s = val.as_str().unwrap();
+                Pubkey::from_str(s).unwrap()
+            })
+            .collect();
+    }
+    let mut bad_signers: Vec<Pubkey> = Vec::new();
+    let signer_strings = object.get("badSig");
+    if let Some(sig_strings) = signer_strings {
+        bad_signers = sig_strings
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|val| {
+                let s = val.as_str().unwrap();
+                Pubkey::from_str(s).unwrap()
+            })
+            .collect();
+    }
+    SignOnly {
+        blockhash,
+        present_signers,
+        absent_signers,
+        bad_signers,
+    }
+}
--- a/cli/src/program.rs
+++ b/cli/src/program.rs
--- a/cli/src/send_tpu.rs
+++ b/cli/src/send_tpu.rs
@@ -1,29 +0,0 @@
-use log::*;
-use solana_client::rpc_response::{RpcContactInfo, RpcLeaderSchedule};
-use std::net::{SocketAddr, UdpSocket};
-
-pub fn get_leader_tpu(
-    slot_index: u64,
-    leader_schedule: Option<&RpcLeaderSchedule>,
-    cluster_nodes: Option<&Vec<RpcContactInfo>>,
-) -> Option<SocketAddr> {
-    leader_schedule?
-        .iter()
-        .find(|(_pubkey, slots)| slots.iter().any(|slot| *slot as u64 == slot_index))
-        .and_then(|(pubkey, _)| {
-            cluster_nodes?
-                .iter()
-                .find(|contact_info| contact_info.pubkey == *pubkey)
-                .and_then(|contact_info| contact_info.tpu)
-        })
-}
-
-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);
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mergify[bot]	69e53ec92a	Gossip log (#11555 ) (#11562 ) Co-authored-by: Carl <carl@solana.com> (cherry picked from commit `1b238dd63e`) Co-authored-by: carllin <wumu727@gmail.com>	2020-08-11 22:55:18 +00:00
mergify[bot]	b8ac76066c	Move cluster slots update to separate thread (#11523 ) (#11558 ) * Add cluster_slots_service Co-authored-by: Carl <carl@solana.com> (cherry picked from commit `7ef50a9352`) Co-authored-by: carllin <wumu727@gmail.com>	2020-08-11 21:24:34 +00:00
mergify[bot]	1a1d7744bd	Add getTokenLargestAccounts to docs (#11560 ) (#11564 ) (cherry picked from commit `697a0e2947`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-11 21:21:35 +00:00
mergify[bot]	61af485732	filter out old gossip pull requests (#11448 ) (#11553 ) * init * builds * stats * revert * tests * clippy * add some jitter * shorter jitter timer * update * fixup! update * use saturating_sub * fix filters (cherry picked from commit `713851b68d`) Co-authored-by: anatoly yakovenko <anatoly@solana.com>	2020-08-11 19:42:32 +00:00
mergify[bot]	6a60d7bf8e	Adapt RpcClient to recent token method changes (#11519 ) (#11548 ) * Avoid skip_serializing_if since that breaks deserialization * Adapt RpcClient to recent token method changes (cherry picked from commit `17645ee20c`) Co-authored-by: Michael Vines <mvines@gmail.com>	2020-08-11 17:31:57 +00:00
mergify[bot]	53e917b54f	Fix bad rent in Bank::deposit as if since epoch 0 (#10468 ) (#11539 ) * Fix bad rent in Bank::deposit as if since epoch 0 * Remove redundant predicate * Rename * Start to add tests with some cleanup * Forgot to add refactor code... * Enchance test * Really fix rent timing in deposit with robust test * Simplify new behavior by disabling rent altogether (cherry picked from commit `6c242f3fec`) Co-authored-by: Ryo Onodera <ryoqun@gmail.com>	2020-08-11 16:20:06 +00:00
mergify[bot]	4d49c99ac9	Fix simulateTransaction JSON-RPC docs (#11533 ) (#11535 ) (cherry picked from commit `f12fc66a69`) Co-authored-by: Justin Starry <justin@solana.com>	2020-08-11 10:26:20 +00:00
mergify[bot]	83597a5ce1	Fix solana CLI deploy (#11520 ) (#11530 ) * Refresh blockhash for program writes and finalize transactions * Refactor to use current api, eliminating an rpc call * Review comment (cherry picked from commit `c0d6761f63`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-11 09:52:11 +00:00
mergify[bot]	1589a41178	Add config param to specify offset/length for single and program account info (bp #11515 ) (#11518 ) * Add config param to specify offset/length for single and program account info (#11515) * Add config param to specify dataSlice for account info and program accounts * Use match instead of if (cherry picked from commit `88ca04dbdb`) # Conflicts: # cli/src/cli.rs * Fix conflicts Co-authored-by: Tyera Eulberg <teulberg@gmail.com> Co-authored-by: Tyera Eulberg <tyera@solana.com>	2020-08-11 00:03:18 +00:00
mergify[bot]	23a381b995	Fix parsing of spl-token Mint (#11512 ) (#11514 ) * Add failing test * Fix jsonParsed mint (cherry picked from commit `da210ddd51`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-10 21:51:20 +00:00
mergify[bot]	eb7ac42b2e	Return account data size with parsed accounts (#11506 ) (#11511 ) (cherry picked from commit `1925b0bd0b`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-10 20:09:13 +00:00
mergify[bot]	88cf5e79f5	Unified signature for create_program_address (#11460 ) (#11509 ) (cherry picked from commit `140b2392f6`) Co-authored-by: Jack May <jack@solana.com>	2020-08-10 18:31:51 +00:00
mergify[bot]	520453e1f3	Blockstore address signatures: handle slots that cross primary indexes, and refactor get_confirmed_signatures_for_address2 (#11497 ) (#11508 ) * Freeze address-signature index in the middle of slot to show failure case * Secondary filter on signature * Use AddressSignatures iterator instead of manually decrementing slots * Remove unused method * Add metrics * Add transaction-status-index doccumentation (cherry picked from commit `de5fb3ba0e`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-10 17:43:00 +00:00
mergify[bot]	27815555a1	Fallback to base64 account encoding if json parse fails (#11483 ) (#11488 ) * Fallback to base64 account encoding if json parse fails * Remove default binary conversion (cherry picked from commit `ebc45bd73f`) Co-authored-by: Justin Starry <justin@solana.com>	2020-08-09 16:15:09 +00:00
mergify[bot]	3e483314b6	Decode native-program and sysvar accounts (bp #11463 ) (#11485 ) * Decode native-program and sysvar accounts (#11463) * Pass pubkey in to account-decoder for sysvars * Decode sysvar accounts * Decode config accounts; move validator-info lower * Decode stake accounts * Review comments * Stringify any account lamports and epochs that can be set to u64::MAX (cherry picked from commit `a9f76862fb`) # Conflicts: # Cargo.lock # account-decoder/Cargo.toml * Fix conflicts Co-authored-by: Tyera Eulberg <teulberg@gmail.com> Co-authored-by: Tyera Eulberg <tyera@solana.com>	2020-08-09 09:18:17 +00:00
mergify[bot]	8a67504578	Add Binary64 option for account data (#11474 ) (#11481 ) * Add Binary64 option for account data * Decode into binary64 * Reword docs (cherry picked from commit `068d23f298`) Co-authored-by: sakridge <sakridge@gmail.com>	2020-08-09 06:50:24 +00:00
mergify[bot]	a1b238280b	Return delegated amount as UiTokenAmount (#11475 ) (#11477 ) * Return delegated amount as UiTokenAmount * Omit delegate and delegatedAmount when none (cherry picked from commit `88d8d3d02a`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-09 00:01:01 +00:00
Trent Nelson	f9e07f575e	Bump version to v1.3.2	2020-08-08 06:26:20 +00:00
Trent Nelson	c8bad57455	Bump version to v1.3.1	2020-08-07 19:21:41 -06:00
mergify[bot]	71654c0457	Fix cbindgen compatibility (#11455 ) (#11459 ) (cherry picked from commit `5a7e99f283`) Co-authored-by: Jack May <jack@solana.com>	2020-08-07 23:44:49 +00:00
mergify[bot]	f9d6fb48a4	Send votes from banking stage to vote listener (#11434 ) (#11454 ) * Send votes from banking stage to vote listener Co-authored-by: Carl <carl@solana.com> (cherry picked from commit `7e25130529`) Co-authored-by: carllin <wumu727@gmail.com>	2020-08-07 19:45:40 +00:00
mergify[bot]	fa9aa0a1d7	Token Accounts: return ui_amount, decimals with decoded account (#11407 ) (#11453 ) * Return ui_amount, decimals from token client methods * Return ui_amount, decimals in RPC jsonParsed token accounts * Fixup docs * Return ui_amount, decimals in pubsub jsonParsed token accounts * Remove unnecessary duplicate struct * StringAmount rename (cherry picked from commit `b7c2681903`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-07 19:05:35 +00:00
mergify[bot]	9758ebfc99	Only run web3.js/explorer CI when targeting master branch (#11440 ) (cherry picked from commit `a3165c6a61`) Co-authored-by: Trent Nelson <trent@solana.com>	2020-08-07 06:24:42 +00:00
mergify[bot]	8be23a2bb2	Add address-based lower bound to get_confirmed_signatures_for_address2 loop (#11426 ) (#11432 ) (cherry picked from commit `5530ee4c95`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-07 00:06:44 +00:00
mergify[bot]	4ff9a6910d	Fix blockstore empty panic (#11423 ) (#11430 ) * Add panicking test * Add failing test: fresh transaction-status column shouldn't point at valid root 0 * Prevent transaction status match outside of primary-index bounds * Initialize transaction-status and address-signature primer entries with Slot::MAX * Revert "Add failing test: fresh transaction-status column shouldn't point at valid root 0" This reverts commit `cbad2a9fae`. * Revert "Initialize transaction-status and address-signature primer entries with Slot::MAX" This reverts commit `ffaeac0669`. (cherry picked from commit `1061b50665`) Co-authored-by: Tyera Eulberg <teulberg@gmail.com>	2020-08-06 23:39:01 +00:00
mergify[bot]	fd192e3641	Link fix (#11368 ) (#11425 ) * fixes logo * cleans up homepage on docs * adds icon files and tightens margins * cleans up sidenav, adds top nav items * fixes a link * removes icon files Co-authored-by: Dan Albert <dan@solana.com> (cherry picked from commit `14dcaaee6c`) Co-authored-by: Raj Gokal <rajivgokal@gmail.com>	2020-08-06 19:37:04 +00:00
mergify[bot]	a8de467ef8	Realloc not supported (#11418 ) (cherry picked from commit `bc4c5c5a97`) Co-authored-by: Jack May <jack@solana.com>	2020-08-06 16:24:14 +00:00
Michael Vines	1a186beb5c	Update lib.rs (cherry picked from commit `5a63c9d535`)	2020-08-06 07:58:05 -07:00
Michael Vines	66a21ed65e	Enable cross program support in mainnet-beta epoch 63 (cherry picked from commit `c9b1d08218`)	2020-08-06 07:58:05 -07:00
mergify[bot]	1a42a40492	RPC: Plug getConfirmedSignaturesForAddress2 into bigtable storage (bp #11395 ) (#11406 ) * Plug getConfirmedSignaturesForAddress2 into bigtable storage (cherry picked from commit `4222932e08`) * Upgrade help description (cherry picked from commit `9abb7db5f8`) Co-authored-by: Michael Vines <mvines@gmail.com>	2020-08-06 07:14:46 +00:00
mergify[bot]	5841e4d665	Long-term ledger storage with BigTable (bp #11222 ) (#11392 ) * ledger-storage-bigtable boilerplate (cherry picked from commit `9d2293bb32`) * $ wget https://pki.goog/roots.pem -O pki-goog-roots.pem (cherry picked from commit `1617a025ce`) * Add access_token module (cherry picked from commit `59d266a111`) * Add root_ca_certificate (cherry picked from commit `faa016e4b7`) * Add build-proto (cherry picked from commit `c31e1f5bf0`) * UiTransactionEncoding is now copy (cherry picked from commit `494968be66`) * Increase timeout (cherry picked from commit `57dfebc5ba`) * Add build-proto/build.sh output (cherry picked from commit `54dae6ba2c`) * Supress doctest errors (cherry picked from commit `019c75797d`) * Add compression (cherry picked from commit `243e05d59f`) * Add bigtable (cherry picked from commit `6e0353965a`) * Add configuration info (cherry picked from commit `98cca1e774`) * Add ledger-tool bigtable subcommands (cherry picked from commit `f9049d6ee4`) # Conflicts: # ledger-tool/Cargo.toml * Make room for tokio 0.2 (cherry picked from commit `b876fb84ba`) # Conflicts: # core/Cargo.toml * Setup a tokio 0.2 runtime for RPC usage (cherry picked from commit `0e02740565`) # Conflicts: # core/Cargo.toml * Plumb Bigtable ledger storage into the RPC subsystem (cherry picked from commit `dfae9a9864`) # Conflicts: # core/Cargo.toml * Add RPC transaction history design (cherry picked from commit `e56ea138c7`) * Simplify access token refreshing (cherry picked from commit `1f7af14386`) * Report block status more frequently (cherry picked from commit `22c46ebf96`) * after -> before (cherry picked from commit `227ea934ff`) * Rebase * Cargo.lock Co-authored-by: Michael Vines <mvines@gmail.com>	2020-08-06 04:06:44 +00:00
mergify[bot]	6542a04521	Mark token-specific rpcs as unstable (#11402 ) (cherry picked from commit `7430896c79`) Co-authored-by: Tyera Eulberg <tyera@solana.com>	2020-08-06 04:00:18 +00:00
mergify[bot]	5c27009758	Force program address off the curve (#11323 ) (#11398 ) (cherry picked from commit `03263c850a`) Co-authored-by: Jack May <jack@solana.com>	2020-08-06 01:00:42 +00:00
mergify[bot]	888f3522d8	Add getConfirmedSignaturesForAddress2 RPC method (bp #11259 ) (#11394 ) * Add getConfirmedSignaturesForAddress2 RPC method (cherry picked from commit `1b2276520b`) * Reimplement transaction-history command with getConfirmedSignaturesForAddress2 (cherry picked from commit `087fd32ce3`) * Rework get_confirmed_signatures_for_address2 (cherry picked from commit `a11f137810`) * Rename startAfter to before (cherry picked from commit `02c0981ecf`) Co-authored-by: Michael Vines <mvines@gmail.com>	2020-08-05 22:47:50 +00:00