Gossip log (#11555) (#11562)

Co-authored-by: Carl <carl@solana.com>
(cherry picked from commit 1b238dd63e)

Co-authored-by: carllin <wumu727@gmail.com>

.buildkite/env/secrets.ejson

@@ -1,12 +1,12 @@
 {
     "_public_key": "ae29f4f7ad2fc92de70d470e411c8426d5d48db8817c9e3dae574b122192335f",
     "environment": {
-      "CODECOV_TOKEN": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:JnxhrIxh09AvqdJgrVSYmb7PxSrh19aE:07WzVExCHEd1lJ1m8QizRRthGri+WBNeZRKjjEvsy5eo4gv3HD7zVEm42tVTGkqITKkBNQ==]",
-      "CRATES_IO_TOKEN": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:d0jJqC32/axwzq/N7kMRmpxKhnRrhtpt:zvcPHwkOzGnjhNkAQSejwdy1Jkr9wR1qXFFCnfIjyt/XQYubzB1tLkoly/qdmeb5]",
-      "GEOLOCATION_API_KEY": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:R4gfB6Ey4i50HyfLt4UZDLBqg3qHEUye:UfZCOgt8XI6Y2g+ivCRVoS1fjFycFs7/GSevvCqh1B50mG0+hzpEyzXQLuKG5OeI]",
-      "GITHUB_TOKEN": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:Vq2dkGTOzfEpRht0BAGHFp/hDogMvXJe:tFXHg1epVt2mq9hkuc5sRHe+KAnVREi/p8S+IZu67XRyzdiA/nGak1k860FXYuuzuaE0QWekaEc=]",
-      "INFLUX_DATABASE": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:5KI9WBkXx3R/W4m256mU5MJOE7N8aAT9:Cb8QFELZ9I60t5zhJ9h55Kcs]",
-      "INFLUX_PASSWORD": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:hQRMpLCrav+OYkNphkeM4hagdVoZv5Iw:AUO76rr6+gF1OLJA8ZLSG8wHKXgYCPNk6gRCV8rBhZBJ4KwDaxpvOhMl7bxxXG6jol7v4aRa/Lk=]",
-      "INFLUX_USERNAME": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:R7BNmQjfeqoGDAFTJu9bYTGHol2NgnYN:Q2tOT/EBcFvhFk+DKLKmVU7tLCpVC3Ui]"
+      "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]"
     }
 }

.buildkite/pipeline-upload.sh

@@ -9,23 +9,10 @@
 
 set -e
 cd "$(dirname "$0")"/..
+source ci/_
 
-if [[ -n $BUILDKITE_TAG ]]; then
-  buildkite-agent annotate --style info --context release-tag \
-    "https://github.com/solana-labs/solana/releases/$BUILDKITE_TAG"
-  buildkite-agent pipeline upload ci/buildkite-release.yml
-else
-  if [[ $BUILDKITE_BRANCH =~ ^pull ]]; then
-    # Add helpful link back to the corresponding Github Pull Request
-    buildkite-agent annotate --style info --context pr-backlink \
-      "Github Pull Request: https://github.com/solana-labs/solana/$BUILDKITE_BRANCH"
-  fi
+_ ci/buildkite-pipeline.sh pipeline.yml
+echo +++ pipeline
+cat pipeline.yml
 
-  if [[ $BUILDKITE_MESSAGE =~ GitBook: ]]; then
-    buildkite-agent annotate --style info --context gitbook-ci-skip \
-      "GitBook commit detected, CI skipped"
-    exit
-  fi
-
-  buildkite-agent pipeline upload ci/buildkite.yml
-fi
+_ buildkite-agent pipeline upload pipeline.yml

.gitbook.yaml

@@ -1,18 +0,0 @@
-root: ./docs/src
-
-structure:
-    readme: introduction.md
-    summary: SUMMARY.md
-
-redirects:
-    wallet: ./wallet-guide/README.md
-    wallet/app-wallets: ./wallet-guide/apps.md
-    wallet/app-wallets/trust-wallet: ./wallet-guide/trust-wallet.md
-    wallet/app-wallets/ledger-live:  ./wallet-guide/ledger-live.md
-    wallet/cli-wallets:  ./wallet-guide/cli.md
-    wallet/cli-wallets/paper-wallet:  ./paper-wallet/README.md
-    wallet/cli-wallets/paper-wallet/paper-wallet-usage: ./paper-wallet/paper-wallet-usage.md
-    wallet/cli-wallets/remote-wallet: ./hardware-wallets/README.md
-    wallet/cli-wallets/remote-wallet/ledger: ./hardware-wallets/ledger.md
-    wallet/cli-wallets/file-system-wallet: ./file-system-wallet/README.md
-    wallet/support: ./wallet-guide/support.md

.github/dependabot.yml

@@ -0,0 +1,41 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "01:00"
+    timezone: America/Los_Angeles
+  #labels:
+  #  - "automerge"
+  open-pull-requests-limit: 3
+  
+- package-ecosystem: npm
+  directory: "/web3.js"
+  schedule:
+    interval: daily
+    time: "01:00"
+    timezone: America/Los_Angeles
+  labels:
+    - "automerge"
+  commit-message:
+    prefix: "chore:"
+  open-pull-requests-limit: 3
+  
+- package-ecosystem: npm
+  directory: "/explorer"
+  schedule:
+    interval: daily
+    time: "01:00"
+    timezone: America/Los_Angeles
+  labels:
+    - "automerge"
+  commit-message:
+    prefix: "chore:"
+    include: "scope"
+  open-pull-requests-limit: 3

.github/stale.yml

@@ -9,6 +9,7 @@ daysUntilClose: 7
 # Issues with these labels will never be considered stale
 exemptLabels:
   - security
+  - blocked
 
 # Label to use when marking a pull request as stale
 staleLabel: stale

.gitignore

@@ -23,3 +23,9 @@ log-*/
 /.idea/
 /solana.iml
 /.vscode/
+
+# fetch-spl.sh artifacts
+/spl-genesis-args.sh
+/spl_*.so
+
+.DS_Store

.mergify.yml

@@ -1,9 +1,40 @@
 # Validate your changes with:
 #
-#   $ curl -F 'data=@.mergify.yml' https://gh.mergify.io/validate
+#   $ curl -F 'data=@.mergify.yml' https://gh.mergify.io/validate/
 #
 # https://doc.mergify.io/
 pull_request_rules:
+  - name: automatic merge (squash) on CI success
+    conditions:
+      - status-success=buildkite/solana
+      - status-success=Travis CI - Pull Request
+      - status-success=ci-gate
+      - label=automerge
+      - author≠@dont-squash-my-commits
+    actions:
+      merge:
+        method: squash
+  # Join the dont-squash-my-commits group if you won't like your commits squashed
+  - name: automatic merge (rebase) on CI success
+    conditions:
+      - status-success=buildkite/solana
+      - status-success=Travis CI - Pull Request
+      - status-success=ci-gate
+      - label=automerge
+      - author=@dont-squash-my-commits
+    actions:
+      merge:
+        method: rebase
+  - name: remove automerge label on CI failure
+    conditions:
+      - label=automerge
+      - "#status-failure!=0"
+    actions:
+      label:
+        remove:
+          - automerge
+      comment:
+        message: automerge label removed due to a CI failure
   - name: remove outdated reviews
     conditions:
       - base=master
@@ -19,14 +50,6 @@ pull_request_rules:
       label:
         add:
           - automerge
-  - name: v1.0 backport
-    conditions:
-      - label=v1.0
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.0
   - name: v1.1 backport
     conditions:
       - label=v1.1
@@ -43,3 +66,11 @@ pull_request_rules:
         ignore_conflicts: true
         branches:
           - v1.2
+  - name: v1.3 backport
+    conditions:
+      - label=v1.3
+    actions:
+      backport:
+        ignore_conflicts: true
+        branches:
+          - v1.3

.travis.yml

@@ -1,43 +1,132 @@
-os:
-  - osx
-  - windows
-
-language: rust
-rust:
-  - stable
-
-install:
-  - source ci/rust-version.sh
-
-script:
-  - source ci/env.sh
-  - ci/publish-tarball.sh
-
 branches:
   only:
     - master
     - /^v\d+\.\d+/
 
 notifications:
+  email: false
   slack:
     on_success: change
+    if: NOT type = pull_request
     secure: F4IjOE05MyaMOdPRL+r8qhs7jBvv4yDM3RmFKE1zNXnfUOqV4X38oQM1EI+YVsgpMQLj/pxnEB7wcTE4Bf86N6moLssEULCpvAuMVoXj4QbWdomLX+01WbFa6fLVeNQIg45NHrz2XzVBhoKOrMNnl+QI5mbR2AlS5oqsudHsXDnyLzZtd4Y5SDMdYG1zVWM01+oNNjgNfjcCGmOE/K0CnOMl6GPi3X9C34tJ19P2XT7MTDsz1/IfEF7fro2Q8DHEYL9dchJMoisXSkem5z7IDQkGzXsWdWT4NnndUvmd1MlTCE9qgoXDqRf95Qh8sB1Dz08HtvgfaosP2XjtNTfDI9BBYS15Ibw9y7PchAJE1luteNjF35EOy6OgmCLw/YpnweqfuNViBZz+yOPWXVC0kxnPIXKZ1wyH9ibeH6E4hr7a8o9SV/6SiWIlbYF+IR9jPXyTCLP/cc3sYljPWxDnhWFwFdRVIi3PbVAhVu7uWtVUO17Oc9gtGPgs/GrhOMkJfwQPXaudRJDpVZowxTX4x9kefNotlMAMRgq+Drbmgt4eEBiCNp0ITWgh17BiE1U09WS3myuduhoct85+FoVeaUkp1sxzHVtGsNQH0hcz7WcpZyOM+AwistJA/qzeEDQao5zi1eKWPbO2xAhi2rV1bDH6bPf/4lDBwLRqSiwvlWU=
 
-deploy:
-  - provider: s3
-    access_key_id: $AWS_ACCESS_KEY_ID
-    secret_access_key: $AWS_SECRET_ACCESS_KEY
-    bucket: release.solana.com
-    region: us-west-1
-    skip_cleanup: true
-    acl: public_read
-    local_dir: travis-s3-upload
-    on:
-      all_branches: true
-  - provider: releases
-    api_key: $GITHUB_TOKEN
-    skip_cleanup: true
-    file_glob: true
-    file: travis-release-upload/*
-    on:
-      tags: true
+os: linux
+dist: bionic
+language: minimal
+
+jobs:
+  include:
+    - name: "Export Github Repositories"
+      if: type IN (push, cron) AND branch = master
+      language: python
+      git:
+        depth: false
+      script:
+        - .travis/export-github-repo.sh web3.js/ solana-web3.js
+        - .travis/export-github-repo.sh explorer/ explorer
+
+    - &release-artifacts
+      if: type IN (api, cron) OR tag IS present
+      name: "macOS release artifacts"
+      os: osx
+      language: rust
+      rust:
+        - stable
+      install:
+        - source ci/rust-version.sh
+      script:
+        - source ci/env.sh
+        - ci/publish-tarball.sh
+      deploy:
+        - provider: s3
+          access_key_id: $AWS_ACCESS_KEY_ID
+          secret_access_key: $AWS_SECRET_ACCESS_KEY
+          bucket: release.solana.com
+          region: us-west-1
+          skip_cleanup: true
+          acl: public_read
+          local_dir: travis-s3-upload
+          on:
+            all_branches: true
+        - provider: releases
+          token: $GITHUB_TOKEN
+          skip_cleanup: true
+          file_glob: true
+          file: travis-release-upload/*
+          on:
+            tags: true
+    - <<: *release-artifacts
+      name: "Windows release artifacts"
+      os: windows
+    #  Linux release artifacts are still built by ci/buildkite-secondary.yml
+    #- <<: *release-artifacts
+    #  name: "Linux release artifacts"
+    #  os: linux
+    #  before_install:
+    #    - sudo apt-get install libssl-dev libudev-dev
+
+    # explorer pull request
+    - name: "explorer"
+      if: type = pull_request AND branch = master
+
+      language: node_js
+      node_js:
+        - "node"
+
+      cache:
+        directories:
+          - ~/.npm
+
+      before_install:
+        - .travis/affects.sh explorer/ .travis || travis_terminate 0
+        - cd explorer
+
+      script:
+        - npm run build
+        - npm run format
+
+    # web3.js pull request
+    - name: "web3.js"
+      if: type = pull_request AND branch = master
+
+      language: node_js
+      node_js:
+        - "lts/*"
+
+      services:
+        - docker
+
+      cache:
+        directories:
+          - ~/.npm
+
+      before_install:
+        - .travis/affects.sh web3.js/ .travis || travis_terminate 0
+        - cd web3.js/
+        - source .travis/before_install.sh
+
+      script:
+        - ../.travis/commitlint.sh
+        - source .travis/script.sh
+
+    # docs pull request
+    - name: "docs"
+      if: type IN (push, pull_request) OR tag IS present
+      language: node_js
+      node_js:
+        - "node"
+
+      services:
+        - docker
+
+      cache:
+        directories:
+          - ~/.npm
+
+      before_install:
+        - .travis/affects.sh docs/ .travis || travis_terminate 0
+        - cd docs/
+        - source .travis/before_install.sh
+
+      script:
+        - source .travis/script.sh

.travis/affects.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+#
+# Check if files in the commit range match one or more prefixes
+#
+
+# Always run the job if we are on a tagged release
+if [[ -n "$TRAVIS_TAG" ]]; then
+  exit 0
+fi
+
+(
+  set -x
+  git diff --name-only "$TRAVIS_COMMIT_RANGE"
+)
+
+for file in $(git diff --name-only "$TRAVIS_COMMIT_RANGE"); do
+  for prefix in "$@"; do
+    if [[ $file =~ ^"$prefix" ]]; then
+      exit 0
+    fi
+    done
+done
+
+echo "No modifications to $*"
+exit 1

.travis/commitlint.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+#
+# Runs commitlint in the provided subdirectory
+#
+
+set -e
+
+basedir=$1
+if [[ -z "$basedir" ]]; then
+  basedir=.
+fi
+
+if [[ ! -d "$basedir" ]]; then
+  echo "Error: not a directory: $basedir"
+  exit 1
+fi
+
+if [[ ! -f "$basedir"/commitlint.config.js ]]; then
+  echo "Error: No commitlint configuration found"
+  exit 1
+fi
+
+if [[ -z $TRAVIS_COMMIT_RANGE ]]; then
+  echo "Error: TRAVIS_COMMIT_RANGE not defined"
+  exit 1
+fi
+
+cd "$basedir"
+echo "Checking commits in TRAVIS_COMMIT_RANGE: $TRAVIS_COMMIT_RANGE"
+while IFS= read -r line; do
+  echo "$line" | npx commitlint
+done < <(git log "$TRAVIS_COMMIT_RANGE" --format=%s -- .)

.travis/export-github-repo.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+#
+# Exports a subdirectory into another github repository
+#
+
+set -e
+if [[ -z $GITHUB_TOKEN ]]; then
+  echo GITHUB_TOKEN not defined
+  exit 1
+fi
+
+cd "$(dirname "$0")/.."
+
+pip3 install git-filter-repo
+
+declare subdir=$1
+declare repo_name=$2
+
+[[ -n "$subdir" ]] || {
+  echo "Error: subdir not specified"
+  exit 1
+}
+[[ -n "$repo_name" ]] || {
+  echo "Error: repo_name not specified"
+  exit 1
+}
+
+echo "Exporting $subdir"
+
+set -x
+rm -rf .github_export/"$repo_name"
+git clone https://"$GITHUB_TOKEN"@github.com/solana-labs/"$repo_name" .github_export/"$repo_name"
+git filter-repo --subdirectory-filter "$subdir" --target .github_export/"$repo_name"
+git -C .github_export/"$repo_name" push https://"$GITHUB_TOKEN"@github.com/solana-labs/"$repo_name"

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "bench-tps",
     "accounts-bench",
     "banking-bench",
+    "clap-utils",
     "cli-config",
     "client",
     "core",
@@ -25,15 +26,15 @@ members = [
     "log-analyzer",
     "merkle-tree",
     "stake-o-matic",
+    "storage-bigtable",
     "streamer",
     "measure",
     "metrics",
     "net-shaper",
     "notifier",
+    "poh-bench",
     "programs/bpf_loader",
     "programs/budget",
-    "programs/btc_spv",
-    "programs/btc_spv_bin",
     "programs/config",
     "programs/exchange",
     "programs/failure",
@@ -52,6 +53,7 @@ members = [
     "sys-tuner",
     "tokens",
     "transaction-status",
+    "account-decoder",
     "upload-perf",
     "net-utils",
     "version",
@@ -63,6 +65,4 @@ members = [
 
 exclude = [
     "programs/bpf",
-    "programs/move_loader",
-    "programs/librapay",
 ]

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2018 Solana Labs, Inc.
+Copyright 2020 Solana Foundation.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

RELEASE.md

@@ -76,21 +76,20 @@ There are three release channels that map to branches as follows:
     git push -u origin <branchname>
     ```
 
-### Update master branch with the next version
+Alternatively use the Github UI.
+
+### Update master branch to the next release minor version
 
 1. After the new branch has been created and pushed, update the Cargo.toml files on **master** to the next semantic version (e.g. 0.9.0 -> 0.10.0) with:
      ```
-     scripts/increment-cargo-version.sh minor
+     $ scripts/increment-cargo-version.sh minor
+     $ ./scripts/cargo-for-all-lock-files.sh update
      ```
-1. Rebuild to get an updated version of `Cargo.lock`:
-    ```
-    cargo build
-    ```
 1. Push all the changed Cargo.toml and Cargo.lock files to the `master` branch with something like:
     ```
     git co -b version_update
     git ls-files -m | xargs git add
-    git commit -m 'Update Cargo.toml versions from X.Y to X.Y+1'
+    git commit -m 'Bump version to X.Y+1.0'
     git push -u origin version_update
     ```
 1. Confirm that your freshly cut release branch is shown as `BETA_CHANNEL` and the previous release branch as `STABLE_CHANNEL`:
@@ -102,84 +101,51 @@ There are three release channels that map to branches as follows:
 
 ### Create the Release Tag on GitHub
 
-1. Go to [GitHub's Releases UI](https://github.com/solana-labs/solana/releases) for tagging a release.
+1. Go to [GitHub Releases](https://github.com/solana-labs/solana/releases) for tagging a release.
 1. Click "Draft new release".  The release tag must exactly match the `version`
    field in `/Cargo.toml` prefixed by `v`.
-   1.  If the Cargo.toml verion field is **0.12.3**, then the release tag must be **v0.12.3**
+   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. 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. Click "Save Draft", then confirm the release notes look good and the tag name and branch are correct.  Go back into edit the release and click "Publish release" when ready.
+   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 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
 
 1. After the new release has been tagged, update the Cargo.toml files on **release branch** to the next semantic version (e.g. 0.9.0 -> 0.9.1) with:
      ```
-     scripts/increment-cargo-version.sh patch
+     $ scripts/increment-cargo-version.sh patch
+     $ ./scripts/cargo-for-all-lock-files.sh tree
      ```
-1. Rebuild to get an updated version of `Cargo.lock`:
-    ```
-    cargo build
-    ```
 1. Push all the changed Cargo.toml and Cargo.lock files to the **release branch** with something like:
     ```
-    git co -b version_update
-    git ls-files -m | xargs git add
-    git commit -m 'Update Cargo.toml versions from X.Y.Z to X.Y.Z+1'
-    git push -u origin version_update
+    git co -b version_update origin/vX.Y
+    git add -u
+    git commit -m 'Bump version to X.Y.Z+1'
+    git push -u <user-remote> version_update
     ```
+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 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.
 
 ### Verify release automation success
-1. Go to [Solana Releases](https://github.com/solana-labs/solana/releases) and click on the latest release that you just published.  Verify that all of the build artifacts are present.  This can take up to 90 minutes after creating the tag.
-1. The `solana-secondary` Buildkite pipeline handles creating the binary tarballs and updated crates.  Look for a job under the tag name of the release: https://buildkite.com/solana-labs/solana-secondary
-1. [Crates.io](https://crates.io/crates/solana) should have an updated Solana version.
+Go to [Solana Releases](https://github.com/solana-labs/solana/releases) and click on the latest release that you just published.
+Verify that all of the build artifacts are present, then the uncheck **"This is a pre-release"** for the release.
 
-### Update documentation
-TODO: Documentation update procedure is WIP as we move to gitbook
+Build artifacts can take up to 60 minutes after creating the tag before
+appearing.  To check for progress:
+* The `solana-secondary` Buildkite pipeline handles creating the Linux release artifacts and updated crates.  Look for a job under the tag name of the release: https://buildkite.com/solana-labs/solana-secondary.
+* The macOS and Windows release artifacts are produced by Travis CI: https://travis-ci.com/github/solana-labs/solana/branches
 
-Document the new recommended version by updating `docs/src/running-archiver.md` and `docs/src/validator-testnet.md` on the release (beta) branch to point at the `solana-install` for the upcoming release version.
+[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
-
-The testnet running on devnet.solana.com is set to use a fixed release tag
-which is set in the Buildkite testnet-management pipeline.
-This tag needs to be updated and the testnet restarted after a new release
-tag is created.
-
-#### Update testnet schedules
-
-Go to https://buildkite.com/solana-labs and click through: Pipelines ->
-testnet-management -> Pipeline Settings -> Schedules
-Or just click here:
-https://buildkite.com/solana-labs/testnet-management/settings/schedules
-
-There are two scheduled jobs for testnet: a daily restart and an hourly sanity-or-restart. \
-https://buildkite.com/solana-labs/testnet-management/settings/schedules/0efd7856-7143-4713-8817-47e6bdb05387
-https://buildkite.com/solana-labs/testnet-management/settings/schedules/2a926646-d972-42b5-aeb9-bb6759592a53
-
-On each schedule:
-1.  Set TESTNET_TAG environment variable to the desired release tag.
-    1. Example, TESTNET_TAG=v0.13.2
-1.  Set the Build Branch to the branch that TESTNET_TAG is from.
-    1. Example: v0.13
-
-#### Restart the testnet
-
-Trigger a TESTNET_OP=create-and-start to refresh the cluster with the new version
-
-1.  Go to https://buildkite.com/solana-labs/testnet-management
-2.  Click "New Build" and use the following settings, then click "Create Build"
-    1.  Commit: HEAD
-    1.  Branch: [channel branch as set in the schedules]
-    1.  Environment Variables:
-```
-TESTNET=testnet
-TESTNET_TAG=[same value as used in TESTNET_TAG in the schedules]
-TESTNET_OP=create-and-start
-```
-
-### Alert the community
-
-Notify Discord users on #validator-support that a new release for
-devnet.solana.com is available
+### Update software on devnet.solana.com/testnet.solama.com/mainnet-beta.solana.com
+See the documentation at https://github.com/solana-labs/cluster-ops/

account-decoder/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "solana-account-decoder"
+version = "1.3.2"
+description = "Solana account decoder"
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+repository = "https://github.com/solana-labs/solana"
+homepage = "https://solana.com/"
+license = "Apache-2.0"
+edition = "2018"
+
+[dependencies]
+base64 = "0.12.3"
+bincode = "1.3.1"
+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"
+thiserror = "1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

account-decoder/src/lib.rs

@@ -0,0 +1,173 @@
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate serde_derive;
+
+pub mod parse_account_data;
+pub mod parse_config;
+pub mod parse_nonce;
+pub mod parse_stake;
+pub mod parse_sysvar;
+pub mod parse_token;
+pub mod parse_vote;
+pub mod validator_info;
+
+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;
+
+/// A duplicate representation of an Account for pretty JSON serialization
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct UiAccount {
+    pub lamports: u64,
+    pub data: UiAccountData,
+    pub owner: String,
+    pub executable: bool,
+    pub rent_epoch: Epoch,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum UiAccountData {
+    Binary(String),
+    Json(ParsedAccount),
+    Binary64(String),
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum UiAccountEncoding {
+    Binary,
+    JsonParsed,
+    Binary64,
+}
+
+impl UiAccount {
+    pub fn encode(
+        pubkey: &Pubkey,
+        account: Account,
+        encoding: UiAccountEncoding,
+        additional_data: Option<AccountAdditionalData>,
+        data_slice_config: Option<UiDataSliceConfig>,
+    ) -> Self {
+        let data = match encoding {
+            UiAccountEncoding::Binary => UiAccountData::Binary(
+                bs58::encode(slice_data(&account.data, data_slice_config)).into_string(),
+            ),
+            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::Binary64(base64::encode(&account.data))
+                }
+            }
+        };
+        UiAccount {
+            lamports: account.lamports,
+            data,
+            owner: account.owner.to_string(),
+            executable: account.executable,
+            rent_epoch: account.rent_epoch,
+        }
+    }
+
+    pub fn decode(&self) -> Option<Account> {
+        let data = match &self.data {
+            UiAccountData::Json(_) => None,
+            UiAccountData::Binary(blob) => bs58::decode(blob).into_vec().ok(),
+            UiAccountData::Binary64(blob) => base64::decode(blob).ok(),
+        }?;
+        Some(Account {
+            lamports: self.lamports,
+            data,
+            owner: Pubkey::from_str(&self.owner).ok()?,
+            executable: self.executable,
+            rent_epoch: self.rent_epoch,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiFeeCalculator {
+    pub lamports_per_signature: StringAmount,
+}
+
+impl From<FeeCalculator> for UiFeeCalculator {
+    fn from(fee_calculator: FeeCalculator) -> Self {
+        Self {
+            lamports_per_signature: fee_calculator.lamports_per_signature.to_string(),
+        }
+    }
+}
+
+impl Default for UiFeeCalculator {
+    fn default() -> Self {
+        Self {
+            lamports_per_signature: "0".to_string(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UiDataSliceConfig {
+    pub offset: usize,
+    pub length: usize,
+}
+
+fn slice_data(data: &[u8], data_slice_config: Option<UiDataSliceConfig>) -> &[u8] {
+    if let Some(UiDataSliceConfig { offset, length }) = data_slice_config {
+        if offset >= data.len() {
+            &[]
+        } else if length > data.len() - offset {
+            &data[offset..]
+        } else {
+            &data[offset..offset + length]
+        }
+    } else {
+        data
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_slice_data() {
+        let data = vec![1, 2, 3, 4, 5];
+        let slice_config = Some(UiDataSliceConfig {
+            offset: 0,
+            length: 5,
+        });
+        assert_eq!(slice_data(&data, slice_config), &data[..]);
+
+        let slice_config = Some(UiDataSliceConfig {
+            offset: 0,
+            length: 10,
+        });
+        assert_eq!(slice_data(&data, slice_config), &data[..]);
+
+        let slice_config = Some(UiDataSliceConfig {
+            offset: 1,
+            length: 2,
+        });
+        assert_eq!(slice_data(&data, slice_config), &data[1..3]);
+
+        let slice_config = Some(UiDataSliceConfig {
+            offset: 10,
+            length: 2,
+        });
+        assert_eq!(slice_data(&data, slice_config), &[] as &[u8]);
+    }
+}

account-decoder/src/parse_account_data.rs

@@ -0,0 +1,145 @@
+use crate::{
+    parse_config::parse_config,
+    parse_nonce::parse_nonce,
+    parse_stake::parse_stake,
+    parse_sysvar::parse_sysvar,
+    parse_token::{parse_token, spl_token_id_v1_0},
+    parse_vote::parse_vote,
+};
+use inflector::Inflector;
+use serde_json::Value;
+use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, system_program, sysvar};
+use std::collections::HashMap;
+use thiserror::Error;
+
+lazy_static! {
+    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_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(*CONFIG_PROGRAM_ID, ParsableAccount::Config);
+        m.insert(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
+        m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::SplToken);
+        m.insert(*STAKE_PROGRAM_ID, ParsableAccount::Stake);
+        m.insert(*SYSVAR_PROGRAM_ID, ParsableAccount::Sysvar);
+        m.insert(*VOTE_PROGRAM_ID, ParsableAccount::Vote);
+        m
+    };
+}
+
+#[derive(Error, Debug)]
+pub enum ParseAccountError {
+    #[error("{0:?} account not parsable")]
+    AccountNotParsable(ParsableAccount),
+
+    #[error("Program not parsable")]
+    ProgramNotParsable,
+
+    #[error("Additional data required to parse: {0}")]
+    AdditionalDataMissing(String),
+
+    #[error("Instruction error")]
+    InstructionError(#[from] InstructionError),
+
+    #[error("Serde json error")]
+    SerdeJsonError(#[from] serde_json::error::Error),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ParsedAccount {
+    pub program: String,
+    pub parsed: Value,
+    pub space: u64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ParsableAccount {
+    Config,
+    Nonce,
+    SplToken,
+    Stake,
+    Sysvar,
+    Vote,
+}
+
+#[derive(Default)]
+pub struct AccountAdditionalData {
+    pub spl_token_decimals: Option<u8>,
+}
+
+pub fn parse_account_data(
+    pubkey: &Pubkey,
+    program_id: &Pubkey,
+    data: &[u8],
+    additional_data: Option<AccountAdditionalData>,
+) -> Result<ParsedAccount, ParseAccountError> {
+    let program_name = PARSABLE_PROGRAM_IDS
+        .get(program_id)
+        .ok_or_else(|| ParseAccountError::ProgramNotParsable)?;
+    let additional_data = additional_data.unwrap_or_default();
+    let parsed_json = match program_name {
+        ParsableAccount::Config => serde_json::to_value(parse_config(data, pubkey)?)?,
+        ParsableAccount::Nonce => serde_json::to_value(parse_nonce(data)?)?,
+        ParsableAccount::SplToken => {
+            serde_json::to_value(parse_token(data, additional_data.spl_token_decimals)?)?
+        }
+        ParsableAccount::Stake => serde_json::to_value(parse_stake(data)?)?,
+        ParsableAccount::Sysvar => serde_json::to_value(parse_sysvar(data, pubkey)?)?,
+        ParsableAccount::Vote => serde_json::to_value(parse_vote(data)?)?,
+    };
+    Ok(ParsedAccount {
+        program: format!("{:?}", program_name).to_kebab_case(),
+        parsed: parsed_json,
+        space: data.len() as u64,
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_sdk::nonce::{
+        state::{Data, Versions},
+        State,
+    };
+    use solana_vote_program::vote_state::{VoteState, VoteStateVersions};
+
+    #[test]
+    fn test_parse_account_data() {
+        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::Current(Box::new(vote_state));
+        VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
+        let parsed = parse_account_data(
+            &account_pubkey,
+            &solana_vote_program::id(),
+            &vote_account_data,
+            None,
+        )
+        .unwrap();
+        assert_eq!(parsed.program, "vote".to_string());
+        assert_eq!(parsed.space, VoteState::size_of() as u64);
+
+        let nonce_data = Versions::new_current(State::Initialized(Data::default()));
+        let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
+        let parsed = parse_account_data(
+            &account_pubkey,
+            &system_program::id(),
+            &nonce_account_data,
+            None,
+        )
+        .unwrap();
+        assert_eq!(parsed.program, "nonce".to_string());
+        assert_eq!(parsed.space, State::size() as u64);
+    }
+}

account-decoder/src/parse_config.rs

@@ -0,0 +1,146 @@
+use crate::{
+    parse_account_data::{ParsableAccount, ParseAccountError},
+    validator_info,
+};
+use bincode::deserialize;
+use serde_json::Value;
+use solana_config_program::{get_config_data, ConfigKeys};
+use solana_sdk::pubkey::Pubkey;
+use solana_stake_program::config::Config as StakeConfig;
+
+pub fn parse_config(data: &[u8], pubkey: &Pubkey) -> Result<ConfigAccountType, ParseAccountError> {
+    let parsed_account = if pubkey == &solana_stake_program::config::id() {
+        get_config_data(data)
+            .ok()
+            .and_then(|data| deserialize::<StakeConfig>(data).ok())
+            .map(|config| ConfigAccountType::StakeConfig(config.into()))
+    } else {
+        deserialize::<ConfigKeys>(data).ok().and_then(|key_list| {
+            if !key_list.keys.is_empty() && key_list.keys[0].0 == validator_info::id() {
+                parse_config_data::<String>(data, key_list.keys).and_then(|validator_info| {
+                    Some(ConfigAccountType::ValidatorInfo(UiConfig {
+                        keys: validator_info.keys,
+                        config_data: serde_json::from_str(&validator_info.config_data).ok()?,
+                    }))
+                })
+            } else {
+                None
+            }
+        })
+    };
+    parsed_account.ok_or(ParseAccountError::AccountNotParsable(
+        ParsableAccount::Config,
+    ))
+}
+
+fn parse_config_data<T>(data: &[u8], keys: Vec<(Pubkey, bool)>) -> Option<UiConfig<T>>
+where
+    T: serde::de::DeserializeOwned,
+{
+    let config_data: T = deserialize(&get_config_data(data).ok()?).ok()?;
+    let keys = keys
+        .iter()
+        .map(|key| UiConfigKey {
+            pubkey: key.0.to_string(),
+            signer: key.1,
+        })
+        .collect();
+    Some(UiConfig { keys, config_data })
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum ConfigAccountType {
+    StakeConfig(UiStakeConfig),
+    ValidatorInfo(UiConfig<Value>),
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiConfigKey {
+    pub pubkey: String,
+    pub signer: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiStakeConfig {
+    pub warmup_cooldown_rate: f64,
+    pub slash_penalty: u8,
+}
+
+impl From<StakeConfig> for UiStakeConfig {
+    fn from(config: StakeConfig) -> Self {
+        Self {
+            warmup_cooldown_rate: config.warmup_cooldown_rate,
+            slash_penalty: config.slash_penalty,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiConfig<T> {
+    pub keys: Vec<UiConfigKey>,
+    pub config_data: T,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::validator_info::ValidatorInfo;
+    use serde_json::json;
+    use solana_config_program::create_config_account;
+
+    #[test]
+    fn test_parse_config() {
+        let stake_config = StakeConfig {
+            warmup_cooldown_rate: 0.25,
+            slash_penalty: 50,
+        };
+        let stake_config_account = create_config_account(vec![], &stake_config, 10);
+        assert_eq!(
+            parse_config(
+                &stake_config_account.data,
+                &solana_stake_program::config::id()
+            )
+            .unwrap(),
+            ConfigAccountType::StakeConfig(UiStakeConfig {
+                warmup_cooldown_rate: 0.25,
+                slash_penalty: 50,
+            }),
+        );
+
+        let validator_info = ValidatorInfo {
+            info: serde_json::to_string(&json!({
+                "name": "Solana",
+            }))
+            .unwrap(),
+        };
+        let info_pubkey = Pubkey::new_rand();
+        let validator_info_config_account = create_config_account(
+            vec![(validator_info::id(), false), (info_pubkey, true)],
+            &validator_info,
+            10,
+        );
+        assert_eq!(
+            parse_config(&validator_info_config_account.data, &info_pubkey).unwrap(),
+            ConfigAccountType::ValidatorInfo(UiConfig {
+                keys: vec![
+                    UiConfigKey {
+                        pubkey: validator_info::id().to_string(),
+                        signer: false,
+                    },
+                    UiConfigKey {
+                        pubkey: info_pubkey.to_string(),
+                        signer: true,
+                    }
+                ],
+                config_data: serde_json::from_str(r#"{"name":"Solana"}"#).unwrap(),
+            }),
+        );
+
+        let bad_data = vec![0; 4];
+        assert!(parse_config(&bad_data, &info_pubkey).is_err());
+    }
+}

account-decoder/src/parse_nonce.rs

@@ -0,0 +1,67 @@
+use crate::{parse_account_data::ParseAccountError, UiFeeCalculator};
+use solana_sdk::{
+    instruction::InstructionError,
+    nonce::{state::Versions, State},
+};
+
+pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> {
+    let nonce_state: Versions = bincode::deserialize(data)
+        .map_err(|_| ParseAccountError::from(InstructionError::InvalidAccountData))?;
+    let nonce_state = nonce_state.convert_to_current();
+    match nonce_state {
+        State::Uninitialized => Ok(UiNonceState::Uninitialized),
+        State::Initialized(data) => Ok(UiNonceState::Initialized(UiNonceData {
+            authority: data.authority.to_string(),
+            blockhash: data.blockhash.to_string(),
+            fee_calculator: data.fee_calculator.into(),
+        })),
+    }
+}
+
+/// A duplicate representation of NonceState for pretty JSON serialization
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum UiNonceState {
+    Uninitialized,
+    Initialized(UiNonceData),
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiNonceData {
+    pub authority: String,
+    pub blockhash: String,
+    pub fee_calculator: UiFeeCalculator,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_sdk::{
+        hash::Hash,
+        nonce::{
+            state::{Data, Versions},
+            State,
+        },
+        pubkey::Pubkey,
+    };
+
+    #[test]
+    fn test_parse_nonce() {
+        let nonce_data = Versions::new_current(State::Initialized(Data::default()));
+        let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
+        assert_eq!(
+            parse_nonce(&nonce_account_data).unwrap(),
+            UiNonceState::Initialized(UiNonceData {
+                authority: Pubkey::default().to_string(),
+                blockhash: Hash::default().to_string(),
+                fee_calculator: UiFeeCalculator {
+                    lamports_per_signature: 0.to_string(),
+                },
+            }),
+        );
+
+        let bad_data = vec![0; 4];
+        assert!(parse_nonce(&bad_data).is_err());
+    }
+}

account-decoder/src/parse_stake.rs

@@ -0,0 +1,235 @@
+use crate::{
+    parse_account_data::{ParsableAccount, ParseAccountError},
+    StringAmount,
+};
+use bincode::deserialize;
+use solana_sdk::clock::{Epoch, UnixTimestamp};
+use solana_stake_program::stake_state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState};
+
+pub fn parse_stake(data: &[u8]) -> Result<StakeAccountType, ParseAccountError> {
+    let stake_state: StakeState = deserialize(data)
+        .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::Stake))?;
+    let parsed_account = match stake_state {
+        StakeState::Uninitialized => StakeAccountType::Uninitialized,
+        StakeState::Initialized(meta) => StakeAccountType::Initialized(UiStakeAccount {
+            meta: meta.into(),
+            stake: None,
+        }),
+        StakeState::Stake(meta, stake) => StakeAccountType::Delegated(UiStakeAccount {
+            meta: meta.into(),
+            stake: Some(stake.into()),
+        }),
+        StakeState::RewardsPool => StakeAccountType::RewardsPool,
+    };
+    Ok(parsed_account)
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum StakeAccountType {
+    Uninitialized,
+    Initialized(UiStakeAccount),
+    Delegated(UiStakeAccount),
+    RewardsPool,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiStakeAccount {
+    pub meta: UiMeta,
+    pub stake: Option<UiStake>,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiMeta {
+    pub rent_exempt_reserve: StringAmount,
+    pub authorized: UiAuthorized,
+    pub lockup: UiLockup,
+}
+
+impl From<Meta> for UiMeta {
+    fn from(meta: Meta) -> Self {
+        Self {
+            rent_exempt_reserve: meta.rent_exempt_reserve.to_string(),
+            authorized: meta.authorized.into(),
+            lockup: meta.lockup.into(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiLockup {
+    pub unix_timestamp: UnixTimestamp,
+    pub epoch: Epoch,
+    pub custodian: String,
+}
+
+impl From<Lockup> for UiLockup {
+    fn from(lockup: Lockup) -> Self {
+        Self {
+            unix_timestamp: lockup.unix_timestamp,
+            epoch: lockup.epoch,
+            custodian: lockup.custodian.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiAuthorized {
+    pub staker: String,
+    pub withdrawer: String,
+}
+
+impl From<Authorized> for UiAuthorized {
+    fn from(authorized: Authorized) -> Self {
+        Self {
+            staker: authorized.staker.to_string(),
+            withdrawer: authorized.withdrawer.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiStake {
+    pub delegation: UiDelegation,
+    pub credits_observed: u64,
+}
+
+impl From<Stake> for UiStake {
+    fn from(stake: Stake) -> Self {
+        Self {
+            delegation: stake.delegation.into(),
+            credits_observed: stake.credits_observed,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiDelegation {
+    pub voter: String,
+    pub stake: StringAmount,
+    pub activation_epoch: StringAmount,
+    pub deactivation_epoch: StringAmount,
+    pub warmup_cooldown_rate: f64,
+}
+
+impl From<Delegation> for UiDelegation {
+    fn from(delegation: Delegation) -> Self {
+        Self {
+            voter: delegation.voter_pubkey.to_string(),
+            stake: delegation.stake.to_string(),
+            activation_epoch: delegation.activation_epoch.to_string(),
+            deactivation_epoch: delegation.deactivation_epoch.to_string(),
+            warmup_cooldown_rate: delegation.warmup_cooldown_rate,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use bincode::serialize;
+    use solana_sdk::pubkey::Pubkey;
+
+    #[test]
+    fn test_parse_stake() {
+        let stake_state = StakeState::Uninitialized;
+        let stake_data = serialize(&stake_state).unwrap();
+        assert_eq!(
+            parse_stake(&stake_data).unwrap(),
+            StakeAccountType::Uninitialized
+        );
+
+        let pubkey = Pubkey::new_rand();
+        let custodian = Pubkey::new_rand();
+        let authorized = Authorized::auto(&pubkey);
+        let lockup = Lockup {
+            unix_timestamp: 0,
+            epoch: 1,
+            custodian,
+        };
+        let meta = Meta {
+            rent_exempt_reserve: 42,
+            authorized,
+            lockup,
+        };
+
+        let stake_state = StakeState::Initialized(meta);
+        let stake_data = serialize(&stake_state).unwrap();
+        assert_eq!(
+            parse_stake(&stake_data).unwrap(),
+            StakeAccountType::Initialized(UiStakeAccount {
+                meta: UiMeta {
+                    rent_exempt_reserve: 42.to_string(),
+                    authorized: UiAuthorized {
+                        staker: pubkey.to_string(),
+                        withdrawer: pubkey.to_string(),
+                    },
+                    lockup: UiLockup {
+                        unix_timestamp: 0,
+                        epoch: 1,
+                        custodian: custodian.to_string(),
+                    }
+                },
+                stake: None,
+            })
+        );
+
+        let voter_pubkey = Pubkey::new_rand();
+        let stake = Stake {
+            delegation: Delegation {
+                voter_pubkey,
+                stake: 20,
+                activation_epoch: 2,
+                deactivation_epoch: std::u64::MAX,
+                warmup_cooldown_rate: 0.25,
+            },
+            credits_observed: 10,
+        };
+
+        let stake_state = StakeState::Stake(meta, stake);
+        let stake_data = serialize(&stake_state).unwrap();
+        assert_eq!(
+            parse_stake(&stake_data).unwrap(),
+            StakeAccountType::Delegated(UiStakeAccount {
+                meta: UiMeta {
+                    rent_exempt_reserve: 42.to_string(),
+                    authorized: UiAuthorized {
+                        staker: pubkey.to_string(),
+                        withdrawer: pubkey.to_string(),
+                    },
+                    lockup: UiLockup {
+                        unix_timestamp: 0,
+                        epoch: 1,
+                        custodian: custodian.to_string(),
+                    }
+                },
+                stake: Some(UiStake {
+                    delegation: UiDelegation {
+                        voter: voter_pubkey.to_string(),
+                        stake: 20.to_string(),
+                        activation_epoch: 2.to_string(),
+                        deactivation_epoch: std::u64::MAX.to_string(),
+                        warmup_cooldown_rate: 0.25,
+                    },
+                    credits_observed: 10,
+                })
+            })
+        );
+
+        let stake_state = StakeState::RewardsPool;
+        let stake_data = serialize(&stake_state).unwrap();
+        assert_eq!(
+            parse_stake(&stake_data).unwrap(),
+            StakeAccountType::RewardsPool
+        );
+
+        let bad_data = vec![1, 2, 3, 4];
+        assert!(parse_stake(&bad_data).is_err());
+    }
+}

account-decoder/src/parse_sysvar.rs

@@ -0,0 +1,328 @@
+use crate::{
+    parse_account_data::{ParsableAccount, ParseAccountError},
+    StringAmount, UiFeeCalculator,
+};
+use bincode::deserialize;
+use bv::BitVec;
+use solana_sdk::{
+    clock::{Clock, Epoch, Slot, UnixTimestamp},
+    epoch_schedule::EpochSchedule,
+    pubkey::Pubkey,
+    rent::Rent,
+    slot_hashes::SlotHashes,
+    slot_history::{self, SlotHistory},
+    stake_history::{StakeHistory, StakeHistoryEntry},
+    sysvar::{self, fees::Fees, recent_blockhashes::RecentBlockhashes, rewards::Rewards},
+};
+
+pub fn parse_sysvar(data: &[u8], pubkey: &Pubkey) -> Result<SysvarAccountType, ParseAccountError> {
+    let parsed_account = {
+        if pubkey == &sysvar::clock::id() {
+            deserialize::<Clock>(data)
+                .ok()
+                .map(|clock| SysvarAccountType::Clock(clock.into()))
+        } else if pubkey == &sysvar::epoch_schedule::id() {
+            deserialize(data).ok().map(SysvarAccountType::EpochSchedule)
+        } else if pubkey == &sysvar::fees::id() {
+            deserialize::<Fees>(data)
+                .ok()
+                .map(|fees| SysvarAccountType::Fees(fees.into()))
+        } else if pubkey == &sysvar::recent_blockhashes::id() {
+            deserialize::<RecentBlockhashes>(data)
+                .ok()
+                .map(|recent_blockhashes| {
+                    let recent_blockhashes = recent_blockhashes
+                        .iter()
+                        .map(|entry| UiRecentBlockhashesEntry {
+                            blockhash: entry.blockhash.to_string(),
+                            fee_calculator: entry.fee_calculator.clone().into(),
+                        })
+                        .collect();
+                    SysvarAccountType::RecentBlockhashes(recent_blockhashes)
+                })
+        } else if pubkey == &sysvar::rent::id() {
+            deserialize::<Rent>(data)
+                .ok()
+                .map(|rent| SysvarAccountType::Rent(rent.into()))
+        } else if pubkey == &sysvar::rewards::id() {
+            deserialize::<Rewards>(data)
+                .ok()
+                .map(|rewards| SysvarAccountType::Rewards(rewards.into()))
+        } else if pubkey == &sysvar::slot_hashes::id() {
+            deserialize::<SlotHashes>(data).ok().map(|slot_hashes| {
+                let slot_hashes = slot_hashes
+                    .iter()
+                    .map(|slot_hash| UiSlotHashEntry {
+                        slot: slot_hash.0,
+                        hash: slot_hash.1.to_string(),
+                    })
+                    .collect();
+                SysvarAccountType::SlotHashes(slot_hashes)
+            })
+        } else if pubkey == &sysvar::slot_history::id() {
+            deserialize::<SlotHistory>(data).ok().map(|slot_history| {
+                SysvarAccountType::SlotHistory(UiSlotHistory {
+                    next_slot: slot_history.next_slot,
+                    bits: format!("{:?}", SlotHistoryBits(slot_history.bits)),
+                })
+            })
+        } else if pubkey == &sysvar::stake_history::id() {
+            deserialize::<StakeHistory>(data).ok().map(|stake_history| {
+                let stake_history = stake_history
+                    .iter()
+                    .map(|entry| UiStakeHistoryEntry {
+                        epoch: entry.0,
+                        stake_history: entry.1.clone(),
+                    })
+                    .collect();
+                SysvarAccountType::StakeHistory(stake_history)
+            })
+        } else {
+            None
+        }
+    };
+    parsed_account.ok_or(ParseAccountError::AccountNotParsable(
+        ParsableAccount::Sysvar,
+    ))
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum SysvarAccountType {
+    Clock(UiClock),
+    EpochSchedule(EpochSchedule),
+    Fees(UiFees),
+    RecentBlockhashes(Vec<UiRecentBlockhashesEntry>),
+    Rent(UiRent),
+    Rewards(UiRewards),
+    SlotHashes(Vec<UiSlotHashEntry>),
+    SlotHistory(UiSlotHistory),
+    StakeHistory(Vec<UiStakeHistoryEntry>),
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct UiClock {
+    pub slot: Slot,
+    pub epoch: Epoch,
+    pub leader_schedule_epoch: Epoch,
+    pub unix_timestamp: UnixTimestamp,
+}
+
+impl From<Clock> for UiClock {
+    fn from(clock: Clock) -> Self {
+        Self {
+            slot: clock.slot,
+            epoch: clock.epoch,
+            leader_schedule_epoch: clock.leader_schedule_epoch,
+            unix_timestamp: clock.unix_timestamp,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct UiFees {
+    pub fee_calculator: UiFeeCalculator,
+}
+impl From<Fees> for UiFees {
+    fn from(fees: Fees) -> Self {
+        Self {
+            fee_calculator: fees.fee_calculator.into(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct UiRent {
+    pub lamports_per_byte_year: StringAmount,
+    pub exemption_threshold: f64,
+    pub burn_percent: u8,
+}
+
+impl From<Rent> for UiRent {
+    fn from(rent: Rent) -> Self {
+        Self {
+            lamports_per_byte_year: rent.lamports_per_byte_year.to_string(),
+            exemption_threshold: rent.exemption_threshold,
+            burn_percent: rent.burn_percent,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct UiRewards {
+    pub validator_point_value: f64,
+}
+
+impl From<Rewards> for UiRewards {
+    fn from(rewards: Rewards) -> Self {
+        Self {
+            validator_point_value: rewards.validator_point_value,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiRecentBlockhashesEntry {
+    pub blockhash: String,
+    pub fee_calculator: UiFeeCalculator,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiSlotHashEntry {
+    pub slot: Slot,
+    pub hash: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiSlotHistory {
+    pub next_slot: Slot,
+    pub bits: String,
+}
+
+struct SlotHistoryBits(BitVec<u64>);
+
+impl std::fmt::Debug for SlotHistoryBits {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for i in 0..slot_history::MAX_ENTRIES {
+            if self.0.get(i) {
+                write!(f, "1")?;
+            } else {
+                write!(f, "0")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiStakeHistoryEntry {
+    pub epoch: Epoch,
+    pub stake_history: StakeHistoryEntry,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_sdk::{
+        fee_calculator::FeeCalculator,
+        hash::Hash,
+        sysvar::{recent_blockhashes::IterItem, Sysvar},
+    };
+    use std::iter::FromIterator;
+
+    #[test]
+    fn test_parse_sysvars() {
+        let clock_sysvar = Clock::default().create_account(1);
+        assert_eq!(
+            parse_sysvar(&clock_sysvar.data, &sysvar::clock::id()).unwrap(),
+            SysvarAccountType::Clock(UiClock::default()),
+        );
+
+        let epoch_schedule = EpochSchedule {
+            slots_per_epoch: 12,
+            leader_schedule_slot_offset: 0,
+            warmup: false,
+            first_normal_epoch: 1,
+            first_normal_slot: 12,
+        };
+        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 = Fees::default().create_account(1);
+        assert_eq!(
+            parse_sysvar(&fees_sysvar.data, &sysvar::fees::id()).unwrap(),
+            SysvarAccountType::Fees(UiFees::default()),
+        );
+
+        let hash = Hash::new(&[1; 32]);
+        let fee_calculator = FeeCalculator {
+            lamports_per_signature: 10,
+        };
+        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,
+                &sysvar::recent_blockhashes::id()
+            )
+            .unwrap(),
+            SysvarAccountType::RecentBlockhashes(vec![UiRecentBlockhashesEntry {
+                blockhash: hash.to_string(),
+                fee_calculator: fee_calculator.into(),
+            }]),
+        );
+
+        let rent = Rent {
+            lamports_per_byte_year: 10,
+            exemption_threshold: 2.0,
+            burn_percent: 5,
+        };
+        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 = Rewards::default().create_account(1);
+        assert_eq!(
+            parse_sysvar(&rewards_sysvar.data, &sysvar::rewards::id()).unwrap(),
+            SysvarAccountType::Rewards(UiRewards::default()),
+        );
+
+        let mut slot_hashes = SlotHashes::default();
+        slot_hashes.add(1, hash);
+        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 {
+                slot: 1,
+                hash: hash.to_string(),
+            }]),
+        );
+
+        let mut slot_history = SlotHistory::default();
+        slot_history.add(42);
+        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 {
+                next_slot: slot_history.next_slot,
+                bits: format!("{:?}", SlotHistoryBits(slot_history.bits)),
+            }),
+        );
+
+        let mut stake_history = StakeHistory::default();
+        let stake_history_entry = StakeHistoryEntry {
+            effective: 10,
+            activating: 2,
+            deactivating: 3,
+        };
+        stake_history.add(1, stake_history_entry.clone());
+        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 {
+                epoch: 1,
+                stake_history: stake_history_entry,
+            }]),
+        );
+
+        let bad_pubkey = Pubkey::new_rand();
+        assert!(parse_sysvar(&stake_history_sysvar.data, &bad_pubkey).is_err());
+
+        let bad_data = vec![0; 4];
+        assert!(parse_sysvar(&bad_data, &sysvar::stake_history::id()).is_err());
+    }
+}

account-decoder/src/parse_token.rs

@@ -0,0 +1,250 @@
+use crate::{
+    parse_account_data::{ParsableAccount, ParseAccountError},
+    StringAmount,
+};
+use solana_sdk::pubkey::Pubkey;
+use spl_token_v1_0::{
+    option::COption,
+    solana_sdk::pubkey::Pubkey as SplTokenPubkey,
+    state::{unpack, Account, Mint, Multisig},
+};
+use std::{mem::size_of, str::FromStr};
+
+// 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_v1_0() -> Pubkey {
+    Pubkey::from_str(&spl_token_v1_0::id().to_string()).unwrap()
+}
+
+// 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_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> {
+    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(
+                "no mint_decimals provided to parse spl-token account".to_string(),
+            )
+        })?;
+        Ok(TokenAccountType::Account(UiTokenAccount {
+            mint: account.mint.to_string(),
+            owner: account.owner.to_string(),
+            token_amount: token_amount_to_ui_amount(account.amount, decimals),
+            delegate: match account.delegate {
+                COption::Some(pubkey) => Some(pubkey.to_string()),
+                COption::None => None,
+            },
+            is_initialized: account.is_initialized,
+            is_native: account.is_native,
+            delegated_amount: if account.delegate.is_none() {
+                None
+            } else {
+                Some(token_amount_to_ui_amount(
+                    account.delegated_amount,
+                    decimals,
+                ))
+            },
+        }))
+    } else if data.len() == size_of::<Mint>() {
+        let mint: Mint = *unpack(&mut data)
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
+        Ok(TokenAccountType::Mint(UiMint {
+            owner: match mint.owner {
+                COption::Some(pubkey) => Some(pubkey.to_string()),
+                COption::None => None,
+            },
+            decimals: mint.decimals,
+            is_initialized: mint.is_initialized,
+        }))
+    } 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,
+            num_valid_signers: multisig.n,
+            is_initialized: multisig.is_initialized,
+            signers: multisig
+                .signers
+                .iter()
+                .filter_map(|pubkey| {
+                    if pubkey != &SplTokenPubkey::default() {
+                        Some(pubkey.to_string())
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+        }))
+    } else {
+        Err(ParseAccountError::AccountNotParsable(
+            ParsableAccount::SplToken,
+        ))
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum TokenAccountType {
+    Account(UiTokenAccount),
+    Mint(UiMint),
+    Multisig(UiMultisig),
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiTokenAccount {
+    pub mint: String,
+    pub owner: String,
+    pub token_amount: UiTokenAmount,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delegate: Option<String>,
+    pub is_initialized: bool,
+    pub is_native: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delegated_amount: Option<UiTokenAmount>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiTokenAmount {
+    pub ui_amount: f64,
+    pub decimals: u8,
+    pub amount: StringAmount,
+}
+
+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;
+    UiTokenAmount {
+        ui_amount: amount_decimals,
+        decimals,
+        amount: amount.to_string(),
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiMint {
+    pub owner: Option<String>,
+    pub decimals: u8,
+    pub is_initialized: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiMultisig {
+    pub num_required_signers: u8,
+    pub num_valid_signers: u8,
+    pub is_initialized: bool,
+    pub signers: Vec<String>,
+}
+
+pub fn get_token_account_mint(data: &[u8]) -> Option<Pubkey> {
+    if data.len() == size_of::<Account>() {
+        Some(Pubkey::new(&data[0..32]))
+    } else {
+        None
+    }
+}
+
+#[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 = [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.is_initialized = true;
+        assert!(parse_token(&account_data, None).is_err());
+        assert_eq!(
+            parse_token(&account_data, Some(2)).unwrap(),
+            TokenAccountType::Account(UiTokenAccount {
+                mint: mint_pubkey.to_string(),
+                owner: owner_pubkey.to_string(),
+                token_amount: UiTokenAmount {
+                    ui_amount: 0.42,
+                    decimals: 2,
+                    amount: "42".to_string()
+                },
+                delegate: None,
+                is_initialized: true,
+                is_native: false,
+                delegated_amount: None,
+            }),
+        );
+
+        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;
+        assert_eq!(
+            parse_token(&mint_data, None).unwrap(),
+            TokenAccountType::Mint(UiMint {
+                owner: Some(owner_pubkey.to_string()),
+                decimals: 3,
+                is_initialized: true,
+            }),
+        );
+
+        let signer1 = SplTokenPubkey::new(&[1; 32]);
+        let signer2 = SplTokenPubkey::new(&[2; 32]);
+        let signer3 = SplTokenPubkey::new(&[3; 32]);
+        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;
+        multisig.m = 2;
+        multisig.n = 3;
+        multisig.is_initialized = true;
+        multisig.signers = signers;
+        assert_eq!(
+            parse_token(&multisig_data, None).unwrap(),
+            TokenAccountType::Multisig(UiMultisig {
+                num_required_signers: 2,
+                num_valid_signers: 3,
+                is_initialized: true,
+                signers: vec![
+                    signer1.to_string(),
+                    signer2.to_string(),
+                    signer3.to_string()
+                ],
+            }),
+        );
+
+        let bad_data = vec![0; 4];
+        assert!(parse_token(&bad_data, None).is_err());
+    }
+
+    #[test]
+    fn test_get_token_account_mint() {
+        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
+        let mut account_data = [0; size_of::<Account>()];
+        let mut account: &mut Account = unpack_unchecked(&mut account_data).unwrap();
+        account.mint = mint_pubkey;
+
+        let expected_mint_pubkey = Pubkey::new(&[2; 32]);
+        assert_eq!(
+            get_token_account_mint(&account_data),
+            Some(expected_mint_pubkey)
+        );
+    }
+}

account-decoder/src/parse_vote.rs

@@ -0,0 +1,144 @@
+use crate::{parse_account_data::ParseAccountError, StringAmount};
+use solana_sdk::{
+    clock::{Epoch, Slot},
+    pubkey::Pubkey,
+};
+use solana_vote_program::vote_state::{BlockTimestamp, Lockout, VoteState};
+
+pub fn parse_vote(data: &[u8]) -> Result<VoteAccountType, ParseAccountError> {
+    let mut vote_state = VoteState::deserialize(data).map_err(ParseAccountError::from)?;
+    let epoch_credits = vote_state
+        .epoch_credits()
+        .iter()
+        .map(|(epoch, credits, previous_credits)| UiEpochCredits {
+            epoch: *epoch,
+            credits: credits.to_string(),
+            previous_credits: previous_credits.to_string(),
+        })
+        .collect();
+    let votes = vote_state
+        .votes
+        .iter()
+        .map(|lockout| UiLockout {
+            slot: lockout.slot,
+            confirmation_count: lockout.confirmation_count,
+        })
+        .collect();
+    let authorized_voters = vote_state
+        .authorized_voters()
+        .iter()
+        .map(|(epoch, authorized_voter)| UiAuthorizedVoters {
+            epoch: *epoch,
+            authorized_voter: authorized_voter.to_string(),
+        })
+        .collect();
+    let prior_voters = vote_state
+        .prior_voters()
+        .buf()
+        .iter()
+        .filter(|(pubkey, _, _)| pubkey != &Pubkey::default())
+        .map(
+            |(authorized_pubkey, epoch_of_last_authorized_switch, target_epoch)| UiPriorVoters {
+                authorized_pubkey: authorized_pubkey.to_string(),
+                epoch_of_last_authorized_switch: *epoch_of_last_authorized_switch,
+                target_epoch: *target_epoch,
+            },
+        )
+        .collect();
+    Ok(VoteAccountType::Vote(UiVoteState {
+        node_pubkey: vote_state.node_pubkey.to_string(),
+        authorized_withdrawer: vote_state.authorized_withdrawer.to_string(),
+        commission: vote_state.commission,
+        votes,
+        root_slot: vote_state.root_slot,
+        authorized_voters,
+        prior_voters,
+        epoch_credits,
+        last_timestamp: vote_state.last_timestamp,
+    }))
+}
+
+/// A wrapper enum for consistency across programs
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum VoteAccountType {
+    Vote(UiVoteState),
+}
+
+/// A duplicate representation of VoteState for pretty JSON serialization
+#[derive(Debug, Serialize, Deserialize, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiVoteState {
+    node_pubkey: String,
+    authorized_withdrawer: String,
+    commission: u8,
+    votes: Vec<UiLockout>,
+    root_slot: Option<Slot>,
+    authorized_voters: Vec<UiAuthorizedVoters>,
+    prior_voters: Vec<UiPriorVoters>,
+    epoch_credits: Vec<UiEpochCredits>,
+    last_timestamp: BlockTimestamp,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+struct UiLockout {
+    slot: Slot,
+    confirmation_count: u32,
+}
+
+impl From<&Lockout> for UiLockout {
+    fn from(lockout: &Lockout) -> Self {
+        Self {
+            slot: lockout.slot,
+            confirmation_count: lockout.confirmation_count,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+struct UiAuthorizedVoters {
+    epoch: Epoch,
+    authorized_voter: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+struct UiPriorVoters {
+    authorized_pubkey: String,
+    epoch_of_last_authorized_switch: Epoch,
+    target_epoch: Epoch,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+struct UiEpochCredits {
+    epoch: Epoch,
+    credits: StringAmount,
+    previous_credits: StringAmount,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_vote_program::vote_state::VoteStateVersions;
+
+    #[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::Current(Box::new(vote_state));
+        VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
+        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)
+        );
+
+        let bad_data = vec![0; 4];
+        assert!(parse_vote(&bad_data).is_err());
+    }
+}

account-decoder/src/validator_info.rs

@@ -0,0 +1,18 @@
+use solana_config_program::ConfigState;
+
+pub const MAX_SHORT_FIELD_LENGTH: usize = 70;
+pub const MAX_LONG_FIELD_LENGTH: usize = 300;
+pub const MAX_VALIDATOR_INFO: u64 = 576;
+
+solana_sdk::declare_id!("Va1idator1nfo111111111111111111111111111111");
+
+#[derive(Debug, Deserialize, PartialEq, Serialize, Default)]
+pub struct ValidatorInfo {
+    pub info: String,
+}
+
+impl ConfigState for ValidatorInfo {
+    fn max_space() -> u64 {
+        MAX_VALIDATOR_INFO
+    }
+}

accounts-bench/Cargo.toml

@@ -1,19 +1,19 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-accounts-bench"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
 log = "0.4.6"
-rayon = "1.3.0"
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
+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"

banking-bench/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -12,17 +12,17 @@ clap = "2.33.1"
 crossbeam-channel = "0.4"
 log = "0.4.6"
 rand = "0.7.0"
-rayon = "1.3.0"
-solana-core = { path = "../core", version = "1.2.0" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-streamer = { path = "../streamer", version = "1.2.0" }
-solana-perf = { path = "../perf", version = "1.2.0" }
-solana-ledger = { path = "../ledger", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
+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"]

banking-bench/src/main.rs

@@ -11,14 +11,13 @@ use solana_core::{
     poh_recorder::WorkingBankEntry,
 };
 use solana_ledger::{
-    bank_forks::BankForks,
     blockstore::Blockstore,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
     get_tmp_ledger_path,
 };
 use solana_measure::measure::Measure;
 use solana_perf::packet::to_packets_chunked;
-use solana_runtime::bank::Bank;
+use solana_runtime::{bank::Bank, bank_forks::BankForks};
 use solana_sdk::{
     hash::Hash,
     pubkey::Pubkey,
@@ -168,8 +167,9 @@ fn main() {
 
     let (verified_sender, verified_receiver) = unbounded();
     let (vote_sender, vote_receiver) = unbounded();
+    let (replay_vote_sender, _replay_vote_receiver) = unbounded();
     let bank0 = Bank::new(&genesis_config);
-    let mut bank_forks = BankForks::new(0, bank0);
+    let mut bank_forks = BankForks::new(bank0);
     let mut bank = bank_forks.working_bank();
 
     info!("threads: {} txs: {}", num_threads, total_num_transactions);
@@ -209,7 +209,7 @@ fn main() {
         bank.clear_signatures();
     }
 
-    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), packets_per_chunk);
+    let mut verified: Vec<_> = to_packets_chunked(&transactions, packets_per_chunk);
     let ledger_path = get_tmp_ledger_path!();
     {
         let blockstore = Arc::new(
@@ -225,6 +225,7 @@ fn main() {
             verified_receiver,
             vote_receiver,
             None,
+            replay_vote_sender,
         );
         poh_recorder.lock().unwrap().set_bank(&bank);
 

bench-exchange/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -15,24 +15,24 @@ log = "0.4.8"
 num-derive = "0.3"
 num-traits = "0.2"
 rand = "0.7.0"
-rayon = "1.3.0"
-serde_json = "1.0.53"
-serde_yaml = "0.8.12"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-core = { path = "../core", version = "1.2.0" }
-solana-genesis = { path = "../genesis", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-metrics = { path = "../metrics", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
+rayon = "1.3.1"
+serde_json = "1.0.56"
+serde_yaml = "0.8.13"
+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.2.0" }
+solana-local-cluster = { path = "../local-cluster", version = "1.3.2" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-exchange/src/bench.rs

@@ -14,6 +14,7 @@ use solana_metrics::datapoint_info;
 use solana_sdk::{
     client::{Client, SyncClient},
     commitment_config::CommitmentConfig,
+    message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     timing::{duration_as_ms, duration_as_s},
@@ -178,19 +179,13 @@ where
 
     info!("Generating {:?} account keys", total_keys);
     let mut account_keypairs = generate_keypairs(total_keys);
-    let src_keypairs: Vec<_> = account_keypairs
-        .drain(0..accounts_in_groups)
-        .map(|keypair| keypair)
-        .collect();
+    let src_keypairs: Vec<_> = account_keypairs.drain(0..accounts_in_groups).collect();
     let src_pubkeys: Vec<Pubkey> = src_keypairs
         .iter()
         .map(|keypair| keypair.pubkey())
         .collect();
 
-    let profit_keypairs: Vec<_> = account_keypairs
-        .drain(0..accounts_in_groups)
-        .map(|keypair| keypair)
-        .collect();
+    let profit_keypairs: Vec<_> = account_keypairs.drain(0..accounts_in_groups).collect();
     let profit_pubkeys: Vec<Pubkey> = profit_keypairs
         .iter()
         .map(|keypair| keypair.pubkey())
@@ -449,7 +444,7 @@ fn swapper<T>(
             }
             account_group = (account_group + 1) % account_groups as usize;
 
-            let (blockhash, _fee_calculator) = client
+            let (blockhash, _fee_calculator, _last_valid_slot) = client
                 .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                 .expect("Failed to get blockhash");
             let to_swap_txs: Vec<_> = to_swap
@@ -457,16 +452,14 @@ fn swapper<T>(
                 .map(|(signer, swap, profit)| {
                     let s: &Keypair = &signer;
                     let owner = &signer.pubkey();
-                    Transaction::new_signed_instructions(
-                        &[s],
-                        &[exchange_instruction::swap_request(
-                            owner,
-                            &swap.0.pubkey,
-                            &swap.1.pubkey,
-                            &profit,
-                        )],
-                        blockhash,
-                    )
+                    let instruction = exchange_instruction::swap_request(
+                        owner,
+                        &swap.0.pubkey,
+                        &swap.1.pubkey,
+                        &profit,
+                    );
+                    let message = Message::new(&[instruction], Some(&s.pubkey()));
+                    Transaction::new(&[s], message, blockhash)
                 })
                 .collect();
 
@@ -577,7 +570,7 @@ fn trader<T>(
         }
         account_group = (account_group + 1) % account_groups as usize;
 
-        let (blockhash, _fee_calculator) = client
+        let (blockhash, _fee_calculator, _last_valid_slot) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
 
@@ -588,28 +581,26 @@ fn trader<T>(
                     let owner_pubkey = &owner.pubkey();
                     let trade_pubkey = &trade.pubkey();
                     let space = mem::size_of::<ExchangeState>() as u64;
-                    Transaction::new_signed_instructions(
-                        &[owner.as_ref(), trade],
-                        &[
-                            system_instruction::create_account(
-                                owner_pubkey,
-                                trade_pubkey,
-                                1,
-                                space,
-                                &id(),
-                            ),
-                            exchange_instruction::trade_request(
-                                owner_pubkey,
-                                trade_pubkey,
-                                *side,
-                                pair,
-                                tokens,
-                                price,
-                                src,
-                            ),
-                        ],
-                        blockhash,
-                    )
+                    let instructions = [
+                        system_instruction::create_account(
+                            owner_pubkey,
+                            trade_pubkey,
+                            1,
+                            space,
+                            &id(),
+                        ),
+                        exchange_instruction::trade_request(
+                            owner_pubkey,
+                            trade_pubkey,
+                            *side,
+                            pair,
+                            tokens,
+                            price,
+                            src,
+                        ),
+                    ];
+                    let message = Message::new(&instructions, Some(&owner_pubkey));
+                    Transaction::new(&[owner.as_ref(), trade], message, blockhash)
                 })
                 .collect();
 
@@ -747,13 +738,9 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
             let mut to_fund_txs: Vec<_> = chunk
                 .par_iter()
                 .map(|(k, m)| {
-                    (
-                        k.clone(),
-                        Transaction::new_unsigned_instructions(&system_instruction::transfer_many(
-                            &k.pubkey(),
-                            &m,
-                        )),
-                    )
+                    let instructions = system_instruction::transfer_many(&k.pubkey(), &m);
+                    let message = Message::new(&instructions, Some(&k.pubkey()));
+                    (k.clone(), Transaction::new_unsigned(message))
                 })
                 .collect();
 
@@ -776,7 +763,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                     to_fund_txs.len(),
                 );
 
-                let (blockhash, _fee_calculator) = client
+                let (blockhash, _fee_calculator, _last_valid_slot) = client
                     .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("blockhash");
                 to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
@@ -848,9 +835,10 @@ pub fn create_token_accounts<T: Client>(
                     );
                     let request_ix =
                         exchange_instruction::account_request(owner_pubkey, &new_keypair.pubkey());
+                    let message = Message::new(&[create_ix, request_ix], Some(&owner_pubkey));
                     (
                         (from_keypair, new_keypair),
-                        Transaction::new_unsigned_instructions(&[create_ix, request_ix]),
+                        Transaction::new_unsigned(message),
                     )
                 })
                 .collect();
@@ -868,7 +856,7 @@ pub fn create_token_accounts<T: Client>(
 
             let mut retries = 0;
             while !to_create_txs.is_empty() {
-                let (blockhash, _fee_calculator) = client
+                let (blockhash, _fee_calculator, _last_valid_slot) = client
                     .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("Failed to get blockhash");
                 to_create_txs
@@ -997,7 +985,7 @@ pub fn airdrop_lamports<T: Client>(
 
     let mut tries = 0;
     loop {
-        let (blockhash, _fee_calculator) = client
+        let (blockhash, _fee_calculator, _last_valid_slot) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
         match request_airdrop_transaction(&faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {

bench-streamer/Cargo.toml

@@ -1,19 +1,19 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
 clap = "2.33.1"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-streamer = { path = "../streamer", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
+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"]

bench-tps/Cargo.toml

@@ -1,41 +1,36 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
-bincode = "1.2.1"
+bincode = "1.3.1"
 clap = "2.33.1"
 log = "0.4.8"
-rayon = "1.3.0"
-serde_json = "1.0.53"
-serde_yaml = "0.8.12"
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-core = { path = "../core", version = "1.2.0" }
-solana-genesis = { path = "../genesis", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-solana-librapay = { path = "../programs/librapay", version = "1.2.0", optional = true }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-metrics = { path = "../metrics", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-move-loader-program = { path = "../programs/move_loader", version = "1.2.0", optional = true }
-solana-version = { path = "../version", version = "1.2.0" }
+rayon = "1.3.1"
+serde_json = "1.0.56"
+serde_yaml = "0.8.13"
+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.2.0" }
-
-[features]
-move = ["solana-librapay", "solana-move-loader-program"]
+solana-local-cluster = { path = "../local-cluster", version = "1.3.2" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-tps/src/bench.rs

@@ -4,8 +4,6 @@ use rayon::prelude::*;
 use solana_client::perf_utils::{sample_txs, SampleStats};
 use solana_core::gen_keys::GenKeys;
 use solana_faucet::faucet::request_airdrop_transaction;
-#[cfg(feature = "move")]
-use solana_librapay::{create_genesis, upload_mint_script, upload_payment_script};
 use solana_measure::measure::Measure;
 use solana_metrics::{self, datapoint_info};
 use solana_sdk::{
@@ -14,6 +12,7 @@ use solana_sdk::{
     commitment_config::CommitmentConfig,
     fee_calculator::FeeCalculator,
     hash::Hash,
+    message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     system_instruction, system_transaction,
@@ -36,9 +35,6 @@ use std::{
 const MAX_TX_QUEUE_AGE: u64 =
     MAX_PROCESSING_AGE as u64 * DEFAULT_TICKS_PER_SLOT / DEFAULT_TICKS_PER_SECOND;
 
-#[cfg(feature = "move")]
-use solana_librapay::librapay_transaction;
-
 pub const MAX_SPENDS_PER_TX: u64 = 4;
 
 #[derive(Debug)]
@@ -50,12 +46,12 @@ pub type Result<T> = std::result::Result<T, BenchTpsError>;
 
 pub type SharedTransactions = Arc<RwLock<VecDeque<Vec<(Transaction, u64)>>>>;
 
-type LibraKeys = (Keypair, Pubkey, Pubkey, Vec<Keypair>);
-
 fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
     loop {
         match client.get_recent_blockhash_with_commitment(CommitmentConfig::recent()) {
-            Ok((blockhash, fee_calculator)) => return (blockhash, fee_calculator),
+            Ok((blockhash, fee_calculator, _last_valid_slot)) => {
+                return (blockhash, fee_calculator)
+            }
             Err(err) => {
                 info!("Couldn't get recent blockhash: {:?}", err);
                 sleep(Duration::from_secs(1));
@@ -119,7 +115,6 @@ fn generate_chunked_transfers(
     threads: usize,
     duration: Duration,
     sustained: bool,
-    libra_args: Option<LibraKeys>,
 ) {
     // generate and send transactions for the specified duration
     let start = Instant::now();
@@ -134,7 +129,6 @@ fn generate_chunked_transfers(
             &dest_keypair_chunks[chunk_index],
             threads,
             reclaim_lamports_back_to_source_account,
-            &libra_args,
         );
 
         // In sustained mode, overlap the transfers with generation. This has higher average
@@ -202,12 +196,7 @@ where
         .collect()
 }
 
-pub fn do_bench_tps<T>(
-    client: Arc<T>,
-    config: Config,
-    gen_keypairs: Vec<Keypair>,
-    libra_args: Option<LibraKeys>,
-) -> u64
+pub fn do_bench_tps<T>(client: Arc<T>, config: Config, gen_keypairs: Vec<Keypair>) -> u64
 where
     T: 'static + Client + Send + Sync,
 {
@@ -291,7 +280,6 @@ where
         threads,
         duration,
         sustained,
-        libra_args,
     );
 
     // Stop the sampling threads so it will collect the stats
@@ -337,52 +325,6 @@ fn metrics_submit_lamport_balance(lamport_balance: u64) {
     );
 }
 
-#[cfg(feature = "move")]
-fn generate_move_txs(
-    source: &[&Keypair],
-    dest: &VecDeque<&Keypair>,
-    reclaim: bool,
-    move_keypairs: &[Keypair],
-    libra_pay_program_id: &Pubkey,
-    libra_mint_id: &Pubkey,
-    blockhash: &Hash,
-) -> Vec<(Transaction, u64)> {
-    let count = move_keypairs.len() / 2;
-    let source_move = &move_keypairs[..count];
-    let dest_move = &move_keypairs[count..];
-    let pairs: Vec<_> = if !reclaim {
-        source_move
-            .iter()
-            .zip(dest_move.iter())
-            .zip(source.iter())
-            .collect()
-    } else {
-        dest_move
-            .iter()
-            .zip(source_move.iter())
-            .zip(dest.iter())
-            .collect()
-    };
-
-    pairs
-        .par_iter()
-        .map(|((from, to), payer)| {
-            (
-                librapay_transaction::transfer(
-                    libra_pay_program_id,
-                    libra_mint_id,
-                    &payer,
-                    &from,
-                    &to.pubkey(),
-                    1,
-                    *blockhash,
-                ),
-                timestamp(),
-            )
-        })
-        .collect()
-}
-
 fn generate_system_txs(
     source: &[&Keypair],
     dest: &VecDeque<&Keypair>,
@@ -413,7 +355,6 @@ fn generate_txs(
     dest: &VecDeque<&Keypair>,
     threads: usize,
     reclaim: bool,
-    libra_args: &Option<LibraKeys>,
 ) {
     let blockhash = *blockhash.read().unwrap();
     let tx_count = source.len();
@@ -423,33 +364,7 @@ fn generate_txs(
     );
     let signing_start = Instant::now();
 
-    let transactions = if let Some((
-        _libra_genesis_keypair,
-        _libra_pay_program_id,
-        _libra_mint_program_id,
-        _libra_keys,
-    )) = libra_args
-    {
-        #[cfg(not(feature = "move"))]
-        {
-            return;
-        }
-
-        #[cfg(feature = "move")]
-        {
-            generate_move_txs(
-                source,
-                dest,
-                reclaim,
-                &_libra_keys,
-                _libra_pay_program_id,
-                &_libra_genesis_keypair.pubkey(),
-                &blockhash,
-            )
-        }
-    } else {
-        generate_system_txs(source, dest, reclaim, &blockhash)
-    };
+    let transactions = generate_system_txs(source, dest, reclaim, &blockhash);
 
     let duration = signing_start.elapsed();
     let ns = duration.as_secs() * 1_000_000_000 + u64::from(duration.subsec_nanos());
@@ -650,10 +565,9 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
         let to_fund_txs: Vec<(&Keypair, Transaction)> = to_fund
             .par_iter()
             .map(|(k, t)| {
-                let tx = Transaction::new_unsigned_instructions(
-                    &system_instruction::transfer_many(&k.pubkey(), &t),
-                );
-                (*k, tx)
+                let instructions = system_instruction::transfer_many(&k.pubkey(), &t);
+                let message = Message::new(&instructions, Some(&k.pubkey()));
+                (*k, Transaction::new_unsigned(message))
             })
             .collect();
         make_txs.stop();
@@ -952,181 +866,13 @@ pub fn generate_keypairs(seed_keypair: &Keypair, count: u64) -> (Vec<Keypair>, u
     (rnd.gen_n_keypairs(total_keys), extra)
 }
 
-#[cfg(feature = "move")]
-fn fund_move_keys<T: Client>(
-    client: &T,
-    funding_key: &Keypair,
-    keypairs: &[Keypair],
-    total: u64,
-    libra_pay_program_id: &Pubkey,
-    libra_mint_program_id: &Pubkey,
-    libra_genesis_key: &Keypair,
-) {
-    let (mut blockhash, _fee_calculator) = get_recent_blockhash(client);
-
-    info!("creating the libra funding account..");
-    let libra_funding_key = Keypair::new();
-    let tx = librapay_transaction::create_account(funding_key, &libra_funding_key, 1, blockhash);
-    client
-        .send_message(&[funding_key, &libra_funding_key], tx.message)
-        .unwrap();
-
-    info!("minting to funding keypair");
-    let tx = librapay_transaction::mint_tokens(
-        &libra_mint_program_id,
-        funding_key,
-        libra_genesis_key,
-        &libra_funding_key.pubkey(),
-        total,
-        blockhash,
-    );
-    client
-        .send_message(&[funding_key, libra_genesis_key], tx.message)
-        .unwrap();
-
-    info!("creating {} move accounts...", keypairs.len());
-    let total_len = keypairs.len();
-    let create_len = 5;
-    let mut funding_time = Measure::start("funding_time");
-    for (i, keys) in keypairs.chunks(create_len).enumerate() {
-        if client
-            .get_balance_with_commitment(&keys[0].pubkey(), CommitmentConfig::recent())
-            .unwrap_or(0)
-            > 0
-        {
-            // already created these accounts.
-            break;
-        }
-
-        let keypairs: Vec<_> = keys.iter().map(|k| k).collect();
-        let tx = librapay_transaction::create_accounts(funding_key, &keypairs, 1, blockhash);
-        let ser_size = bincode::serialized_size(&tx).unwrap();
-        let mut keys = vec![funding_key];
-        keys.extend(&keypairs);
-        client.send_message(&keys, tx.message).unwrap();
-
-        if i % 10 == 0 {
-            info!(
-                "created {} accounts of {} (size {})",
-                i,
-                total_len / create_len,
-                ser_size,
-            );
-        }
-    }
-
-    const NUM_FUNDING_KEYS: usize = 10;
-    let funding_keys: Vec<_> = (0..NUM_FUNDING_KEYS).map(|_| Keypair::new()).collect();
-    let pubkey_amounts: Vec<_> = funding_keys
-        .iter()
-        .map(|key| (key.pubkey(), total / NUM_FUNDING_KEYS as u64))
-        .collect();
-    let tx = Transaction::new_signed_instructions(
-        &[funding_key],
-        &system_instruction::transfer_many(&funding_key.pubkey(), &pubkey_amounts),
-        blockhash,
-    );
-    client.send_message(&[funding_key], tx.message).unwrap();
-    let mut balance = 0;
-    for _ in 0..20 {
-        if let Ok(balance_) = client
-            .get_balance_with_commitment(&funding_keys[0].pubkey(), CommitmentConfig::recent())
-        {
-            if balance_ > 0 {
-                balance = balance_;
-                break;
-            }
-        }
-        sleep(Duration::from_millis(100));
-    }
-    assert!(balance > 0);
-    info!(
-        "funded multiple funding accounts with {:?} lanports",
-        balance
-    );
-
-    let libra_funding_keys: Vec<_> = (0..NUM_FUNDING_KEYS).map(|_| Keypair::new()).collect();
-    for (i, key) in libra_funding_keys.iter().enumerate() {
-        let tx = librapay_transaction::create_account(&funding_keys[i], &key, 1, blockhash);
-        client
-            .send_message(&[&funding_keys[i], &key], tx.message)
-            .unwrap();
-
-        let tx = librapay_transaction::transfer(
-            libra_pay_program_id,
-            &libra_genesis_key.pubkey(),
-            &funding_keys[i],
-            &libra_funding_key,
-            &key.pubkey(),
-            total / NUM_FUNDING_KEYS as u64,
-            blockhash,
-        );
-        client
-            .send_message(&[&funding_keys[i], &libra_funding_key], tx.message)
-            .unwrap();
-
-        info!("funded libra funding key {}", i);
-    }
-
-    let keypair_count = keypairs.len();
-    let amount = total / (keypair_count as u64);
-    for (i, keys) in keypairs[..keypair_count]
-        .chunks(NUM_FUNDING_KEYS)
-        .enumerate()
-    {
-        for (j, key) in keys.iter().enumerate() {
-            let tx = librapay_transaction::transfer(
-                libra_pay_program_id,
-                &libra_genesis_key.pubkey(),
-                &funding_keys[j],
-                &libra_funding_keys[j],
-                &key.pubkey(),
-                amount,
-                blockhash,
-            );
-
-            let _sig = client
-                .async_send_transaction(tx.clone())
-                .expect("create_account in generate_and_fund_keypairs");
-        }
-
-        for (j, key) in keys.iter().enumerate() {
-            let mut times = 0;
-            loop {
-                let balance =
-                    librapay_transaction::get_libra_balance(client, &key.pubkey()).unwrap();
-                if balance >= amount {
-                    break;
-                } else if times > 20 {
-                    info!("timed out.. {} key: {} balance: {}", i, j, balance);
-                    break;
-                } else {
-                    times += 1;
-                    sleep(Duration::from_millis(100));
-                }
-            }
-        }
-
-        info!(
-            "funded group {} of {}",
-            i + 1,
-            keypairs.len() / NUM_FUNDING_KEYS
-        );
-        blockhash = get_recent_blockhash(client).0;
-    }
-
-    funding_time.stop();
-    info!("done funding keys, took {} ms", funding_time.as_ms());
-}
-
 pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
     client: Arc<T>,
     faucet_addr: Option<SocketAddr>,
     funding_key: &Keypair,
     keypair_count: usize,
     lamports_per_account: u64,
-    use_move: bool,
-) -> Result<(Vec<Keypair>, Option<LibraKeys>)> {
+) -> Result<Vec<Keypair>> {
     info!("Creating {} keypairs...", keypair_count);
     let (mut keypairs, extra) = generate_keypairs(funding_key, keypair_count as u64);
     info!("Get lamports...");
@@ -1139,12 +885,6 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
     let last_key = keypairs[keypair_count - 1].pubkey();
     let last_keypair_balance = client.get_balance(&last_key).unwrap_or(0);
 
-    #[cfg(feature = "move")]
-    let mut move_keypairs_ret = None;
-
-    #[cfg(not(feature = "move"))]
-    let move_keypairs_ret = None;
-
     // Repeated runs will eat up keypair balances from transaction fees. In order to quickly
     //   start another bench-tps run without re-funding all of the keypairs, check if the
     //   keypairs still have at least 80% of the expected funds. That should be enough to
@@ -1155,10 +895,7 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
         let max_fee = fee_rate_governor.max_lamports_per_signature;
         let extra_fees = extra * max_fee;
         let total_keypairs = keypairs.len() as u64 + 1; // Add one for funding keypair
-        let mut total = lamports_per_account * total_keypairs + extra_fees;
-        if use_move {
-            total *= 3;
-        }
+        let total = lamports_per_account * total_keypairs + extra_fees;
 
         let funding_key_balance = client.get_balance(&funding_key.pubkey()).unwrap_or(0);
         info!(
@@ -1170,40 +907,6 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
             airdrop_lamports(client.as_ref(), &faucet_addr.unwrap(), funding_key, total)?;
         }
 
-        #[cfg(feature = "move")]
-        {
-            if use_move {
-                let libra_genesis_keypair =
-                    create_genesis(&funding_key, client.as_ref(), 10_000_000);
-                let libra_mint_program_id = upload_mint_script(&funding_key, client.as_ref());
-                let libra_pay_program_id = upload_payment_script(&funding_key, client.as_ref());
-
-                // Generate another set of keypairs for move accounts.
-                // Still fund the solana ones which will be used for fees.
-                let seed = [0u8; 32];
-                let mut rnd = GenKeys::new(seed);
-                let move_keypairs = rnd.gen_n_keypairs(keypair_count as u64);
-                fund_move_keys(
-                    client.as_ref(),
-                    funding_key,
-                    &move_keypairs,
-                    total / 3,
-                    &libra_pay_program_id,
-                    &libra_mint_program_id,
-                    &libra_genesis_keypair,
-                );
-                move_keypairs_ret = Some((
-                    libra_genesis_keypair,
-                    libra_pay_program_id,
-                    libra_mint_program_id,
-                    move_keypairs,
-                ));
-
-                // Give solana keys 1/3 and move keys 1/3 the lamports. Keep 1/3 for fees.
-                total /= 3;
-            }
-        }
-
         fund_keys(
             client,
             funding_key,
@@ -1217,7 +920,7 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
     // 'generate_keypairs' generates extra keys to be able to have size-aligned funding batches for fund_keys.
     keypairs.truncate(keypair_count);
 
-    Ok((keypairs, move_keypairs_ret))
+    Ok(keypairs)
 }
 
 #[cfg(test)]
@@ -1241,11 +944,11 @@ mod tests {
         config.duration = Duration::from_secs(5);
 
         let keypair_count = config.tx_count * config.keypair_multiplier;
-        let (keypairs, _move_keypairs) =
-            generate_and_fund_keypairs(client.clone(), None, &config.id, keypair_count, 20, false)
+        let keypairs =
+            generate_and_fund_keypairs(client.clone(), None, &config.id, keypair_count, 20)
                 .unwrap();
 
-        do_bench_tps(client, config, keypairs, None);
+        do_bench_tps(client, config, keypairs);
     }
 
     #[test]
@@ -1256,9 +959,8 @@ mod tests {
         let keypair_count = 20;
         let lamports = 20;
 
-        let (keypairs, _move_keypairs) =
-            generate_and_fund_keypairs(client.clone(), None, &id, keypair_count, lamports, false)
-                .unwrap();
+        let keypairs =
+            generate_and_fund_keypairs(client.clone(), None, &id, keypair_count, lamports).unwrap();
 
         for kp in &keypairs {
             assert_eq!(
@@ -1280,9 +982,8 @@ mod tests {
         let keypair_count = 20;
         let lamports = 20;
 
-        let (keypairs, _move_keypairs) =
-            generate_and_fund_keypairs(client.clone(), None, &id, keypair_count, lamports, false)
-                .unwrap();
+        let keypairs =
+            generate_and_fund_keypairs(client.clone(), None, &id, keypair_count, lamports).unwrap();
 
         for kp in &keypairs {
             assert_eq!(client.get_balance(&kp.pubkey()).unwrap(), lamports);

bench-tps/src/cli.rs

@@ -1,7 +1,10 @@
 use clap::{crate_description, crate_name, App, Arg, ArgMatches};
 use solana_faucet::faucet::FAUCET_PORT;
 use solana_sdk::fee_calculator::FeeRateGovernor;
-use solana_sdk::signature::{read_keypair_file, Keypair};
+use solana_sdk::{
+    pubkey::Pubkey,
+    signature::{read_keypair_file, Keypair},
+};
 use std::{net::SocketAddr, process::exit, time::Duration};
 
 const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;
@@ -23,9 +26,9 @@ pub struct Config {
     pub read_from_client_file: bool,
     pub target_lamports_per_signature: u64,
     pub multi_client: bool,
-    pub use_move: bool,
     pub num_lamports_per_account: u64,
     pub target_slots_per_epoch: u64,
+    pub target_node: Option<Pubkey>,
 }
 
 impl Default for Config {
@@ -46,9 +49,9 @@ impl Default for Config {
             read_from_client_file: false,
             target_lamports_per_signature: FeeRateGovernor::default().target_lamports_per_signature,
             multi_client: true,
-            use_move: false,
             num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
             target_slots_per_epoch: 0,
+            target_node: None,
         }
     }
 }
@@ -109,16 +112,19 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                 .long("sustained")
                 .help("Use sustained performance mode vs. peak mode. This overlaps the tx generation with transfers."),
         )
-        .arg(
-            Arg::with_name("use-move")
-                .long("use-move")
-                .help("Use Move language transactions to perform transfers."),
-        )
         .arg(
             Arg::with_name("no-multi-client")
                 .long("no-multi-client")
                 .help("Disable multi-client support, only transact with the entrypoint."),
         )
+        .arg(
+            Arg::with_name("target_node")
+                .long("target-node")
+                .requires("no-multi-client")
+                .takes_value(true)
+                .value_name("PUBKEY")
+                .help("Specify an exact node to send transactions to."),
+        )
         .arg(
             Arg::with_name("tx_count")
                 .long("tx_count")
@@ -263,8 +269,10 @@ pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
         args.target_lamports_per_signature = v.to_string().parse().expect("can't parse lamports");
     }
 
-    args.use_move = matches.is_present("use-move");
     args.multi_client = !matches.is_present("no-multi-client");
+    args.target_node = matches
+        .value_of("target_node")
+        .map(|target_str| target_str.parse().unwrap());
 
     if let Some(v) = matches.value_of("num_lamports_per_account") {
         args.num_lamports_per_account = v.to_string().parse().expect("can't parse lamports");

bench-tps/src/main.rs

@@ -29,9 +29,9 @@ fn main() {
         write_to_client_file,
         read_from_client_file,
         target_lamports_per_signature,
-        use_move,
         multi_client,
         num_lamports_per_account,
+        target_node,
         ..
     } = &cli_config;
 
@@ -82,11 +82,24 @@ fn main() {
             exit(1);
         }
         Arc::new(client)
+    } else if let Some(target_node) = target_node {
+        info!("Searching for target_node: {:?}", target_node);
+        let mut target_client = None;
+        for node in nodes {
+            if node.id == *target_node {
+                target_client = Some(Arc::new(get_client(&[node])));
+                break;
+            }
+        }
+        target_client.unwrap_or_else(|| {
+            eprintln!("Target node {} not found", target_node);
+            exit(1);
+        })
     } else {
         Arc::new(get_client(&nodes))
     };
 
-    let (keypairs, move_keypairs) = if *read_from_client_file && !use_move {
+    let keypairs = if *read_from_client_file {
         let path = Path::new(&client_ids_and_stake_file);
         let file = File::open(path).unwrap();
 
@@ -115,8 +128,8 @@ fn main() {
         // Sort keypairs so that do_bench_tps() uses the same subset of accounts for each run.
         // This prevents the amount of storage needed for bench-tps accounts from creeping up
         // across multiple runs.
-        keypairs.sort_by(|x, y| x.pubkey().to_string().cmp(&y.pubkey().to_string()));
-        (keypairs, None)
+        keypairs.sort_by_key(|x| x.pubkey().to_string());
+        keypairs
     } else {
         generate_and_fund_keypairs(
             client.clone(),
@@ -124,7 +137,6 @@ fn main() {
             &id,
             keypair_count,
             *num_lamports_per_account,
-            *use_move,
         )
         .unwrap_or_else(|e| {
             eprintln!("Error could not fund keys: {:?}", e);
@@ -132,5 +144,5 @@ fn main() {
         })
     };
 
-    do_bench_tps(client, cli_config, keypairs, move_keypairs);
+    do_bench_tps(client, cli_config, keypairs);
 }

bench-tps/tests/bench_tps.rs

@@ -6,17 +6,11 @@ use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
 use solana_core::validator::ValidatorConfig;
 use solana_faucet::faucet::run_local_faucet;
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
-#[cfg(feature = "move")]
-use solana_sdk::move_loader::solana_move_loader_program;
 use solana_sdk::signature::{Keypair, Signer};
 use std::sync::{mpsc::channel, Arc};
 use std::time::Duration;
 
 fn test_bench_tps_local_cluster(config: Config) {
-    #[cfg(feature = "move")]
-    let native_instruction_processors = vec![solana_move_loader_program()];
-
-    #[cfg(not(feature = "move"))]
     let native_instruction_processors = vec![];
 
     solana_logger::setup();
@@ -48,17 +42,16 @@ fn test_bench_tps_local_cluster(config: Config) {
     let lamports_per_account = 100;
 
     let keypair_count = config.tx_count * config.keypair_multiplier;
-    let (keypairs, move_keypairs) = generate_and_fund_keypairs(
+    let keypairs = generate_and_fund_keypairs(
         client.clone(),
         Some(faucet_addr),
         &config.id,
         keypair_count,
         lamports_per_account,
-        config.use_move,
     )
     .unwrap();
 
-    let _total = do_bench_tps(client, config, keypairs, move_keypairs);
+    let _total = do_bench_tps(client, config, keypairs);
 
     #[cfg(not(debug_assertions))]
     assert!(_total > 100);
@@ -73,14 +66,3 @@ fn test_bench_tps_local_cluster_solana() {
 
     test_bench_tps_local_cluster(config);
 }
-
-#[test]
-#[serial]
-fn test_bench_tps_local_cluster_move() {
-    let mut config = Config::default();
-    config.tx_count = 100;
-    config.duration = Duration::from_secs(10);
-    config.use_move = true;
-
-    test_bench_tps_local_cluster(config);
-}

ci/affects-files.sh

@@ -1,43 +0,0 @@
-#!/usr/bin/env bash
-#
-# Checks if a CI build affects one or more path patterns.  Each command-line
-# argument is checked in series.
-#
-# Bash regular expressions are permitted in the pattern:
-#     ./affects-files.sh .rs$    -- any file or directory ending in .rs
-#     ./affects-files.sh .rs     -- also matches foo.rs.bar
-#     ./affects-files.sh ^snap/  -- anything under the snap/ subdirectory
-#     ./affects-files.sh snap/   -- also matches foo/snap/
-# Any pattern starting with the ! character will be negated:
-#     ./affects-files.sh !^docs/  -- anything *not* under the docs/ subdirectory
-#
-set -e
-cd "$(dirname "$0")"/..
-
-if [[ -n $CI_PULL_REQUEST ]]; then
-  affectedFiles="$(buildkite-agent meta-data get affected_files)"
-  echo "Affected files in this PR: $affectedFiles"
-
-  IFS=':' read -ra files <<< "$affectedFiles"
-  for pattern in "$@"; do
-    if [[ ${pattern:0:1} = "!" ]]; then
-      for file in "${files[@]}"; do
-        if [[ ! $file =~ ${pattern:1} ]]; then
-          exit 0
-        fi
-      done
-    else
-      for file in "${files[@]}"; do
-        if [[ $file =~ $pattern ]]; then
-          exit 0
-        fi
-      done
-    fi
-  done
-
-  exit 1
-fi
-
-# affected_files metadata is not currently available for non-PR builds, so assume
-# the worse (affected)
-exit 0

ci/buildkite-pipeline.sh

@@ -0,0 +1,254 @@
+#!/usr/bin/env bash
+#
+# Builds a buildkite pipeline based on the environment variables
+#
+
+set -e
+cd "$(dirname "$0")"/..
+
+output_file=${1:-/dev/stderr}
+
+if [[ -n $CI_PULL_REQUEST ]]; then
+  IFS=':' read -ra affected_files <<< "$(buildkite-agent meta-data get affected_files)"
+  if [[ ${#affected_files[*]} -eq 0 ]]; then
+    echo "Unable to determine the files affected by this PR"
+    exit 1
+  fi
+else
+  affected_files=()
+fi
+
+annotate() {
+  if [[ -n $BUILDKITE ]]; then
+    buildkite-agent annotate "$@"
+  fi
+}
+
+# Checks if a CI pull request affects one or more path patterns.  Each
+# pattern argument is checked in series. If one of them found to be affected,
+# return immediately as such.
+#
+# Bash regular expressions are permitted in the pattern:
+#     affects .rs$    -- any file or directory ending in .rs
+#     affects .rs     -- also matches foo.rs.bar
+#     affects ^snap/  -- anything under the snap/ subdirectory
+#     affects snap/   -- also matches foo/snap/
+# Any pattern starting with the ! character will be negated:
+#     affects !^docs/  -- anything *not* under the docs/ subdirectory
+#
+affects() {
+  if [[ -z $CI_PULL_REQUEST ]]; then
+    # affected_files metadata is not currently available for non-PR builds so assume
+    # the worse (affected)
+    return 0
+  fi
+  # Assume everyting needs to be tested when any Dockerfile changes
+  for pattern in ^ci/docker-rust/Dockerfile ^ci/docker-rust-nightly/Dockerfile "$@"; do
+    if [[ ${pattern:0:1} = "!" ]]; then
+      for file in "${affected_files[@]}"; do
+        if [[ ! $file =~ ${pattern:1} ]]; then
+          return 0 # affected
+        fi
+      done
+    else
+      for file in "${affected_files[@]}"; do
+        if [[ $file =~ $pattern ]]; then
+          return 0 # affected
+        fi
+      done
+    fi
+  done
+
+  return 1 # not affected
+}
+
+
+# Checks if a CI pull request affects anything other than the provided path patterns
+#
+# Syntax is the same as `affects()` except that the negation prefix is not
+# supported
+#
+affects_other_than() {
+  if [[ -z $CI_PULL_REQUEST ]]; then
+    # affected_files metadata is not currently available for non-PR builds so assume
+    # the worse (affected)
+    return 0
+  fi
+
+  for file in "${affected_files[@]}"; do
+    declare matched=false
+    for pattern in "$@"; do
+        if [[ $file =~ $pattern ]]; then
+          matched=true
+        fi
+    done
+    if ! $matched; then
+      return 0 # affected
+    fi
+  done
+
+  return 1 # not affected
+}
+
+
+start_pipeline() {
+  echo "# $*" > "$output_file"
+  echo "steps:" >> "$output_file"
+}
+
+command_step() {
+  cat >> "$output_file" <<EOF
+  - name: "$1"
+    command: "$2"
+    timeout_in_minutes: $3
+    artifact_paths: "log-*.txt"
+EOF
+}
+
+
+trigger_secondary_step() {
+  cat  >> "$output_file" <<"EOF"
+  - trigger: "solana-secondary"
+    branches: "!pull/*"
+    async: true
+    build:
+      message: "${BUILDKITE_MESSAGE}"
+      commit: "${BUILDKITE_COMMIT}"
+      branch: "${BUILDKITE_BRANCH}"
+      env:
+        TRIGGERED_BUILDKITE_TAG: "${BUILDKITE_TAG}"
+EOF
+}
+
+wait_step() {
+  echo "  - wait" >> "$output_file"
+}
+
+all_test_steps() {
+  command_step checks ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_nightly_docker_image ci/test-checks.sh" 20
+  wait_step
+
+  # Coverage...
+  if affects \
+             .rs$ \
+             Cargo.lock$ \
+             Cargo.toml$ \
+             ^ci/rust-version.sh \
+             ^ci/test-coverage.sh \
+             ^scripts/coverage.sh \
+      ; then
+    command_step coverage ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_nightly_docker_image ci/test-coverage.sh" 30
+    wait_step
+  else
+    annotate --style info --context test-coverage \
+      "Coverage skipped as no .rs files were modified"
+  fi
+
+  # Full test suite
+  command_step stable ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-stable.sh" 60
+  wait_step
+
+  # Perf test suite
+  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/ \
+      ; then
+    cat >> "$output_file" <<"EOF"
+  - command: "ci/test-stable-perf.sh"
+    name: "stable-perf"
+    timeout_in_minutes: 40
+    artifact_paths: "log-*.txt"
+    agents:
+      - "queue=cuda"
+EOF
+  else
+    annotate --style info \
+      "Stable-perf skipped as no relevant files were modified"
+  fi
+
+  # Benches...
+  if affects \
+             .rs$ \
+             Cargo.lock$ \
+             Cargo.toml$ \
+             ^ci/rust-version.sh \
+             ^ci/test-coverage.sh \
+             ^ci/test-bench.sh \
+      ; then
+    command_step bench "ci/test-bench.sh" 30
+  else
+    annotate --style info --context test-bench \
+      "Bench skipped as no .rs files were modified"
+  fi
+
+  command_step "local-cluster" \
+    ". ci/rust-version.sh; ci/docker-run.sh \$\$rust_stable_docker_image ci/test-local-cluster.sh" \
+    45
+}
+
+pull_or_push_steps() {
+  command_step sanity "ci/test-sanity.sh" 5
+  wait_step
+
+  # Check for any .sh file changes
+  if affects .sh$; then
+    command_step shellcheck "ci/shellcheck.sh" 5
+    wait_step
+  fi
+
+  # Run the full test suite by default, skipping only if modifications are local
+  # to some particular areas of the tree
+  if affects_other_than ^.buildkite ^.mergify .md$ ^docs/ ^web3.js/ ^explorer/ ^.gitbook; then
+    all_test_steps
+  fi
+
+  # web3.js, explorer and docs changes run on Travis...
+}
+
+
+if [[ -n $BUILDKITE_TAG ]]; then
+  start_pipeline "Tag pipeline for $BUILDKITE_TAG"
+
+  annotate --style info --context release-tag \
+    "https://github.com/solana-labs/solana/releases/$BUILDKITE_TAG"
+
+  # Jump directly to the secondary build to publish release artifacts quickly
+  trigger_secondary_step
+  exit 0
+fi
+
+
+if [[ $BUILDKITE_BRANCH =~ ^pull ]]; then
+  echo "+++ Affected files in this PR"
+  for file in "${affected_files[@]}"; do
+    echo "- $file"
+  done
+
+  start_pipeline "Pull request pipeline for $BUILDKITE_BRANCH"
+
+  # Add helpful link back to the corresponding Github Pull Request
+  annotate --style info --context pr-backlink \
+    "Github Pull Request: https://github.com/solana-labs/solana/$BUILDKITE_BRANCH"
+
+  if [[ $GITHUB_USER = "dependabot-preview[bot]" ]]; then
+    command_step dependabot "ci/dependabot-pr.sh" 5
+    wait_step
+  fi
+  pull_or_push_steps
+  exit 0
+fi
+
+start_pipeline "Push pipeline for ${BUILDKITE_BRANCH:-?unknown branch?}"
+pull_or_push_steps
+wait_step
+trigger_secondary_step
+exit 0

ci/buildkite-release.yml

@@ -1,15 +0,0 @@
-# Build steps that run on a release tag
-#
-# All the steps in `buildkite.yml` are skipped and we jump directly to the
-# secondary build steps since it's assumed the commit that was tagged is known
-# to be good so there's no need to rebuild and retest it.
-steps:
-  - trigger: "solana-secondary"
-    branches: "!pull/*"
-    async: true
-    build:
-      message: "${BUILDKITE_MESSAGE}"
-      commit: "${BUILDKITE_COMMIT}"
-      branch: "${BUILDKITE_BRANCH}"
-      env:
-        TRIGGERED_BUILDKITE_TAG: "${BUILDKITE_TAG}"

ci/buildkite-secondary.yml

@@ -5,9 +5,6 @@ steps:
   - command: "ci/publish-tarball.sh"
     timeout_in_minutes: 60
     name: "publish tarball"
-  - command: "ci/publish-docs.sh"
-    timeout_in_minutes: 15
-    name: "publish docs"
   - command: "ci/publish-bpf-sdk.sh"
     timeout_in_minutes: 5
     name: "publish bpf sdk"
@@ -19,6 +16,3 @@ steps:
     timeout_in_minutes: 240
     name: "publish crate"
     branches: "!master"
-    #  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-move.sh"
-    #    name: "move"
-    #    timeout_in_minutes: 20

ci/buildkite-tests.yml

@@ -1,26 +0,0 @@
-# These steps are conditionally triggered by ci/buildkite.yml when files
-# other than those in docs/ are modified
-
-steps:
-  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-coverage.sh"
-    name: "coverage"
-    timeout_in_minutes: 30
-  - wait
-  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-stable.sh"
-    name: "stable"
-    timeout_in_minutes: 60
-    artifact_paths: "log-*.txt"
-  - wait
-  - command: "ci/test-stable-perf.sh"
-    name: "stable-perf"
-    timeout_in_minutes: 40
-    artifact_paths: "log-*.txt"
-    agents:
-      - "queue=cuda"
-  - command: "ci/test-bench.sh"
-    name: "bench"
-    timeout_in_minutes: 30
-  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-local-cluster.sh"
-    name: "local-cluster"
-    timeout_in_minutes: 45
-    artifact_paths: "log-*.txt"

ci/buildkite.yml

@@ -1,38 +0,0 @@
-# Build steps that run on pushes and pull requests.
-# If files other than those in docs/ were modified, this will be followed up by
-# ci/buildkite-tests.yml
-#
-# Release tags use buildkite-release.yml instead
-
-steps:
-  - command: "ci/dependabot-pr.sh"
-    name: "dependabot"
-    timeout_in_minutes: 5
-    if: build.env("GITHUB_USER") == "dependabot-preview[bot]"
-
-  - wait
-
-  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-checks.sh"
-    name: "checks"
-    timeout_in_minutes: 20
-  - command: "ci/shellcheck.sh"
-    name: "shellcheck"
-    timeout_in_minutes: 5
-
-  - wait
-
-  - command: "ci/maybe-trigger-tests.sh"
-    name: "maybe-trigger-tests"
-    timeout_in_minutes: 2
-
-  - wait
-
-  - trigger: "solana-secondary"
-    branches: "!pull/*"
-    async: true
-    build:
-      message: "${BUILDKITE_MESSAGE}"
-      commit: "${BUILDKITE_COMMIT}"
-      branch: "${BUILDKITE_BRANCH}"
-      env:
-        TRIGGERED_BUILDKITE_TAG: "${BUILDKITE_TAG}"

ci/dependabot-updater.sh

@@ -7,14 +7,14 @@ source ci/_
 commit_range="$(git merge-base HEAD origin/master)..HEAD"
 parsed_update_args="$(
   git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
-    grep -o 'Bump.*$' |
-    sed -r 's/Bump ([^ ]+) from ([^ ]+) to ([^ ]+)/-p \1:\2 --precise \3/'
+    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-preview" --oneline -n1 |
-    grep -o 'Bump.*$' |
-    sed -r 's/Bump ([^ ]+) from [^ ]+ to ([^ ]+)/-p \1 --precise \2/'
+    grep -o '[Bb]ump.*$' |
+    sed -r 's/[Bb]ump ([^ ]+) from [^ ]+ to ([^ ]+)/-p \1 --precise \2/'
 )"
 package=$(echo "$parsed_update_args" | awk '{print $2}' | grep -o "^[^:]*")
 if [[ -n $parsed_update_args ]]; then

ci/docker-run.sh

@@ -60,6 +60,12 @@ if [[ -z "$SOLANA_DOCKER_RUN_NOSETUID" ]]; then
   ARGS+=(--user "$(id -u):$(id -g)")
 fi
 
+if [[ -n $SOLANA_ALLOCATE_TTY ]]; then
+  # Colored output, progress bar and Ctrl-C:
+  # https://stackoverflow.com/a/41099052/10242004
+  ARGS+=(--interactive --tty)
+fi
+
 # Environment variables to propagate into the container
 ARGS+=(
   --env BUILDKITE
@@ -67,6 +73,7 @@ ARGS+=(
   --env BUILDKITE_JOB_ID
   --env CI
   --env CI_BRANCH
+  --env CI_BASE_BRANCH
   --env CI_TAG
   --env CI_BUILD_ID
   --env CI_COMMIT

ci/docker-rust-nightly/Dockerfile

@@ -1,9 +1,10 @@
-FROM solanalabs/rust:1.43.0
+FROM solanalabs/rust:1.45.1
 ARG date
 
 RUN set -x \
  && rustup install nightly-$date \
  && rustup component add clippy --toolchain=nightly-$date \
+ && rustup component add rustfmt --toolchain=nightly-$date \
  && rustup show \
  && rustc --version \
  && cargo --version \

ci/docker-rust-nightly/README.md

@@ -2,23 +2,27 @@ Docker image containing rust nightly and some preinstalled crates used in CI.
 
 This image may be manually updated by running `CI=true ./build.sh` if you are a member
 of the [Solana Labs](https://hub.docker.com/u/solanalabs/) Docker Hub
-organization, but it is also automatically updated periodically by
-[this automation](https://buildkite.com/solana-labs/solana-ci-docker-rust-nightly).
+organization.
 
 ## Moving to a newer nightly
 
+NOTE: Follow instructions in docker-rust/README.md before this when updating the stable
+rust version as well.
+
 We pin the version of nightly (see the `ARG nightly=xyz` line in `Dockerfile`)
 to avoid the build breaking at unexpected times, as occasionally nightly will
 introduce breaking changes.
 
 To update the pinned version:
+1. Edit `Dockerfile` to match the desired stable rust version to base on if needed.
 1. Run `ci/docker-rust-nightly/build.sh` to rebuild the nightly image locally,
    or potentially `ci/docker-rust-nightly/build.sh YYYY-MM-DD` if there's a
    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 `YYY-MM-DD`
-1. Run `SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-coverage.sh`
+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
 1. Run `docker login` to enable pushing images to Docker Hub, if you're authorized.
 1. Run `CI=true ci/docker-rust-nightly/build.sh YYYY-MM-DD` to push the new nightly image to dockerhub.com.

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.43.0
+FROM rust:1.45.1
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0

ci/docker-rust/README.md

@@ -1,7 +1,11 @@
 Docker image containing rust and some preinstalled packages used in CI.
 
+NOTE: Recreate rust-nightly docker image after this when updating the stable rust
+version! Both of docker images must be updated in tandem.
+
 This image manually maintained:
 1. Edit `Dockerfile` to match the desired rust version
-2. Run `./build.sh` to publish the new image, if you are a member of the [Solana
+1. Run `docker login` to enable pushing images to Docker Hub, if you're authorized.
+1. Run `./build.sh` to publish the new image, if you are a member of the [Solana
    Labs](https://hub.docker.com/u/solanalabs/) Docker Hub organization.
 

ci/env.sh

@@ -8,10 +8,11 @@ if [[ -n $CI ]]; then
   export CI=1
   if [[ -n $TRAVIS ]]; then
     export CI_BRANCH=$TRAVIS_BRANCH
+    export CI_BASE_BRANCH=$TRAVIS_BRANCH
     export CI_BUILD_ID=$TRAVIS_BUILD_ID
     export CI_COMMIT=$TRAVIS_COMMIT
     export CI_JOB_ID=$TRAVIS_JOB_ID
-    if $TRAVIS_PULL_REQUEST; then
+    if [[ $TRAVIS_PULL_REQUEST != false ]]; then
       export CI_PULL_REQUEST=true
     else
       export CI_PULL_REQUEST=
@@ -28,8 +29,10 @@ if [[ -n $CI ]]; then
     # to how solana-ci-gate is used to trigger PR builds rather than using the
     # standard Buildkite PR trigger.
     if [[ $CI_BRANCH =~ pull/* ]]; then
+      export CI_BASE_BRANCH=$BUILDKITE_PULL_REQUEST_BASE_BRANCH
       export CI_PULL_REQUEST=true
     else
+      export CI_BASE_BRANCH=$BUILDKITE_BRANCH
       export CI_PULL_REQUEST=
     fi
     export CI_OS_NAME=linux

ci/maybe-trigger-tests.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-set -e
-cd "$(dirname "$0")/.."
-
-annotate() {
-  ${BUILDKITE:-false} && {
-    buildkite-agent annotate "$@"
-  }
-}
-
-# Skip if only the docs have been modified
-ci/affects-files.sh \
-  \!^docs/ \
-|| {
-  annotate --style info \
-    "Skipping all further tests as only docs/ files were modified"
-  exit 0
-}
-
-annotate --style info "Triggering tests"
-buildkite-agent pipeline upload ci/buildkite-tests.yml

ci/publish-docs.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$0")/.."
-
-echo --- build docs
-(
-  set -x
-  . ci/rust-version.sh stable
-  ci/docker-run.sh "$rust_stable_docker_image" docs/build.sh
-)
-
-echo --- update gitbook-cage
-if [[ -n $CI_BRANCH ]]; then
-  (
-    # make a local commit for the svgs and generated/updated markdown
-    set -x
-    git add -f docs/src
-    if ! git diff-index --quiet HEAD; then
-      git config user.email maintainers@solana.com
-      git config user.name "$(basename "$0")"
-      git commit -m "gitbook-cage update $(date -Is)"
-      git push -f git@github.com:solana-labs/solana-gitbook-cage.git HEAD:refs/heads/"$CI_BRANCH"
-      # pop off the local commit
-      git reset --hard HEAD~
-    fi
-  )
-else
-  echo CI_BRANCH not set
-fi
-
-exit 0

ci/publish-tarball.sh

@@ -45,7 +45,16 @@ linux)
   TARGET=x86_64-unknown-linux-gnu
   ;;
 windows)
-  TARGET=x86_64-pc-windows-gnu
+  TARGET=x86_64-pc-windows-msvc
+  # Enable symlinks used by some build.rs files
+  # source: https://stackoverflow.com/a/52097145/10242004
+  (
+    set -x
+    git --version
+    git config core.symlinks true
+    find . -type l -delete
+    git reset --hard
+  )
   ;;
 *)
   echo CI_OS_NAME unset
@@ -53,11 +62,14 @@ windows)
   ;;
 esac
 
+RELEASE_BASENAME="${RELEASE_BASENAME:=solana-release}"
+TARBALL_BASENAME="${TARBALL_BASENAME:="$RELEASE_BASENAME"}"
+
 echo --- Creating release tarball
 (
   set -x
-  rm -rf solana-release/
-  mkdir solana-release/
+  rm -rf "${RELEASE_BASENAME:?}"/
+  mkdir "${RELEASE_BASENAME}"/
 
   COMMIT="$(git rev-parse HEAD)"
 
@@ -65,18 +77,18 @@ echo --- Creating release tarball
     echo "channel: $CHANNEL_OR_TAG"
     echo "commit: $COMMIT"
     echo "target: $TARGET"
-  ) > solana-release/version.yml
+  ) > "${RELEASE_BASENAME}"/version.yml
 
   # Make CHANNEL available to include in the software version information
   export CHANNEL
 
   source ci/rust-version.sh stable
-  scripts/cargo-install-all.sh +"$rust_stable" solana-release
+  scripts/cargo-install-all.sh +"$rust_stable" "${RELEASE_BASENAME}"
 
-  tar cvf solana-release-$TARGET.tar solana-release
-  bzip2 solana-release-$TARGET.tar
-  cp solana-release/bin/solana-install-init solana-install-init-$TARGET
-  cp solana-release/version.yml solana-release-$TARGET.yml
+  tar cvf "${TARBALL_BASENAME}"-$TARGET.tar "${RELEASE_BASENAME}"
+  bzip2 "${TARBALL_BASENAME}"-$TARGET.tar
+  cp "${RELEASE_BASENAME}"/bin/solana-install-init solana-install-init-$TARGET
+  cp "${RELEASE_BASENAME}"/version.yml "${TARBALL_BASENAME}"-$TARGET.yml
 )
 
 # Metrics tarball is platform agnostic, only publish it from Linux
@@ -94,7 +106,7 @@ fi
 
 source ci/upload-ci-artifact.sh
 
-for file in solana-release-$TARGET.tar.bz2 solana-release-$TARGET.yml solana-install-init-"$TARGET"* $MAYBE_TARBALLS; do
+for file in "${TARBALL_BASENAME}"-$TARGET.tar.bz2 "${TARBALL_BASENAME}"-$TARGET.yml solana-install-init-"$TARGET"* $MAYBE_TARBALLS; do
   if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
     upload-ci-artifact "$file"
     echo "Skipped $file due to DO_NOT_PUBLISH_TAR"

ci/run-sanity.sh

@@ -7,7 +7,7 @@ source multinode-demo/common.sh
 
 rm -rf config/run/init-completed config/ledger config/snapshot-ledger
 
-timeout 15 ./run.sh &
+timeout 120 ./run.sh &
 pid=$!
 
 attempts=20
@@ -19,10 +19,16 @@ while [[ ! -f config/run/init-completed ]]; do
   fi
 done
 
+snapshot_slot=1
+
+# wait a bit longer than snapshot_slot
+while [[ $($solana_cli --url http://localhost:8899 slot --commitment recent) -le $((snapshot_slot + 1)) ]]; do
+  sleep 1
+done
 curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' http://localhost:8899
 
 wait $pid
 
-$solana_ledger_tool create-snapshot --ledger config/ledger 1 config/snapshot-ledger
+$solana_ledger_tool create-snapshot --ledger config/ledger "$snapshot_slot" config/snapshot-ledger
 cp config/ledger/genesis.tar.bz2 config/snapshot-ledger
 $solana_ledger_tool verify --ledger config/snapshot-ledger

ci/rust-version.sh

@@ -18,13 +18,13 @@
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.43.0
+  stable_version=1.45.1
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2020-04-23
+  nightly_version=2020-07-27
 fi
 
 
@@ -38,7 +38,8 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
 
   rustup_install() {
     declare toolchain=$1
-    if ! cargo +"$toolchain" -V; then
+    if ! cargo +"$toolchain" -V > /dev/null; then
+      echo "$0: Missing toolchain? Installing...: $toolchain" >&2
       rustup install "$toolchain"
       cargo +"$toolchain" -V
     fi
@@ -58,7 +59,7 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
      rustup_install "$rust_nightly"
     ;;
   *)
-    echo "Note: ignoring unknown argument: $1"
+    echo "$0: Note: ignoring unknown argument: $1" >&2
     ;;
   esac
 )

ci/test-bench.sh

@@ -2,25 +2,6 @@
 set -e
 cd "$(dirname "$0")/.."
 
-annotate() {
-  ${BUILDKITE:-false} && {
-    buildkite-agent annotate "$@"
-  }
-}
-
-ci/affects-files.sh \
-  .rs$ \
-  Cargo.lock$ \
-  Cargo.toml$ \
-  ^ci/rust-version.sh \
-  ^ci/test-bench.sh \
-|| {
-  annotate --style info --context test-bench \
-    "Bench skipped as no .rs files were modified"
-  exit 0
-}
-
-
 source ci/_
 source ci/upload-ci-artifact.sh
 

ci/test-checks.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+
 set -e
 
 cd "$(dirname "$0")/.."
@@ -6,33 +7,55 @@ cd "$(dirname "$0")/.."
 source ci/_
 source ci/rust-version.sh stable
 source ci/rust-version.sh nightly
+eval "$(ci/channel-info.sh)"
+
+echo --- build environment
+(
+  set -x
+
+  rustup run "$rust_stable" rustc --version --verbose
+  rustup run "$rust_nightly" rustc --version --verbose
+
+  cargo +"$rust_stable" --version --verbose
+  cargo +"$rust_nightly" --version --verbose
+
+  cargo +"$rust_stable" clippy --version --verbose
+  cargo +"$rust_nightly" clippy --version --verbose
+
+  # audit is done only with stable
+  cargo +"$rust_stable" audit --version
+)
 
 export RUST_BACKTRACE=1
-export RUSTFLAGS="-D warnings"
+export RUSTFLAGS="-D warnings -A incomplete_features"
 
-# Look for failed mergify.io backports
-_ git show HEAD --check --oneline
-
-if _ scripts/cargo-for-all-lock-files.sh +"$rust_nightly" check --locked --all-targets; then
-  true
+# Only force up-to-date lock files on edge
+if [[ $CI_BASE_BRANCH = "$EDGE_CHANNEL" ]]; then
+  # Exclude --benches as it's not available in rust stable yet
+  if _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" check --locked --tests --bins --examples; then
+    true
+  else
+    check_status=$?
+    echo "$0: Some Cargo.lock might be outdated; sync them (or just be a compilation error?)" >&2
+    echo "$0: protip: $ ./scripts/cargo-for-all-lock-files.sh [--ignore-exit-code] ... \\" >&2
+    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
 else
-  check_status=$?
-  echo "Some Cargo.lock is outdated; please update them as well"
-  echo "protip: you can use ./scripts/cargo-for-all-lock-files.sh update ..."
-  exit "$check_status"
+  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 +"$rust_stable" fmt --all -- --check
 
-_ cargo +"$rust_stable" clippy --version
-_ cargo +"$rust_stable" clippy --workspace -- --deny=warnings
+# -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 +"$rust_nightly" clippy -Zunstable-options --workspace --all-targets -- --deny=warnings
 
-_ cargo +"$rust_stable" audit --version
 _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008
-_ ci/nits.sh
-_ ci/order-crates-for-publishing.py
-_ docs/build.sh
-_ ci/check-ssh-keys.sh
 
 {
   cd programs/bpf
@@ -43,7 +66,6 @@ _ ci/check-ssh-keys.sh
       cd "$project"
       _ cargo +"$rust_stable" fmt -- --check
       _ cargo +"$rust_nightly" test
-      _ cargo +"$rust_nightly" clippy --version
       _ cargo +"$rust_nightly" clippy -- --deny=warnings --allow=clippy::missing_safety_doc
     )
   done

ci/test-coverage.sh

@@ -8,23 +8,14 @@ annotate() {
   }
 }
 
-ci/affects-files.sh \
-  .rs$ \
-  Cargo.lock$ \
-  Cargo.toml$ \
-  ^ci/rust-version.sh \
-  ^ci/test-coverage.sh \
-  ^scripts/coverage.sh \
-|| {
-  annotate --style info --context test-coverage \
-    "Coverage skipped as no .rs files were modified"
-  exit 0
-}
-
 source ci/upload-ci-artifact.sh
 source scripts/ulimit-n.sh
 
-scripts/coverage.sh
+scripts/coverage.sh "$@"
+
+if [[ -z $CI ]]; then
+  exit
+fi
 
 report=coverage-"${CI_COMMIT:0:9}".tar.gz
 mv target/cov/report.tar.gz "$report"

ci/test-move.sh

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

ci/test-sanity.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")/.."
+
+source ci/_
+
+(
+  echo --- git diff --check
+  set -x
+  # Look for failed mergify.io backports by searching leftover conflict markers
+  # Also check for any trailing whitespaces!
+  git fetch origin "$CI_BASE_BRANCH"
+  git diff "$(git merge-base HEAD "origin/$CI_BASE_BRANCH")..HEAD" --check --oneline
+)
+
+echo
+
+_ ci/nits.sh
+_ ci/check-ssh-keys.sh
+
+echo --- ok

ci/test-stable.sh

@@ -13,15 +13,6 @@ annotate() {
 # Run the appropriate test based on entrypoint
 testName=$(basename "$0" .sh)
 
-# Skip if only the docs have been modified
-ci/affects-files.sh \
-  \!^docs/ \
-|| {
-  annotate --style info \
-    "Skipped $testName as only docs/ files were modified"
-  exit 0
-}
-
 source ci/rust-version.sh stable
 
 export RUST_BACKTRACE=1
@@ -39,35 +30,16 @@ test -d target/release/bpf && find target/release/bpf -name '*.d' -delete
 rm -rf target/xargo # Issue #3105
 
 # Limit compiler jobs to reduce memory usage
-# on machines with 1gb/thread of memory
+# on machines with 2gb/thread of memory
 NPROC=$(nproc)
-NPROC=$((NPROC>16 ? 16 : NPROC))
+NPROC=$((NPROC>14 ? 14 : NPROC))
 
 echo "Executing $testName"
 case $testName in
 test-stable)
   _ cargo +"$rust_stable" test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
-  _ cargo +"$rust_stable" test --manifest-path bench-tps/Cargo.toml --features=move ${V:+--verbose} test_bench_tps_local_cluster_move -- --nocapture
   ;;
 test-stable-perf)
-  ci/affects-files.sh \
-    .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/ \
-  || {
-    annotate --style info \
-      "Skipped $testName as no relevant files were modified"
-    exit 0
-  }
-
   # BPF program tests
   _ make -C programs/bpf/c tests
   _ cargo +"$rust_stable" test \
@@ -92,27 +64,7 @@ test-stable-perf)
 
   _ cargo +"$rust_stable" build --bins ${V:+--verbose}
   _ cargo +"$rust_stable" test --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
-  ;;
-test-move)
-  ci/affects-files.sh \
-    Cargo.lock$ \
-    Cargo.toml$ \
-    ^ci/rust-version.sh \
-    ^ci/test-stable.sh \
-    ^ci/test-move.sh \
-    ^programs/move_loader \
-    ^programs/librapay \
-    ^logger/ \
-    ^runtime/ \
-    ^sdk/ \
-  || {
-    annotate --style info \
-      "Skipped $testName as no relevant files were modified"
-    exit 0
-  }
-  _ cargo +"$rust_stable" test --manifest-path programs/move_loader/Cargo.toml ${V:+--verbose} -- --nocapture
-  _ cargo +"$rust_stable" test --manifest-path programs/librapay/Cargo.toml ${V:+--verbose} -- --nocapture
-  exit 0
+  _ cargo +"$rust_stable" run --manifest-path poh-bench/Cargo.toml ${V:+--verbose} -- --hashes-per-tick 10
   ;;
 test-local-cluster)
   _ cargo +"$rust_stable" build --release --bins ${V:+--verbose}

ci/upload-github-release-asset.sh

@@ -23,10 +23,14 @@ if [[ -z $CI_TAG ]]; then
   exit 1
 fi
 
-if [[ -z $CI_REPO_SLUG ]]; then
-  echo Error: CI_REPO_SLUG not defined
-  exit 1
-fi
+# Force CI_REPO_SLUG since sometimes
+# BUILDKITE_TRIGGERED_FROM_BUILD_PIPELINE_SLUG is not set correctly, causing the
+# artifact upload to fail
+CI_REPO_SLUG=solana-labs/solana
+#if [[ -z $CI_REPO_SLUG ]]; then
+#  echo Error: CI_REPO_SLUG not defined
+#  exit 1
+#fi
 
 releaseId=$( \
   curl -s "https://api.github.com/repos/$CI_REPO_SLUG/releases/tags/$CI_TAG" \
@@ -38,6 +42,7 @@ echo "Github release id for $CI_TAG is $releaseId"
 for file in "$@"; do
   echo "--- Uploading $file to tag $CI_TAG of $CI_REPO_SLUG"
   curl \
+    --verbose \
     --data-binary @"$file" \
     -H "Authorization: token $GITHUB_TOKEN" \
     -H "Content-Type: application/octet-stream" \

clap-utils/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "solana-clap-utils"
-version = "1.2.0"
+version = "1.3.2"
 description = "Solana utilities for the clap"
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,9 +11,9 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-thiserror = "1.0.11"
+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"

clap-utils/src/input_validators.rs

@@ -6,50 +6,86 @@ use solana_sdk::{
     pubkey::Pubkey,
     signature::{read_keypair_file, Signature},
 };
+use std::fmt::Display;
 use std::str::FromStr;
 
+fn is_parsable_generic<U, T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+    U: FromStr,
+    U::Err: Display,
+{
+    string
+        .as_ref()
+        .parse::<U>()
+        .map(|_| ())
+        .map_err(|err| format!("error parsing '{}': {}", string, err))
+}
+
+// Return an error if string cannot be parsed as type T.
+// Takes a String to avoid second type parameter when used as a clap validator
+pub fn is_parsable<T>(string: String) -> Result<(), String>
+where
+    T: FromStr,
+    T::Err: Display,
+{
+    is_parsable_generic::<T, String>(string)
+}
+
 // Return an error if a pubkey cannot be parsed.
-pub fn is_pubkey(string: String) -> Result<(), String> {
-    match string.parse::<Pubkey>() {
-        Ok(_) => Ok(()),
-        Err(err) => Err(format!("{}", err)),
-    }
+pub fn is_pubkey<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    is_parsable_generic::<Pubkey, _>(string)
 }
 
 // Return an error if a hash cannot be parsed.
-pub fn is_hash(string: String) -> Result<(), String> {
-    match string.parse::<Hash>() {
-        Ok(_) => Ok(()),
-        Err(err) => Err(format!("{}", err)),
-    }
+pub fn is_hash<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    is_parsable_generic::<Hash, _>(string)
 }
 
 // Return an error if a keypair file cannot be parsed.
-pub fn is_keypair(string: String) -> Result<(), String> {
-    read_keypair_file(&string)
+pub fn is_keypair<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    read_keypair_file(string.as_ref())
         .map(|_| ())
         .map_err(|err| format!("{}", err))
 }
 
 // Return an error if a keypair file cannot be parsed
-pub fn is_keypair_or_ask_keyword(string: String) -> Result<(), String> {
-    if string.as_str() == ASK_KEYWORD {
+pub fn is_keypair_or_ask_keyword<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    if string.as_ref() == ASK_KEYWORD {
         return Ok(());
     }
-    read_keypair_file(&string)
+    read_keypair_file(string.as_ref())
         .map(|_| ())
         .map_err(|err| format!("{}", err))
 }
 
 // Return an error if string cannot be parsed as pubkey string or keypair file location
-pub fn is_pubkey_or_keypair(string: String) -> Result<(), String> {
-    is_pubkey(string.clone()).or_else(|_| is_keypair(string))
+pub fn is_pubkey_or_keypair<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    is_pubkey(string.as_ref()).or_else(|_| is_keypair(string))
 }
 
 // Return an error if string cannot be parsed as a pubkey string, or a valid Signer that can
 // produce a pubkey()
-pub fn is_valid_pubkey(string: String) -> Result<(), String> {
-    match parse_keypair_path(&string) {
+pub fn is_valid_pubkey<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    match parse_keypair_path(string.as_ref()) {
         KeypairUrl::Filepath(path) => is_keypair(path),
         _ => Ok(()),
     }
@@ -63,13 +99,19 @@ pub fn is_valid_pubkey(string: String) -> Result<(), String> {
 // when paired with an offline `--signer` argument to provide a Presigner (pubkey + signature).
 // Clap validators can't check multiple fields at once, so the verification that a `--signer` is
 // also provided and correct happens in parsing, not in validation.
-pub fn is_valid_signer(string: String) -> Result<(), String> {
+pub fn is_valid_signer<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
     is_valid_pubkey(string)
 }
 
 // Return an error if string cannot be parsed as pubkey=signature string
-pub fn is_pubkey_sig(string: String) -> Result<(), String> {
-    let mut signer = string.split('=');
+pub fn is_pubkey_sig<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    let mut signer = string.as_ref().split('=');
     match Pubkey::from_str(
         signer
             .next()
@@ -90,8 +132,11 @@ pub fn is_pubkey_sig(string: String) -> Result<(), String> {
 }
 
 // Return an error if a url cannot be parsed.
-pub fn is_url(string: String) -> Result<(), String> {
-    match url::Url::parse(&string) {
+pub fn is_url<T>(string: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    match url::Url::parse(string.as_ref()) {
         Ok(url) => {
             if url.has_host() {
                 Ok(())
@@ -103,20 +148,26 @@ pub fn is_url(string: String) -> Result<(), String> {
     }
 }
 
-pub fn is_slot(slot: String) -> Result<(), String> {
-    slot.parse::<Slot>()
-        .map(|_| ())
-        .map_err(|e| format!("{}", e))
+pub fn is_slot<T>(slot: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    is_parsable_generic::<Slot, _>(slot)
 }
 
-pub fn is_port(port: String) -> Result<(), String> {
-    port.parse::<u16>()
-        .map(|_| ())
-        .map_err(|e| format!("{}", e))
+pub fn is_port<T>(port: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    is_parsable_generic::<u16, _>(port)
 }
 
-pub fn is_valid_percentage(percentage: String) -> Result<(), String> {
+pub fn is_valid_percentage<T>(percentage: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
     percentage
+        .as_ref()
         .parse::<u8>()
         .map_err(|e| {
             format!(
@@ -136,8 +187,11 @@ pub fn is_valid_percentage(percentage: String) -> Result<(), String> {
         })
 }
 
-pub fn is_amount(amount: String) -> Result<(), String> {
-    if amount.parse::<u64>().is_ok() || amount.parse::<f64>().is_ok() {
+pub fn is_amount<T>(amount: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    if amount.as_ref().parse::<u64>().is_ok() || amount.as_ref().parse::<f64>().is_ok() {
         Ok(())
     } else {
         Err(format!(
@@ -147,8 +201,14 @@ pub fn is_amount(amount: String) -> Result<(), String> {
     }
 }
 
-pub fn is_amount_or_all(amount: String) -> Result<(), String> {
-    if amount.parse::<u64>().is_ok() || amount.parse::<f64>().is_ok() || amount == "ALL" {
+pub fn is_amount_or_all<T>(amount: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    if amount.as_ref().parse::<u64>().is_ok()
+        || amount.as_ref().parse::<f64>().is_ok()
+        || amount.as_ref() == "ALL"
+    {
         Ok(())
     } else {
         Err(format!(
@@ -158,14 +218,20 @@ pub fn is_amount_or_all(amount: String) -> Result<(), String> {
     }
 }
 
-pub fn is_rfc3339_datetime(value: String) -> Result<(), String> {
-    DateTime::parse_from_rfc3339(&value)
+pub fn is_rfc3339_datetime<T>(value: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    DateTime::parse_from_rfc3339(value.as_ref())
         .map(|_| ())
         .map_err(|e| format!("{}", e))
 }
 
-pub fn is_derivation(value: String) -> Result<(), String> {
-    let value = value.replace("'", "");
+pub fn is_derivation<T>(value: T) -> Result<(), String>
+where
+    T: AsRef<str> + Display,
+{
+    let value = value.as_ref().replace("'", "");
     let mut parts = value.split('/');
     let account = parts.next().unwrap();
     account
@@ -197,14 +263,14 @@ mod tests {
 
     #[test]
     fn test_is_derivation() {
-        assert_eq!(is_derivation("2".to_string()), Ok(()));
-        assert_eq!(is_derivation("0".to_string()), Ok(()));
-        assert_eq!(is_derivation("65537".to_string()), Ok(()));
-        assert_eq!(is_derivation("0/2".to_string()), Ok(()));
-        assert_eq!(is_derivation("0'/2'".to_string()), Ok(()));
-        assert!(is_derivation("a".to_string()).is_err());
-        assert!(is_derivation("4294967296".to_string()).is_err());
-        assert!(is_derivation("a/b".to_string()).is_err());
-        assert!(is_derivation("0/4294967296".to_string()).is_err());
+        assert_eq!(is_derivation("2"), Ok(()));
+        assert_eq!(is_derivation("0"), Ok(()));
+        assert_eq!(is_derivation("65537"), Ok(()));
+        assert_eq!(is_derivation("0/2"), Ok(()));
+        assert_eq!(is_derivation("0'/2'"), Ok(()));
+        assert!(is_derivation("a").is_err());
+        assert!(is_derivation("4294967296").is_err());
+        assert!(is_derivation("a/b").is_err());
+        assert!(is_derivation("0/4294967296").is_err());
     }
 }

cli-config/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli-config"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@@ -11,9 +11,9 @@ homepage = "https://solana.com/"
 [dependencies]
 dirs = "2.0.2"
 lazy_static = "1.4.0"
-serde = "1.0.110"
+serde = "1.0.112"
 serde_derive = "1.0.103"
-serde_yaml = "0.8.12"
+serde_yaml = "0.8.13"
 url = "2.1.1"
 
 [package.metadata.docs.rs]

cli-config/src/config.rs

@@ -1,6 +1,6 @@
 // Wallet settings that can be configured for long-term use
 use serde_derive::{Deserialize, Serialize};
-use std::io;
+use std::{collections::HashMap, io, path::Path};
 use url::Url;
 
 lazy_static! {
@@ -17,6 +17,9 @@ pub struct Config {
     pub json_rpc_url: String,
     pub websocket_url: String,
     pub keypair_path: String,
+
+    #[serde(default)]
+    pub address_labels: HashMap<String, String>,
 }
 
 impl Default for Config {
@@ -32,10 +35,17 @@ impl Default for Config {
         // `Config::compute_websocket_url(&json_rpc_url)`
         let websocket_url = "".to_string();
 
+        let mut address_labels = HashMap::new();
+        address_labels.insert(
+            "11111111111111111111111111111111".to_string(),
+            "System Program".to_string(),
+        );
+
         Self {
             json_rpc_url,
             websocket_url,
             keypair_path,
+            address_labels,
         }
     }
 }
@@ -65,6 +75,24 @@ impl Config {
         }
         ws_url.to_string()
     }
+
+    pub fn import_address_labels<P>(&mut self, filename: P) -> Result<(), io::Error>
+    where
+        P: AsRef<Path>,
+    {
+        let imports: HashMap<String, String> = crate::load_config_file(filename)?;
+        for (address, label) in imports.into_iter() {
+            self.address_labels.insert(address, label);
+        }
+        Ok(())
+    }
+
+    pub fn export_address_labels<P>(&self, filename: P) -> Result<(), io::Error>
+    where
+        P: AsRef<Path>,
+    {
+        crate::save_config_file(&self.address_labels, filename)
+    }
 }
 
 #[cfg(test)]

cli/Cargo.toml

@@ -1,54 +1,55 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.0"
+version = "1.3.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
-bincode = "1.2.1"
+bincode = "1.3.1"
 bs58 = "0.3.1"
 chrono = { version = "0.4.11", features = ["serde"] }
 clap = "2.33.1"
 criterion-stats = "0.3.0"
-ctrlc = { version = "3.1.4", features = ["termination"] }
-console = "0.10.1"
+ctrlc = { version = "3.1.5", features = ["termination"] }
+console = "0.11.3"
 dirs = "2.0.2"
 log = "0.4.8"
 Inflector = "0.11.4"
-indicatif = "0.14.0"
-humantime = "2.0.0"
+indicatif = "0.15.0"
+humantime = "2.0.1"
 num-traits = "0.2"
 pretty-hex = "0.1.1"
-reqwest = { version = "0.10.4", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde = "1.0.110"
+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.53"
-solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-cli-config = { path = "../cli-config", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-config-program = { path = "../programs/config", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.0" }
-solana-transaction-status = { path = "../transaction-status", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
-solana-vote-signer = { path = "../vote-signer", version = "1.2.0" }
-thiserror = "1.0.19"
+serde_json = "1.0.56"
+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.2.0" }
-solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
+solana-core = { path = "../core", version = "1.3.2" }
+solana-budget-program = { path = "../programs/budget", version = "1.3.2" }
 tempfile = "3.1.0"
 
 [[bin]]

cli/src/checks.rs

@@ -4,7 +4,8 @@ use solana_client::{
     rpc_client::RpcClient,
 };
 use solana_sdk::{
-    fee_calculator::FeeCalculator, message::Message, native_token::lamports_to_sol, pubkey::Pubkey,
+    commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message,
+    native_token::lamports_to_sol, pubkey::Pubkey,
 };
 
 pub fn check_account_for_fee(
@@ -16,14 +17,46 @@ pub fn check_account_for_fee(
     check_account_for_multiple_fees(rpc_client, account_pubkey, fee_calculator, &[message])
 }
 
+pub fn check_account_for_fee_with_commitment(
+    rpc_client: &RpcClient,
+    account_pubkey: &Pubkey,
+    fee_calculator: &FeeCalculator,
+    message: &Message,
+    commitment: CommitmentConfig,
+) -> Result<(), CliError> {
+    check_account_for_multiple_fees_with_commitment(
+        rpc_client,
+        account_pubkey,
+        fee_calculator,
+        &[message],
+        commitment,
+    )
+}
+
 pub fn check_account_for_multiple_fees(
     rpc_client: &RpcClient,
     account_pubkey: &Pubkey,
     fee_calculator: &FeeCalculator,
     messages: &[&Message],
+) -> Result<(), CliError> {
+    check_account_for_multiple_fees_with_commitment(
+        rpc_client,
+        account_pubkey,
+        fee_calculator,
+        messages,
+        CommitmentConfig::default(),
+    )
+}
+
+pub fn check_account_for_multiple_fees_with_commitment(
+    rpc_client: &RpcClient,
+    account_pubkey: &Pubkey,
+    fee_calculator: &FeeCalculator,
+    messages: &[&Message],
+    commitment: CommitmentConfig,
 ) -> Result<(), CliError> {
     let fee = calculate_fee(fee_calculator, messages);
-    if !check_account_for_balance(rpc_client, account_pubkey, fee)
+    if !check_account_for_balance_with_commitment(rpc_client, account_pubkey, fee, commitment)
         .map_err(Into::<ClientError>::into)?
     {
         return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
@@ -43,7 +76,23 @@ pub fn check_account_for_balance(
     account_pubkey: &Pubkey,
     balance: u64,
 ) -> ClientResult<bool> {
-    let lamports = rpc_client.get_balance(account_pubkey)?;
+    check_account_for_balance_with_commitment(
+        rpc_client,
+        account_pubkey,
+        balance,
+        CommitmentConfig::default(),
+    )
+}
+
+pub fn check_account_for_balance_with_commitment(
+    rpc_client: &RpcClient,
+    account_pubkey: &Pubkey,
+    balance: u64,
+    commitment: CommitmentConfig,
+) -> ClientResult<bool> {
+    let lamports = rpc_client
+        .get_balance_with_commitment(account_pubkey, commitment)?
+        .value;
     if lamports != 0 && lamports >= balance {
         return Ok(true);
     }
@@ -88,11 +137,11 @@ mod tests {
         let pubkey0 = Pubkey::new(&[0; 32]);
         let pubkey1 = Pubkey::new(&[1; 32]);
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let message0 = Message::new(&[ix0]);
+        let message0 = Message::new(&[ix0], Some(&pubkey0));
 
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
         let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
-        let message1 = Message::new(&[ix0, ix1]);
+        let message1 = Message::new(&[ix0, ix1], Some(&pubkey0));
 
         let mut mocks = HashMap::new();
         mocks.insert(RpcRequest::GetBalance, account_balance_response.clone());
@@ -176,13 +225,13 @@ mod tests {
         let pubkey0 = Pubkey::new(&[0; 32]);
         let pubkey1 = Pubkey::new(&[1; 32]);
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let message0 = Message::new(&[ix0]);
+        let message0 = Message::new(&[ix0], Some(&pubkey0));
         assert_eq!(calculate_fee(&fee_calculator, &[&message0]), 1);
 
         // Two messages, additive fees.
         let ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
         let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
-        let message1 = Message::new(&[ix0, ix1]);
+        let message1 = Message::new(&[ix0, ix1], Some(&pubkey0));
         assert_eq!(calculate_fee(&fee_calculator, &[&message0, &message1]), 3);
     }
 

cli/src/cli_output.rs

@@ -1,4 +1,7 @@
-use crate::{cli::build_balance_message, display::writeln_name_value};
+use crate::{
+    cli::build_balance_message,
+    display::{format_labeled_address, writeln_name_value},
+};
 use chrono::{DateTime, NaiveDateTime, SecondsFormat, Utc};
 use console::{style, Emoji};
 use inflector::cases::titlecase::to_title_case;
@@ -18,7 +21,11 @@ use solana_vote_program::{
     authorized_voters::AuthorizedVoters,
     vote_state::{BlockTimestamp, Lockout},
 };
-use std::{collections::BTreeMap, fmt, time::Duration};
+use std::{
+    collections::{BTreeMap, HashMap},
+    fmt,
+    time::Duration,
+};
 
 static WARNING: Emoji = Emoji("⚠️", "!");
 
@@ -199,6 +206,11 @@ impl From<EpochInfo> for CliEpochInfo {
 impl fmt::Display for CliEpochInfo {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(f)?;
+        writeln_name_value(
+            f,
+            "Block height:",
+            &self.epoch_info.block_height.to_string(),
+        )?;
         writeln_name_value(f, "Slot:", &self.epoch_info.absolute_slot.to_string())?;
         writeln_name_value(f, "Epoch:", &self.epoch_info.epoch.to_string())?;
         let start_slot = self.epoch_info.absolute_slot - self.epoch_info.slot_index;
@@ -247,6 +259,15 @@ fn slot_to_human_time(slot: Slot) -> String {
     .to_string()
 }
 
+#[derive(Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CliValidatorsStakeByVersion {
+    pub current_validators: usize,
+    pub delinquent_validators: usize,
+    pub current_active_stake: u64,
+    pub delinquent_active_stake: u64,
+}
+
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CliValidators {
@@ -255,6 +276,7 @@ pub struct CliValidators {
     pub total_deliquent_stake: u64,
     pub current_validators: Vec<CliValidator>,
     pub delinquent_validators: Vec<CliValidator>,
+    pub stake_by_version: BTreeMap<String, CliValidatorsStakeByVersion>,
     #[serde(skip_serializing)]
     pub use_lamports_unit: bool,
 }
@@ -278,7 +300,7 @@ impl fmt::Display for CliValidators {
 
             writeln!(
                 f,
-                "{} {:<44}  {:<44}  {:>9}%   {:>8}  {:>10}  {:>7}  {}",
+                "{} {:<44}  {:<44}  {:>3}%   {:>8}  {:>10}  {:>10}  {:>17}  {}",
                 if delinquent {
                     WARNING.to_string()
                 } else {
@@ -290,11 +312,12 @@ impl fmt::Display for CliValidators {
                 non_zero_or_dash(validator.last_vote),
                 non_zero_or_dash(validator.root_slot),
                 validator.credits,
+                validator.version,
                 if validator.activated_stake > 0 {
                     format!(
                         "{} ({:.2}%)",
                         build_balance_message(validator.activated_stake, use_lamports_unit, true),
-                        100. * validator.activated_stake as f64 / total_active_stake as f64
+                        100. * validator.activated_stake as f64 / total_active_stake as f64,
                     )
                 } else {
                     "-".into()
@@ -330,18 +353,41 @@ impl fmt::Display for CliValidators {
                 ),
             )?;
         }
+
+        writeln!(f)?;
+        writeln!(f, "{}", style("Stake By Version:").bold())?;
+        for (version, info) in self.stake_by_version.iter() {
+            writeln!(
+                f,
+                "{:<16} - {:3} current validators ({:>5.2}%){}",
+                version,
+                info.current_validators,
+                100. * info.current_active_stake as f64 / self.total_active_stake as f64,
+                if info.delinquent_validators > 0 {
+                    format!(
+                        ", {:3} delinquent validators ({:>5.2}%)",
+                        info.delinquent_validators,
+                        100. * info.delinquent_active_stake as f64 / self.total_active_stake as f64
+                    )
+                } else {
+                    "".to_string()
+                },
+            )?;
+        }
+
         writeln!(f)?;
         writeln!(
             f,
             "{}",
             style(format!(
-                "  {:<44}  {:<44}  {}  {}  {}  {:>7}  {}",
+                "  {:<44}  {:<38}  {}  {}  {}  {:>10}  {:^17}  {}",
                 "Identity Pubkey",
                 "Vote Account Pubkey",
                 "Commission",
                 "Last Vote",
                 "Root Block",
                 "Credits",
+                "Version",
                 "Active Stake",
             ))
             .bold()
@@ -378,13 +424,19 @@ pub struct CliValidator {
     pub root_slot: u64,
     pub credits: u64,
     pub activated_stake: u64,
+    pub version: String,
 }
 
 impl CliValidator {
-    pub fn new(vote_account: &RpcVoteAccountInfo, current_epoch: Epoch) -> Self {
+    pub fn new(
+        vote_account: &RpcVoteAccountInfo,
+        current_epoch: Epoch,
+        version: String,
+        address_labels: &HashMap<String, String>,
+    ) -> Self {
         Self {
-            identity_pubkey: vote_account.node_pubkey.to_string(),
-            vote_account_pubkey: vote_account.vote_pubkey.to_string(),
+            identity_pubkey: format_labeled_address(&vote_account.node_pubkey, address_labels),
+            vote_account_pubkey: format_labeled_address(&vote_account.vote_pubkey, address_labels),
             commission: vote_account.commission,
             last_vote: vote_account.last_vote,
             root_slot: vote_account.root_slot,
@@ -400,6 +452,7 @@ impl CliValidator {
                 })
                 .unwrap_or(0),
             activated_stake: vote_account.activated_stake,
+            version,
         }
     }
 }
@@ -482,7 +535,7 @@ impl fmt::Display for CliKeyedStakeState {
 #[serde(rename_all = "camelCase")]
 pub struct CliStakeState {
     pub stake_type: CliStakeType,
-    pub total_stake: u64,
+    pub account_balance: u64,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub delegated_stake: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -497,6 +550,16 @@ pub struct CliStakeState {
     pub lockup: Option<CliLockup>,
     #[serde(skip_serializing)]
     pub use_lamports_unit: bool,
+    #[serde(skip_serializing)]
+    pub current_epoch: Epoch,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rent_exempt_reserve: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_stake: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub activating_stake: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deactivating_stake: Option<u64>,
 }
 
 impl fmt::Display for CliStakeState {
@@ -506,71 +569,147 @@ impl fmt::Display for CliStakeState {
             writeln!(f, "Withdraw Authority: {}", authorized.withdrawer)?;
             Ok(())
         }
-        fn show_lockup(f: &mut fmt::Formatter, lockup: &CliLockup) -> fmt::Result {
+        fn show_lockup(f: &mut fmt::Formatter, lockup: Option<&CliLockup>) -> fmt::Result {
+            if let Some(lockup) = lockup {
+                if lockup.unix_timestamp != UnixTimestamp::default() {
+                    writeln!(
+                        f,
+                        "Lockup Timestamp: {} (UnixTimestamp: {})",
+                        DateTime::<Utc>::from_utc(
+                            NaiveDateTime::from_timestamp(lockup.unix_timestamp, 0),
+                            Utc
+                        )
+                        .to_rfc3339_opts(SecondsFormat::Secs, true),
+                        lockup.unix_timestamp
+                    )?;
+                }
+                if lockup.epoch != Epoch::default() {
+                    writeln!(f, "Lockup Epoch: {}", lockup.epoch)?;
+                }
+                writeln!(f, "Lockup Custodian: {}", lockup.custodian)?;
+            }
+            Ok(())
+        }
+
+        writeln!(
+            f,
+            "Balance: {}",
+            build_balance_message(self.account_balance, self.use_lamports_unit, true)
+        )?;
+
+        if let Some(rent_exempt_reserve) = self.rent_exempt_reserve {
             writeln!(
                 f,
-                "Lockup Timestamp: {} (UnixTimestamp: {})",
-                DateTime::<Utc>::from_utc(
-                    NaiveDateTime::from_timestamp(lockup.unix_timestamp, 0),
-                    Utc
-                )
-                .to_rfc3339_opts(SecondsFormat::Secs, true),
-                lockup.unix_timestamp
+                "Rent Exempt Reserve: {}",
+                build_balance_message(rent_exempt_reserve, self.use_lamports_unit, true)
             )?;
-            writeln!(f, "Lockup Epoch: {}", lockup.epoch)?;
-            writeln!(f, "Lockup Custodian: {}", lockup.custodian)?;
-            Ok(())
         }
 
         match self.stake_type {
             CliStakeType::RewardsPool => writeln!(f, "Stake account is a rewards pool")?,
             CliStakeType::Uninitialized => writeln!(f, "Stake account is uninitialized")?,
             CliStakeType::Initialized => {
-                writeln!(
-                    f,
-                    "Total Stake: {}",
-                    build_balance_message(self.total_stake, self.use_lamports_unit, true)
-                )?;
                 writeln!(f, "Stake account is undelegated")?;
                 show_authorized(f, self.authorized.as_ref().unwrap())?;
-                show_lockup(f, self.lockup.as_ref().unwrap())?;
+                show_lockup(f, self.lockup.as_ref())?;
             }
             CliStakeType::Stake => {
-                writeln!(
-                    f,
-                    "Total Stake: {}",
-                    build_balance_message(self.total_stake, self.use_lamports_unit, true)
-                )?;
-                writeln!(
-                    f,
-                    "Delegated Stake: {}",
-                    build_balance_message(
-                        self.delegated_stake.unwrap(),
-                        self.use_lamports_unit,
-                        true
-                    )
-                )?;
-                if let Some(delegated_vote_account_address) = &self.delegated_vote_account_address {
+                let show_delegation = {
+                    self.active_stake.is_some()
+                        || self.activating_stake.is_some()
+                        || self.deactivating_stake.is_some()
+                        || self
+                            .deactivation_epoch
+                            .map(|de| de > self.current_epoch)
+                            .unwrap_or(true)
+                };
+                if show_delegation {
+                    let delegated_stake = self.delegated_stake.unwrap();
                     writeln!(
                         f,
-                        "Delegated Vote Account Address: {}",
-                        delegated_vote_account_address
-                    )?;
-                }
-                writeln!(
-                    f,
-                    "Stake activates starting from epoch: {}",
-                    self.activation_epoch.unwrap()
-                )?;
-                if let Some(deactivation_epoch) = self.deactivation_epoch {
-                    writeln!(
-                        f,
-                        "Stake deactivates starting from epoch: {}",
-                        deactivation_epoch
+                        "Delegated Stake: {}",
+                        build_balance_message(delegated_stake, self.use_lamports_unit, true)
                     )?;
+                    if self
+                        .deactivation_epoch
+                        .map(|d| self.current_epoch <= d)
+                        .unwrap_or(true)
+                    {
+                        let active_stake = self.active_stake.unwrap_or(0);
+                        writeln!(
+                            f,
+                            "Active Stake: {}",
+                            build_balance_message(active_stake, self.use_lamports_unit, true),
+                        )?;
+                        let activating_stake = self.activating_stake.or_else(|| {
+                            if self.active_stake.is_none() {
+                                Some(delegated_stake)
+                            } else {
+                                None
+                            }
+                        });
+                        if let Some(activating_stake) = activating_stake {
+                            writeln!(
+                                f,
+                                "Activating Stake: {}",
+                                build_balance_message(
+                                    activating_stake,
+                                    self.use_lamports_unit,
+                                    true
+                                ),
+                            )?;
+                            writeln!(
+                                f,
+                                "Stake activates starting from epoch: {}",
+                                self.activation_epoch.unwrap()
+                            )?;
+                        }
+                    }
+
+                    if let Some(deactivation_epoch) = self.deactivation_epoch {
+                        if self.current_epoch > deactivation_epoch {
+                            let deactivating_stake = self.deactivating_stake.or(self.active_stake);
+                            if let Some(deactivating_stake) = deactivating_stake {
+                                writeln!(
+                                    f,
+                                    "Inactive Stake: {}",
+                                    build_balance_message(
+                                        delegated_stake - deactivating_stake,
+                                        self.use_lamports_unit,
+                                        true
+                                    ),
+                                )?;
+                                writeln!(
+                                    f,
+                                    "Deactivating Stake: {}",
+                                    build_balance_message(
+                                        deactivating_stake,
+                                        self.use_lamports_unit,
+                                        true
+                                    ),
+                                )?;
+                            }
+                        }
+                        writeln!(
+                            f,
+                            "Stake deactivates starting from epoch: {}",
+                            deactivation_epoch
+                        )?;
+                    }
+                    if let Some(delegated_vote_account_address) =
+                        &self.delegated_vote_account_address
+                    {
+                        writeln!(
+                            f,
+                            "Delegated Vote Account Address: {}",
+                            delegated_vote_account_address
+                        )?;
+                    }
+                } else {
+                    writeln!(f, "Stake account is undelegated")?;
                 }
                 show_authorized(f, self.authorized.as_ref().unwrap())?;
-                show_lockup(f, self.lockup.as_ref().unwrap())?;
+                show_lockup(f, self.lockup.as_ref())?;
             }
         }
         Ok(())
@@ -900,6 +1039,7 @@ impl fmt::Display for CliSignOnlyData {
 }
 
 #[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct CliSignature {
     pub signature: String,
 }
@@ -913,6 +1053,7 @@ impl fmt::Display for CliSignature {
 }
 
 #[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct CliAccountBalances {
     pub accounts: Vec<RpcAccountBalance>,
 }
@@ -937,6 +1078,7 @@ impl fmt::Display for CliAccountBalances {
 }
 
 #[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct CliSupply {
     pub total: u64,
     pub circulating: u64,
@@ -981,3 +1123,25 @@ impl fmt::Display for CliSupply {
         Ok(())
     }
 }
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CliFees {
+    pub slot: Slot,
+    pub blockhash: String,
+    pub lamports_per_signature: u64,
+    pub last_valid_slot: Slot,
+}
+
+impl fmt::Display for CliFees {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln_name_value(f, "Blockhash:", &self.blockhash)?;
+        writeln_name_value(
+            f,
+            "Lamports per signature:",
+            &self.lamports_per_signature.to_string(),
+        )?;
+        writeln_name_value(f, "Last valid slot:", &self.last_valid_slot.to_string())?;
+        Ok(())
+    }
+}

cli/src/cluster_query.rs

@@ -1,23 +1,18 @@
 use crate::{
     cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
     cli_output::*,
-    display::println_name_value,
+    display::{format_labeled_address, new_spinner_progress_bar, println_name_value},
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
 use console::{style, Emoji};
-use indicatif::{ProgressBar, ProgressStyle};
 use solana_clap_utils::{
-    commitment::{commitment_arg, COMMITMENT_ARG},
-    input_parsers::*,
-    input_validators::*,
-    keypair::signer_from_path,
+    commitment::commitment_arg, input_parsers::*, input_validators::*, keypair::signer_from_path,
 };
 use solana_client::{
     pubsub_client::{PubsubClient, SlotInfoMessage},
     rpc_client::RpcClient,
     rpc_config::{RpcLargestAccountsConfig, RpcLargestAccountsFilter},
-    rpc_request::MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE,
 };
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
@@ -28,12 +23,17 @@ use solana_sdk::{
     message::Message,
     native_token::lamports_to_sol,
     pubkey::{self, Pubkey},
+    signature::Signature,
     system_instruction, system_program,
-    sysvar::{self, Sysvar},
+    sysvar::{
+        self,
+        stake_history::{self, StakeHistory},
+        Sysvar,
+    },
     transaction::Transaction,
 };
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::{BTreeMap, HashMap, VecDeque},
     net::SocketAddr,
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -115,6 +115,10 @@ impl ClusterQuerySubCommands for App<'_, '_> {
             .alias("get-slot")
             .arg(commitment_arg()),
         )
+        .subcommand(
+            SubCommand::with_name("block-height").about("Get current block height")
+            .arg(commitment_arg()),
+        )
         .subcommand(
             SubCommand::with_name("epoch").about("Get current epoch")
             .arg(commitment_arg()),
@@ -253,9 +257,8 @@ impl ClusterQuerySubCommands for App<'_, '_> {
         )
         .subcommand(
             SubCommand::with_name("transaction-history")
-                .about("Show historical transactions affecting the given address, \
-                       ordered based on the slot in which they were confirmed in \
-                       from lowest to highest slot")
+                .about("Show historical transactions affecting the given address \
+                        from newest to oldest")
                 .arg(
                     pubkey!(Arg::with_name("address")
                         .index(1)
@@ -263,26 +266,22 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .required(true),
                         "Account address"),
                 )
-                .arg(
-                    Arg::with_name("end_slot")
-                        .takes_value(false)
-                        .value_name("SLOT")
-                        .index(2)
-                        .validator(is_slot)
-                        .help(
-                            "Slot to start from [default: latest slot at maximum commitment]"
-                        ),
-                )
                 .arg(
                     Arg::with_name("limit")
                         .long("limit")
                         .takes_value(true)
-                        .value_name("NUMBER OF SLOTS")
+                        .value_name("LIMIT")
                         .validator(is_slot)
-                        .help(
-                            "Limit the search to this many slots"
-                        ),
-                ),
+                        .default_value("1000")
+                        .help("Maximum number of transaction signatures to return"),
+                )
+                .arg(
+                    Arg::with_name("before")
+                        .long("before")
+                        .value_name("TRANSACTION_SIGNATURE")
+                        .takes_value(true)
+                        .help("Start with the first signature older than this one"),
+                )
         )
     }
 }
@@ -293,13 +292,11 @@ pub fn parse_catchup(
 ) -> Result<CliCommandInfo, CliError> {
     let node_pubkey = pubkey_of_signer(matches, "node_pubkey", wallet_manager)?.unwrap();
     let node_json_rpc_url = value_t!(matches, "node_json_rpc_url", String).ok();
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
     let follow = matches.is_present("follow");
     Ok(CliCommandInfo {
         command: CliCommand::Catchup {
             node_pubkey,
             node_json_rpc_url,
-            commitment_config,
             follow,
         },
         signers: vec![],
@@ -319,14 +316,12 @@ pub fn parse_cluster_ping(
         None
     };
     let timeout = Duration::from_secs(value_t_or_exit!(matches, "timeout", u64));
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
     Ok(CliCommandInfo {
         command: CliCommand::Ping {
             lamports,
             interval,
             count,
             timeout,
-            commitment_config,
         },
         signers: vec![signer_from_path(
             matches,
@@ -345,32 +340,35 @@ pub fn parse_get_block_time(matches: &ArgMatches<'_>) -> Result<CliCommandInfo,
     })
 }
 
-pub fn parse_get_epoch_info(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+pub fn parse_get_epoch(_matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     Ok(CliCommandInfo {
-        command: CliCommand::GetEpochInfo { commitment_config },
+        command: CliCommand::GetEpoch,
         signers: vec![],
     })
 }
 
-pub fn parse_get_slot(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+pub fn parse_get_epoch_info(_matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     Ok(CliCommandInfo {
-        command: CliCommand::GetSlot { commitment_config },
+        command: CliCommand::GetEpochInfo,
         signers: vec![],
     })
 }
 
-pub fn parse_get_epoch(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+pub fn parse_get_slot(_matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     Ok(CliCommandInfo {
-        command: CliCommand::GetEpoch { commitment_config },
+        command: CliCommand::GetSlot,
+        signers: vec![],
+    })
+}
+
+pub fn parse_get_block_height(_matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
+    Ok(CliCommandInfo {
+        command: CliCommand::GetBlockHeight,
         signers: vec![],
     })
 }
 
 pub fn parse_largest_accounts(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
     let filter = if matches.is_present("circulating") {
         Some(RpcLargestAccountsFilter::Circulating)
     } else if matches.is_present("non_circulating") {
@@ -379,38 +377,29 @@ pub fn parse_largest_accounts(matches: &ArgMatches<'_>) -> Result<CliCommandInfo
         None
     };
     Ok(CliCommandInfo {
-        command: CliCommand::LargestAccounts {
-            commitment_config,
-            filter,
-        },
+        command: CliCommand::LargestAccounts { filter },
         signers: vec![],
     })
 }
 
 pub fn parse_supply(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
     let print_accounts = matches.is_present("print_accounts");
     Ok(CliCommandInfo {
-        command: CliCommand::Supply {
-            commitment_config,
-            print_accounts,
-        },
+        command: CliCommand::Supply { print_accounts },
         signers: vec![],
     })
 }
 
-pub fn parse_total_supply(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+pub fn parse_total_supply(_matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     Ok(CliCommandInfo {
-        command: CliCommand::TotalSupply { commitment_config },
+        command: CliCommand::TotalSupply,
         signers: vec![],
     })
 }
 
-pub fn parse_get_transaction_count(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
+pub fn parse_get_transaction_count(_matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     Ok(CliCommandInfo {
-        command: CliCommand::GetTransactionCount { commitment_config },
+        command: CliCommand::GetTransactionCount,
         signers: vec![],
     })
 }
@@ -434,13 +423,9 @@ pub fn parse_show_stakes(
 
 pub fn parse_show_validators(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let use_lamports_unit = matches.is_present("lamports");
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
 
     Ok(CliCommandInfo {
-        command: CliCommand::ShowValidators {
-            use_lamports_unit,
-            commitment_config,
-        },
+        command: CliCommand::ShowValidators { use_lamports_unit },
         signers: vec![],
     })
 }
@@ -450,33 +435,32 @@ pub fn parse_transaction_history(
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
     let address = pubkey_of_signer(matches, "address", wallet_manager)?.unwrap();
-    let end_slot = value_t!(matches, "end_slot", Slot).ok();
-    let slot_limit = value_t!(matches, "limit", u64).ok();
+
+    let before = match matches.value_of("before") {
+        Some(signature) => Some(
+            signature
+                .parse()
+                .map_err(|err| CliError::BadParameter(format!("Invalid signature: {}", err)))?,
+        ),
+        None => None,
+    };
+    let limit = value_t_or_exit!(matches, "limit", usize);
 
     Ok(CliCommandInfo {
         command: CliCommand::TransactionHistory {
             address,
-            end_slot,
-            slot_limit,
+            before,
+            limit,
         },
         signers: vec![],
     })
 }
 
-/// Creates a new process bar for processing that will take an unknown amount of time
-fn new_spinner_progress_bar() -> ProgressBar {
-    let progress_bar = ProgressBar::new(42);
-    progress_bar
-        .set_style(ProgressStyle::default_spinner().template("{spinner:.green} {wide_msg}"));
-    progress_bar.enable_steady_tick(100);
-    progress_bar
-}
-
 pub fn process_catchup(
     rpc_client: &RpcClient,
+    config: &CliConfig,
     node_pubkey: &Pubkey,
     node_json_rpc_url: &Option<String>,
-    commitment_config: CommitmentConfig,
     follow: bool,
 ) -> ProcessResult {
     let sleep_interval = 5;
@@ -525,8 +509,8 @@ pub fn process_catchup(
     let mut previous_rpc_slot = std::u64::MAX;
     let mut previous_slot_distance = 0;
     loop {
-        let rpc_slot = rpc_client.get_slot_with_commitment(commitment_config)?;
-        let node_slot = node_client.get_slot_with_commitment(commitment_config)?;
+        let rpc_slot = rpc_client.get_slot_with_commitment(config.commitment)?;
+        let node_slot = node_client.get_slot_with_commitment(config.commitment)?;
         if !follow && node_slot > std::cmp::min(previous_rpc_slot, rpc_slot) {
             progress_bar.finish_and_clear();
             return Ok(format!(
@@ -597,13 +581,16 @@ pub fn process_cluster_version(rpc_client: &RpcClient) -> ProcessResult {
     Ok(remote_version.solana_core)
 }
 
-pub fn process_fees(rpc_client: &RpcClient) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-
-    Ok(format!(
-        "blockhash: {}\nlamports per signature: {}",
-        recent_blockhash, fee_calculator.lamports_per_signature
-    ))
+pub fn process_fees(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
+    let result = rpc_client.get_recent_blockhash_with_commitment(CommitmentConfig::default())?;
+    let (recent_blockhash, fee_calculator, last_valid_slot) = result.value;
+    let fees = CliFees {
+        slot: result.context.slot,
+        blockhash: recent_blockhash.to_string(),
+        lamports_per_signature: fee_calculator.lamports_per_signature,
+        last_valid_slot,
+    };
+    Ok(config.output_format.formatted_string(&fees))
 }
 
 pub fn process_leader_schedule(rpc_client: &RpcClient) -> ProcessResult {
@@ -656,13 +643,14 @@ pub fn process_get_block_time(
     Ok(config.output_format.formatted_string(&block_time))
 }
 
-pub fn process_get_epoch_info(
-    rpc_client: &RpcClient,
-    config: &CliConfig,
-    commitment_config: CommitmentConfig,
-) -> ProcessResult {
+pub fn process_get_epoch(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
+    let epoch_info = rpc_client.get_epoch_info_with_commitment(config.commitment)?;
+    Ok(epoch_info.epoch.to_string())
+}
+
+pub fn process_get_epoch_info(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
     let epoch_info: CliEpochInfo = rpc_client
-        .get_epoch_info_with_commitment(commitment_config.clone())?
+        .get_epoch_info_with_commitment(config.commitment)?
         .into();
     Ok(config.output_format.formatted_string(&epoch_info))
 }
@@ -672,20 +660,16 @@ pub fn process_get_genesis_hash(rpc_client: &RpcClient) -> ProcessResult {
     Ok(genesis_hash.to_string())
 }
 
-pub fn process_get_slot(
-    rpc_client: &RpcClient,
-    commitment_config: CommitmentConfig,
-) -> ProcessResult {
-    let slot = rpc_client.get_slot_with_commitment(commitment_config.clone())?;
+pub fn process_get_slot(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
+    let slot = rpc_client.get_slot_with_commitment(config.commitment)?;
     Ok(slot.to_string())
 }
 
-pub fn process_get_epoch(
-    rpc_client: &RpcClient,
-    commitment_config: CommitmentConfig,
-) -> ProcessResult {
-    let epoch_info = rpc_client.get_epoch_info_with_commitment(commitment_config.clone())?;
-    Ok(epoch_info.epoch.to_string())
+pub fn process_get_block_height(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
+    let epoch_info: CliEpochInfo = rpc_client
+        .get_epoch_info_with_commitment(config.commitment)?
+        .into();
+    Ok(epoch_info.epoch_info.block_height.to_string())
 }
 
 pub fn parse_show_block_production(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
@@ -771,11 +755,12 @@ pub fn process_show_block_production(
     let leader_schedule = leader_schedule.unwrap();
 
     let mut leader_per_slot_index = Vec::new();
-    leader_per_slot_index.resize(total_slots, "?");
+    leader_per_slot_index.resize(total_slots, "?".to_string());
     for (pubkey, leader_slots) in leader_schedule.iter() {
+        let pubkey = format_labeled_address(pubkey, &config.address_labels);
         for slot_index in leader_slots.iter() {
             if *slot_index >= start_slot_index && *slot_index <= end_slot_index {
-                leader_per_slot_index[*slot_index - start_slot_index] = pubkey;
+                leader_per_slot_index[*slot_index - start_slot_index] = pubkey.clone();
             }
         }
     }
@@ -852,12 +837,11 @@ pub fn process_show_block_production(
 pub fn process_largest_accounts(
     rpc_client: &RpcClient,
     config: &CliConfig,
-    commitment_config: CommitmentConfig,
     filter: Option<RpcLargestAccountsFilter>,
 ) -> ProcessResult {
     let accounts = rpc_client
         .get_largest_accounts_with_config(RpcLargestAccountsConfig {
-            commitment: Some(commitment_config),
+            commitment: Some(config.commitment),
             filter,
         })?
         .value;
@@ -868,29 +852,21 @@ pub fn process_largest_accounts(
 pub fn process_supply(
     rpc_client: &RpcClient,
     config: &CliConfig,
-    commitment_config: CommitmentConfig,
     print_accounts: bool,
 ) -> ProcessResult {
-    let supply_response = rpc_client.supply_with_commitment(commitment_config.clone())?;
+    let supply_response = rpc_client.supply_with_commitment(config.commitment)?;
     let mut supply: CliSupply = supply_response.value.into();
     supply.print_accounts = print_accounts;
     Ok(config.output_format.formatted_string(&supply))
 }
 
-pub fn process_total_supply(
-    rpc_client: &RpcClient,
-    commitment_config: CommitmentConfig,
-) -> ProcessResult {
-    let total_supply = rpc_client.total_supply_with_commitment(commitment_config.clone())?;
+pub fn process_total_supply(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
+    let total_supply = rpc_client.total_supply_with_commitment(config.commitment)?;
     Ok(format!("{} SOL", lamports_to_sol(total_supply)))
 }
 
-pub fn process_get_transaction_count(
-    rpc_client: &RpcClient,
-    commitment_config: CommitmentConfig,
-) -> ProcessResult {
-    let transaction_count =
-        rpc_client.get_transaction_count_with_commitment(commitment_config.clone())?;
+pub fn process_get_transaction_count(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
+    let transaction_count = rpc_client.get_transaction_count_with_commitment(config.commitment)?;
     Ok(transaction_count.to_string())
 }
 
@@ -901,7 +877,6 @@ pub fn process_ping(
     interval: &Duration,
     count: &Option<u64>,
     timeout: &Duration,
-    commitment_config: CommitmentConfig,
 ) -> ProcessResult {
     println_name_value("Source Account:", &config.signers[0].pubkey().to_string());
     println!();
@@ -938,7 +913,7 @@ pub fn process_ping(
 
         let build_message = |lamports| {
             let ix = system_instruction::transfer(&config.signers[0].pubkey(), &to, lamports);
-            Message::new(&[ix])
+            Message::new(&[ix], Some(&config.signers[0].pubkey()))
         };
         let (message, _) = resolve_spend_tx_and_check_account_balance(
             rpc_client,
@@ -947,6 +922,7 @@ pub fn process_ping(
             &fee_calculator,
             &config.signers[0].pubkey(),
             build_message,
+            config.commitment,
         )?;
         let mut tx = Transaction::new_unsigned(message);
         tx.try_sign(&config.signers, blockhash)?;
@@ -955,10 +931,8 @@ pub fn process_ping(
             Ok(signature) => {
                 let transaction_sent = Instant::now();
                 loop {
-                    let signature_status = rpc_client.get_signature_status_with_commitment(
-                        &signature,
-                        commitment_config.clone(),
-                    )?;
+                    let signature_status = rpc_client
+                        .get_signature_status_with_commitment(&signature, config.commitment)?;
                     let elapsed_time = Instant::now().duration_since(transaction_sent);
                     if let Some(transaction_status) = signature_status {
                         match transaction_status {
@@ -1133,7 +1107,7 @@ pub fn process_live_slots(url: &str) -> ProcessResult {
     Ok("".to_string())
 }
 
-pub fn process_show_gossip(rpc_client: &RpcClient) -> ProcessResult {
+pub fn process_show_gossip(rpc_client: &RpcClient, config: &CliConfig) -> ProcessResult {
     let cluster_nodes = rpc_client.get_cluster_nodes()?;
 
     fn format_port(addr: Option<SocketAddr>) -> String {
@@ -1142,26 +1116,27 @@ pub fn process_show_gossip(rpc_client: &RpcClient) -> ProcessResult {
     }
 
     let s: Vec<_> = cluster_nodes
-        .iter()
+        .into_iter()
         .map(|node| {
             format!(
-                "{:15} | {:44} | {:6} | {:5} | {:5}",
+                "{:15} | {:44} | {:6} | {:5} | {:5} | {}",
                 node.gossip
                     .map(|addr| addr.ip().to_string())
                     .unwrap_or_else(|| "none".to_string()),
-                node.pubkey,
+                format_labeled_address(&node.pubkey, &config.address_labels),
                 format_port(node.gossip),
                 format_port(node.tpu),
                 format_port(node.rpc),
+                node.version.unwrap_or_else(|| "unknown".to_string()),
             )
         })
         .collect();
 
     Ok(format!(
         "IP Address      | Node identifier                              \
-         | Gossip | TPU   | RPC\n\
+         | Gossip | TPU   | RPC   | Version\n\
          ----------------+----------------------------------------------+\
-         --------+-------+-------\n\
+         --------+-------+-------+----------------\n\
          {}\n\
          Nodes: {}",
         s.join("\n"),
@@ -1181,7 +1156,16 @@ pub fn process_show_stakes(
     let progress_bar = new_spinner_progress_bar();
     progress_bar.set_message("Fetching stake accounts...");
     let all_stake_accounts = rpc_client.get_program_accounts(&solana_stake_program::id())?;
+    let stake_history_account = rpc_client.get_account(&stake_history::id())?;
     progress_bar.finish_and_clear();
+    let clock_account = rpc_client.get_account(&sysvar::clock::id())?;
+
+    let stake_history = StakeHistory::from_account(&stake_history_account).ok_or_else(|| {
+        CliError::RpcRequestError("Failed to deserialize stake history".to_string())
+    })?;
+    let clock: Clock = Sysvar::from_account(&clock_account).ok_or_else(|| {
+        CliError::RpcRequestError("Failed to deserialize clock sysvar".to_string())
+    })?;
 
     let mut stake_accounts: Vec<CliKeyedStakeState> = vec![];
     for (stake_pubkey, stake_account) in all_stake_accounts {
@@ -1195,6 +1179,8 @@ pub fn process_show_stakes(
                                 stake_account.lamports,
                                 &stake_state,
                                 use_lamports_unit,
+                                &stake_history,
+                                &clock,
                             ),
                         });
                     }
@@ -1211,6 +1197,8 @@ pub fn process_show_stakes(
                                 stake_account.lamports,
                                 &stake_state,
                                 use_lamports_unit,
+                                &stake_history,
+                                &clock,
                             ),
                         });
                     }
@@ -1228,10 +1216,21 @@ pub fn process_show_validators(
     rpc_client: &RpcClient,
     config: &CliConfig,
     use_lamports_unit: bool,
-    commitment_config: CommitmentConfig,
 ) -> ProcessResult {
-    let epoch_info = rpc_client.get_epoch_info_with_commitment(commitment_config)?;
-    let vote_accounts = rpc_client.get_vote_accounts_with_commitment(commitment_config)?;
+    let epoch_info = rpc_client.get_epoch_info_with_commitment(config.commitment)?;
+    let vote_accounts = rpc_client.get_vote_accounts_with_commitment(config.commitment)?;
+
+    let mut node_version = HashMap::new();
+    let unknown_version = "unknown".to_string();
+    for contact_info in rpc_client.get_cluster_nodes()? {
+        node_version.insert(
+            contact_info.pubkey,
+            contact_info
+                .version
+                .unwrap_or_else(|| unknown_version.clone()),
+        );
+    }
+
     let total_active_stake = vote_accounts
         .current
         .iter()
@@ -1250,21 +1249,58 @@ pub fn process_show_validators(
     current.sort_by(|a, b| b.activated_stake.cmp(&a.activated_stake));
     let current_validators: Vec<CliValidator> = current
         .iter()
-        .map(|vote_account| CliValidator::new(vote_account, epoch_info.epoch))
+        .map(|vote_account| {
+            CliValidator::new(
+                vote_account,
+                epoch_info.epoch,
+                node_version
+                    .get(&vote_account.node_pubkey)
+                    .unwrap_or(&unknown_version)
+                    .clone(),
+                &config.address_labels,
+            )
+        })
         .collect();
     let mut delinquent = vote_accounts.delinquent;
     delinquent.sort_by(|a, b| b.activated_stake.cmp(&a.activated_stake));
     let delinquent_validators: Vec<CliValidator> = delinquent
         .iter()
-        .map(|vote_account| CliValidator::new(vote_account, epoch_info.epoch))
+        .map(|vote_account| {
+            CliValidator::new(
+                vote_account,
+                epoch_info.epoch,
+                node_version
+                    .get(&vote_account.node_pubkey)
+                    .unwrap_or(&unknown_version)
+                    .clone(),
+                &config.address_labels,
+            )
+        })
         .collect();
 
+    let mut stake_by_version: BTreeMap<_, CliValidatorsStakeByVersion> = BTreeMap::new();
+    for validator in current_validators.iter() {
+        let mut entry = stake_by_version
+            .entry(validator.version.clone())
+            .or_default();
+        entry.current_validators += 1;
+        entry.current_active_stake += validator.activated_stake;
+    }
+    for validator in delinquent_validators.iter() {
+        let mut entry = stake_by_version
+            .entry(validator.version.clone())
+            .or_default();
+        entry.delinquent_validators += 1;
+        entry.delinquent_active_stake += validator.activated_stake;
+    }
+
     let cli_validators = CliValidators {
         total_active_stake,
         total_current_stake,
         total_deliquent_stake,
         current_validators,
         delinquent_validators,
+        stake_by_version,
         use_lamports_unit,
     };
     Ok(config.output_format.formatted_string(&cli_validators))
@@ -1272,41 +1308,36 @@ pub fn process_show_validators(
 
 pub fn process_transaction_history(
     rpc_client: &RpcClient,
+    config: &CliConfig,
     address: &Pubkey,
-    end_slot: Option<Slot>, // None == use latest slot
-    slot_limit: Option<u64>,
+    before: Option<Signature>,
+    limit: usize,
 ) -> ProcessResult {
-    let end_slot = {
-        if let Some(end_slot) = end_slot {
-            end_slot
+    let results = rpc_client.get_confirmed_signatures_for_address2_with_config(
+        address,
+        before,
+        Some(limit),
+    )?;
+
+    let transactions_found = format!("{} transactions found", results.len());
+
+    for result in results {
+        if config.verbose {
+            println!(
+                "{} [slot={} status={}] {}",
+                result.signature,
+                result.slot,
+                match result.err {
+                    None => "Confirmed".to_string(),
+                    Some(err) => format!("Failed: {:?}", err),
+                },
+                result.memo.unwrap_or_else(|| "".to_string()),
+            );
         } else {
-            rpc_client.get_slot_with_commitment(CommitmentConfig::max())?
+            println!("{}", result.signature);
         }
-    };
-    let mut start_slot = match slot_limit {
-        Some(slot_limit) => end_slot.saturating_sub(slot_limit),
-        None => rpc_client.minimum_ledger_slot()?,
-    };
-
-    println!(
-        "Transactions affecting {} within slots [{},{}]",
-        address, start_slot, end_slot
-    );
-
-    let mut transaction_count = 0;
-    while start_slot < end_slot {
-        let signatures = rpc_client.get_confirmed_signatures_for_address(
-            address,
-            start_slot,
-            (start_slot + MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE).min(end_slot),
-        )?;
-        for signature in &signatures {
-            println!("{}", signature);
-        }
-        transaction_count += signatures.len();
-        start_slot += MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE;
     }
-    Ok(format!("{} transactions found", transaction_count))
+    Ok(transactions_found)
 }
 
 #[cfg(test)]
@@ -1372,15 +1403,24 @@ mod tests {
             }
         );
 
+        let test_get_epoch = test_commands
+            .clone()
+            .get_matches_from(vec!["test", "epoch"]);
+        assert_eq!(
+            parse_command(&test_get_epoch, &default_keypair_file, &mut None).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::GetEpoch,
+                signers: vec![],
+            }
+        );
+
         let test_get_epoch_info = test_commands
             .clone()
             .get_matches_from(vec!["test", "epoch-info"]);
         assert_eq!(
             parse_command(&test_get_epoch_info, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::GetEpochInfo {
-                    commitment_config: CommitmentConfig::recent(),
-                },
+                command: CliCommand::GetEpochInfo,
                 signers: vec![],
             }
         );
@@ -1400,22 +1440,7 @@ mod tests {
         assert_eq!(
             parse_command(&test_get_slot, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::GetSlot {
-                    commitment_config: CommitmentConfig::recent(),
-                },
-                signers: vec![],
-            }
-        );
-
-        let test_get_epoch = test_commands
-            .clone()
-            .get_matches_from(vec!["test", "epoch"]);
-        assert_eq!(
-            parse_command(&test_get_epoch, &default_keypair_file, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::GetEpoch {
-                    commitment_config: CommitmentConfig::recent(),
-                },
+                command: CliCommand::GetSlot,
                 signers: vec![],
             }
         );
@@ -1426,9 +1451,7 @@ mod tests {
         assert_eq!(
             parse_command(&test_total_supply, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::TotalSupply {
-                    commitment_config: CommitmentConfig::recent(),
-                },
+                command: CliCommand::TotalSupply,
                 signers: vec![],
             }
         );
@@ -1439,9 +1462,7 @@ mod tests {
         assert_eq!(
             parse_command(&test_transaction_count, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::GetTransactionCount {
-                    commitment_config: CommitmentConfig::recent(),
-                },
+                command: CliCommand::GetTransactionCount,
                 signers: vec![],
             }
         );
@@ -1466,7 +1487,6 @@ mod tests {
                     interval: Duration::from_secs(1),
                     count: Some(2),
                     timeout: Duration::from_secs(3),
-                    commitment_config: CommitmentConfig::max(),
                 },
                 signers: vec![default_keypair.into()],
             }

cli/src/display.rs

@@ -1,11 +1,12 @@
 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,
 };
-use solana_transaction_status::RpcTransactionStatusMeta;
-use std::{fmt, io};
+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) {
@@ -26,6 +27,19 @@ pub fn writeln_name_value(f: &mut fmt::Formatter, name: &str, value: &str) -> fm
     writeln!(f, "{} {}", style(name).bold(), styled_value)
 }
 
+pub fn format_labeled_address(pubkey: &str, address_labels: &HashMap<String, String>) -> String {
+    let label = address_labels.get(pubkey);
+    match label {
+        Some(label) => format!(
+            "{:.31} ({:.4}..{})",
+            label,
+            pubkey,
+            pubkey.split_at(pubkey.len() - 4).1
+        ),
+        None => pubkey.to_string(),
+    }
+}
+
 pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) {
     let description = match setting_type {
         SettingType::Explicit => "",
@@ -67,7 +81,7 @@ pub fn println_signers(
 pub fn write_transaction<W: io::Write>(
     w: &mut W,
     transaction: &Transaction,
-    transaction_status: &Option<RpcTransactionStatusMeta>,
+    transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
 ) -> io::Result<()> {
     let message = &transaction.message;
@@ -190,7 +204,7 @@ pub fn write_transaction<W: io::Write>(
 
 pub fn println_transaction(
     transaction: &Transaction,
-    transaction_status: &Option<RpcTransactionStatusMeta>,
+    transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
 ) {
     let mut w = Vec::new();
@@ -200,3 +214,41 @@ pub fn println_transaction(
         }
     }
 }
+
+/// Creates a new process bar for processing that will take an unknown amount of time
+pub fn new_spinner_progress_bar() -> ProgressBar {
+    let progress_bar = ProgressBar::new(42);
+    progress_bar
+        .set_style(ProgressStyle::default_spinner().template("{spinner:.green} {wide_msg}"));
+    progress_bar.enable_steady_tick(100);
+    progress_bar
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_sdk::pubkey::Pubkey;
+
+    #[test]
+    fn test_format_labeled_address() {
+        let pubkey = Pubkey::default().to_string();
+        let mut address_labels = HashMap::new();
+
+        assert_eq!(format_labeled_address(&pubkey, &address_labels), pubkey);
+
+        address_labels.insert(pubkey.to_string(), "Default Address".to_string());
+        assert_eq!(
+            &format_labeled_address(&pubkey, &address_labels),
+            "Default Address (1111..1111)"
+        );
+
+        address_labels.insert(
+            pubkey.to_string(),
+            "abcdefghijklmnopqrstuvwxyz1234567890".to_string(),
+        );
+        assert_eq!(
+            &format_labeled_address(&pubkey, &address_labels),
+            "abcdefghijklmnopqrstuvwxyz12345 (1111..1111)"
+        );
+    }
+}

cli/src/main.rs

@@ -1,25 +1,43 @@
-use clap::{crate_description, crate_name, AppSettings, Arg, ArgGroup, ArgMatches, SubCommand};
+use clap::{
+    crate_description, crate_name, value_t_or_exit, AppSettings, Arg, ArgGroup, ArgMatches,
+    SubCommand,
+};
 use console::style;
 
 use solana_clap_utils::{
-    input_validators::is_url, keypair::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, CliSigners},
+    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_client::rpc_config::RpcSendTransactionConfig;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
-use std::{error, sync::Arc};
+use std::{collections::HashMap, error, path::PathBuf, sync::Arc, time::Duration};
 
 fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error>> {
     let parse_args = match matches.subcommand() {
-        ("config", Some(matches)) => match matches.subcommand() {
-            ("get", Some(subcommand_matches)) => {
-                if let Some(config_file) = matches.value_of("config_file") {
-                    let config = Config::load(config_file).unwrap_or_default();
+        ("config", Some(matches)) => {
+            let config_file = match matches.value_of("config_file") {
+                None => {
+                    println!(
+                        "{} Either provide the `--config` arg or ensure home directory exists to use the default config location",
+                        style("No config file found.").bold()
+                    );
+                    return Ok(false);
+                }
+                Some(config_file) => config_file,
+            };
+            let mut config = Config::load(config_file).unwrap_or_default();
 
+            match matches.subcommand() {
+                ("get", Some(subcommand_matches)) => {
                     let (url_setting_type, json_rpc_url) =
                         CliConfig::compute_json_rpc_url_setting("", &config.json_rpc_url);
                     let (ws_setting_type, websocket_url) = CliConfig::compute_websocket_url_setting(
@@ -45,17 +63,8 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                         println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
                         println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
                     }
-                } else {
-                    println!(
-                        "{} Either provide the `--config` arg or ensure home directory exists to use the default config location",
-                        style("No config file found.").bold()
-                    );
                 }
-                false
-            }
-            ("set", Some(subcommand_matches)) => {
-                if let Some(config_file) = matches.value_of("config_file") {
-                    let mut config = Config::load(config_file).unwrap_or_default();
+                ("set", Some(subcommand_matches)) => {
                     if let Some(url) = subcommand_matches.value_of("json_rpc_url") {
                         config.json_rpc_url = url.to_string();
                         // Revert to a computed `websocket_url` value when `json_rpc_url` is
@@ -68,6 +77,7 @@ 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();
                     }
+
                     config.save(config_file)?;
 
                     let (url_setting_type, json_rpc_url) =
@@ -85,16 +95,22 @@ 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);
-                } else {
-                    println!(
-                        "{} Either provide the `--config` arg or ensure home directory exists to use the default config location",
-                        style("No config file found.").bold()
-                    );
                 }
-                false
+                ("import-address-labels", Some(subcommand_matches)) => {
+                    let filename = value_t_or_exit!(subcommand_matches, "filename", PathBuf);
+                    config.import_address_labels(&filename)?;
+                    config.save(config_file)?;
+                    println!("Address labels imported from {:?}", filename);
+                }
+                ("export-address-labels", Some(subcommand_matches)) => {
+                    let filename = value_t_or_exit!(subcommand_matches, "filename", PathBuf);
+                    config.export_address_labels(&filename)?;
+                    println!("Address labels exported to {:?}", filename);
+                }
+                _ => unreachable!(),
             }
-            _ => unreachable!(),
-        },
+            false
+        }
         _ => true,
     };
     Ok(parse_args)
@@ -113,6 +129,10 @@ pub fn parse_args<'a>(
         matches.value_of("json_rpc_url").unwrap_or(""),
         &config.json_rpc_url,
     );
+
+    let rpc_timeout = value_t_or_exit!(matches, "rpc_timeout", u64);
+    let rpc_timeout = Duration::from_secs(rpc_timeout);
+
     let (_, websocket_url) = CliConfig::compute_websocket_url_setting(
         matches.value_of("websocket_url").unwrap_or(""),
         &config.websocket_url,
@@ -136,6 +156,18 @@ pub fn parse_args<'a>(
         })
         .unwrap_or(OutputFormat::Display);
 
+    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()
+    } else {
+        config.address_labels
+    };
+
     Ok((
         CliConfig {
             command,
@@ -144,8 +176,12 @@ pub fn parse_args<'a>(
             signers: vec![],
             keypair_path: default_signer_path,
             rpc_client: None,
+            rpc_timeout,
             verbose: matches.is_present("verbose"),
             output_format,
+            commitment,
+            send_transaction_config: RpcSendTransactionConfig::default(),
+            address_labels,
         },
         signers,
     ))
@@ -207,6 +243,12 @@ fn main() -> Result<(), Box<dyn error::Error>> {
             .global(true)
             .help("Show additional information"),
     )
+    .arg(
+        Arg::with_name("no_address_labels")
+            .long("no-address-labels")
+            .global(true)
+            .help("Do not use address labels in the output"),
+    )
     .arg(
         Arg::with_name("output_format")
             .long("output")
@@ -222,6 +264,16 @@ fn main() -> Result<(), Box<dyn error::Error>> {
             .global(true)
             .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
     )
+    .arg(
+        Arg::with_name("rpc_timeout")
+            .long("rpc-timeout")
+            .value_name("SECONDS")
+            .takes_value(true)
+            .default_value(DEFAULT_RPC_TIMEOUT_SECONDS)
+            .global(true)
+            .hidden(true)
+            .help("Timeout value for RPC requests"),
+    )
     .subcommand(
         SubCommand::with_name("config")
             .about("Solana command-line tool configuration settings")
@@ -248,6 +300,28 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                             .multiple(true)
                             .required(true),
                     ),
+            )
+            .subcommand(
+                SubCommand::with_name("import-address-labels")
+                    .about("Import a list of address labels")
+                    .arg(
+                        Arg::with_name("filename")
+                            .index(1)
+                            .value_name("FILENAME")
+                            .takes_value(true)
+                            .help("YAML file of address labels"),
+                    ),
+            )
+            .subcommand(
+                SubCommand::with_name("export-address-labels")
+                    .about("Export the current address labels")
+                    .arg(
+                        Arg::with_name("filename")
+                            .index(1)
+                            .value_name("FILENAME")
+                            .takes_value(true)
+                            .help("YAML file to receive the current address labels"),
+                    ),
             ),
     )
     .get_matches();

cli/src/nonce.rs

@@ -1,5 +1,5 @@
 use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
+    checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
         generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
         CliConfig, CliError, ProcessResult, SignerIndex,
@@ -16,6 +16,7 @@ use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     account::Account,
     account_utils::StateMut,
+    commitment_config::CommitmentConfig,
     hash::Hash,
     message::Message,
     nonce::{
@@ -222,10 +223,23 @@ 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(nonce_pubkey)
+        .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),
@@ -433,21 +447,28 @@ 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);
-    let message = Message::new_with_payer(&[ix], Some(&config.signers[0].pubkey()));
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
 
-    check_account_for_fee(
+    check_account_for_fee_with_commitment(
         rpc_client,
         &config.signers[0].pubkey(),
         &fee_calculator,
         &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)
 }
 
@@ -491,10 +512,12 @@ pub fn process_create_nonce_account(
                 lamports,
             )
         };
-        Message::new_with_payer(&ixs, Some(&config.signers[0].pubkey()))
+        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,
@@ -503,9 +526,12 @@ pub fn process_create_nonce_account(
         &fee_calculator,
         &config.signers[0].pubkey(),
         build_message,
+        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 {
@@ -528,12 +554,22 @@ 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)
 }
 
-pub fn process_get_nonce(rpc_client: &RpcClient, nonce_account_pubkey: &Pubkey) -> ProcessResult {
-    match get_account(rpc_client, nonce_account_pubkey).and_then(|ref a| state_from_account(a))? {
+pub fn process_get_nonce(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    nonce_account_pubkey: &Pubkey,
+) -> ProcessResult {
+    match get_account_with_commitment(rpc_client, nonce_account_pubkey, config.commitment)
+        .and_then(|ref a| state_from_account(a))?
+    {
         State::Uninitialized => Ok("Nonce account is uninitialized".to_string()),
         State::Initialized(ref data) => Ok(format!("{:?}", data.blockhash)),
     }
@@ -550,7 +586,9 @@ pub fn process_new_nonce(
         (&nonce_account, "nonce_account_pubkey".to_string()),
     )?;
 
-    if rpc_client.get_account(&nonce_account).is_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(),
         )
@@ -559,17 +597,24 @@ pub fn process_new_nonce(
 
     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 message = Message::new_with_payer(&[ix], Some(&config.signers[0].pubkey()));
+    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)?;
-    check_account_for_fee(
+    check_account_for_fee_with_commitment(
         rpc_client,
         &config.signers[0].pubkey(),
         &fee_calculator,
         &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)
 }
 
@@ -579,7 +624,8 @@ pub fn process_show_nonce_account(
     nonce_account_pubkey: &Pubkey,
     use_lamports_unit: bool,
 ) -> ProcessResult {
-    let nonce_account = get_account(rpc_client, nonce_account_pubkey)?;
+    let nonce_account =
+        get_account_with_commitment(rpc_client, nonce_account_pubkey, config.commitment)?;
     let print_account = |data: Option<&nonce::state::Data>| {
         let mut nonce_account = CliNonceAccount {
             balance: nonce_account.lamports,
@@ -610,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(
@@ -619,16 +667,21 @@ pub fn process_withdraw_from_nonce_account(
         destination_account_pubkey,
         lamports,
     );
-    let message = Message::new_with_payer(&[ix], Some(&config.signers[0].pubkey()));
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
-    check_account_for_fee(
+    check_account_for_fee_with_commitment(
         rpc_client,
         &config.signers[0].pubkey(),
         &fee_calculator,
         &tx.message,
+        config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<NonceError>(result, &config)
 }
 

cli/src/offline/blockhash_query.rs

@@ -1,4 +1,5 @@
 use super::*;
+use solana_sdk::commitment_config::CommitmentConfig;
 
 #[derive(Debug, PartialEq)]
 pub enum Source {
@@ -10,14 +11,17 @@ impl Source {
     pub fn get_blockhash_and_fee_calculator(
         &self,
         rpc_client: &RpcClient,
+        commitment: CommitmentConfig,
     ) -> Result<(Hash, FeeCalculator), Box<dyn std::error::Error>> {
         match self {
             Self::Cluster => {
-                let res = rpc_client.get_recent_blockhash()?;
-                Ok(res)
+                let res = rpc_client
+                    .get_recent_blockhash_with_commitment(commitment)?
+                    .value;
+                Ok((res.0, res.1))
             }
             Self::NonceAccount(ref pubkey) => {
-                let data = nonce::get_account(rpc_client, pubkey)
+                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))
             }
@@ -28,23 +32,21 @@ impl Source {
         &self,
         rpc_client: &RpcClient,
         blockhash: &Hash,
+        commitment: CommitmentConfig,
     ) -> Result<Option<FeeCalculator>, Box<dyn std::error::Error>> {
         match self {
             Self::Cluster => {
-                let res = rpc_client.get_fee_calculator_for_blockhash(blockhash)?;
+                let res = rpc_client
+                    .get_fee_calculator_for_blockhash_with_commitment(blockhash, commitment)?
+                    .value;
                 Ok(res)
             }
             Self::NonceAccount(ref pubkey) => {
-                let res = nonce::get_account(rpc_client, pubkey)
-                    .and_then(|ref a| nonce::data_from_account(a))
-                    .and_then(|d| {
-                        if d.blockhash == *blockhash {
-                            Ok(Some(d.fee_calculator))
-                        } else {
-                            Ok(None)
-                        }
-                    })?;
-                Ok(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))
             }
         }
     }
@@ -80,16 +82,19 @@ impl BlockhashQuery {
     pub fn get_blockhash_and_fee_calculator(
         &self,
         rpc_client: &RpcClient,
+        commitment: CommitmentConfig,
     ) -> Result<(Hash, FeeCalculator), Box<dyn std::error::Error>> {
         match self {
             BlockhashQuery::None(hash) => Ok((*hash, FeeCalculator::default())),
             BlockhashQuery::FeeCalculator(source, hash) => {
                 let fee_calculator = source
-                    .get_fee_calculator(rpc_client, hash)?
+                    .get_fee_calculator(rpc_client, hash, commitment)?
                     .ok_or(format!("Hash has expired {:?}", hash))?;
                 Ok((*hash, fee_calculator))
             }
-            BlockhashQuery::All(source) => source.get_blockhash_and_fee_calculator(rpc_client),
+            BlockhashQuery::All(source) => {
+                source.get_blockhash_and_fee_calculator(rpc_client, commitment)
+            }
         }
     }
 }
@@ -106,9 +111,10 @@ mod tests {
     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_client::{
         rpc_request::RpcRequest,
-        rpc_response::{Response, RpcAccount, RpcFeeCalculator, RpcResponseContext},
+        rpc_response::{Response, RpcFeeCalculator, RpcResponseContext},
     };
     use solana_sdk::{
         account::Account, fee_calculator::FeeCalculator, hash::hash, nonce, system_program,
@@ -292,7 +298,7 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::default()
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .unwrap(),
             (rpc_blockhash, rpc_fee_calc.clone()),
         );
@@ -308,7 +314,7 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::FeeCalculator(Source::Cluster, test_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .unwrap(),
             (test_blockhash, rpc_fee_calc),
         );
@@ -320,13 +326,13 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::None(test_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .unwrap(),
             (test_blockhash, FeeCalculator::default()),
         );
         let rpc_client = RpcClient::new_mock("fails".to_string());
         assert!(BlockhashQuery::default()
-            .get_blockhash_and_fee_calculator(&rpc_client)
+            .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
             .is_err());
 
         let nonce_blockhash = Hash::new(&[2u8; 32]);
@@ -344,7 +350,13 @@ mod tests {
         )
         .unwrap();
         let nonce_pubkey = Pubkey::new(&[4u8; 32]);
-        let rpc_nonce_account = RpcAccount::encode(nonce_account);
+        let rpc_nonce_account = UiAccount::encode(
+            &nonce_pubkey,
+            nonce_account,
+            UiAccountEncoding::Binary64,
+            None,
+            None,
+        );
         let get_account_response = json!(Response {
             context: RpcResponseContext { slot: 1 },
             value: json!(Some(rpc_nonce_account)),
@@ -355,7 +367,7 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::All(Source::NonceAccount(nonce_pubkey))
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .unwrap(),
             (nonce_blockhash, nonce_fee_calc.clone()),
         );
@@ -364,7 +376,7 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::FeeCalculator(Source::NonceAccount(nonce_pubkey), nonce_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .unwrap(),
             (nonce_blockhash, nonce_fee_calc),
         );
@@ -373,7 +385,7 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert!(
             BlockhashQuery::FeeCalculator(Source::NonceAccount(nonce_pubkey), test_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .is_err()
         );
         let mut mocks = HashMap::new();
@@ -381,14 +393,14 @@ mod tests {
         let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
         assert_eq!(
             BlockhashQuery::None(nonce_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
+                .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
                 .unwrap(),
             (nonce_blockhash, FeeCalculator::default()),
         );
 
         let rpc_client = RpcClient::new_mock("fails".to_string());
         assert!(BlockhashQuery::All(Source::NonceAccount(nonce_pubkey))
-            .get_blockhash_and_fee_calculator(&rpc_client)
+            .get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
             .is_err());
     }
 }

cli/src/spend_utils.rs

@@ -1,12 +1,13 @@
 use crate::{
-    checks::{calculate_fee, check_account_for_balance},
+    checks::{calculate_fee, check_account_for_balance_with_commitment},
     cli::CliError,
 };
 use clap::ArgMatches;
 use solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG};
 use solana_client::rpc_client::RpcClient;
 use solana_sdk::{
-    fee_calculator::FeeCalculator, message::Message, native_token::lamports_to_sol, pubkey::Pubkey,
+    commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message,
+    native_token::lamports_to_sol, pubkey::Pubkey,
 };
 
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -49,6 +50,7 @@ pub fn resolve_spend_tx_and_check_account_balance<F>(
     fee_calculator: &FeeCalculator,
     from_pubkey: &Pubkey,
     build_message: F,
+    commitment: CommitmentConfig,
 ) -> Result<(Message, u64), CliError>
 where
     F: Fn(u64) -> Message,
@@ -61,6 +63,7 @@ where
         from_pubkey,
         from_pubkey,
         build_message,
+        commitment,
     )
 }
 
@@ -72,6 +75,7 @@ pub fn resolve_spend_tx_and_check_account_balances<F>(
     from_pubkey: &Pubkey,
     fee_pubkey: &Pubkey,
     build_message: F,
+    commitment: CommitmentConfig,
 ) -> Result<(Message, u64), CliError>
 where
     F: Fn(u64) -> Message,
@@ -87,7 +91,9 @@ where
         );
         Ok((message, spend))
     } else {
-        let from_balance = rpc_client.get_balance(&from_pubkey)?;
+        let from_balance = rpc_client
+            .get_balance_with_commitment(&from_pubkey, commitment)?
+            .value;
         let (message, SpendAndFee { spend, fee }) = resolve_spend_message(
             amount,
             fee_calculator,
@@ -107,7 +113,8 @@ where
             if from_balance < spend {
                 return Err(CliError::InsufficientFundsForSpend(lamports_to_sol(spend)));
             }
-            if !check_account_for_balance(rpc_client, fee_pubkey, fee)? {
+            if !check_account_for_balance_with_commitment(rpc_client, fee_pubkey, fee, commitment)?
+            {
                 return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
             }
         }

cli/src/stake.rs

@@ -1,25 +1,27 @@
 use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
+    checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
         fee_payer_arg, generate_unique_signers, log_instruction_custom_error, nonce_authority_arg,
         return_signers, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
         SignerIndex, FEE_PAYER_ARG,
     },
     cli_output::{CliStakeHistory, CliStakeHistoryEntry, CliStakeState, CliStakeType},
-    nonce::{check_nonce_account, nonce_arg, NONCE_ARG, NONCE_AUTHORITY_ARG},
+    nonce::{self, check_nonce_account, nonce_arg, NONCE_ARG, NONCE_AUTHORITY_ARG},
     offline::{blockhash_query::BlockhashQuery, *},
     spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
 };
 use clap::{App, Arg, ArgGroup, ArgMatches, SubCommand};
 use solana_clap_utils::{input_parsers::*, input_validators::*, offline::*, ArgConstant};
-use solana_client::rpc_client::RpcClient;
+use solana_client::{rpc_client::RpcClient, rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE};
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
     account_utils::StateMut,
+    clock::Clock,
     message::Message,
     pubkey::Pubkey,
     system_instruction::SystemError,
     sysvar::{
+        clock,
         stake_history::{self, StakeHistory},
         Sysvar,
     },
@@ -264,6 +266,29 @@ impl StakeSubCommands for App<'_, '_> {
                 .arg(nonce_authority_arg())
                 .arg(fee_payer_arg())
         )
+        .subcommand(
+            SubCommand::with_name("merge-stake")
+                .about("Merges one stake account into another")
+                .arg(
+                    pubkey!(Arg::with_name("stake_account_pubkey")
+                        .index(1)
+                        .value_name("STAKE_ACCOUNT_ADDRESS")
+                        .required(true),
+                        "Stake account to merge into")
+                )
+                .arg(
+                    pubkey!(Arg::with_name("source_stake_account_pubkey")
+                        .index(2)
+                        .value_name("SOURCE_STAKE_ACCOUNT_ADDRESS")
+                        .required(true),
+                        "Source stake account for the merge.  If successful, this stake account will no longer exist after the merge")
+                )
+                .arg(stake_authority_arg())
+                .offline_args()
+                .arg(nonce_arg())
+                .arg(nonce_authority_arg())
+                .arg(fee_payer_arg())
+        )
         .subcommand(
             SubCommand::with_name("withdraw-stake")
                 .about("Withdraw the unstaked SOL from the stake account")
@@ -606,6 +631,47 @@ pub fn parse_split_stake(
     })
 }
 
+pub fn parse_merge_stake(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let stake_account_pubkey =
+        pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
+
+    let source_stake_account_pubkey = pubkey_of(matches, "source_stake_account_pubkey").unwrap();
+
+    let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+    let blockhash_query = BlockhashQuery::new_from_matches(matches);
+    let nonce_account = pubkey_of(matches, NONCE_ARG.name);
+    let (stake_authority, stake_authority_pubkey) =
+        signer_of(matches, STAKE_AUTHORITY_ARG.name, wallet_manager)?;
+    let (nonce_authority, nonce_authority_pubkey) =
+        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
+    let (fee_payer, fee_payer_pubkey) = signer_of(matches, FEE_PAYER_ARG.name, wallet_manager)?;
+
+    let mut bulk_signers = vec![stake_authority, fee_payer];
+    if nonce_account.is_some() {
+        bulk_signers.push(nonce_authority);
+    }
+    let signer_info =
+        generate_unique_signers(bulk_signers, matches, default_signer_path, wallet_manager)?;
+
+    Ok(CliCommandInfo {
+        command: CliCommand::MergeStake {
+            stake_account_pubkey,
+            source_stake_account_pubkey,
+            stake_authority: signer_info.index_of(stake_authority_pubkey).unwrap(),
+            sign_only,
+            blockhash_query,
+            nonce_account,
+            nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
+            fee_payer: signer_info.index_of(fee_payer_pubkey).unwrap(),
+        },
+        signers: signer_info.signers,
+    })
+}
+
 pub fn parse_stake_deactivate_stake(
     matches: &ArgMatches<'_>,
     default_signer_path: &str,
@@ -825,12 +891,12 @@ pub fn process_create_stake_account(
                 &nonce_authority.pubkey(),
             )
         } else {
-            Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+            Message::new(&ixs, Some(&fee_payer.pubkey()))
         }
     };
 
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
 
     let (message, lamports) = resolve_spend_tx_and_check_account_balances(
         rpc_client,
@@ -840,6 +906,7 @@ pub fn process_create_stake_account(
         &from.pubkey(),
         &fee_payer.pubkey(),
         build_message,
+        config.commitment,
     )?;
 
     if !sign_only {
@@ -867,7 +934,8 @@ pub fn process_create_stake_account(
         }
 
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
     }
@@ -878,7 +946,11 @@ pub fn process_create_stake_account(
         return_signers(&tx, &config)
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<SystemError>(result, &config)
     }
 }
@@ -911,7 +983,7 @@ pub fn process_stake_authorize(
     }
 
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
 
     let nonce_authority = config.signers[nonce_authority];
     let fee_payer = config.signers[fee_payer];
@@ -924,7 +996,7 @@ pub fn process_stake_authorize(
             &nonce_authority.pubkey(),
         )
     } else {
-        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
     };
     let mut tx = Transaction::new_unsigned(message);
 
@@ -934,16 +1006,22 @@ pub fn process_stake_authorize(
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
-        check_account_for_fee(
+        check_account_for_fee_with_commitment(
             rpc_client,
             &tx.message.account_keys[0],
             &fee_calculator,
             &tx.message,
+            config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -961,7 +1039,7 @@ pub fn process_deactivate_stake_account(
     fee_payer: SignerIndex,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
     let stake_authority = config.signers[stake_authority];
     let ixs = vec![stake_instruction::deactivate_stake(
         stake_account_pubkey,
@@ -978,7 +1056,7 @@ pub fn process_deactivate_stake_account(
             &nonce_authority.pubkey(),
         )
     } else {
-        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
     };
     let mut tx = Transaction::new_unsigned(message);
 
@@ -988,16 +1066,22 @@ pub fn process_deactivate_stake_account(
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
-        check_account_for_fee(
+        check_account_for_fee_with_commitment(
             rpc_client,
             &tx.message.account_keys[0],
             &fee_calculator,
             &tx.message,
+            config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -1018,7 +1102,7 @@ pub fn process_withdraw_stake(
     fee_payer: SignerIndex,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
     let withdraw_authority = config.signers[withdraw_authority];
     let custodian = custodian.map(|index| config.signers[index]);
 
@@ -1041,7 +1125,7 @@ pub fn process_withdraw_stake(
             &nonce_authority.pubkey(),
         )
     } else {
-        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
     };
     let mut tx = Transaction::new_unsigned(message);
 
@@ -1051,16 +1135,22 @@ pub fn process_withdraw_stake(
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
-        check_account_for_fee(
+        check_account_for_fee_with_commitment(
             rpc_client,
             &tx.message.account_keys[0],
             &fee_calculator,
             &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)
     }
 }
@@ -1145,7 +1235,7 @@ pub fn process_split_stake(
     }
 
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
 
     let ixs = if let Some(seed) = split_stake_account_seed {
         stake_instruction::split_with_seed(
@@ -1175,7 +1265,7 @@ pub fn process_split_stake(
             &nonce_authority.pubkey(),
         )
     } else {
-        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
     };
     let mut tx = Transaction::new_unsigned(message);
 
@@ -1185,16 +1275,121 @@ pub fn process_split_stake(
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
-        check_account_for_fee(
+        check_account_for_fee_with_commitment(
             rpc_client,
             &tx.message.account_keys[0],
             &fee_calculator,
             &tx.message,
+            config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
+        log_instruction_custom_error::<StakeError>(result, &config)
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn process_merge_stake(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    stake_account_pubkey: &Pubkey,
+    source_stake_account_pubkey: &Pubkey,
+    stake_authority: SignerIndex,
+    sign_only: bool,
+    blockhash_query: &BlockhashQuery,
+    nonce_account: Option<Pubkey>,
+    nonce_authority: SignerIndex,
+    fee_payer: SignerIndex,
+) -> ProcessResult {
+    let fee_payer = config.signers[fee_payer];
+
+    check_unique_pubkeys(
+        (&fee_payer.pubkey(), "fee-payer keypair".to_string()),
+        (&stake_account_pubkey, "stake_account".to_string()),
+    )?;
+    check_unique_pubkeys(
+        (&fee_payer.pubkey(), "fee-payer keypair".to_string()),
+        (
+            &source_stake_account_pubkey,
+            "source_stake_account".to_string(),
+        ),
+    )?;
+    check_unique_pubkeys(
+        (&stake_account_pubkey, "stake_account".to_string()),
+        (
+            &source_stake_account_pubkey,
+            "source_stake_account".to_string(),
+        ),
+    )?;
+
+    let stake_authority = config.signers[stake_authority];
+
+    if !sign_only {
+        for stake_account_address in &[stake_account_pubkey, source_stake_account_pubkey] {
+            if let Ok(stake_account) = rpc_client.get_account(stake_account_address) {
+                if stake_account.owner != solana_stake_program::id() {
+                    return Err(CliError::BadParameter(format!(
+                        "Account {} is not a stake account",
+                        stake_account_address
+                    ))
+                    .into());
+                }
+            }
+        }
+    }
+
+    let (recent_blockhash, fee_calculator) =
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
+
+    let ixs = stake_instruction::merge(
+        &stake_account_pubkey,
+        &source_stake_account_pubkey,
+        &stake_authority.pubkey(),
+    );
+
+    let nonce_authority = config.signers[nonce_authority];
+
+    let message = if let Some(nonce_account) = &nonce_account {
+        Message::new_with_nonce(
+            ixs,
+            Some(&fee_payer.pubkey()),
+            nonce_account,
+            &nonce_authority.pubkey(),
+        )
+    } else {
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
+    };
+    let mut tx = Transaction::new_unsigned(message);
+
+    if sign_only {
+        tx.try_partial_sign(&config.signers, recent_blockhash)?;
+        return_signers(&tx, &config)
+    } else {
+        tx.try_sign(&config.signers, recent_blockhash)?;
+        if let Some(nonce_account) = &nonce_account {
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
+            check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
+        }
+        check_account_for_fee_with_commitment(
+            rpc_client,
+            &tx.message.account_keys[0],
+            &fee_calculator,
+            &tx.message,
+            config.commitment,
+        )?;
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -1213,7 +1408,7 @@ pub fn process_stake_set_lockup(
     fee_payer: SignerIndex,
 ) -> ProcessResult {
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
     let custodian = config.signers[custodian];
 
     let ixs = vec![stake_instruction::set_lockup(
@@ -1232,7 +1427,7 @@ pub fn process_stake_set_lockup(
             &nonce_authority.pubkey(),
         )
     } else {
-        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
     };
     let mut tx = Transaction::new_unsigned(message);
 
@@ -1242,69 +1437,119 @@ pub fn process_stake_set_lockup(
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
-        check_account_for_fee(
+        check_account_for_fee_with_commitment(
             rpc_client,
             &tx.message.account_keys[0],
             &fee_calculator,
             &tx.message,
+            config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
 
+fn u64_some_if_not_zero(n: u64) -> Option<u64> {
+    if n > 0 {
+        Some(n)
+    } else {
+        None
+    }
+}
+
 pub fn build_stake_state(
-    stake_lamports: u64,
+    account_balance: u64,
     stake_state: &StakeState,
     use_lamports_unit: bool,
+    stake_history: &StakeHistory,
+    clock: &Clock,
 ) -> CliStakeState {
     match stake_state {
         StakeState::Stake(
             Meta {
-                authorized, lockup, ..
+                rent_exempt_reserve,
+                authorized,
+                lockup,
             },
             stake,
-        ) => CliStakeState {
-            stake_type: CliStakeType::Stake,
-            total_stake: stake_lamports,
-            delegated_stake: Some(stake.delegation.stake),
-            delegated_vote_account_address: if stake.delegation.voter_pubkey != Pubkey::default() {
-                Some(stake.delegation.voter_pubkey.to_string())
+        ) => {
+            let current_epoch = clock.epoch;
+            let (active_stake, activating_stake, deactivating_stake) = stake
+                .delegation
+                .stake_activating_and_deactivating(current_epoch, Some(stake_history));
+            let lockup = if lockup.is_in_force(clock, None) {
+                Some(lockup.into())
             } else {
                 None
-            },
-            activation_epoch: Some(if stake.delegation.activation_epoch < std::u64::MAX {
-                stake.delegation.activation_epoch
-            } else {
-                0
-            }),
-            deactivation_epoch: if stake.delegation.deactivation_epoch < std::u64::MAX {
-                Some(stake.delegation.deactivation_epoch)
-            } else {
-                None
-            },
-            authorized: Some(authorized.into()),
-            lockup: Some(lockup.into()),
-            use_lamports_unit,
-        },
+            };
+            CliStakeState {
+                stake_type: CliStakeType::Stake,
+                account_balance,
+                delegated_stake: Some(stake.delegation.stake),
+                delegated_vote_account_address: if stake.delegation.voter_pubkey
+                    != Pubkey::default()
+                {
+                    Some(stake.delegation.voter_pubkey.to_string())
+                } else {
+                    None
+                },
+                activation_epoch: Some(if stake.delegation.activation_epoch < std::u64::MAX {
+                    stake.delegation.activation_epoch
+                } else {
+                    0
+                }),
+                deactivation_epoch: if stake.delegation.deactivation_epoch < std::u64::MAX {
+                    Some(stake.delegation.deactivation_epoch)
+                } else {
+                    None
+                },
+                authorized: Some(authorized.into()),
+                lockup,
+                use_lamports_unit,
+                current_epoch,
+                rent_exempt_reserve: Some(*rent_exempt_reserve),
+                active_stake: u64_some_if_not_zero(active_stake),
+                activating_stake: u64_some_if_not_zero(activating_stake),
+                deactivating_stake: u64_some_if_not_zero(deactivating_stake),
+            }
+        }
         StakeState::RewardsPool => CliStakeState {
             stake_type: CliStakeType::RewardsPool,
+            account_balance,
+            ..CliStakeState::default()
+        },
+        StakeState::Uninitialized => CliStakeState {
+            account_balance,
             ..CliStakeState::default()
         },
-        StakeState::Uninitialized => CliStakeState::default(),
         StakeState::Initialized(Meta {
-            authorized, lockup, ..
-        }) => CliStakeState {
-            stake_type: CliStakeType::Initialized,
-            total_stake: stake_lamports,
-            authorized: Some(authorized.into()),
-            lockup: Some(lockup.into()),
-            use_lamports_unit,
-            ..CliStakeState::default()
-        },
+            rent_exempt_reserve,
+            authorized,
+            lockup,
+        }) => {
+            let lockup = if lockup.is_in_force(clock, None) {
+                Some(lockup.into())
+            } else {
+                None
+            };
+            CliStakeState {
+                stake_type: CliStakeType::Initialized,
+                account_balance,
+                authorized: Some(authorized.into()),
+                lockup,
+                use_lamports_unit,
+                rent_exempt_reserve: Some(*rent_exempt_reserve),
+                ..CliStakeState::default()
+            }
+        }
     }
 }
 
@@ -1324,7 +1569,23 @@ pub fn process_show_stake_account(
     }
     match stake_account.state() {
         Ok(stake_state) => {
-            let state = build_stake_state(stake_account.lamports, &stake_state, use_lamports_unit);
+            let stake_history_account = rpc_client.get_account(&stake_history::id())?;
+            let stake_history =
+                StakeHistory::from_account(&stake_history_account).ok_or_else(|| {
+                    CliError::RpcRequestError("Failed to deserialize stake history".to_string())
+                })?;
+            let clock_account = rpc_client.get_account(&clock::id())?;
+            let clock: Clock = Sysvar::from_account(&clock_account).ok_or_else(|| {
+                CliError::RpcRequestError("Failed to deserialize clock sysvar".to_string())
+            })?;
+
+            let state = build_stake_state(
+                stake_account.lamports,
+                &stake_state,
+                use_lamports_unit,
+                &stake_history,
+                &clock,
+            );
             Ok(config.output_format.formatted_string(&state))
         }
         Err(err) => Err(CliError::RpcRequestError(format!(
@@ -1379,14 +1640,23 @@ pub fn process_delegate_stake(
     if !sign_only {
         // Sanity check the vote account to ensure it is attached to a validator that has recently
         // voted at the tip of the ledger
-        let vote_account_data = rpc_client
-            .get_account_data(vote_account_pubkey)
+        let vote_account = rpc_client
+            .get_account_with_commitment(vote_account_pubkey, config.commitment)
             .map_err(|_| {
                 CliError::RpcRequestError(format!(
                     "Vote account not found: {}",
                     vote_account_pubkey
                 ))
             })?;
+        let vote_account_data = if let Some(account) = vote_account.value {
+            account.data
+        } else {
+            return Err(CliError::RpcRequestError(format!(
+                "Vote account not found: {}",
+                vote_account_pubkey
+            ))
+            .into());
+        };
 
         let vote_state = VoteState::deserialize(&vote_account_data).map_err(|_| {
             CliError::RpcRequestError(
@@ -1399,13 +1669,15 @@ pub fn process_delegate_stake(
                 "Unable to delegate. Vote account has no root slot".to_string(),
             )),
             Some(root_slot) => {
-                let slot = rpc_client.get_slot()?;
-                if root_slot + solana_sdk::clock::DEFAULT_SLOTS_PER_TURN < slot {
-                    Err(CliError::BadParameter(
-                        format!(
-                        "Unable to delegate. Vote account root slot ({}) is too old, the current slot is {}", root_slot, slot
-                        )
-                    ))
+                let min_root_slot = rpc_client
+                    .get_slot()?
+                    .saturating_sub(DELINQUENT_VALIDATOR_SLOT_DISTANCE);
+                if root_slot < min_root_slot {
+                    Err(CliError::DynamicProgramError(format!(
+                        "Unable to delegate.  Vote account appears delinquent \
+                                 because its current root slot, {}, is less than {}",
+                        root_slot, min_root_slot
+                    )))
                 } else {
                     Ok(())
                 }
@@ -1422,7 +1694,7 @@ pub fn process_delegate_stake(
     }
 
     let (recent_blockhash, fee_calculator) =
-        blockhash_query.get_blockhash_and_fee_calculator(rpc_client)?;
+        blockhash_query.get_blockhash_and_fee_calculator(rpc_client, config.commitment)?;
 
     let ixs = vec![stake_instruction::delegate_stake(
         stake_account_pubkey,
@@ -1440,7 +1712,7 @@ pub fn process_delegate_stake(
             &nonce_authority.pubkey(),
         )
     } else {
-        Message::new_with_payer(&ixs, Some(&fee_payer.pubkey()))
+        Message::new(&ixs, Some(&fee_payer.pubkey()))
     };
     let mut tx = Transaction::new_unsigned(message);
 
@@ -1450,16 +1722,22 @@ pub fn process_delegate_stake(
     } else {
         tx.try_sign(&config.signers, recent_blockhash)?;
         if let Some(nonce_account) = &nonce_account {
-            let nonce_account = rpc_client.get_account(nonce_account)?;
+            let nonce_account =
+                nonce::get_account_with_commitment(rpc_client, nonce_account, config.commitment)?;
             check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
         }
-        check_account_for_fee(
+        check_account_for_fee_with_commitment(
             rpc_client,
             &tx.message.account_keys[0],
             &fee_calculator,
             &tx.message,
+            config.commitment,
         )?;
-        let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+        let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+            &tx,
+            config.commitment,
+            config.send_transaction_config,
+        );
         log_instruction_custom_error::<StakeError>(result, &config)
     }
 }
@@ -2878,5 +3156,34 @@ mod tests {
                 ],
             }
         );
+
+        // Test MergeStake SubCommand
+        let (keypair_file, mut tmp_file) = make_tmp_file();
+        let stake_account_keypair = Keypair::new();
+        write_keypair(&stake_account_keypair, tmp_file.as_file_mut()).unwrap();
+
+        let source_stake_account_pubkey = Pubkey::new_rand();
+        let test_merge_stake_account = test_commands.clone().get_matches_from(vec![
+            "test",
+            "merge-stake",
+            &keypair_file,
+            &source_stake_account_pubkey.to_string(),
+        ]);
+        assert_eq!(
+            parse_command(&test_merge_stake_account, &default_keypair_file, &mut None).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::MergeStake {
+                    stake_account_pubkey: stake_account_keypair.pubkey(),
+                    source_stake_account_pubkey,
+                    stake_authority: 0,
+                    sign_only: false,
+                    blockhash_query: BlockhashQuery::default(),
+                    nonce_account: None,
+                    nonce_authority: 0,
+                    fee_payer: 0,
+                },
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into(),],
+            }
+        );
     }
 }

cli/src/test_utils.rs

@@ -1,10 +1,13 @@
 use solana_client::rpc_client::RpcClient;
-use solana_sdk::pubkey::Pubkey;
+use solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig, pubkey::Pubkey};
 use std::{thread::sleep, time::Duration};
 
-pub fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
     (0..5).for_each(|tries| {
-        let balance = client.get_balance(pubkey).unwrap();
+        let balance = client
+            .get_balance_with_commitment(pubkey, CommitmentConfig::recent())
+            .unwrap()
+            .value;
         if balance == expected_balance {
             return;
         }
@@ -14,3 +17,13 @@ pub fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey)
         sleep(Duration::from_millis(500));
     });
 }
+
+pub fn check_ready(rpc_client: &RpcClient) {
+    while rpc_client
+        .get_slot_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        < 5
+    {
+        sleep(Duration::from_millis(DEFAULT_MS_PER_SLOT));
+    }
+}

cli/src/validator_info.rs

@@ -6,9 +6,10 @@ use crate::{
 use bincode::deserialize;
 use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
 use reqwest::blocking::Client;
-use serde_derive::{Deserialize, Serialize};
 use serde_json::{Map, Value};
-
+use solana_account_decoder::validator_info::{
+    self, ValidatorInfo, MAX_LONG_FIELD_LENGTH, MAX_SHORT_FIELD_LENGTH,
+};
 use solana_clap_utils::{
     input_parsers::pubkey_of,
     input_validators::{is_pubkey, is_url},
@@ -27,23 +28,6 @@ use solana_sdk::{
 };
 use std::{error, sync::Arc};
 
-pub const MAX_SHORT_FIELD_LENGTH: usize = 70;
-pub const MAX_LONG_FIELD_LENGTH: usize = 300;
-pub const MAX_VALIDATOR_INFO: u64 = 576;
-
-solana_sdk::declare_id!("Va1idator1nfo111111111111111111111111111111");
-
-#[derive(Debug, Deserialize, PartialEq, Serialize, Default)]
-pub struct ValidatorInfo {
-    info: String,
-}
-
-impl ConfigState for ValidatorInfo {
-    fn max_space() -> u64 {
-        MAX_VALIDATOR_INFO
-    }
-}
-
 // Return an error if a validator details are longer than the max length.
 pub fn check_details_length(string: String) -> Result<(), String> {
     if string.len() > MAX_LONG_FIELD_LENGTH {
@@ -289,7 +273,7 @@ pub fn process_set_validator_info(
         .iter()
         .filter(|(_, account)| {
             let key_list: ConfigKeys = deserialize(&account.data).map_err(|_| false).unwrap();
-            key_list.keys.contains(&(id(), false))
+            key_list.keys.contains(&(validator_info::id(), false))
         })
         .find(|(pubkey, account)| {
             let (validator_pubkey, _) = parse_validator_info(&pubkey, &account).unwrap();
@@ -328,7 +312,10 @@ pub fn process_set_validator_info(
     };
 
     let build_message = |lamports| {
-        let keys = vec![(id(), false), (config.signers[0].pubkey(), true)];
+        let keys = vec![
+            (validator_info::id(), false),
+            (config.signers[0].pubkey(), true),
+        ];
         if balance == 0 {
             println!(
                 "Publishing info for Validator {:?}",
@@ -346,7 +333,7 @@ pub fn process_set_validator_info(
                 keys,
                 &validator_info,
             )]);
-            Message::new(&instructions)
+            Message::new(&instructions, Some(&config.signers[0].pubkey()))
         } else {
             println!(
                 "Updating Validator {:?} info at: {:?}",
@@ -359,7 +346,7 @@ pub fn process_set_validator_info(
                 keys,
                 &validator_info,
             )];
-            Message::new_with_payer(&instructions, Some(&config.signers[0].pubkey()))
+            Message::new(&instructions, Some(&config.signers[0].pubkey()))
         }
     };
 
@@ -372,6 +359,7 @@ pub fn process_set_validator_info(
         &fee_calculator,
         &config.signers[0].pubkey(),
         build_message,
+        config.commitment,
     )?;
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&signers, recent_blockhash)?;
@@ -400,7 +388,7 @@ pub fn process_get_validator_info(
                 let key_list: ConfigKeys = deserialize(&validator_info_account.data)
                     .map_err(|_| false)
                     .unwrap();
-                key_list.keys.contains(&(id(), false))
+                key_list.keys.contains(&(validator_info::id(), false))
             })
             .collect()
     };
@@ -502,7 +490,7 @@ mod tests {
     #[test]
     fn test_parse_validator_info() {
         let pubkey = Pubkey::new_rand();
-        let keys = vec![(id(), false), (pubkey, true)];
+        let keys = vec![(validator_info::id(), false), (pubkey, true)];
         let config = ConfigKeys { keys };
 
         let mut info = Map::new();

cli/src/vote.rs

@@ -1,5 +1,5 @@
 use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
+    checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
     cli::{
         generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
         CliConfig, CliError, ProcessResult, SignerIndex,
@@ -8,16 +8,13 @@ use crate::{
     spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
 };
 use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
-use solana_clap_utils::{
-    commitment::{commitment_arg, COMMITMENT_ARG},
-    input_parsers::*,
-    input_validators::*,
-};
+use solana_clap_utils::{commitment::commitment_arg, input_parsers::*, input_validators::*};
 use solana_client::rpc_client::RpcClient;
 use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
-    account::Account, commitment_config::CommitmentConfig, message::Message, pubkey::Pubkey,
-    system_instruction::SystemError, transaction::Transaction,
+    account::Account, commitment_config::CommitmentConfig, message::Message,
+    native_token::lamports_to_sol, pubkey::Pubkey, system_instruction::SystemError,
+    transaction::Transaction,
 };
 use solana_vote_program::{
     vote_instruction::{self, withdraw, VoteError},
@@ -161,6 +158,35 @@ impl VoteSubCommands for App<'_, '_> {
                         .help("Authorized withdrawer keypair"),
                 )
         )
+        .subcommand(
+            SubCommand::with_name("vote-update-commission")
+                .about("Update the vote account's commission")
+                .arg(
+                    pubkey!(Arg::with_name("vote_account_pubkey")
+                        .index(1)
+                        .value_name("VOTE_ACCOUNT_ADDRESS")
+                        .required(true),
+                        "Vote account to update. "),
+                )
+                .arg(
+                    Arg::with_name("commission")
+                        .index(2)
+                        .value_name("PERCENTAGE")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_percentage)
+                        .help("The new commission")
+                )
+                .arg(
+                    Arg::with_name("authorized_withdrawer")
+                        .index(3)
+                        .value_name("AUTHORIZED_KEYPAIR")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_valid_signer)
+                        .help("Authorized withdrawer keypair"),
+                )
+        )
         .subcommand(
             SubCommand::with_name("vote-account")
                 .about("Show the contents of a vote account")
@@ -203,8 +229,8 @@ impl VoteSubCommands for App<'_, '_> {
                         .value_name("AMOUNT")
                         .takes_value(true)
                         .required(true)
-                        .validator(is_amount)
-                        .help("The amount to withdraw, in SOL"),
+                        .validator(is_amount_or_all)
+                        .help("The amount to withdraw, in SOL; accepts keyword ALL"),
                 )
                 .arg(
                     Arg::with_name("authorized_withdrawer")
@@ -223,7 +249,7 @@ pub fn parse_create_vote_account(
     default_signer_path: &str,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
-    let (vote_account, _) = signer_of(matches, "vote_account", wallet_manager)?;
+    let (vote_account, vote_account_pubkey) = signer_of(matches, "vote_account", wallet_manager)?;
     let seed = matches.value_of("seed").map(|s| s.to_string());
     let (identity_account, identity_pubkey) =
         signer_of(matches, "identity_account", wallet_manager)?;
@@ -241,6 +267,7 @@ pub fn parse_create_vote_account(
 
     Ok(CliCommandInfo {
         command: CliCommand::CreateVoteAccount {
+            vote_account: signer_info.index_of(vote_account_pubkey).unwrap(),
             seed,
             identity_account: signer_info.index_of(identity_pubkey).unwrap(),
             authorized_voter,
@@ -290,7 +317,8 @@ pub fn parse_vote_update_validator(
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
     let (new_identity_account, new_identity_pubkey) =
         signer_of(matches, "new_identity_account", wallet_manager)?;
-    let (authorized_withdrawer, _) = signer_of(matches, "authorized_withdrawer", wallet_manager)?;
+    let (authorized_withdrawer, authorized_withdrawer_pubkey) =
+        signer_of(matches, "authorized_withdrawer", wallet_manager)?;
 
     let payer_provided = None;
     let signer_info = generate_unique_signers(
@@ -304,6 +332,36 @@ pub fn parse_vote_update_validator(
         command: CliCommand::VoteUpdateValidator {
             vote_account_pubkey,
             new_identity_account: signer_info.index_of(new_identity_pubkey).unwrap(),
+            withdraw_authority: signer_info.index_of(authorized_withdrawer_pubkey).unwrap(),
+        },
+        signers: signer_info.signers,
+    })
+}
+
+pub fn parse_vote_update_commission(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let vote_account_pubkey =
+        pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
+    let (authorized_withdrawer, authorized_withdrawer_pubkey) =
+        signer_of(matches, "authorized_withdrawer", wallet_manager)?;
+    let commission = value_t_or_exit!(matches, "commission", u8);
+
+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, authorized_withdrawer],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;
+
+    Ok(CliCommandInfo {
+        command: CliCommand::VoteUpdateCommission {
+            vote_account_pubkey,
+            commission,
+            withdraw_authority: signer_info.index_of(authorized_withdrawer_pubkey).unwrap(),
         },
         signers: signer_info.signers,
     })
@@ -316,12 +374,10 @@ pub fn parse_vote_get_account_command(
     let vote_account_pubkey =
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
     let use_lamports_unit = matches.is_present("lamports");
-    let commitment_config = commitment_of(matches, COMMITMENT_ARG.long).unwrap();
     Ok(CliCommandInfo {
         command: CliCommand::ShowVoteAccount {
             pubkey: vote_account_pubkey,
             use_lamports_unit,
-            commitment_config,
         },
         signers: vec![],
     })
@@ -336,7 +392,8 @@ pub fn parse_withdraw_from_vote_account(
         pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
     let destination_account_pubkey =
         pubkey_of_signer(matches, "destination_account_pubkey", wallet_manager)?.unwrap();
-    let lamports = lamports_of_sol(matches, "amount").unwrap();
+    let withdraw_amount = SpendAmount::new_from_matches(matches, "amount");
+
     let (withdraw_authority, withdraw_authority_pubkey) =
         signer_of(matches, "authorized_withdrawer", wallet_manager)?;
 
@@ -353,7 +410,7 @@ pub fn parse_withdraw_from_vote_account(
             vote_account_pubkey,
             destination_account_pubkey,
             withdraw_authority: signer_info.index_of(withdraw_authority_pubkey).unwrap(),
-            lamports,
+            withdraw_amount,
         },
         signers: signer_info.signers,
     })
@@ -362,13 +419,14 @@ pub fn parse_withdraw_from_vote_account(
 pub fn process_create_vote_account(
     rpc_client: &RpcClient,
     config: &CliConfig,
+    vote_account: SignerIndex,
     seed: &Option<String>,
     identity_account: SignerIndex,
     authorized_voter: &Option<Pubkey>,
     authorized_withdrawer: &Option<Pubkey>,
     commission: u8,
 ) -> ProcessResult {
-    let vote_account = config.signers[1];
+    let vote_account = config.signers[vote_account];
     let vote_account_pubkey = vote_account.pubkey();
     let vote_account_address = if let Some(seed) = seed {
         Pubkey::create_with_seed(&vote_account_pubkey, &seed, &solana_vote_program::id())?
@@ -417,22 +475,28 @@ pub fn process_create_vote_account(
                 lamports,
             )
         };
-        Message::new(&ixs)
+        Message::new(&ixs, Some(&config.signers[0].pubkey()))
     };
 
-    if let Ok(vote_account) = rpc_client.get_account(&vote_account_address) {
-        let err_msg = if vote_account.owner == solana_vote_program::id() {
-            format!("Vote account {} already exists", vote_account_address)
-        } else {
-            format!(
-                "Account {} already exists and is not a vote account",
-                vote_account_address
-            )
-        };
-        return Err(CliError::BadParameter(err_msg).into());
+    if let Ok(response) =
+        rpc_client.get_account_with_commitment(&vote_account_address, config.commitment)
+    {
+        if let Some(vote_account) = response.value {
+            let err_msg = if vote_account.owner == solana_vote_program::id() {
+                format!("Vote account {} already exists", vote_account_address)
+            } else {
+                format!(
+                    "Account {} already exists and is not a vote account",
+                    vote_account_address
+                )
+            };
+            return Err(CliError::BadParameter(err_msg).into());
+        }
     }
 
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
 
     let (message, _) = resolve_spend_tx_and_check_account_balance(
         rpc_client,
@@ -441,10 +505,15 @@ pub fn process_create_vote_account(
         &fee_calculator,
         &config.signers[0].pubkey(),
         build_message,
+        config.commitment,
     )?;
     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)
 }
 
@@ -467,7 +536,9 @@ pub fn process_vote_authorize(
         (&authorized.pubkey(), "authorized_account".to_string()),
         (new_authorized_pubkey, "new_authorized_pubkey".to_string()),
     )?;
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let ixs = vec![vote_instruction::authorize(
         vote_account_pubkey,   // vote account to update
         &authorized.pubkey(),  // current authorized
@@ -475,16 +546,21 @@ pub fn process_vote_authorize(
         vote_authorize,        // vote or withdraw
     )];
 
-    let message = Message::new_with_payer(&ixs, Some(&config.signers[0].pubkey()));
+    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
-    check_account_for_fee(
+    check_account_for_fee_with_commitment(
         rpc_client,
         &config.signers[0].pubkey(),
         &fee_calculator,
         &tx.message,
+        config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 
@@ -493,31 +569,74 @@ pub fn process_vote_update_validator(
     config: &CliConfig,
     vote_account_pubkey: &Pubkey,
     new_identity_account: SignerIndex,
+    withdraw_authority: SignerIndex,
 ) -> ProcessResult {
-    let authorized_withdrawer = config.signers[1];
+    let authorized_withdrawer = config.signers[withdraw_authority];
     let new_identity_account = config.signers[new_identity_account];
     let new_identity_pubkey = new_identity_account.pubkey();
     check_unique_pubkeys(
         (vote_account_pubkey, "vote_account_pubkey".to_string()),
         (&new_identity_pubkey, "new_identity_account".to_string()),
     )?;
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let ixs = vec![vote_instruction::update_validator_identity(
         vote_account_pubkey,
         &authorized_withdrawer.pubkey(),
         &new_identity_pubkey,
     )];
 
-    let message = Message::new_with_payer(&ixs, Some(&config.signers[0].pubkey()));
+    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
     let mut tx = Transaction::new_unsigned(message);
     tx.try_sign(&config.signers, recent_blockhash)?;
-    check_account_for_fee(
+    check_account_for_fee_with_commitment(
         rpc_client,
         &config.signers[0].pubkey(),
         &fee_calculator,
         &tx.message,
+        config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
+    log_instruction_custom_error::<VoteError>(result, &config)
+}
+
+pub fn process_vote_update_commission(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    vote_account_pubkey: &Pubkey,
+    commission: u8,
+    withdraw_authority: SignerIndex,
+) -> ProcessResult {
+    let authorized_withdrawer = config.signers[withdraw_authority];
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
+    let ixs = vec![vote_instruction::update_commission(
+        vote_account_pubkey,
+        &authorized_withdrawer.pubkey(),
+        commission,
+    )];
+
+    let message = Message::new(&ixs, Some(&config.signers[0].pubkey()));
+    let mut tx = Transaction::new_unsigned(message);
+    tx.try_sign(&config.signers, recent_blockhash)?;
+    check_account_for_fee_with_commitment(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+        config.commitment,
+    )?;
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 
@@ -554,10 +673,9 @@ pub fn process_show_vote_account(
     config: &CliConfig,
     vote_account_pubkey: &Pubkey,
     use_lamports_unit: bool,
-    commitment_config: CommitmentConfig,
 ) -> ProcessResult {
     let (vote_account, vote_state) =
-        get_vote_account(rpc_client, vote_account_pubkey, commitment_config)?;
+        get_vote_account(rpc_client, vote_account_pubkey, config.commitment)?;
 
     let epoch_schedule = rpc_client.get_epoch_schedule()?;
 
@@ -600,12 +718,32 @@ pub fn process_withdraw_from_vote_account(
     config: &CliConfig,
     vote_account_pubkey: &Pubkey,
     withdraw_authority: SignerIndex,
-    lamports: u64,
+    withdraw_amount: SpendAmount,
     destination_account_pubkey: &Pubkey,
 ) -> ProcessResult {
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+    let (recent_blockhash, fee_calculator, _) = rpc_client
+        .get_recent_blockhash_with_commitment(config.commitment)?
+        .value;
     let withdraw_authority = config.signers[withdraw_authority];
 
+    let current_balance = rpc_client
+        .get_balance_with_commitment(&vote_account_pubkey, config.commitment)?
+        .value;
+    let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(VoteState::size_of())?;
+
+    let lamports = match withdraw_amount {
+        SpendAmount::All => current_balance.saturating_sub(minimum_balance),
+        SpendAmount::Some(withdraw_amount) => {
+            if current_balance.saturating_sub(withdraw_amount) < minimum_balance {
+                return Err(CliError::BadParameter(format!(
+                    "Withdraw amount too large. The vote account balance must be at least {} SOL to remain rent exempt", lamports_to_sol(minimum_balance)
+                ))
+                .into());
+            }
+            withdraw_amount
+        }
+    };
+
     let ix = withdraw(
         vote_account_pubkey,
         &withdraw_authority.pubkey(),
@@ -613,16 +751,21 @@ pub fn process_withdraw_from_vote_account(
         destination_account_pubkey,
     );
 
-    let message = Message::new_with_payer(&[ix], Some(&config.signers[0].pubkey()));
+    let message = Message::new(&[ix], Some(&config.signers[0].pubkey()));
     let mut transaction = Transaction::new_unsigned(message);
     transaction.try_sign(&config.signers, recent_blockhash)?;
-    check_account_for_fee(
+    check_account_for_fee_with_commitment(
         rpc_client,
         &config.signers[0].pubkey(),
         &fee_calculator,
         &transaction.message,
+        config.commitment,
     )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&transaction);
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &transaction,
+        config.commitment,
+        config.send_transaction_config,
+    );
     log_instruction_custom_error::<VoteError>(result, &config)
 }
 
@@ -716,6 +859,7 @@ mod tests {
             parse_command(&test_create_vote_account, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
+                    vote_account: 1,
                     seed: None,
                     identity_account: 2,
                     authorized_voter: None,
@@ -744,6 +888,7 @@ mod tests {
             parse_command(&test_create_vote_account2, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
+                    vote_account: 1,
                     seed: None,
                     identity_account: 2,
                     authorized_voter: None,
@@ -776,6 +921,7 @@ mod tests {
             parse_command(&test_create_vote_account3, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
+                    vote_account: 1,
                     seed: None,
                     identity_account: 2,
                     authorized_voter: Some(authed),
@@ -806,6 +952,7 @@ mod tests {
             parse_command(&test_create_vote_account4, &default_keypair_file, &mut None).unwrap(),
             CliCommandInfo {
                 command: CliCommand::CreateVoteAccount {
+                    vote_account: 1,
                     seed: None,
                     identity_account: 2,
                     authorized_voter: None,
@@ -833,6 +980,7 @@ mod tests {
                 command: CliCommand::VoteUpdateValidator {
                     vote_account_pubkey: pubkey,
                     new_identity_account: 2,
+                    withdraw_authority: 1,
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),
@@ -842,6 +990,28 @@ mod tests {
             }
         );
 
+        let test_update_commission = test_commands.clone().get_matches_from(vec![
+            "test",
+            "vote-update-commission",
+            &pubkey_string,
+            "42",
+            &keypair_file,
+        ]);
+        assert_eq!(
+            parse_command(&test_update_commission, &default_keypair_file, &mut None).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::VoteUpdateCommission {
+                    vote_account_pubkey: pubkey,
+                    commission: 42,
+                    withdraw_authority: 1,
+                },
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    Box::new(read_keypair_file(&keypair_file).unwrap()),
+                ],
+            }
+        );
+
         // Test WithdrawFromVoteAccount subcommand
         let test_withdraw_from_vote_account = test_commands.clone().get_matches_from(vec![
             "test",
@@ -862,7 +1032,33 @@ mod tests {
                     vote_account_pubkey: read_keypair_file(&keypair_file).unwrap().pubkey(),
                     destination_account_pubkey: pubkey,
                     withdraw_authority: 0,
-                    lamports: 42_000_000_000
+                    withdraw_amount: SpendAmount::Some(42_000_000_000),
+                },
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
+            }
+        );
+
+        // Test WithdrawFromVoteAccount subcommand
+        let test_withdraw_from_vote_account = test_commands.clone().get_matches_from(vec![
+            "test",
+            "withdraw-from-vote-account",
+            &keypair_file,
+            &pubkey_string,
+            "ALL",
+        ]);
+        assert_eq!(
+            parse_command(
+                &test_withdraw_from_vote_account,
+                &default_keypair_file,
+                &mut None
+            )
+            .unwrap(),
+            CliCommandInfo {
+                command: CliCommand::WithdrawFromVoteAccount {
+                    vote_account_pubkey: read_keypair_file(&keypair_file).unwrap().pubkey(),
+                    destination_account_pubkey: pubkey,
+                    withdraw_authority: 0,
+                    withdraw_amount: SpendAmount::All,
                 },
                 signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
             }
@@ -893,7 +1089,7 @@ mod tests {
                     vote_account_pubkey: read_keypair_file(&keypair_file).unwrap().pubkey(),
                     destination_account_pubkey: pubkey,
                     withdraw_authority: 1,
-                    lamports: 42_000_000_000
+                    withdraw_amount: SpendAmount::Some(42_000_000_000),
                 },
                 signers: vec![
                     read_keypair_file(&default_keypair_file).unwrap().into(),

cli/tests/deploy.rs

@@ -3,7 +3,12 @@ use solana_cli::cli::{process_command, CliCommand, CliConfig};
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::TestValidator;
 use solana_faucet::faucet::run_local_faucet;
-use solana_sdk::{bpf_loader, pubkey::Pubkey, signature::Keypair};
+use solana_sdk::{
+    bpf_loader,
+    commitment_config::CommitmentConfig,
+    pubkey::Pubkey,
+    signature::{Keypair, Signer},
+};
 use std::{
     fs::{remove_dir_all, File},
     io::Read,
@@ -43,19 +48,22 @@ fn test_cli_deploy_program() {
         .get_minimum_balance_for_rent_exemption(program_data.len())
         .unwrap();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     let keypair = Keypair::new();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.command = CliCommand::Airdrop {
         faucet_host: None,
         faucet_port: faucet_addr.port(),
         pubkey: None,
-        lamports: minimum_balance_for_rent_exemption + 1, // min balance for rent exemption + leftover for tx processing
+        lamports: 3 * minimum_balance_for_rent_exemption, // min balance for rent exemption for two programs + leftover for tx processing
     };
     config.signers = vec![&keypair];
     process_command(&config).unwrap();
 
-    config.command = CliCommand::Deploy(pathbuf.to_str().unwrap().to_string());
+    config.command = CliCommand::Deploy {
+        program_location: pathbuf.to_str().unwrap().to_string(),
+        address: None,
+    };
 
     let response = process_command(&config);
     let json: Value = serde_json::from_str(&response.unwrap()).unwrap();
@@ -67,16 +75,41 @@ fn test_cli_deploy_program() {
         .as_str()
         .unwrap();
     let program_id = Pubkey::from_str(&program_id_str).unwrap();
-    let account = rpc_client.get_account(&program_id).unwrap();
-    assert_eq!(account.lamports, minimum_balance_for_rent_exemption);
-    assert_eq!(account.owner, bpf_loader::id());
-    assert_eq!(account.executable, true);
+    let account0 = rpc_client
+        .get_account_with_commitment(&program_id, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
+    assert_eq!(account0.lamports, minimum_balance_for_rent_exemption);
+    assert_eq!(account0.owner, bpf_loader::id());
+    assert_eq!(account0.executable, true);
 
     let mut file = File::open(pathbuf.to_str().unwrap().to_string()).unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
 
-    assert_eq!(account.data, elf);
+    assert_eq!(account0.data, elf);
+
+    // Test custom address
+    let custom_address_keypair = Keypair::new();
+    config.signers = vec![&keypair, &custom_address_keypair];
+    config.command = CliCommand::Deploy {
+        program_location: pathbuf.to_str().unwrap().to_string(),
+        address: Some(1),
+    };
+    process_command(&config).unwrap();
+    let account1 = rpc_client
+        .get_account_with_commitment(&custom_address_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
+    assert_eq!(account1.lamports, minimum_balance_for_rent_exemption);
+    assert_eq!(account1.owner, bpf_loader::id());
+    assert_eq!(account1.executable, true);
+    assert_eq!(account0.data, account1.data);
+
+    // Attempt to redeploy to the same address
+    process_command(&config).unwrap_err();
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();

cli/tests/nonce.rs

@@ -1,4 +1,3 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     cli_output::OutputFormat,
@@ -8,12 +7,14 @@ use solana_cli::{
         parse_sign_only_reply_string,
     },
     spend_utils::SpendAmount,
+    test_utils::{check_ready, check_recent_balance},
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::contact_info::ContactInfo;
 use solana_core::validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
+    commitment_config::CommitmentConfig,
     hash::Hash,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, Signer},
@@ -83,7 +84,7 @@ fn full_battery_tests(
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
-    let mut config_payer = CliConfig::default();
+    let mut config_payer = CliConfig::recent_for_tests();
     config_payer.json_rpc_url = json_rpc_url.clone();
     let payer = Keypair::new();
     config_payer.signers = vec![&payer];
@@ -96,9 +97,9 @@ fn full_battery_tests(
         &config_payer,
     )
     .unwrap();
-    check_balance(2000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(2000, &rpc_client, &config_payer.signers[0].pubkey());
 
-    let mut config_nonce = CliConfig::default();
+    let mut config_nonce = CliConfig::recent_for_tests();
     config_nonce.json_rpc_url = json_rpc_url;
     let nonce_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
     config_nonce.signers = vec![&nonce_keypair];
@@ -131,8 +132,8 @@ fn full_battery_tests(
     };
 
     process_command(&config_payer).unwrap();
-    check_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
-    check_balance(1000, &rpc_client, &nonce_account);
+    check_recent_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(1000, &rpc_client, &nonce_account);
 
     // Get nonce
     config_payer.signers.pop();
@@ -181,9 +182,9 @@ fn full_battery_tests(
         lamports: 100,
     };
     process_command(&config_payer).unwrap();
-    check_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
-    check_balance(900, &rpc_client, &nonce_account);
-    check_balance(100, &rpc_client, &payee_pubkey);
+    check_recent_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(900, &rpc_client, &nonce_account);
+    check_recent_balance(100, &rpc_client, &payee_pubkey);
 
     // Show nonce account
     config_payer.command = CliCommand::ShowNonceAccount {
@@ -224,9 +225,9 @@ fn full_battery_tests(
         lamports: 100,
     };
     process_command(&config_payer).unwrap();
-    check_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
-    check_balance(800, &rpc_client, &nonce_account);
-    check_balance(200, &rpc_client, &payee_pubkey);
+    check_recent_balance(1000, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(800, &rpc_client, &nonce_account);
+    check_recent_balance(200, &rpc_client, &payee_pubkey);
 }
 
 #[test]
@@ -250,7 +251,7 @@ fn test_create_account_with_seed() {
     let offline_nonce_authority_signer = keypair_from_seed(&[1u8; 32]).unwrap();
     let online_nonce_creator_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     let to_address = Pubkey::new(&[3u8; 32]);
-    let config = CliConfig::default();
+    let config = CliConfig::recent_for_tests();
 
     // Setup accounts
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
@@ -270,9 +271,11 @@ fn test_create_account_with_seed() {
         &config,
     )
     .unwrap();
-    check_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
-    check_balance(4242, &rpc_client, &online_nonce_creator_signer.pubkey());
-    check_balance(0, &rpc_client, &to_address);
+    check_recent_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
+    check_recent_balance(4242, &rpc_client, &online_nonce_creator_signer.pubkey());
+    check_recent_balance(0, &rpc_client, &to_address);
+
+    check_ready(&rpc_client);
 
     // Create nonce account
     let creator_pubkey = online_nonce_creator_signer.pubkey();
@@ -280,9 +283,9 @@ fn test_create_account_with_seed() {
     let seed = authority_pubkey.to_string()[0..32].to_string();
     let nonce_address =
         Pubkey::create_with_seed(&creator_pubkey, &seed, &system_program::id()).unwrap();
-    check_balance(0, &rpc_client, &nonce_address);
+    check_recent_balance(0, &rpc_client, &nonce_address);
 
-    let mut creator_config = CliConfig::default();
+    let mut creator_config = CliConfig::recent_for_tests();
     creator_config.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     creator_config.signers = vec![&online_nonce_creator_signer];
@@ -293,19 +296,20 @@ fn test_create_account_with_seed() {
         amount: SpendAmount::Some(241),
     };
     process_command(&creator_config).unwrap();
-    check_balance(241, &rpc_client, &nonce_address);
-    check_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
-    check_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
-    check_balance(0, &rpc_client, &to_address);
+    check_recent_balance(241, &rpc_client, &nonce_address);
+    check_recent_balance(42, &rpc_client, &offline_nonce_authority_signer.pubkey());
+    check_recent_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
+    check_recent_balance(0, &rpc_client, &to_address);
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_address)
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash =
+        nonce::get_account_with_commitment(&rpc_client, &nonce_address, CommitmentConfig::recent())
+            .and_then(|ref a| nonce::data_from_account(a))
+            .unwrap()
+            .blockhash;
 
     // Test by creating transfer TX with nonce, fully offline
-    let mut authority_config = CliConfig::default();
+    let mut authority_config = CliConfig::recent_for_tests();
     authority_config.json_rpc_url = String::default();
     authority_config.signers = vec![&offline_nonce_authority_signer];
     // Verify we cannot contact the cluster
@@ -329,7 +333,7 @@ fn test_create_account_with_seed() {
     assert_eq!(sign_only.blockhash, nonce_hash);
 
     // And submit it
-    let mut submit_config = CliConfig::default();
+    let mut submit_config = CliConfig::recent_for_tests();
     submit_config.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     submit_config.signers = vec![&authority_presigner];
@@ -348,10 +352,10 @@ fn test_create_account_with_seed() {
         fee_payer: 0,
     };
     process_command(&submit_config).unwrap();
-    check_balance(241, &rpc_client, &nonce_address);
-    check_balance(31, &rpc_client, &offline_nonce_authority_signer.pubkey());
-    check_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
-    check_balance(10, &rpc_client, &to_address);
+    check_recent_balance(241, &rpc_client, &nonce_address);
+    check_recent_balance(31, &rpc_client, &offline_nonce_authority_signer.pubkey());
+    check_recent_balance(4000, &rpc_client, &online_nonce_creator_signer.pubkey());
+    check_recent_balance(10, &rpc_client, &to_address);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();

cli/tests/pay.rs

@@ -1,6 +1,5 @@
 use chrono::prelude::*;
 use serde_json::Value;
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig, PayCommand},
     cli_output::OutputFormat,
@@ -10,11 +9,13 @@ use solana_cli::{
         parse_sign_only_reply_string,
     },
     spend_utils::SpendAmount,
+    test_utils::check_recent_balance,
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::TestValidator;
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
+    commitment_config::CommitmentConfig,
     nonce::State as NonceState,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
@@ -40,12 +41,12 @@ fn test_cli_timestamp_tx() {
     let default_signer0 = Keypair::new();
     let default_signer1 = Keypair::new();
 
-    let mut config_payer = CliConfig::default();
+    let mut config_payer = CliConfig::recent_for_tests();
     config_payer.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_payer.signers = vec![&default_signer0];
 
-    let mut config_witness = CliConfig::default();
+    let mut config_witness = CliConfig::recent_for_tests();
     config_witness.json_rpc_url = config_payer.json_rpc_url.clone();
     config_witness.signers = vec![&default_signer1];
 
@@ -62,7 +63,7 @@ fn test_cli_timestamp_tx() {
         &config_witness,
     )
     .unwrap();
-    check_balance(50, &rpc_client, &config_payer.signers[0].pubkey());
+    check_recent_balance(50, &rpc_client, &config_payer.signers[0].pubkey());
 
     request_and_confirm_airdrop(
         &rpc_client,
@@ -92,17 +93,17 @@ fn test_cli_timestamp_tx() {
         .expect("base58-encoded public key");
     let process_id = Pubkey::new(&process_id_vec);
 
-    check_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
-    check_balance(10, &rpc_client, &process_id); // contract balance
-    check_balance(0, &rpc_client, &bob_pubkey); // recipient balance
+    check_recent_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
+    check_recent_balance(10, &rpc_client, &process_id); // contract balance
+    check_recent_balance(0, &rpc_client, &bob_pubkey); // recipient balance
 
     // Sign transaction by config_witness
     config_witness.command = CliCommand::TimeElapsed(bob_pubkey, process_id, dt);
     process_command(&config_witness).unwrap();
 
-    check_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
-    check_balance(0, &rpc_client, &process_id); // contract balance
-    check_balance(10, &rpc_client, &bob_pubkey); // recipient balance
+    check_recent_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
+    check_recent_balance(0, &rpc_client, &process_id); // contract balance
+    check_recent_balance(10, &rpc_client, &bob_pubkey); // recipient balance
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -127,12 +128,12 @@ fn test_cli_witness_tx() {
     let default_signer0 = Keypair::new();
     let default_signer1 = Keypair::new();
 
-    let mut config_payer = CliConfig::default();
+    let mut config_payer = CliConfig::recent_for_tests();
     config_payer.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_payer.signers = vec![&default_signer0];
 
-    let mut config_witness = CliConfig::default();
+    let mut config_witness = CliConfig::recent_for_tests();
     config_witness.json_rpc_url = config_payer.json_rpc_url.clone();
     config_witness.signers = vec![&default_signer1];
 
@@ -174,17 +175,17 @@ fn test_cli_witness_tx() {
         .expect("base58-encoded public key");
     let process_id = Pubkey::new(&process_id_vec);
 
-    check_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
-    check_balance(10, &rpc_client, &process_id); // contract balance
-    check_balance(0, &rpc_client, &bob_pubkey); // recipient balance
+    check_recent_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
+    check_recent_balance(10, &rpc_client, &process_id); // contract balance
+    check_recent_balance(0, &rpc_client, &bob_pubkey); // recipient balance
 
     // Sign transaction by config_witness
     config_witness.command = CliCommand::Witness(bob_pubkey, process_id);
     process_command(&config_witness).unwrap();
 
-    check_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
-    check_balance(0, &rpc_client, &process_id); // contract balance
-    check_balance(10, &rpc_client, &bob_pubkey); // recipient balance
+    check_recent_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
+    check_recent_balance(0, &rpc_client, &process_id); // contract balance
+    check_recent_balance(10, &rpc_client, &bob_pubkey); // recipient balance
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -209,12 +210,12 @@ fn test_cli_cancel_tx() {
     let default_signer0 = Keypair::new();
     let default_signer1 = Keypair::new();
 
-    let mut config_payer = CliConfig::default();
+    let mut config_payer = CliConfig::recent_for_tests();
     config_payer.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_payer.signers = vec![&default_signer0];
 
-    let mut config_witness = CliConfig::default();
+    let mut config_witness = CliConfig::recent_for_tests();
     config_witness.json_rpc_url = config_payer.json_rpc_url.clone();
     config_witness.signers = vec![&default_signer1];
 
@@ -249,17 +250,17 @@ fn test_cli_cancel_tx() {
         .expect("base58-encoded public key");
     let process_id = Pubkey::new(&process_id_vec);
 
-    check_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
-    check_balance(10, &rpc_client, &process_id); // contract balance
-    check_balance(0, &rpc_client, &bob_pubkey); // recipient balance
+    check_recent_balance(40, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
+    check_recent_balance(10, &rpc_client, &process_id); // contract balance
+    check_recent_balance(0, &rpc_client, &bob_pubkey); // recipient balance
 
     // Sign transaction by config_witness
     config_payer.command = CliCommand::Cancel(process_id);
     process_command(&config_payer).unwrap();
 
-    check_balance(50, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
-    check_balance(0, &rpc_client, &process_id); // contract balance
-    check_balance(0, &rpc_client, &bob_pubkey); // recipient balance
+    check_recent_balance(50, &rpc_client, &config_payer.signers[0].pubkey()); // config_payer balance
+    check_recent_balance(0, &rpc_client, &process_id); // contract balance
+    check_recent_balance(0, &rpc_client, &bob_pubkey); // recipient balance
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -284,11 +285,11 @@ fn test_offline_pay_tx() {
     let default_signer = Keypair::new();
     let default_offline_signer = Keypair::new();
 
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     config_offline.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_offline.signers = vec![&default_offline_signer];
-    let mut config_online = CliConfig::default();
+    let mut config_online = CliConfig::recent_for_tests();
     config_online.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_online.signers = vec![&default_signer];
@@ -314,8 +315,8 @@ fn test_offline_pay_tx() {
         &config_offline,
     )
     .unwrap();
-    check_balance(50, &rpc_client, &config_offline.signers[0].pubkey());
-    check_balance(50, &rpc_client, &config_online.signers[0].pubkey());
+    check_recent_balance(50, &rpc_client, &config_offline.signers[0].pubkey());
+    check_recent_balance(50, &rpc_client, &config_online.signers[0].pubkey());
 
     let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
     config_offline.command = CliCommand::Pay(PayCommand {
@@ -328,9 +329,9 @@ fn test_offline_pay_tx() {
     config_offline.output_format = OutputFormat::JsonCompact;
     let sig_response = process_command(&config_offline).unwrap();
 
-    check_balance(50, &rpc_client, &config_offline.signers[0].pubkey());
-    check_balance(50, &rpc_client, &config_online.signers[0].pubkey());
-    check_balance(0, &rpc_client, &bob_pubkey);
+    check_recent_balance(50, &rpc_client, &config_offline.signers[0].pubkey());
+    check_recent_balance(50, &rpc_client, &config_online.signers[0].pubkey());
+    check_recent_balance(0, &rpc_client, &bob_pubkey);
 
     let sign_only = parse_sign_only_reply_string(&sig_response);
     assert!(sign_only.has_all_signers());
@@ -347,9 +348,9 @@ fn test_offline_pay_tx() {
     });
     process_command(&config_online).unwrap();
 
-    check_balance(40, &rpc_client, &config_offline.signers[0].pubkey());
-    check_balance(50, &rpc_client, &online_pubkey);
-    check_balance(10, &rpc_client, &bob_pubkey);
+    check_recent_balance(40, &rpc_client, &config_offline.signers[0].pubkey());
+    check_recent_balance(50, &rpc_client, &online_pubkey);
+    check_recent_balance(10, &rpc_client, &bob_pubkey);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -373,7 +374,7 @@ fn test_nonced_pay_tx() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
@@ -389,7 +390,7 @@ fn test_nonced_pay_tx() {
         &config,
     )
     .unwrap();
-    check_balance(
+    check_recent_balance(
         50 + minimum_nonce_balance,
         &rpc_client,
         &config.signers[0].pubkey(),
@@ -406,14 +407,18 @@ fn test_nonced_pay_tx() {
     config.signers.push(&nonce_account);
     process_command(&config).unwrap();
 
-    check_balance(50, &rpc_client, &config.signers[0].pubkey());
-    check_balance(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
+    check_recent_balance(50, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     let bob_pubkey = Pubkey::new_rand();
     config.signers = vec![&default_signer];
@@ -429,14 +434,18 @@ fn test_nonced_pay_tx() {
     });
     process_command(&config).expect("failed to process pay command");
 
-    check_balance(40, &rpc_client, &config.signers[0].pubkey());
-    check_balance(10, &rpc_client, &bob_pubkey);
+    check_recent_balance(40, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(10, &rpc_client, &bob_pubkey);
 
     // Verify that nonce has been used
-    let nonce_hash2 = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash2 = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
     assert_ne!(nonce_hash, nonce_hash2);
 
     server.close().unwrap();

cli/tests/request_airdrop.rs

@@ -2,7 +2,7 @@ use solana_cli::cli::{process_command, CliCommand, CliConfig};
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::TestValidator;
 use solana_faucet::faucet::run_local_faucet;
-use solana_sdk::signature::Keypair;
+use solana_sdk::{commitment_config::CommitmentConfig, signature::Keypair};
 use std::{fs::remove_dir_all, sync::mpsc::channel};
 
 #[test]
@@ -18,7 +18,7 @@ fn test_cli_request_airdrop() {
     run_local_faucet(alice, sender, None);
     let faucet_addr = receiver.recv().unwrap();
 
-    let mut bob_config = CliConfig::default();
+    let mut bob_config = CliConfig::recent_for_tests();
     bob_config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     bob_config.command = CliCommand::Airdrop {
         faucet_host: None,
@@ -35,8 +35,9 @@ fn test_cli_request_airdrop() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let balance = rpc_client
-        .get_balance(&bob_config.signers[0].pubkey())
-        .unwrap();
+        .get_balance_with_commitment(&bob_config.signers[0].pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value;
     assert_eq!(balance, 50);
 
     server.close().unwrap();

cli/tests/stake.rs

@@ -1,4 +1,3 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     cli_output::OutputFormat,
@@ -8,12 +7,14 @@ use solana_cli::{
         parse_sign_only_reply_string,
     },
     spend_utils::SpendAmount,
+    test_utils::{check_ready, check_recent_balance},
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
     account_utils::StateMut,
+    commitment_config::CommitmentConfig,
     nonce::State as NonceState,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, Signer},
@@ -40,7 +41,7 @@ fn test_stake_delegation_force() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
@@ -57,6 +58,7 @@ fn test_stake_delegation_force() {
     let vote_keypair = Keypair::new();
     config.signers = vec![&default_signer, &vote_keypair];
     config.command = CliCommand::CreateVoteAccount {
+        vote_account: 1,
         seed: None,
         identity_account: 0,
         authorized_voter: None,
@@ -136,7 +138,7 @@ fn test_seed_stake_delegation_and_deactivation() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let validator_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
-    let mut config_validator = CliConfig::default();
+    let mut config_validator = CliConfig::recent_for_tests();
     config_validator.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_validator.signers = vec![&validator_keypair];
@@ -149,7 +151,7 @@ fn test_seed_stake_delegation_and_deactivation() {
         &config_validator,
     )
     .unwrap();
-    check_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     let stake_address = Pubkey::create_with_seed(
         &config_validator.signers[0].pubkey(),
@@ -181,7 +183,7 @@ fn test_seed_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_address,
         vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
-        force: false,
+        force: true,
         sign_only: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
@@ -225,7 +227,7 @@ fn test_stake_delegation_and_deactivation() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let validator_keypair = Keypair::new();
 
-    let mut config_validator = CliConfig::default();
+    let mut config_validator = CliConfig::recent_for_tests();
     config_validator.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config_validator.signers = vec![&validator_keypair];
@@ -240,7 +242,7 @@ fn test_stake_delegation_and_deactivation() {
         &config_validator,
     )
     .unwrap();
-    check_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     // Create stake account
     config_validator.signers.push(&stake_keypair);
@@ -266,7 +268,7 @@ fn test_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
-        force: false,
+        force: true,
         sign_only: false,
         blockhash_query: BlockhashQuery::default(),
         nonce_account: None,
@@ -309,19 +311,19 @@ fn test_offline_stake_delegation_and_deactivation() {
 
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
-    let mut config_validator = CliConfig::default();
+    let mut config_validator = CliConfig::recent_for_tests();
     config_validator.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     let validator_keypair = Keypair::new();
     config_validator.signers = vec![&validator_keypair];
 
-    let mut config_payer = CliConfig::default();
+    let mut config_payer = CliConfig::recent_for_tests();
     config_payer.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
     let stake_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
 
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     config_offline.json_rpc_url = String::default();
     config_offline.command = CliCommand::ClusterVersion;
     let offline_keypair = Keypair::new();
@@ -337,7 +339,7 @@ fn test_offline_stake_delegation_and_deactivation() {
         &config_offline,
     )
     .unwrap();
-    check_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_validator.signers[0].pubkey());
 
     request_and_confirm_airdrop(
         &rpc_client,
@@ -347,7 +349,7 @@ fn test_offline_stake_delegation_and_deactivation() {
         &config_validator,
     )
     .unwrap();
-    check_balance(100_000, &rpc_client, &config_offline.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config_offline.signers[0].pubkey());
 
     // Create stake account
     config_validator.signers.push(&stake_keypair);
@@ -373,7 +375,7 @@ fn test_offline_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
-        force: false,
+        force: true,
         sign_only: true,
         blockhash_query: BlockhashQuery::None(blockhash),
         nonce_account: None,
@@ -392,7 +394,7 @@ fn test_offline_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
-        force: false,
+        force: true,
         sign_only: false,
         blockhash_query: BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
         nonce_account: None,
@@ -453,7 +455,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
     let config_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.signers = vec![&config_keypair];
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
@@ -501,10 +503,14 @@ fn test_nonced_stake_delegation_and_deactivation() {
     process_command(&config).unwrap();
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Delegate stake
     config.signers = vec![&config_keypair];
@@ -512,7 +518,7 @@ fn test_nonced_stake_delegation_and_deactivation() {
         stake_account_pubkey: stake_keypair.pubkey(),
         vote_account_pubkey: vote_pubkey,
         stake_authority: 0,
-        force: false,
+        force: true,
         sign_only: false,
         blockhash_query: BlockhashQuery::FeeCalculator(
             blockhash_query::Source::NonceAccount(nonce_account.pubkey()),
@@ -525,10 +531,14 @@ fn test_nonced_stake_delegation_and_deactivation() {
     process_command(&config).unwrap();
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Deactivate stake
     config.command = CliCommand::DeactivateStake {
@@ -567,7 +577,7 @@ fn test_stake_authorize() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
@@ -581,7 +591,7 @@ fn test_stake_authorize() {
     .unwrap();
 
     let offline_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     config_offline.signers = vec![&offline_keypair];
     config_offline.json_rpc_url = String::default();
     let offline_authority_pubkey = config_offline.signers[0].pubkey();
@@ -632,7 +642,11 @@ fn test_stake_authorize() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -659,7 +673,11 @@ fn test_stake_authorize() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let (current_staker, current_withdrawer) = match stake_state {
         StakeState::Initialized(meta) => (meta.authorized.staker, meta.authorized.withdrawer),
@@ -681,7 +699,11 @@ fn test_stake_authorize() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -692,7 +714,10 @@ fn test_stake_authorize() {
     // Offline assignment of new nonced stake authority
     let nonced_authority = Keypair::new();
     let nonced_authority_pubkey = nonced_authority.pubkey();
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
         new_authorizations: vec![(StakeAuthorize::Staker, nonced_authority_pubkey, 0)],
@@ -718,7 +743,11 @@ fn test_stake_authorize() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -741,10 +770,14 @@ fn test_stake_authorize() {
     process_command(&config).unwrap();
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Nonced assignment of new online stake authority
     let online_authority = Keypair::new();
@@ -779,7 +812,11 @@ fn test_stake_authorize() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_authority = match stake_state {
         StakeState::Initialized(meta) => meta.authorized.staker,
@@ -787,10 +824,14 @@ fn test_stake_authorize() {
     };
     assert_eq!(current_authority, online_authority_pubkey);
 
-    let new_nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let new_nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
     assert_ne!(nonce_hash, new_nonce_hash);
 
     server.close().unwrap();
@@ -821,18 +862,18 @@ fn test_stake_authorize_with_fee_payer() {
     let default_signer = Keypair::new();
     let default_pubkey = default_signer.pubkey();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
     let payer_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
-    let mut config_payer = CliConfig::default();
+    let mut config_payer = CliConfig::recent_for_tests();
     config_payer.signers = vec![&payer_keypair];
     config_payer.json_rpc_url =
         format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     let payer_pubkey = config_payer.signers[0].pubkey();
 
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     let offline_signer = Keypair::new();
     config_offline.signers = vec![&offline_signer];
     config_offline.json_rpc_url = String::new();
@@ -843,15 +884,17 @@ fn test_stake_authorize_with_fee_payer() {
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &default_pubkey, 100_000, &config)
         .unwrap();
-    check_balance(100_000, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(100_000, &rpc_client, &config.signers[0].pubkey());
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &payer_pubkey, 100_000, &config)
         .unwrap();
-    check_balance(100_000, &rpc_client, &payer_pubkey);
+    check_recent_balance(100_000, &rpc_client, &payer_pubkey);
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
         .unwrap();
-    check_balance(100_000, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
+
+    check_ready(&rpc_client);
 
     // Create stake account, identity is authority
     let stake_keypair = Keypair::new();
@@ -873,7 +916,7 @@ fn test_stake_authorize_with_fee_payer() {
     };
     process_command(&config).unwrap();
     // `config` balance should be 50,000 - 1 stake account sig - 1 fee sig
-    check_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
+    check_recent_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
 
     // Assign authority with separate fee payer
     config.signers = vec![&default_signer, &payer_keypair];
@@ -888,13 +931,16 @@ fn test_stake_authorize_with_fee_payer() {
     };
     process_command(&config).unwrap();
     // `config` balance has not changed, despite submitting the TX
-    check_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
+    check_recent_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
     // `config_payer` however has paid `config`'s authority sig
     // and `config_payer`'s fee sig
-    check_balance(100_000 - SIG_FEE - SIG_FEE, &rpc_client, &payer_pubkey);
+    check_recent_balance(100_000 - SIG_FEE - SIG_FEE, &rpc_client, &payer_pubkey);
 
     // Assign authority with offline fee payer
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
     config_offline.command = CliCommand::StakeAuthorize {
         stake_account_pubkey,
         new_authorizations: vec![(StakeAuthorize::Staker, payer_pubkey, 0)],
@@ -921,10 +967,10 @@ fn test_stake_authorize_with_fee_payer() {
     };
     process_command(&config).unwrap();
     // `config`'s balance again has not changed
-    check_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
+    check_recent_balance(50_000 - SIG_FEE - SIG_FEE, &rpc_client, &default_pubkey);
     // `config_offline` however has paid 1 sig due to being both authority
     // and fee payer
-    check_balance(100_000 - SIG_FEE, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000 - SIG_FEE, &rpc_client, &offline_pubkey);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -953,11 +999,11 @@ fn test_stake_split() {
     let default_signer = Keypair::new();
     let offline_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     config_offline.json_rpc_url = String::default();
     config_offline.signers = vec![&offline_signer];
     let offline_pubkey = config_offline.signers[0].pubkey();
@@ -973,11 +1019,11 @@ fn test_stake_split() {
         &config,
     )
     .unwrap();
-    check_balance(500_000, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
         .unwrap();
-    check_balance(100_000, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
     let minimum_stake_balance = rpc_client
@@ -1001,7 +1047,7 @@ fn test_stake_split() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance(
+    check_recent_balance(
         10 * minimum_stake_balance,
         &rpc_client,
         &stake_account_pubkey,
@@ -1020,17 +1066,21 @@ fn test_stake_split() {
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
-    check_balance(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
+    check_recent_balance(minimum_nonce_balance, &rpc_client, &nonce_account.pubkey());
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Nonced offline split
     let split_account = keypair_from_seed(&[2u8; 32]).unwrap();
-    check_balance(0, &rpc_client, &split_account.pubkey());
+    check_recent_balance(0, &rpc_client, &split_account.pubkey());
     config_offline.signers.push(&split_account);
     config_offline.command = CliCommand::SplitStake {
         stake_account_pubkey,
@@ -1066,12 +1116,12 @@ fn test_stake_split() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(
+    check_recent_balance(
         8 * minimum_stake_balance,
         &rpc_client,
         &stake_account_pubkey,
     );
-    check_balance(
+    check_recent_balance(
         2 * minimum_stake_balance,
         &rpc_client,
         &split_account.pubkey(),
@@ -1104,11 +1154,11 @@ fn test_stake_set_lockup() {
     let default_signer = Keypair::new();
     let offline_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     config_offline.json_rpc_url = String::default();
     config_offline.signers = vec![&offline_signer];
     let offline_pubkey = config_offline.signers[0].pubkey();
@@ -1124,11 +1174,11 @@ fn test_stake_set_lockup() {
         &config,
     )
     .unwrap();
-    check_balance(500_000, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(500_000, &rpc_client, &config.signers[0].pubkey());
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
         .unwrap();
-    check_balance(100_000, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create stake account, identity is authority
     let minimum_stake_balance = rpc_client
@@ -1157,7 +1207,7 @@ fn test_stake_set_lockup() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance(
+    check_recent_balance(
         10 * minimum_stake_balance,
         &rpc_client,
         &stake_account_pubkey,
@@ -1181,7 +1231,11 @@ fn test_stake_set_lockup() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_lockup = match stake_state {
         StakeState::Initialized(meta) => meta.lockup,
@@ -1232,7 +1286,11 @@ fn test_stake_set_lockup() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_lockup = match stake_state {
         StakeState::Initialized(meta) => meta.lockup,
@@ -1277,13 +1335,17 @@ fn test_stake_set_lockup() {
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
-    check_balance(minimum_nonce_balance, &rpc_client, &nonce_account_pubkey);
+    check_recent_balance(minimum_nonce_balance, &rpc_client, &nonce_account_pubkey);
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Nonced offline set lockup
     let lockup = LockupArgs {
@@ -1321,7 +1383,11 @@ fn test_stake_set_lockup() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    let stake_account = rpc_client.get_account(&stake_account_pubkey).unwrap();
+    let stake_account = rpc_client
+        .get_account_with_commitment(&stake_account_pubkey, CommitmentConfig::recent())
+        .unwrap()
+        .value
+        .unwrap();
     let stake_state: StakeState = stake_account.state().unwrap();
     let current_lockup = match stake_state {
         StakeState::Initialized(meta) => meta.lockup,
@@ -1355,12 +1421,12 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
 
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     let default_signer = keypair_from_seed(&[1u8; 32]).unwrap();
     config.signers = vec![&default_signer];
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
 
-    let mut config_offline = CliConfig::default();
+    let mut config_offline = CliConfig::recent_for_tests();
     let offline_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     config_offline.signers = vec![&offline_signer];
     let offline_pubkey = config_offline.signers[0].pubkey();
@@ -1377,11 +1443,11 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         &config,
     )
     .unwrap();
-    check_balance(200_000, &rpc_client, &config.signers[0].pubkey());
+    check_recent_balance(200_000, &rpc_client, &config.signers[0].pubkey());
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 100_000, &config)
         .unwrap();
-    check_balance(100_000, &rpc_client, &offline_pubkey);
+    check_recent_balance(100_000, &rpc_client, &offline_pubkey);
 
     // Create nonce account
     let minimum_nonce_balance = rpc_client
@@ -1399,10 +1465,14 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     process_command(&config).unwrap();
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Create stake account offline
     let stake_keypair = keypair_from_seed(&[4u8; 32]).unwrap();
@@ -1447,13 +1517,17 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         from: 0,
     };
     process_command(&config).unwrap();
-    check_balance(50_000, &rpc_client, &stake_pubkey);
+    check_recent_balance(50_000, &rpc_client, &stake_pubkey);
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Offline, nonced stake-withdraw
     let recipient = keypair_from_seed(&[5u8; 32]).unwrap();
@@ -1491,13 +1565,17 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(42, &rpc_client, &recipient_pubkey);
+    check_recent_balance(42, &rpc_client, &recipient_pubkey);
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Create another stake account. This time with seed
     let seed = "seedy";
@@ -1541,7 +1619,7 @@ fn test_offline_nonced_create_stake_account_and_withdraw() {
     process_command(&config).unwrap();
     let seed_address =
         Pubkey::create_with_seed(&stake_pubkey, seed, &solana_stake_program::id()).unwrap();
-    check_balance(50_000, &rpc_client, &seed_address);
+    check_recent_balance(50_000, &rpc_client, &seed_address);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();

cli/tests/transfer.rs

@@ -1,4 +1,3 @@
-use solana_cli::test_utils::check_balance;
 use solana_cli::{
     cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
     cli_output::OutputFormat,
@@ -8,11 +7,13 @@ use solana_cli::{
         parse_sign_only_reply_string,
     },
     spend_utils::SpendAmount,
+    test_utils::{check_ready, check_recent_balance},
 };
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::{TestValidator, TestValidatorOptions};
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
+    commitment_config::CommitmentConfig,
     nonce::State as NonceState,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, NullSigner, Signer},
@@ -42,7 +43,7 @@ fn test_transfer() {
     let default_signer = Keypair::new();
     let default_offline_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
@@ -51,8 +52,10 @@ fn test_transfer() {
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000, &config)
         .unwrap();
-    check_balance(50_000, &rpc_client, &sender_pubkey);
-    check_balance(0, &rpc_client, &recipient_pubkey);
+    check_recent_balance(50_000, &rpc_client, &sender_pubkey);
+    check_recent_balance(0, &rpc_client, &recipient_pubkey);
+
+    check_ready(&rpc_client);
 
     // Plain ole transfer
     config.command = CliCommand::Transfer {
@@ -67,8 +70,8 @@ fn test_transfer() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(49_989, &rpc_client, &sender_pubkey);
-    check_balance(10, &rpc_client, &recipient_pubkey);
+    check_recent_balance(49_989, &rpc_client, &sender_pubkey);
+    check_recent_balance(10, &rpc_client, &recipient_pubkey);
 
     // Plain ole transfer, failure due to InsufficientFundsForSpendAndFee
     config.command = CliCommand::Transfer {
@@ -83,10 +86,10 @@ fn test_transfer() {
         fee_payer: 0,
     };
     assert!(process_command(&config).is_err());
-    check_balance(49_989, &rpc_client, &sender_pubkey);
-    check_balance(10, &rpc_client, &recipient_pubkey);
+    check_recent_balance(49_989, &rpc_client, &sender_pubkey);
+    check_recent_balance(10, &rpc_client, &recipient_pubkey);
 
-    let mut offline = CliConfig::default();
+    let mut offline = CliConfig::recent_for_tests();
     offline.json_rpc_url = String::default();
     offline.signers = vec![&default_offline_signer];
     // Verify we cannot contact the cluster
@@ -95,10 +98,13 @@ fn test_transfer() {
 
     let offline_pubkey = offline.signers[0].pubkey();
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 50, &config).unwrap();
-    check_balance(50, &rpc_client, &offline_pubkey);
+    check_recent_balance(50, &rpc_client, &offline_pubkey);
 
     // Offline transfer
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
     offline.command = CliCommand::Transfer {
         amount: SpendAmount::Some(10),
         to: recipient_pubkey,
@@ -128,8 +134,8 @@ fn test_transfer() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(39, &rpc_client, &offline_pubkey);
-    check_balance(20, &rpc_client, &recipient_pubkey);
+    check_recent_balance(39, &rpc_client, &offline_pubkey);
+    check_recent_balance(20, &rpc_client, &recipient_pubkey);
 
     // Create nonce account
     let nonce_account = keypair_from_seed(&[3u8; 32]).unwrap();
@@ -144,13 +150,17 @@ fn test_transfer() {
         amount: SpendAmount::Some(minimum_nonce_balance),
     };
     process_command(&config).unwrap();
-    check_balance(49_987 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
+    check_recent_balance(49_987 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Nonced transfer
     config.signers = vec![&default_signer];
@@ -169,12 +179,16 @@ fn test_transfer() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(49_976 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
-    check_balance(30, &rpc_client, &recipient_pubkey);
-    let new_nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    check_recent_balance(49_976 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
+    check_recent_balance(30, &rpc_client, &recipient_pubkey);
+    let new_nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
     assert_ne!(nonce_hash, new_nonce_hash);
 
     // Assign nonce authority to offline
@@ -185,13 +199,17 @@ fn test_transfer() {
         new_authority: offline_pubkey,
     };
     process_command(&config).unwrap();
-    check_balance(49_975 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
+    check_recent_balance(49_975 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
 
     // Fetch nonce hash
-    let nonce_hash = nonce::get_account(&rpc_client, &nonce_account.pubkey())
-        .and_then(|ref a| nonce::data_from_account(a))
-        .unwrap()
-        .blockhash;
+    let nonce_hash = nonce::get_account_with_commitment(
+        &rpc_client,
+        &nonce_account.pubkey(),
+        CommitmentConfig::recent(),
+    )
+    .and_then(|ref a| nonce::data_from_account(a))
+    .unwrap()
+    .blockhash;
 
     // Offline, nonced transfer
     offline.signers = vec![&default_offline_signer];
@@ -226,8 +244,8 @@ fn test_transfer() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(28, &rpc_client, &offline_pubkey);
-    check_balance(40, &rpc_client, &recipient_pubkey);
+    check_recent_balance(28, &rpc_client, &offline_pubkey);
+    check_recent_balance(40, &rpc_client, &recipient_pubkey);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -255,7 +273,7 @@ fn test_transfer_multisession_signing() {
     let offline_from_signer = keypair_from_seed(&[2u8; 32]).unwrap();
     let offline_fee_payer_signer = keypair_from_seed(&[3u8; 32]).unwrap();
     let from_null_signer = NullSigner::new(&offline_from_signer.pubkey());
-    let config = CliConfig::default();
+    let config = CliConfig::recent_for_tests();
 
     // Setup accounts
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
@@ -275,14 +293,19 @@ fn test_transfer_multisession_signing() {
         &config,
     )
     .unwrap();
-    check_balance(43, &rpc_client, &offline_from_signer.pubkey());
-    check_balance(3, &rpc_client, &offline_fee_payer_signer.pubkey());
-    check_balance(0, &rpc_client, &to_pubkey);
+    check_recent_balance(43, &rpc_client, &offline_from_signer.pubkey());
+    check_recent_balance(3, &rpc_client, &offline_fee_payer_signer.pubkey());
+    check_recent_balance(0, &rpc_client, &to_pubkey);
 
-    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    check_ready(&rpc_client);
+
+    let (blockhash, _, _) = rpc_client
+        .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
+        .unwrap()
+        .value;
 
     // Offline fee-payer signs first
-    let mut fee_payer_config = CliConfig::default();
+    let mut fee_payer_config = CliConfig::recent_for_tests();
     fee_payer_config.json_rpc_url = String::default();
     fee_payer_config.signers = vec![&offline_fee_payer_signer, &from_null_signer];
     // Verify we cannot contact the cluster
@@ -308,7 +331,7 @@ fn test_transfer_multisession_signing() {
         .unwrap();
 
     // Now the offline fund source
-    let mut from_config = CliConfig::default();
+    let mut from_config = CliConfig::recent_for_tests();
     from_config.json_rpc_url = String::default();
     from_config.signers = vec![&fee_payer_presigner, &offline_from_signer];
     // Verify we cannot contact the cluster
@@ -334,7 +357,7 @@ fn test_transfer_multisession_signing() {
         .unwrap();
 
     // Finally submit to the cluster
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&fee_payer_presigner, &from_presigner];
     config.command = CliCommand::Transfer {
@@ -350,9 +373,9 @@ fn test_transfer_multisession_signing() {
     };
     process_command(&config).unwrap();
 
-    check_balance(1, &rpc_client, &offline_from_signer.pubkey());
-    check_balance(1, &rpc_client, &offline_fee_payer_signer.pubkey());
-    check_balance(42, &rpc_client, &to_pubkey);
+    check_recent_balance(1, &rpc_client, &offline_from_signer.pubkey());
+    check_recent_balance(1, &rpc_client, &offline_fee_payer_signer.pubkey());
+    check_recent_balance(42, &rpc_client, &to_pubkey);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();
@@ -380,7 +403,7 @@ fn test_transfer_all() {
 
     let default_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
@@ -389,8 +412,10 @@ fn test_transfer_all() {
 
     request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000, &config)
         .unwrap();
-    check_balance(50_000, &rpc_client, &sender_pubkey);
-    check_balance(0, &rpc_client, &recipient_pubkey);
+    check_recent_balance(50_000, &rpc_client, &sender_pubkey);
+    check_recent_balance(0, &rpc_client, &recipient_pubkey);
+
+    check_ready(&rpc_client);
 
     // Plain ole transfer
     config.command = CliCommand::Transfer {
@@ -405,8 +430,8 @@ fn test_transfer_all() {
         fee_payer: 0,
     };
     process_command(&config).unwrap();
-    check_balance(0, &rpc_client, &sender_pubkey);
-    check_balance(49_999, &rpc_client, &recipient_pubkey);
+    check_recent_balance(0, &rpc_client, &sender_pubkey);
+    check_recent_balance(49_999, &rpc_client, &recipient_pubkey);
 
     server.close().unwrap();
     remove_dir_all(ledger_path).unwrap();

cli/tests/vote.rs

@@ -1,10 +1,15 @@
-use solana_cli::cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig};
-use solana_cli::test_utils::check_balance;
+use solana_cli::{
+    cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
+    offline::{blockhash_query::BlockhashQuery, *},
+    spend_utils::SpendAmount,
+    test_utils::check_recent_balance,
+};
 use solana_client::rpc_client::RpcClient;
 use solana_core::validator::TestValidator;
 use solana_faucet::faucet::run_local_faucet;
 use solana_sdk::{
     account_utils::StateMut,
+    commitment_config::CommitmentConfig,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
 };
@@ -27,7 +32,7 @@ fn test_vote_authorize_and_withdraw() {
     let rpc_client = RpcClient::new_socket(leader_data.rpc);
     let default_signer = Keypair::new();
 
-    let mut config = CliConfig::default();
+    let mut config = CliConfig::recent_for_tests();
     config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
     config.signers = vec![&default_signer];
 
@@ -45,6 +50,7 @@ fn test_vote_authorize_and_withdraw() {
     let vote_account_pubkey = vote_account_keypair.pubkey();
     config.signers = vec![&default_signer, &vote_account_keypair];
     config.command = CliCommand::CreateVoteAccount {
+        vote_account: 1,
         seed: None,
         identity_account: 0,
         authorized_voter: None,
@@ -53,7 +59,9 @@ fn test_vote_authorize_and_withdraw() {
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
-        .get_account(&vote_account_keypair.pubkey())
+        .get_account_with_commitment(&vote_account_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
         .unwrap();
     let vote_state: VoteStateVersions = vote_account.state().unwrap();
     let authorized_withdrawer = vote_state.convert_to_current().authorized_withdrawer;
@@ -62,7 +70,24 @@ fn test_vote_authorize_and_withdraw() {
         .get_minimum_balance_for_rent_exemption(VoteState::size_of())
         .unwrap()
         .max(1);
-    check_balance(expected_balance, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
+
+    // Transfer in some more SOL
+    config.signers = vec![&default_signer];
+    config.command = CliCommand::Transfer {
+        amount: SpendAmount::Some(1_000),
+        to: vote_account_pubkey,
+        from: 0,
+        sign_only: false,
+        no_wait: false,
+        blockhash_query: BlockhashQuery::All(blockhash_query::Source::Cluster),
+        nonce_account: None,
+        nonce_authority: 0,
+        fee_payer: 0,
+    };
+    process_command(&config).unwrap();
+    let expected_balance = expected_balance + 1_000;
+    check_recent_balance(expected_balance, &rpc_client, &vote_account_pubkey);
 
     // Authorize vote account withdrawal to another signer
     let withdraw_authority = Keypair::new();
@@ -74,7 +99,9 @@ fn test_vote_authorize_and_withdraw() {
     };
     process_command(&config).unwrap();
     let vote_account = rpc_client
-        .get_account(&vote_account_keypair.pubkey())
+        .get_account_with_commitment(&vote_account_keypair.pubkey(), CommitmentConfig::recent())
+        .unwrap()
+        .value
         .unwrap();
     let vote_state: VoteStateVersions = vote_account.state().unwrap();
     let authorized_withdrawer = vote_state.convert_to_current().authorized_withdrawer;
@@ -86,12 +113,12 @@ fn test_vote_authorize_and_withdraw() {
     config.command = CliCommand::WithdrawFromVoteAccount {
         vote_account_pubkey,
         withdraw_authority: 1,
-        lamports: 100,
+        withdraw_amount: SpendAmount::Some(100),
         destination_account_pubkey: destination_account,
     };
     process_command(&config).unwrap();
-    check_balance(expected_balance - 100, &rpc_client, &vote_account_pubkey);
-    check_balance(100, &rpc_client, &destination_account);
+    check_recent_balance(expected_balance - 100, &rpc_client, &vote_account_pubkey);
+    check_recent_balance(100, &rpc_client, &destination_account);
 
     // Re-assign validator identity
     let new_identity_keypair = Keypair::new();
@@ -99,6 +126,7 @@ fn test_vote_authorize_and_withdraw() {
     config.command = CliCommand::VoteUpdateValidator {
         vote_account_pubkey,
         new_identity_account: 2,
+        withdraw_authority: 1,
     };
     process_command(&config).unwrap();
 

client/Cargo.toml

@@ -1,37 +1,38 @@
 [package]
 name = "solana-client"
-version = "1.2.0"
+version = "1.3.2"
 description = "Solana Client"
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana"
 homepage = "https://solana.com/"
 license = "Apache-2.0"
 edition = "2018"
 
 [dependencies]
-bincode = "1.2.1"
+bincode = "1.3.1"
 bs58 = "0.3.1"
-indicatif = "0.14.0"
-jsonrpc-core = "14.1.0"
+indicatif = "0.15.0"
+jsonrpc-core = "14.2.0"
 log = "0.4.8"
-rayon = "1.3.0"
-reqwest = { version = "0.10.4", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-serde = "1.0.110"
+rayon = "1.3.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.53"
-solana-transaction-status = { path = "../transaction-status", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
+serde_json = "1.0.56"
+solana-account-decoder = { path = "../account-decoder", version = "1.3.2" }
+solana-net-utils = { path = "../net-utils", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-transaction-status = { path = "../transaction-status", version = "1.3.2" }
+solana-vote-program = { path = "../programs/vote", version = "1.3.2" }
 thiserror = "1.0"
 tungstenite = "0.10.1"
 url = "2.1.1"
 
 [dev-dependencies]
 assert_matches = "1.3.0"
-jsonrpc-core = "14.1.0"
-jsonrpc-http-server = "14.1.0"
-solana-logger = { path = "../logger", version = "1.2.0" }
+jsonrpc-core = "14.2.0"
+jsonrpc-http-server = "14.2.0"
+solana-logger = { path = "../logger", version = "1.3.2" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

client/src/lib.rs

@@ -8,6 +8,7 @@ pub mod perf_utils;
 pub mod pubsub_client;
 pub mod rpc_client;
 pub mod rpc_config;
+pub mod rpc_filter;
 pub mod rpc_request;
 pub mod rpc_response;
 pub mod rpc_sender;

client/src/rpc_client.rs

@@ -2,8 +2,12 @@ use crate::{
     client_error::{ClientError, ClientErrorKind, Result as ClientResult},
     http_sender::HttpSender,
     mock_sender::{MockSender, Mocks},
-    rpc_config::RpcLargestAccountsConfig,
-    rpc_request::{RpcError, RpcRequest},
+    rpc_config::RpcAccountInfoConfig,
+    rpc_config::{
+        RpcGetConfirmedSignaturesForAddress2Config, RpcLargestAccountsConfig,
+        RpcSendTransactionConfig, RpcTokenAccountsFilter,
+    },
+    rpc_request::{RpcError, RpcRequest, TokenAccountsFilter},
     rpc_response::*,
     rpc_sender::RpcSender,
 };
@@ -11,29 +15,32 @@ use bincode::serialize;
 use indicatif::{ProgressBar, ProgressStyle};
 use log::*;
 use serde_json::{json, Value};
+use solana_account_decoder::{
+    parse_token::UiTokenAmount,
+    UiAccount,
+    UiAccountData::{Binary, Binary64},
+    UiAccountEncoding,
+};
 use solana_sdk::{
     account::Account,
     clock::{
         Slot, UnixTimestamp, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT,
         MAX_HASH_AGE_IN_SECONDS,
     },
-    commitment_config::CommitmentConfig,
+    commitment_config::{CommitmentConfig, CommitmentLevel},
     epoch_info::EpochInfo,
     epoch_schedule::EpochSchedule,
     fee_calculator::{FeeCalculator, FeeRateGovernor},
     hash::Hash,
-    inflation::Inflation,
     pubkey::Pubkey,
     signature::Signature,
-    signers::Signers,
     transaction::{self, Transaction},
 };
 use solana_transaction_status::{
-    ConfirmedBlock, ConfirmedTransaction, TransactionEncoding, TransactionStatus,
+    ConfirmedBlock, ConfirmedTransaction, TransactionStatus, UiTransactionEncoding,
 };
 use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
 use std::{
-    error,
     net::SocketAddr,
     thread::sleep,
     time::{Duration, Instant},
@@ -54,6 +61,10 @@ impl RpcClient {
         Self::new_sender(HttpSender::new(url))
     }
 
+    pub fn new_with_timeout(url: String, timeout: Duration) -> Self {
+        Self::new_sender(HttpSender::new_with_timeout(url, timeout))
+    }
+
     pub fn new_mock(url: String) -> Self {
         Self::new_sender(MockSender::new(url))
     }
@@ -68,7 +79,7 @@ impl RpcClient {
 
     pub fn new_socket_with_timeout(addr: SocketAddr, timeout: Duration) -> Self {
         let url = get_rpc_request_str(addr, false);
-        Self::new_sender(HttpSender::new_with_timeout(url, timeout))
+        Self::new_with_timeout(url, timeout)
     }
 
     pub fn confirm_transaction(&self, signature: &Signature) -> ClientResult<bool> {
@@ -95,10 +106,20 @@ impl RpcClient {
     }
 
     pub fn send_transaction(&self, transaction: &Transaction) -> ClientResult<Signature> {
+        self.send_transaction_with_config(transaction, RpcSendTransactionConfig::default())
+    }
+
+    pub fn send_transaction_with_config(
+        &self,
+        transaction: &Transaction,
+        config: RpcSendTransactionConfig,
+    ) -> ClientResult<Signature> {
         let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
 
-        let signature_base58_str: String =
-            self.send(RpcRequest::SendTransaction, json!([serialized_encoded]))?;
+        let signature_base58_str: String = self.send(
+            RpcRequest::SendTransaction,
+            json!([serialized_encoded, config]),
+        )?;
 
         let signature = signature_base58_str
             .parse::<Signature>()
@@ -122,7 +143,7 @@ impl RpcClient {
         &self,
         transaction: &Transaction,
         sig_verify: bool,
-    ) -> RpcResult<TransactionStatus> {
+    ) -> RpcResult<RpcSimulateTransactionResult> {
         let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
         self.send(
             RpcRequest::SimulateTransaction,
@@ -230,13 +251,13 @@ impl RpcClient {
     }
 
     pub fn get_confirmed_block(&self, slot: Slot) -> ClientResult<ConfirmedBlock> {
-        self.get_confirmed_block_with_encoding(slot, TransactionEncoding::Json)
+        self.get_confirmed_block_with_encoding(slot, UiTransactionEncoding::Json)
     }
 
     pub fn get_confirmed_block_with_encoding(
         &self,
         slot: Slot,
-        encoding: TransactionEncoding,
+        encoding: UiTransactionEncoding,
     ) -> ClientResult<ConfirmedBlock> {
         self.send(RpcRequest::GetConfirmedBlock, json!([slot, encoding]))
     }
@@ -274,10 +295,36 @@ impl RpcClient {
         Ok(signatures)
     }
 
+    pub fn get_confirmed_signatures_for_address2(
+        &self,
+        address: &Pubkey,
+    ) -> ClientResult<Vec<RpcConfirmedTransactionStatusWithSignature>> {
+        self.get_confirmed_signatures_for_address2_with_config(address, None, None)
+    }
+
+    pub fn get_confirmed_signatures_for_address2_with_config(
+        &self,
+        address: &Pubkey,
+        before: Option<Signature>,
+        limit: Option<usize>,
+    ) -> ClientResult<Vec<RpcConfirmedTransactionStatusWithSignature>> {
+        let config = RpcGetConfirmedSignaturesForAddress2Config {
+            before: before.map(|signature| signature.to_string()),
+            limit,
+        };
+
+        let result: Vec<RpcConfirmedTransactionStatusWithSignature> = self.send(
+            RpcRequest::GetConfirmedSignaturesForAddress2,
+            json!([address.to_string(), config]),
+        )?;
+
+        Ok(result)
+    }
+
     pub fn get_confirmed_transaction(
         &self,
         signature: &Signature,
-        encoding: TransactionEncoding,
+        encoding: UiTransactionEncoding,
     ) -> ClientResult<ConfirmedTransaction> {
         self.send(
             RpcRequest::GetConfirmedTransaction,
@@ -346,8 +393,12 @@ impl RpcClient {
         })
     }
 
-    pub fn get_inflation(&self) -> ClientResult<Inflation> {
-        self.send(RpcRequest::GetInflation, Value::Null)
+    pub fn get_inflation_governor(&self) -> ClientResult<RpcInflationGovernor> {
+        self.send(RpcRequest::GetInflationGovernor, Value::Null)
+    }
+
+    pub fn get_inflation_rate(&self) -> ClientResult<RpcInflationRate> {
+        self.send(RpcRequest::GetInflationRate, Value::Null)
     }
 
     pub fn get_version(&self) -> ClientResult<RpcVersionInfo> {
@@ -403,107 +454,6 @@ impl RpcClient {
         }
     }
 
-    pub fn send_and_confirm_transactions_with_spinner<T: Signers>(
-        &self,
-        mut transactions: Vec<Transaction>,
-        signer_keys: &T,
-    ) -> Result<(), Box<dyn error::Error>> {
-        let progress_bar = new_spinner_progress_bar();
-        let mut send_retries = 5;
-        loop {
-            let mut status_retries = 15;
-
-            // Send all transactions
-            let mut transactions_signatures = vec![];
-            let num_transactions = transactions.len();
-            for transaction in transactions {
-                if cfg!(not(test)) {
-                    // Delay ~1 tick between write transactions in an attempt to reduce AccountInUse errors
-                    // when all the write transactions modify the same program account (eg, deploying a
-                    // new program)
-                    sleep(Duration::from_millis(1000 / DEFAULT_TICKS_PER_SECOND));
-                }
-
-                let signature = self.send_transaction(&transaction).ok();
-                transactions_signatures.push((transaction, signature));
-
-                progress_bar.set_message(&format!(
-                    "[{}/{}] Transactions sent",
-                    transactions_signatures.len(),
-                    num_transactions
-                ));
-            }
-
-            // Collect statuses for all the transactions, drop those that are confirmed
-            while status_retries > 0 {
-                status_retries -= 1;
-
-                progress_bar.set_message(&format!(
-                    "[{}/{}] Transactions confirmed",
-                    num_transactions - transactions_signatures.len(),
-                    num_transactions
-                ));
-
-                if cfg!(not(test)) {
-                    // Retry twice a second
-                    sleep(Duration::from_millis(500));
-                }
-
-                transactions_signatures = transactions_signatures
-                    .into_iter()
-                    .filter(|(_transaction, signature)| {
-                        if let Some(signature) = signature {
-                            if let Ok(status) = self.get_signature_status(&signature) {
-                                if self
-                                    .get_num_blocks_since_signature_confirmation(&signature)
-                                    .unwrap_or(0)
-                                    > 1
-                                {
-                                    return false;
-                                } else {
-                                    return match status {
-                                        None => true,
-                                        Some(result) => result.is_err(),
-                                    };
-                                }
-                            }
-                        }
-                        true
-                    })
-                    .collect();
-
-                if transactions_signatures.is_empty() {
-                    return Ok(());
-                }
-            }
-
-            if send_retries == 0 {
-                return Err(RpcError::ForUser("Transactions failed".to_string()).into());
-            }
-            send_retries -= 1;
-
-            // Re-sign any failed transactions with a new blockhash and retry
-            let (blockhash, _fee_calculator) =
-                self.get_new_blockhash(&transactions_signatures[0].0.message().recent_blockhash)?;
-            transactions = vec![];
-            for (mut transaction, _) in transactions_signatures.into_iter() {
-                transaction.try_sign(signer_keys, blockhash)?;
-                transactions.push(transaction);
-            }
-        }
-    }
-
-    pub fn resign_transaction<T: Signers>(
-        &self,
-        tx: &mut Transaction,
-        signer_keys: &T,
-    ) -> ClientResult<()> {
-        let (blockhash, _fee_calculator) =
-            self.get_new_blockhash(&tx.message().recent_blockhash)?;
-        tx.try_sign(signer_keys, blockhash)?;
-        Ok(())
-    }
-
     pub fn get_account(&self, pubkey: &Pubkey) -> ClientResult<Account> {
         self.get_account_with_commitment(pubkey, CommitmentConfig::default())?
             .value
@@ -515,9 +465,14 @@ impl RpcClient {
         pubkey: &Pubkey,
         commitment_config: CommitmentConfig,
     ) -> RpcResult<Option<Account>> {
+        let config = RpcAccountInfoConfig {
+            encoding: Some(UiAccountEncoding::Binary64),
+            commitment: Some(commitment_config),
+            data_slice: None,
+        };
         let response = self.sender.send(
             RpcRequest::GetAccountInfo,
-            json!([pubkey.to_string(), commitment_config]),
+            json!([pubkey.to_string(), config]),
         );
 
         response
@@ -529,10 +484,19 @@ impl RpcClient {
                 }
                 let Response {
                     context,
-                    value: rpc_account,
-                } = serde_json::from_value::<Response<Option<RpcAccount>>>(result_json)?;
+                    value: mut rpc_account,
+                } = serde_json::from_value::<Response<Option<UiAccount>>>(result_json)?;
+                if let Some(ref mut account) = rpc_account {
+                    if let Binary(_) = &account.data {
+                        let tmp = Binary64(String::new());
+                        match std::mem::replace(&mut account.data, tmp) {
+                            Binary(new_data) => account.data = Binary64(new_data),
+                            _ => panic!("should have gotten binary here."),
+                        }
+                    }
+                }
                 trace!("Response account {:?} {:?}", pubkey, rpc_account);
-                let account = rpc_account.and_then(|rpc_account| rpc_account.decode().ok());
+                let account = rpc_account.and_then(|rpc_account| rpc_account.decode());
                 Ok(Response {
                     context,
                     value: account,
@@ -588,17 +552,7 @@ impl RpcClient {
     pub fn get_program_accounts(&self, pubkey: &Pubkey) -> ClientResult<Vec<(Pubkey, Account)>> {
         let accounts: Vec<RpcKeyedAccount> =
             self.send(RpcRequest::GetProgramAccounts, json!([pubkey.to_string()]))?;
-        let mut pubkey_accounts: Vec<(Pubkey, Account)> = Vec::new();
-        for RpcKeyedAccount { pubkey, account } in accounts.into_iter() {
-            let pubkey = pubkey.parse().map_err(|_| {
-                ClientError::new_with_request(
-                    RpcError::ParseError("Pubkey".to_string()).into(),
-                    RpcRequest::GetProgramAccounts,
-                )
-            })?;
-            pubkey_accounts.push((pubkey, account.decode().unwrap()));
-        }
-        Ok(pubkey_accounts)
+        parse_keyed_accounts(accounts, RpcRequest::GetProgramAccounts)
     }
 
     /// Request the transaction count.
@@ -614,26 +568,46 @@ impl RpcClient {
     }
 
     pub fn get_recent_blockhash(&self) -> ClientResult<(Hash, FeeCalculator)> {
-        Ok(self
+        let (blockhash, fee_calculator, _last_valid_slot) = self
             .get_recent_blockhash_with_commitment(CommitmentConfig::default())?
-            .value)
+            .value;
+        Ok((blockhash, fee_calculator))
     }
 
     pub fn get_recent_blockhash_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
-    ) -> RpcResult<(Hash, FeeCalculator)> {
-        let Response {
+    ) -> RpcResult<(Hash, FeeCalculator, Slot)> {
+        let (context, blockhash, fee_calculator, last_valid_slot) = if let Ok(Response {
+            context,
+            value:
+                RpcFees {
+                    blockhash,
+                    fee_calculator,
+                    last_valid_slot,
+                },
+        }) =
+            self.send::<Response<RpcFees>>(RpcRequest::GetFees, json!([commitment_config]))
+        {
+            (context, blockhash, fee_calculator, last_valid_slot)
+        } else if let Ok(Response {
             context,
             value:
                 RpcBlockhashFeeCalculator {
                     blockhash,
                     fee_calculator,
                 },
-        } = self.send::<Response<RpcBlockhashFeeCalculator>>(
+        }) = self.send::<Response<RpcBlockhashFeeCalculator>>(
             RpcRequest::GetRecentBlockhash,
             json!([commitment_config]),
-        )?;
+        ) {
+            (context, blockhash, fee_calculator, 0)
+        } else {
+            return Err(ClientError::new_with_request(
+                RpcError::ParseError("RpcBlockhashFeeCalculator or RpcFees".to_string()).into(),
+                RpcRequest::GetRecentBlockhash,
+            ));
+        };
 
         let blockhash = blockhash.parse().map_err(|_| {
             ClientError::new_with_request(
@@ -643,7 +617,7 @@ impl RpcClient {
         })?;
         Ok(Response {
             context,
-            value: (blockhash, fee_calculator),
+            value: (blockhash, fee_calculator, last_valid_slot),
         })
     }
 
@@ -651,12 +625,28 @@ impl RpcClient {
         &self,
         blockhash: &Hash,
     ) -> ClientResult<Option<FeeCalculator>> {
-        let Response { value, .. } = self.send::<Response<Option<RpcFeeCalculator>>>(
+        Ok(self
+            .get_fee_calculator_for_blockhash_with_commitment(
+                blockhash,
+                CommitmentConfig::default(),
+            )?
+            .value)
+    }
+
+    pub fn get_fee_calculator_for_blockhash_with_commitment(
+        &self,
+        blockhash: &Hash,
+        commitment_config: CommitmentConfig,
+    ) -> RpcResult<Option<FeeCalculator>> {
+        let Response { context, value } = self.send::<Response<Option<RpcFeeCalculator>>>(
             RpcRequest::GetFeeCalculatorForBlockhash,
-            json!([blockhash.to_string()]),
+            json!([blockhash.to_string(), commitment_config]),
         )?;
 
-        Ok(value.map(|rf| rf.fee_calculator))
+        Ok(Response {
+            context,
+            value: value.map(|rf| rf.fee_calculator),
+        })
     }
 
     pub fn get_fee_rate_governor(&self) -> RpcResult<FeeRateGovernor> {
@@ -709,7 +699,119 @@ impl RpcClient {
         Ok(hash)
     }
 
-    pub fn poll_balance_with_timeout_and_commitment(
+    pub fn get_token_account_balance(&self, pubkey: &Pubkey) -> ClientResult<UiTokenAmount> {
+        Ok(self
+            .get_token_account_balance_with_commitment(pubkey, CommitmentConfig::default())?
+            .value)
+    }
+
+    pub fn get_token_account_balance_with_commitment(
+        &self,
+        pubkey: &Pubkey,
+        commitment_config: CommitmentConfig,
+    ) -> RpcResult<UiTokenAmount> {
+        self.send(
+            RpcRequest::GetTokenAccountBalance,
+            json!([pubkey.to_string(), commitment_config]),
+        )
+    }
+
+    pub fn get_token_accounts_by_delegate(
+        &self,
+        delegate: &Pubkey,
+        token_account_filter: TokenAccountsFilter,
+    ) -> ClientResult<Vec<RpcKeyedAccount>> {
+        Ok(self
+            .get_token_accounts_by_delegate_with_commitment(
+                delegate,
+                token_account_filter,
+                CommitmentConfig::default(),
+            )?
+            .value)
+    }
+
+    pub fn get_token_accounts_by_delegate_with_commitment(
+        &self,
+        delegate: &Pubkey,
+        token_account_filter: TokenAccountsFilter,
+        commitment_config: CommitmentConfig,
+    ) -> RpcResult<Vec<RpcKeyedAccount>> {
+        let token_account_filter = match token_account_filter {
+            TokenAccountsFilter::Mint(mint) => RpcTokenAccountsFilter::Mint(mint.to_string()),
+            TokenAccountsFilter::ProgramId(program_id) => {
+                RpcTokenAccountsFilter::ProgramId(program_id.to_string())
+            }
+        };
+
+        let config = RpcAccountInfoConfig {
+            encoding: Some(UiAccountEncoding::JsonParsed),
+            commitment: Some(commitment_config),
+            data_slice: None,
+        };
+
+        self.send(
+            RpcRequest::GetTokenAccountsByOwner,
+            json!([delegate.to_string(), token_account_filter, config]),
+        )
+    }
+
+    pub fn get_token_accounts_by_owner(
+        &self,
+        owner: &Pubkey,
+        token_account_filter: TokenAccountsFilter,
+    ) -> ClientResult<Vec<RpcKeyedAccount>> {
+        Ok(self
+            .get_token_accounts_by_owner_with_commitment(
+                owner,
+                token_account_filter,
+                CommitmentConfig::default(),
+            )?
+            .value)
+    }
+
+    pub fn get_token_accounts_by_owner_with_commitment(
+        &self,
+        owner: &Pubkey,
+        token_account_filter: TokenAccountsFilter,
+        commitment_config: CommitmentConfig,
+    ) -> RpcResult<Vec<RpcKeyedAccount>> {
+        let token_account_filter = match token_account_filter {
+            TokenAccountsFilter::Mint(mint) => RpcTokenAccountsFilter::Mint(mint.to_string()),
+            TokenAccountsFilter::ProgramId(program_id) => {
+                RpcTokenAccountsFilter::ProgramId(program_id.to_string())
+            }
+        };
+
+        let config = RpcAccountInfoConfig {
+            encoding: Some(UiAccountEncoding::JsonParsed),
+            commitment: Some(commitment_config),
+            data_slice: None,
+        };
+
+        self.send(
+            RpcRequest::GetTokenAccountsByOwner,
+            json!([owner.to_string(), token_account_filter, config]),
+        )
+    }
+
+    pub fn get_token_supply(&self, mint: &Pubkey) -> ClientResult<UiTokenAmount> {
+        Ok(self
+            .get_token_supply_with_commitment(mint, CommitmentConfig::default())?
+            .value)
+    }
+
+    pub fn get_token_supply_with_commitment(
+        &self,
+        mint: &Pubkey,
+        commitment_config: CommitmentConfig,
+    ) -> RpcResult<UiTokenAmount> {
+        self.send(
+            RpcRequest::GetTokenSupply,
+            json!([mint.to_string(), commitment_config]),
+        )
+    }
+
+    fn poll_balance_with_timeout_and_commitment(
         &self,
         pubkey: &Pubkey,
         polling_frequency: &Duration,
@@ -718,7 +820,7 @@ impl RpcClient {
     ) -> ClientResult<u64> {
         let now = Instant::now();
         loop {
-            match self.get_balance_with_commitment(&pubkey, commitment_config.clone()) {
+            match self.get_balance_with_commitment(&pubkey, commitment_config) {
                 Ok(bal) => {
                     return Ok(bal.value);
                 }
@@ -753,8 +855,7 @@ impl RpcClient {
     ) -> Option<u64> {
         const LAST: usize = 30;
         for run in 0..LAST {
-            let balance_result =
-                self.poll_get_balance_with_commitment(pubkey, commitment_config.clone());
+            let balance_result = self.poll_get_balance_with_commitment(pubkey, commitment_config);
             if expected_balance.is_none() {
                 return balance_result.ok();
             }
@@ -788,7 +889,7 @@ impl RpcClient {
         let now = Instant::now();
         loop {
             if let Ok(Some(_)) =
-                self.get_signature_status_with_commitment(&signature, commitment_config.clone())
+                self.get_signature_status_with_commitment(&signature, commitment_config)
             {
                 break;
             }
@@ -804,36 +905,6 @@ impl RpcClient {
         Ok(())
     }
 
-    /// Check a signature in the bank.
-    pub fn check_signature(&self, signature: &Signature) -> bool {
-        trace!("check_signature: {:?}", signature);
-
-        for _ in 0..30 {
-            let response =
-                self.confirm_transaction_with_commitment(signature, CommitmentConfig::recent());
-            match response {
-                Ok(Response {
-                    value: signature_status,
-                    ..
-                }) => {
-                    if signature_status {
-                        trace!("Response found signature");
-                    } else {
-                        trace!("Response signature not found");
-                    }
-
-                    return signature_status;
-                }
-                Err(err) => {
-                    debug!("check_signature request failed: {:?}", err);
-                }
-            };
-            sleep(Duration::from_millis(250));
-        }
-
-        panic!("Couldn't check signature of {}", signature);
-    }
-
     /// Poll the server to confirm a transaction.
     pub fn poll_for_signature_confirmation(
         &self,
@@ -914,6 +985,35 @@ impl RpcClient {
         &self,
         transaction: &Transaction,
     ) -> ClientResult<Signature> {
+        self.send_and_confirm_transaction_with_spinner_and_config(
+            transaction,
+            CommitmentConfig::default(),
+            RpcSendTransactionConfig::default(),
+        )
+    }
+
+    pub fn send_and_confirm_transaction_with_spinner_and_commitment(
+        &self,
+        transaction: &Transaction,
+        commitment: CommitmentConfig,
+    ) -> ClientResult<Signature> {
+        self.send_and_confirm_transaction_with_spinner_and_config(
+            transaction,
+            commitment,
+            RpcSendTransactionConfig::default(),
+        )
+    }
+
+    pub fn send_and_confirm_transaction_with_spinner_and_config(
+        &self,
+        transaction: &Transaction,
+        commitment: CommitmentConfig,
+        config: RpcSendTransactionConfig,
+    ) -> ClientResult<Signature> {
+        let desired_confirmations = match commitment.commitment {
+            CommitmentLevel::Max | CommitmentLevel::Root => MAX_LOCKOUT_HISTORY + 1,
+            _ => 1,
+        };
         let mut confirmations = 0;
 
         let progress_bar = new_spinner_progress_bar();
@@ -922,13 +1022,11 @@ impl RpcClient {
         let signature = loop {
             progress_bar.set_message(&format!(
                 "[{}/{}] Finalizing transaction {}",
-                confirmations,
-                MAX_LOCKOUT_HISTORY + 1,
-                transaction.signatures[0],
+                confirmations, desired_confirmations, transaction.signatures[0],
             ));
             let mut status_retries = 15;
             let (signature, status) = loop {
-                let signature = self.send_transaction(transaction)?;
+                let signature = self.send_transaction_with_config(transaction, config)?;
 
                 // Get recent commitment in order to count confirmations for successful transactions
                 let status = self
@@ -978,17 +1076,30 @@ impl RpcClient {
         };
         let now = Instant::now();
         loop {
-            // Return when default (max) commitment is reached
-            // Failed transactions have already been eliminated, `is_some` check is sufficient
-            if self.get_signature_status(&signature)?.is_some() {
-                progress_bar.set_message("Transaction confirmed");
-                progress_bar.finish_and_clear();
-                return Ok(signature);
+            match commitment.commitment {
+                CommitmentLevel::Max | CommitmentLevel::Root =>
+                // Return when default (max) commitment is reached
+                // Failed transactions have already been eliminated, `is_some` check is sufficient
+                {
+                    if self.get_signature_status(&signature)?.is_some() {
+                        progress_bar.set_message("Transaction confirmed");
+                        progress_bar.finish_and_clear();
+                        return Ok(signature);
+                    }
+                }
+                _ => {
+                    // Return when one confirmation has been reached
+                    if confirmations >= desired_confirmations {
+                        progress_bar.set_message("Transaction reached commitment");
+                        progress_bar.finish_and_clear();
+                        return Ok(signature);
+                    }
+                }
             }
             progress_bar.set_message(&format!(
                 "[{}/{}] Finalizing transaction {}",
                 confirmations + 1,
-                MAX_LOCKOUT_HISTORY + 1,
+                desired_confirmations,
                 signature,
             ));
             sleep(Duration::from_millis(500));
@@ -1039,6 +1150,31 @@ pub fn get_rpc_request_str(rpc_addr: SocketAddr, tls: bool) -> String {
     }
 }
 
+fn parse_keyed_accounts(
+    accounts: Vec<RpcKeyedAccount>,
+    request: RpcRequest,
+) -> ClientResult<Vec<(Pubkey, Account)>> {
+    let mut pubkey_accounts: Vec<(Pubkey, Account)> = Vec::new();
+    for RpcKeyedAccount { pubkey, account } in accounts.into_iter() {
+        let pubkey = pubkey.parse().map_err(|_| {
+            ClientError::new_with_request(
+                RpcError::ParseError("Pubkey".to_string()).into(),
+                request,
+            )
+        })?;
+        pubkey_accounts.push((
+            pubkey,
+            account.decode().ok_or_else(|| {
+                ClientError::new_with_request(
+                    RpcError::ParseError("Account from rpc".to_string()).into(),
+                    request,
+                )
+            })?,
+        ));
+    }
+    Ok(pubkey_accounts)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1192,28 +1328,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_resign_transaction() {
-        let rpc_client = RpcClient::new_mock("succeeds".to_string());
-
-        let key = Keypair::new();
-        let to = Pubkey::new_rand();
-        let blockhash: Hash = "HUu3LwEzGRsUkuJS121jzkPJW39Kq62pXCTmTa1F9jDL"
-            .parse()
-            .unwrap();
-        let prev_tx = system_transaction::transfer(&key, &to, 50, blockhash);
-        let mut tx = system_transaction::transfer(&key, &to, 50, blockhash);
-
-        rpc_client.resign_transaction(&mut tx, &[&key]).unwrap();
-
-        assert_ne!(prev_tx, tx);
-        assert_ne!(prev_tx.signatures, tx.signatures);
-        assert_ne!(
-            prev_tx.message().recent_blockhash,
-            tx.message().recent_blockhash
-        );
-    }
-
     #[test]
     fn test_rpc_client_thread() {
         let rpc_client = RpcClient::new_mock("succeeds".to_string());

client/src/rpc_config.rs

@@ -1,4 +1,6 @@
-use solana_sdk::commitment_config::CommitmentConfig;
+use crate::rpc_filter::RpcFilterType;
+use solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig};
+use solana_sdk::{clock::Epoch, commitment_config::CommitmentConfig};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -6,7 +8,13 @@ pub struct RpcSignatureStatusConfig {
     pub search_transaction_history: bool,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcSendTransactionConfig {
+    pub skip_preflight: bool,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcSimulateTransactionConfig {
     pub sig_verify: bool,
@@ -26,3 +34,42 @@ pub struct RpcLargestAccountsConfig {
     pub commitment: Option<CommitmentConfig>,
     pub filter: Option<RpcLargestAccountsFilter>,
 }
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcStakeConfig {
+    pub epoch: Option<Epoch>,
+    #[serde(flatten)]
+    pub commitment: Option<CommitmentConfig>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcAccountInfoConfig {
+    pub encoding: Option<UiAccountEncoding>,
+    pub data_slice: Option<UiDataSliceConfig>,
+    #[serde(flatten)]
+    pub commitment: Option<CommitmentConfig>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcProgramAccountsConfig {
+    pub filters: Option<Vec<RpcFilterType>>,
+    #[serde(flatten)]
+    pub account_config: RpcAccountInfoConfig,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum RpcTokenAccountsFilter {
+    Mint(String),
+    ProgramId(String),
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcGetConfirmedSignaturesForAddress2Config {
+    pub before: Option<String>, // Signature as base-58 string
+    pub limit: Option<usize>,
+}

client/src/rpc_filter.rs

@@ -0,0 +1,143 @@
+use thiserror::Error;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum RpcFilterType {
+    DataSize(u64),
+    Memcmp(Memcmp),
+}
+
+impl RpcFilterType {
+    pub fn verify(&self) -> Result<(), RpcFilterError> {
+        match self {
+            RpcFilterType::DataSize(_) => Ok(()),
+            RpcFilterType::Memcmp(compare) => {
+                let encoding = compare.encoding.as_ref().unwrap_or(&MemcmpEncoding::Binary);
+                match encoding {
+                    MemcmpEncoding::Binary => {
+                        let MemcmpEncodedBytes::Binary(bytes) = &compare.bytes;
+                        bs58::decode(&bytes)
+                            .into_vec()
+                            .map(|_| ())
+                            .map_err(|e| e.into())
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum RpcFilterError {
+    #[error("bs58 decode error")]
+    DecodeError(#[from] bs58::decode::Error),
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum MemcmpEncoding {
+    Binary,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum MemcmpEncodedBytes {
+    Binary(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Memcmp {
+    /// Data offset to begin match
+    pub offset: usize,
+    /// Bytes, encoded with specified encoding, or default Binary
+    pub bytes: MemcmpEncodedBytes,
+    /// Optional encoding specification
+    pub encoding: Option<MemcmpEncoding>,
+}
+
+impl Memcmp {
+    pub fn bytes_match(&self, data: &[u8]) -> bool {
+        match &self.bytes {
+            MemcmpEncodedBytes::Binary(bytes) => {
+                let bytes = bs58::decode(bytes).into_vec();
+                if bytes.is_err() {
+                    return false;
+                }
+                let bytes = bytes.unwrap();
+                if self.offset > data.len() {
+                    return false;
+                }
+                if data[self.offset..].len() < bytes.len() {
+                    return false;
+                }
+                data[self.offset..self.offset + bytes.len()] == bytes[..]
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bytes_match() {
+        let data = vec![1, 2, 3, 4, 5];
+
+        // Exact match of data succeeds
+        assert!(Memcmp {
+            offset: 0,
+            bytes: MemcmpEncodedBytes::Binary(bs58::encode(vec![1, 2, 3, 4, 5]).into_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+
+        // Partial match of data succeeds
+        assert!(Memcmp {
+            offset: 0,
+            bytes: MemcmpEncodedBytes::Binary(bs58::encode(vec![1, 2]).into_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+
+        // Offset partial match of data succeeds
+        assert!(Memcmp {
+            offset: 2,
+            bytes: MemcmpEncodedBytes::Binary(bs58::encode(vec![3, 4]).into_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+
+        // Incorrect partial match of data fails
+        assert!(!Memcmp {
+            offset: 0,
+            bytes: MemcmpEncodedBytes::Binary(bs58::encode(vec![2]).into_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+
+        // Bytes overrun data fails
+        assert!(!Memcmp {
+            offset: 2,
+            bytes: MemcmpEncodedBytes::Binary(bs58::encode(vec![3, 4, 5, 6]).into_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+
+        // Offset outside data fails
+        assert!(!Memcmp {
+            offset: 6,
+            bytes: MemcmpEncodedBytes::Binary(bs58::encode(vec![5]).into_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+
+        // Invalid base-58 fails
+        assert!(!Memcmp {
+            offset: 0,
+            bytes: MemcmpEncodedBytes::Binary("III".to_string()),
+            encoding: None,
+        }
+        .bytes_match(&data));
+    }
+}

client/src/rpc_request.rs

@@ -1,4 +1,5 @@
 use serde_json::{json, Value};
+use solana_sdk::pubkey::Pubkey;
 use std::fmt;
 use thiserror::Error;
 
@@ -13,18 +14,22 @@ pub enum RpcRequest {
     GetConfirmedBlock,
     GetConfirmedBlocks,
     GetConfirmedSignaturesForAddress,
+    GetConfirmedSignaturesForAddress2,
     GetConfirmedTransaction,
     GetEpochInfo,
     GetEpochSchedule,
-    GetGenesisHash,
-    GetIdentity,
-    GetInflation,
-    GetLargestAccounts,
-    GetLeaderSchedule,
-    GetProgramAccounts,
-    GetRecentBlockhash,
     GetFeeCalculatorForBlockhash,
     GetFeeRateGovernor,
+    GetFees,
+    GetGenesisHash,
+    GetIdentity,
+    GetInflationGovernor,
+    GetInflationRate,
+    GetLargestAccounts,
+    GetLeaderSchedule,
+    GetMinimumBalanceForRentExemption,
+    GetProgramAccounts,
+    GetRecentBlockhash,
     GetSignatureStatuses,
     GetSlot,
     GetSlotLeader,
@@ -33,17 +38,20 @@ pub enum RpcRequest {
     GetSlotsPerSegment,
     GetStoragePubkeysForSlot,
     GetSupply,
+    GetTokenAccountBalance,
+    GetTokenAccountsByDelegate,
+    GetTokenAccountsByOwner,
+    GetTokenSupply,
     GetTotalSupply,
     GetTransactionCount,
     GetVersion,
     GetVoteAccounts,
+    MinimumLedgerSlot,
     RegisterNode,
     RequestAirdrop,
     SendTransaction,
     SimulateTransaction,
     SignVote,
-    GetMinimumBalanceForRentExemption,
-    MinimumLedgerSlot,
 }
 
 impl fmt::Display for RpcRequest {
@@ -58,18 +66,22 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetConfirmedBlock => "getConfirmedBlock",
             RpcRequest::GetConfirmedBlocks => "getConfirmedBlocks",
             RpcRequest::GetConfirmedSignaturesForAddress => "getConfirmedSignaturesForAddress",
+            RpcRequest::GetConfirmedSignaturesForAddress2 => "getConfirmedSignaturesForAddress2",
             RpcRequest::GetConfirmedTransaction => "getConfirmedTransaction",
             RpcRequest::GetEpochInfo => "getEpochInfo",
             RpcRequest::GetEpochSchedule => "getEpochSchedule",
-            RpcRequest::GetGenesisHash => "getGenesisHash",
-            RpcRequest::GetIdentity => "getIdentity",
-            RpcRequest::GetInflation => "getInflation",
-            RpcRequest::GetLargestAccounts => "getLargestAccounts",
-            RpcRequest::GetLeaderSchedule => "getLeaderSchedule",
-            RpcRequest::GetProgramAccounts => "getProgramAccounts",
-            RpcRequest::GetRecentBlockhash => "getRecentBlockhash",
             RpcRequest::GetFeeCalculatorForBlockhash => "getFeeCalculatorForBlockhash",
             RpcRequest::GetFeeRateGovernor => "getFeeRateGovernor",
+            RpcRequest::GetFees => "getFees",
+            RpcRequest::GetGenesisHash => "getGenesisHash",
+            RpcRequest::GetIdentity => "getIdentity",
+            RpcRequest::GetInflationGovernor => "getInflationGovernor",
+            RpcRequest::GetInflationRate => "getInflationRate",
+            RpcRequest::GetLargestAccounts => "getLargestAccounts",
+            RpcRequest::GetLeaderSchedule => "getLeaderSchedule",
+            RpcRequest::GetMinimumBalanceForRentExemption => "getMinimumBalanceForRentExemption",
+            RpcRequest::GetProgramAccounts => "getProgramAccounts",
+            RpcRequest::GetRecentBlockhash => "getRecentBlockhash",
             RpcRequest::GetSignatureStatuses => "getSignatureStatuses",
             RpcRequest::GetSlot => "getSlot",
             RpcRequest::GetSlotLeader => "getSlotLeader",
@@ -78,17 +90,20 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetSlotsPerSegment => "getSlotsPerSegment",
             RpcRequest::GetStoragePubkeysForSlot => "getStoragePubkeysForSlot",
             RpcRequest::GetSupply => "getSupply",
+            RpcRequest::GetTokenAccountBalance => "getTokenAccountBalance",
+            RpcRequest::GetTokenAccountsByDelegate => "getTokenAccountsByDelegate",
+            RpcRequest::GetTokenAccountsByOwner => "getTokenAccountsByOwner",
+            RpcRequest::GetTokenSupply => "getTokenSupply",
             RpcRequest::GetTotalSupply => "getTotalSupply",
             RpcRequest::GetTransactionCount => "getTransactionCount",
             RpcRequest::GetVersion => "getVersion",
             RpcRequest::GetVoteAccounts => "getVoteAccounts",
+            RpcRequest::MinimumLedgerSlot => "minimumLedgerSlot",
             RpcRequest::RegisterNode => "registerNode",
             RpcRequest::RequestAirdrop => "requestAirdrop",
             RpcRequest::SendTransaction => "sendTransaction",
             RpcRequest::SimulateTransaction => "simulateTransaction",
             RpcRequest::SignVote => "signVote",
-            RpcRequest::GetMinimumBalanceForRentExemption => "getMinimumBalanceForRentExemption",
-            RpcRequest::MinimumLedgerSlot => "minimumLedgerSlot",
         };
 
         write!(f, "{}", method)
@@ -98,6 +113,11 @@ impl fmt::Display for RpcRequest {
 pub const NUM_LARGEST_ACCOUNTS: usize = 20;
 pub const MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS: usize = 256;
 pub const MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS_SLOT_RANGE: u64 = 10_000;
+pub const MAX_GET_CONFIRMED_BLOCKS_RANGE: u64 = 500_000;
+pub const MAX_GET_CONFIRMED_SIGNATURES_FOR_ADDRESS2_LIMIT: usize = 1_000;
+
+// Validators that are this number of slots behind are considered delinquent
+pub const DELINQUENT_VALIDATOR_SLOT_DISTANCE: u64 = 128;
 
 impl RpcRequest {
     pub(crate) fn build_request_json(self, id: u64, params: Value) -> Value {
@@ -123,31 +143,34 @@ pub enum RpcError {
     ForUser(String), /* "direct-to-user message" */
 }
 
+#[derive(Serialize, Deserialize)]
+pub enum TokenAccountsFilter {
+    Mint(Pubkey),
+    ProgramId(Pubkey),
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::rpc_config::RpcTokenAccountsFilter;
     use solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel};
 
     #[test]
     fn test_build_request_json() {
         let test_request = RpcRequest::GetAccountInfo;
         let addr = json!("deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx");
-        let request = test_request.build_request_json(1, json!([addr.clone()]));
+        let request = test_request.build_request_json(1, json!([addr]));
         assert_eq!(request["method"], "getAccountInfo");
         assert_eq!(request["params"], json!([addr]));
 
         let test_request = RpcRequest::GetBalance;
-        let request = test_request.build_request_json(1, json!([addr.clone()]));
+        let request = test_request.build_request_json(1, json!([addr]));
         assert_eq!(request["method"], "getBalance");
 
         let test_request = RpcRequest::GetEpochInfo;
         let request = test_request.build_request_json(1, Value::Null);
         assert_eq!(request["method"], "getEpochInfo");
 
-        let test_request = RpcRequest::GetInflation;
-        let request = test_request.build_request_json(1, Value::Null);
-        assert_eq!(request["method"], "getInflation");
-
         let test_request = RpcRequest::GetRecentBlockhash;
         let request = test_request.build_request_json(1, Value::Null);
         assert_eq!(request["method"], "getRecentBlockhash");
@@ -186,13 +209,23 @@ mod tests {
 
         // Test request with CommitmentConfig and no params
         let test_request = RpcRequest::GetRecentBlockhash;
-        let request = test_request.build_request_json(1, json!([commitment_config.clone()]));
+        let request = test_request.build_request_json(1, json!([commitment_config]));
         assert_eq!(request["params"], json!([commitment_config.clone()]));
 
         // Test request with CommitmentConfig and params
         let test_request = RpcRequest::GetBalance;
-        let request =
-            test_request.build_request_json(1, json!([addr.clone(), commitment_config.clone()]));
+        let request = test_request.build_request_json(1, json!([addr, commitment_config]));
         assert_eq!(request["params"], json!([addr, commitment_config]));
+
+        // Test request with CommitmentConfig and params
+        let test_request = RpcRequest::GetTokenAccountsByOwner;
+        let mint = Pubkey::new_rand();
+        let token_account_filter = RpcTokenAccountsFilter::Mint(mint.to_string());
+        let request = test_request
+            .build_request_json(1, json!([addr, token_account_filter, commitment_config]));
+        assert_eq!(
+            request["params"],
+            json!([addr, token_account_filter, commitment_config])
+        );
     }
 }

client/src/rpc_response.rs

@@ -1,12 +1,13 @@
-use crate::{client_error, rpc_request::RpcError};
+use crate::client_error;
+use solana_account_decoder::{parse_token::UiTokenAmount, UiAccount};
 use solana_sdk::{
-    account::Account,
     clock::{Epoch, Slot},
     fee_calculator::{FeeCalculator, FeeRateGovernor},
-    pubkey::Pubkey,
+    inflation::Inflation,
     transaction::{Result, TransactionError},
 };
-use std::{collections::HashMap, net::SocketAddr, str::FromStr};
+use solana_transaction_status::ConfirmedTransactionStatusWithSignature;
+use std::{collections::HashMap, net::SocketAddr};
 
 pub type RpcResult<T> = client_error::Result<Response<T>>;
 
@@ -35,6 +36,14 @@ pub struct RpcBlockhashFeeCalculator {
     pub fee_calculator: FeeCalculator,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcFees {
+    pub blockhash: String,
+    pub fee_calculator: FeeCalculator,
+    pub last_valid_slot: Slot,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcFeeCalculator {
@@ -47,11 +56,42 @@ pub struct RpcFeeRateGovernor {
     pub fee_rate_governor: FeeRateGovernor,
 }
 
+#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcInflationGovernor {
+    pub initial: f64,
+    pub terminal: f64,
+    pub taper: f64,
+    pub foundation: f64,
+    pub foundation_term: f64,
+}
+
+impl From<Inflation> for RpcInflationGovernor {
+    fn from(inflation: Inflation) -> Self {
+        Self {
+            initial: inflation.initial,
+            terminal: inflation.terminal,
+            taper: inflation.taper,
+            foundation: inflation.foundation,
+            foundation_term: inflation.foundation_term,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcInflationRate {
+    pub total: f64,
+    pub validator: f64,
+    pub foundation: f64,
+    pub epoch: Epoch,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcKeyedAccount {
     pub pubkey: String,
-    pub account: RpcAccount,
+    pub account: UiAccount,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -60,43 +100,6 @@ pub struct RpcSignatureResult {
     pub err: Option<TransactionError>,
 }
 
-/// A duplicate representation of a Message for pretty JSON serialization
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct RpcAccount {
-    pub lamports: u64,
-    pub data: String,
-    pub owner: String,
-    pub executable: bool,
-    pub rent_epoch: Epoch,
-}
-
-impl RpcAccount {
-    pub fn encode(account: Account) -> Self {
-        RpcAccount {
-            lamports: account.lamports,
-            data: bs58::encode(account.data.clone()).into_string(),
-            owner: account.owner.to_string(),
-            executable: account.executable,
-            rent_epoch: account.rent_epoch,
-        }
-    }
-
-    pub fn decode(&self) -> std::result::Result<Account, RpcError> {
-        Ok(Account {
-            lamports: self.lamports,
-            data: bs58::decode(self.data.clone()).into_vec().map_err(|_| {
-                RpcError::RpcRequestError("Could not parse encoded account data".to_string())
-            })?,
-            owner: Pubkey::from_str(&self.owner).map_err(|_| {
-                RpcError::RpcRequestError("Could not parse encoded account owner".to_string())
-            })?,
-            executable: self.executable,
-            rent_epoch: self.rent_epoch,
-        })
-    }
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct RpcContactInfo {
     /// Pubkey of the node as a base-58 string
@@ -171,6 +174,13 @@ pub struct RpcSignatureConfirmation {
     pub status: Result<()>,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcSimulateTransactionResult {
+    pub err: Option<TransactionError>,
+    pub logs: Option<Vec<String>>,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcStorageTurn {
@@ -193,3 +203,54 @@ pub struct RpcSupply {
     pub non_circulating: u64,
     pub non_circulating_accounts: Vec<String>,
 }
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub enum StakeActivationState {
+    Activating,
+    Active,
+    Deactivating,
+    Inactive,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcStakeActivation {
+    pub state: StakeActivationState,
+    pub active: u64,
+    pub inactive: u64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcTokenAccountBalance {
+    pub address: String,
+    #[serde(flatten)]
+    pub amount: UiTokenAmount,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcConfirmedTransactionStatusWithSignature {
+    pub signature: String,
+    pub slot: Slot,
+    pub err: Option<TransactionError>,
+    pub memo: Option<String>,
+}
+
+impl From<ConfirmedTransactionStatusWithSignature> for RpcConfirmedTransactionStatusWithSignature {
+    fn from(value: ConfirmedTransactionStatusWithSignature) -> Self {
+        let ConfirmedTransactionStatusWithSignature {
+            signature,
+            slot,
+            err,
+            memo,
+        } = value;
+        Self {
+            signature: signature.to_string(),
+            slot,
+            err,
+            memo,
+        }
+    }
+}

client/src/thin_client.rs

@@ -9,7 +9,7 @@ use log::*;
 use solana_sdk::{
     account::Account,
     client::{AsyncClient, Client, SyncClient},
-    clock::MAX_PROCESSING_AGE,
+    clock::{Slot, MAX_PROCESSING_AGE},
     commitment_config::CommitmentConfig,
     epoch_info::EpochInfo,
     fee_calculator::{FeeCalculator, FeeRateGovernor},
@@ -254,37 +254,6 @@ impl ThinClient {
         .into())
     }
 
-    pub fn poll_balance_with_timeout_and_commitment(
-        &self,
-        pubkey: &Pubkey,
-        polling_frequency: &Duration,
-        timeout: &Duration,
-        commitment_config: CommitmentConfig,
-    ) -> TransportResult<u64> {
-        self.rpc_client()
-            .poll_balance_with_timeout_and_commitment(
-                pubkey,
-                polling_frequency,
-                timeout,
-                commitment_config,
-            )
-            .map_err(|e| e.into())
-    }
-
-    pub fn poll_balance_with_timeout(
-        &self,
-        pubkey: &Pubkey,
-        polling_frequency: &Duration,
-        timeout: &Duration,
-    ) -> TransportResult<u64> {
-        self.poll_balance_with_timeout_and_commitment(
-            pubkey,
-            polling_frequency,
-            timeout,
-            CommitmentConfig::default(),
-        )
-    }
-
     pub fn poll_get_balance(&self, pubkey: &Pubkey) -> TransportResult<u64> {
         self.poll_get_balance_with_commitment(pubkey, CommitmentConfig::default())
     }
@@ -330,12 +299,6 @@ impl ThinClient {
             .map_err(|e| e.into())
     }
 
-    /// Check a signature in the bank. This method blocks
-    /// until the server sends a response.
-    pub fn check_signature(&self, signature: &Signature) -> bool {
-        self.rpc_client().check_signature(signature)
-    }
-
     pub fn validator_exit(&self) -> TransportResult<bool> {
         self.rpc_client().validator_exit().map_err(|e| e.into())
     }
@@ -357,7 +320,7 @@ impl Client for ThinClient {
 }
 
 impl SyncClient for ThinClient {
-    fn send_message<T: Signers>(
+    fn send_and_confirm_message<T: Signers>(
         &self,
         keypairs: &T,
         message: Message,
@@ -368,16 +331,16 @@ impl SyncClient for ThinClient {
         Ok(signature)
     }
 
-    fn send_instruction(
+    fn send_and_confirm_instruction(
         &self,
         keypair: &Keypair,
         instruction: Instruction,
     ) -> TransportResult<Signature> {
-        let message = Message::new(&[instruction]);
-        self.send_message(&[keypair], message)
+        let message = Message::new(&[instruction], Some(&keypair.pubkey()));
+        self.send_and_confirm_message(&[keypair], message)
     }
 
-    fn transfer(
+    fn transfer_and_confirm(
         &self,
         lamports: u64,
         keypair: &Keypair,
@@ -385,7 +348,7 @@ impl SyncClient for ThinClient {
     ) -> TransportResult<Signature> {
         let transfer_instruction =
             system_instruction::transfer(&keypair.pubkey(), pubkey, lamports);
-        self.send_instruction(keypair, transfer_instruction)
+        self.send_and_confirm_instruction(keypair, transfer_instruction)
     }
 
     fn get_account_data(&self, pubkey: &Pubkey) -> TransportResult<Option<Vec<u8>>> {
@@ -427,13 +390,15 @@ impl SyncClient for ThinClient {
     }
 
     fn get_recent_blockhash(&self) -> TransportResult<(Hash, FeeCalculator)> {
-        self.get_recent_blockhash_with_commitment(CommitmentConfig::default())
+        let (blockhash, fee_calculator, _last_valid_slot) =
+            self.get_recent_blockhash_with_commitment(CommitmentConfig::default())?;
+        Ok((blockhash, fee_calculator))
     }
 
     fn get_recent_blockhash_with_commitment(
         &self,
         commitment_config: CommitmentConfig,
-    ) -> TransportResult<(Hash, FeeCalculator)> {
+    ) -> TransportResult<(Hash, FeeCalculator, Slot)> {
         let index = self.optimizer.experiment();
         let now = Instant::now();
         let recent_blockhash =
@@ -441,7 +406,7 @@ impl SyncClient for ThinClient {
         match recent_blockhash {
             Ok(Response { value, .. }) => {
                 self.optimizer.report(index, duration_as_ms(&now.elapsed()));
-                Ok(value)
+                Ok((value.0, value.1, value.2))
             }
             Err(e) => {
                 self.optimizer.report(index, std::u64::MAX);
@@ -609,7 +574,7 @@ impl AsyncClient for ThinClient {
         instruction: Instruction,
         recent_blockhash: Hash,
     ) -> TransportResult<Signature> {
-        let message = Message::new(&[instruction]);
+        let message = Message::new(&[instruction], Some(&keypair.pubkey()));
         self.async_send_message(&[keypair], message, recent_blockhash)
     }
     fn async_transfer(

core/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "solana-core"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.0"
+version = "1.3.2"
 documentation = "https://docs.rs/solana"
 homepage = "https://solana.com/"
 readme = "../README.md"
 repository = "https://github.com/solana-labs/solana"
-authors = ["Solana Maintainers <maintainers@solana.com>"]
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 license = "Apache-2.0"
 edition = "2018"
 
@@ -14,71 +14,81 @@ edition = "2018"
 codecov = { repository = "solana-labs/solana", branch = "master", service = "github" }
 
 [dependencies]
-bincode = "1.2.1"
+bincode = "1.3.1"
 bv = { version = "0.11.1", features = ["serde"] }
 bs58 = "0.3.1"
 byteorder = "1.3.4"
 chrono = { version = "0.4.11", features = ["serde"] }
 core_affinity = "0.5.10"
 crossbeam-channel = "0.4"
+ed25519-dalek = "=1.0.0-pre.4"
 fs_extra = "1.1.0"
 flate2 = "1.0"
-indexmap = "1.3"
+indexmap = "1.4"
 itertools = "0.9.0"
-jsonrpc-core = "14.1.0"
-jsonrpc-core-client = { version = "14.1.0", features = ["ws"] }
-jsonrpc-derive = "14.1.0"
-jsonrpc-http-server = "14.1.0"
-jsonrpc-pubsub = "14.1.0"
-jsonrpc-ws-server = "14.1.0"
+jsonrpc-core = "14.2.0"
+jsonrpc-core-client = { version = "14.2.0", features = ["ws"] }
+jsonrpc-derive = "14.2.1"
+jsonrpc-http-server = "14.2.0"
+jsonrpc-pubsub = "14.2.0"
+jsonrpc-ws-server = "14.2.0"
 log = "0.4.8"
 num_cpus = "1.13.0"
 num-traits = "0.2"
 rand = "0.7.0"
 rand_chacha = "0.2.2"
-rayon = "1.3.0"
-regex = "1.3.7"
-serde = "1.0.110"
+raptorq = "1.4.2"
+rayon = "1.3.1"
+regex = "1.3.9"
+serde = "1.0.112"
 serde_derive = "1.0.103"
-serde_json = "1.0.53"
-solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.2.0" }
-solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.0" }
-solana-client = { path = "../client", version = "1.2.0" }
-solana-transaction-status = { path = "../transaction-status", version = "1.2.0" }
-solana-faucet = { path = "../faucet", version = "1.2.0" }
-ed25519-dalek = "=1.0.0-pre.3"
-solana-ledger = { path = "../ledger", version = "1.2.0" }
-solana-logger = { path = "../logger", version = "1.2.0" }
-solana-merkle-tree = { path = "../merkle-tree", version = "1.2.0" }
-solana-metrics = { path = "../metrics", version = "1.2.0" }
-solana-measure = { path = "../measure", version = "1.2.0" }
-solana-net-utils = { path = "../net-utils", version = "1.2.0" }
-solana-perf = { path = "../perf", version = "1.2.0" }
-solana-runtime = { path = "../runtime", version = "1.2.0" }
-solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.0" }
-solana-streamer = { path = "../streamer", version = "1.2.0" }
-solana-version = { path = "../version", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
-solana-vote-signer = { path = "../vote-signer", version = "1.2.0" }
-solana-sys-tuner = { path = "../sys-tuner", version = "1.2.0" }
+serde_json = "1.0.56"
+solana-account-decoder = { path = "../account-decoder", version = "1.3.2" }
+solana-bpf-loader-program = { path = "../programs/bpf_loader", 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-client = { path = "../client", version = "1.3.2" }
+solana-faucet = { path = "../faucet", version = "1.3.2" }
+solana-genesis-programs = { path = "../genesis-programs", version = "1.3.2" }
+solana-ledger = { path = "../ledger", version = "1.3.2" }
+solana-logger = { path = "../logger", version = "1.3.2" }
+solana-merkle-tree = { path = "../merkle-tree", 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-perf = { path = "../perf", version = "1.3.2" }
+solana-runtime = { path = "../runtime", version = "1.3.2" }
+solana-sdk = { path = "../sdk", version = "1.3.2" }
+solana-sdk-macro-frozen-abi = { path = "../sdk/macro-frozen-abi", version = "1.3.2" }
+solana-stake-program = { path = "../programs/stake", version = "1.3.2" }
+solana-storage-bigtable = { path = "../storage-bigtable", version = "1.3.2" }
+solana-streamer = { path = "../streamer", version = "1.3.2" }
+solana-sys-tuner = { path = "../sys-tuner", 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" }
+spl-token-v1-0 = { package = "spl-token", version = "1.0.6", features = ["skip-no-mangle"] }
 tempfile = "3.1.0"
 thiserror = "1.0"
-tokio = "0.1"
-tokio-codec = "0.1"
-tokio-fs = "0.1"
-tokio-io = "0.1"
-solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.2.0" }
+tokio_01 = { version = "0.1", package = "tokio" }
+tokio_fs_01 = { version = "0.1", package = "tokio-fs" }
+tokio_io_01 = { version = "0.1", package = "tokio-io" }
+solana-rayon-threadlimit = { path = "../rayon-threadlimit", version = "1.3.2" }
+tokio = { version = "0.2.22", features = ["full"] }
 trees = "0.2.1"
 
 [dev-dependencies]
+base64 = "0.12.3"
 matches = "0.1.6"
-reqwest = { version = "0.10.4", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+reqwest = { version = "0.10.6", default-features = false, features = ["blocking", "rustls-tls", "json"] }
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"
 systemstat = "0.1.5"
 
+[build-dependencies]
+rustc_version = "0.2"
+
 [[bench]]
 name = "banking_stage"
 

core/benches/banking_stage.rs

@@ -19,6 +19,7 @@ use solana_perf::test_tx::test_tx;
 use solana_runtime::bank::Bank;
 use solana_sdk::genesis_config::GenesisConfig;
 use solana_sdk::hash::Hash;
+use solana_sdk::message::Message;
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::signature::Keypair;
 use solana_sdk::signature::Signature;
@@ -72,6 +73,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
             let batch_len = batch.packets.len();
             packets.push((batch, vec![0usize; batch_len]));
         }
+        let (s, _r) = unbounded();
         // This tests the performance of buffering packets.
         // If the packet buffers are copied, performance will be poor.
         bencher.iter(move || {
@@ -81,6 +83,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
                 &mut packets,
                 10_000,
                 None,
+                &s,
             );
         });
 
@@ -109,7 +112,6 @@ fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Tra
 fn make_programs_txs(txes: usize, hash: Hash) -> Vec<Transaction> {
     let progs = 4;
     (0..txes)
-        .into_iter()
         .map(|_| {
             let mut instructions = vec![];
             let from_key = Keypair::new();
@@ -117,9 +119,8 @@ fn make_programs_txs(txes: usize, hash: Hash) -> Vec<Transaction> {
                 let to_key = Pubkey::new_rand();
                 instructions.push(system_instruction::transfer(&from_key.pubkey(), &to_key, 1));
             }
-            let mut new = Transaction::new_unsigned_instructions(&instructions);
-            new.sign(&[&from_key], hash);
-            new
+            let message = Message::new(&instructions, Some(&from_key.pubkey()));
+            Transaction::new(&[&from_key], message, hash)
         })
         .collect()
 }
@@ -181,7 +182,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
         assert!(r.is_ok(), "sanity parallel execution");
     }
     bank.clear_signatures();
-    let verified: Vec<_> = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
+    let verified: Vec<_> = to_packets_chunked(&transactions, PACKETS_PER_BATCH);
     let ledger_path = get_tmp_ledger_path!();
     {
         let blockstore = Arc::new(
@@ -191,12 +192,14 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
             create_test_recorder(&bank, &blockstore, None);
         let cluster_info = ClusterInfo::new_with_invalid_keypair(Node::new_localhost().info);
         let cluster_info = Arc::new(cluster_info);
+        let (s, _r) = unbounded();
         let _banking_stage = BankingStage::new(
             &cluster_info,
             &poh_recorder,
             verified_receiver,
             vote_receiver,
             None,
+            s,
         );
         poh_recorder.lock().unwrap().set_bank(&bank);
 
@@ -207,7 +210,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
         // If it is dropped before poh_service, then poh_service will error when
         // calling send() on the channel.
         let signal_receiver = Arc::new(signal_receiver);
-        let signal_receiver2 = signal_receiver.clone();
+        let signal_receiver2 = signal_receiver;
         bencher.iter(move || {
             let now = Instant::now();
             let mut sent = 0;
@@ -262,7 +265,7 @@ fn simulate_process_entries(
     mint_keypair: &Keypair,
     mut tx_vector: Vec<Transaction>,
     genesis_config: &GenesisConfig,
-    keypairs: &Vec<Keypair>,
+    keypairs: &[Keypair],
     initial_lamports: u64,
     num_accounts: usize,
 ) {
@@ -288,7 +291,7 @@ fn simulate_process_entries(
         hash: next_hash(&bank.last_blockhash(), 1, &tx_vector),
         transactions: tx_vector,
     };
-    process_entries(&bank, &vec![entry], randomize_txs, None).unwrap();
+    process_entries(&bank, &[entry], randomize_txs, None, None).unwrap();
 }
 
 fn bench_process_entries(randomize_txs: bool, bencher: &mut Bencher) {

core/benches/blockstore.rs

@@ -1,6 +1,4 @@
 #![feature(test)]
-use rand;
-
 extern crate solana_ledger;
 extern crate test;
 

core/benches/cluster_info.rs

@@ -3,6 +3,7 @@
 extern crate test;
 
 use rand::{thread_rng, Rng};
+use solana_core::broadcast_stage::broadcast_metrics::TransmitShredsStats;
 use solana_core::broadcast_stage::{broadcast_shreds, get_broadcast_peers};
 use solana_core::cluster_info::{ClusterInfo, Node};
 use solana_core::contact_info::ContactInfo;
@@ -21,7 +22,7 @@ fn broadcast_shreds_bench(bencher: &mut Bencher) {
     solana_logger::setup();
     let leader_pubkey = Pubkey::new_rand();
     let leader_info = Node::new_localhost_with_pubkey(&leader_pubkey);
-    let cluster_info = ClusterInfo::new_with_invalid_keypair(leader_info.info.clone());
+    let cluster_info = ClusterInfo::new_with_invalid_keypair(leader_info.info);
     let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
 
     const NUM_SHREDS: usize = 32;
@@ -36,7 +37,7 @@ fn broadcast_shreds_bench(bencher: &mut Bencher) {
     }
     let stakes = Arc::new(stakes);
     let cluster_info = Arc::new(cluster_info);
-    let (peers, peers_and_stakes) = get_broadcast_peers(&cluster_info, Some(stakes.clone()));
+    let (peers, peers_and_stakes) = get_broadcast_peers(&cluster_info, Some(stakes));
     let shreds = Arc::new(shreds);
     let last_datapoint = Arc::new(AtomicU64::new(0));
     bencher.iter(move || {
@@ -47,7 +48,7 @@ fn broadcast_shreds_bench(bencher: &mut Bencher) {
             &peers_and_stakes,
             &peers,
             &last_datapoint,
-            &mut 0,
+            &mut TransmitShredsStats::default(),
         )
         .unwrap();
     });

core/benches/poh_verify.rs

@@ -12,9 +12,10 @@ const NUM_ENTRIES: usize = 800;
 
 #[bench]
 fn bench_poh_verify_ticks(bencher: &mut Bencher) {
+    solana_logger::setup();
     let zero = Hash::default();
-    let mut cur_hash = hash(&zero.as_ref());
-    let start = *&cur_hash;
+    let start_hash = hash(&zero.as_ref());
+    let mut cur_hash = start_hash;
 
     let mut ticks: Vec<Entry> = Vec::with_capacity(NUM_ENTRIES);
     for _ in 0..NUM_ENTRIES {
@@ -22,15 +23,15 @@ fn bench_poh_verify_ticks(bencher: &mut Bencher) {
     }
 
     bencher.iter(|| {
-        ticks.verify(&start);
+        assert!(ticks.verify(&start_hash));
     })
 }
 
 #[bench]
 fn bench_poh_verify_transaction_entries(bencher: &mut Bencher) {
     let zero = Hash::default();
-    let mut cur_hash = hash(&zero.as_ref());
-    let start = *&cur_hash;
+    let start_hash = hash(&zero.as_ref());
+    let mut cur_hash = start_hash;
 
     let keypair1 = Keypair::new();
     let pubkey1 = keypair1.pubkey();
@@ -42,6 +43,6 @@ fn bench_poh_verify_transaction_entries(bencher: &mut Bencher) {
     }
 
     bencher.iter(|| {
-        ticks.verify(&start);
+        assert!(ticks.verify(&start_hash));
     })
 }