Don't advertise the snapshot that the node was loaded from

snapshot_packager_service will remove this snapshot hash from gossip when it starts
Remove granularity from genesis (bp #8514 ) (#8518 )
2020-03-02 19:16:06 -07:00 · 2020-03-02 15:42:46 -08:00 · 2020-03-02 15:38:26 -07:00 · 2020-03-02 14:19:18 -08:00 · 2020-03-02 14:21:04 -07:00 · 2020-03-02 13:40:52 -07:00
762 changed files with 44168 additions and 77245 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@ -0,0 +1,42 @@
+version: '{build}'
+
+branches:
+  only:
+  - master
+  - /^v[0-9.]+\.[0-9.]+/
+
+cache:
+  - '%USERPROFILE%\.cargo'
+  - '%APPVEYOR_BUILD_FOLDER%\target'
+
+clone_folder: d:\projects\solana
+
+build_script:
+  - bash ci/publish-tarball.sh
+
+notifications:
+  - provider: Slack
+    incoming_webhook:
+      secure: GJsBey+F5apAtUm86MHVJ68Uqa6WN1SImcuIc4TsTZrDhA8K1QWUNw9FFQPybUWDyOcS5dly3kubnUqlGt9ux6Ad2efsfRIQYWv0tOVXKeY=
+    channel: ci-status
+    on_build_success: false
+    on_build_failure: true
+    on_build_status_changed: true
+
+deploy:
+  - provider: S3
+    access_key_id:
+      secure: fTbJl6JpFebR40J7cOWZ2mXBa3kIvEiXgzxAj6L3N7A=
+    secret_access_key:
+      secure: vItsBXb2rEFLvkWtVn/Rcxu5a5+2EwC+b7GsA0waJy9hXh6XuBAD0lnHd9re3g/4
+    bucket: release.solana.com
+    region: us-west-1
+    set_public: true
+
+  - provider: GitHub
+    auth_token:
+      secure: 81fEmPZ0cV1wLtNuUrcmtgxKF6ROQF1+/ft5m+fHX21z6PoeCbaNo8cTyLioWBj7
+    draft: false
+    prerelease: false
+    on:
+      appveyor_repo_tag: true
--- a/.buildkite/env/secrets.ejson
+++ b/.buildkite/env/secrets.ejson
@ -7,6 +7,9 @@
      "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]"
+      "INFLUX_USERNAME": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:R7BNmQjfeqoGDAFTJu9bYTGHol2NgnYN:Q2tOT/EBcFvhFk+DKLKmVU7tLCpVC3Ui]",
+      "SOLANA_INSTALL_UPDATE_MANIFEST_KEYPAIR_x86_64_unknown_linux_gnu": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:Egc2dMrHDU0NcZ71LwGv/V66shUhwYUE:04VoIb8CKy7KYhQ5W4cEW9SDKZltxWBL5Hob106lMBbUOD/yUvKYcG3Ep8JfTMwO3K8zowW5HpU/IdGoilX0XWLiJJ6t+p05WWK0TA16nOEtwrEG+UK8wm3sN+xCO20i4jDhpNpgg3FYFHT5rKTHW8+zaBTNUX/SFxkN67Lm+92IM28CXYE43SU1WV6H99hGFFVpTK5JVM3JuYU1ex/dHRE+xCzTr4MYUB/F+nGoNFW8HUDV/y0e1jxT9to3x0SmnytEEuk+5RUzFuEt9cKNFeNml3fOCi4qL+sfj/Y5pjH9xDiUxsvH/8NL35jbLP244aFHgWcp]",
+      "SOLANA_INSTALL_UPDATE_MANIFEST_KEYPAIR_x86_64_apple_darwin": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:NeOxSoWCvXB9AL4H6OK26l/7bmsKd/oz:Ijfoxtvk2CHlN1ZXHup3Gg/914kbbAkEGWJfvozA8UIe+aUzUObMyTrKkVOeNAH8Q8YH9tNzk7RRnrTcpnzeCCBLlWcVEeruMxHox3mPRzmSeDLxtbzCl9VePlRO3T7jg90K5hW+ZAkd5J/WJNzpAcmr93ts/of3MbvGHSujId/efCTzJEcP6JInnBb8Vrj7TlgKbzUlnqpq1+NjYPSXN3maKa9pKeo2JWxZlGBMoy6QWUUY5GbYEylw9smwh1LJcHZjlaZNMuOl4gNKtaSr38IXQkAXaRUJDPAmPras00YObKzXU8RkTrP4EoP/jx5LPR7f]",
+      "SOLANA_INSTALL_UPDATE_MANIFEST_KEYPAIR_x86_64_pc_windows_msvc": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:7t+56twjW+jR7fpFNNeRFLPd7E4lbmyN:JuviDpkQrfVcNUGRGsa2e/UhvH6tTYyk1s4cHHE5xZH1NByL7Kpqx36VG/+o1AUGEeSQdsBnKgzYdMoFYbO8o50DoRPc86QIEVXCupD6J9avxLFtQgOWgJp+/mCdUVXlqXiFs/vQgS/L4psrcKdF6WHd77BeUr6ll8DjH+9m5FC9Rcai2pXno6VbPpunHQ0oUdYzhFR64+LiRacBaefQ9igZ+nSEWDLqbaZSyfm9viWkijoVFTq8gAgdXXEh7g0QdxVE5T6bPristJhT6jWBhWunPUCDNFFErWIsbRGctepl4pbCWqh2hNTw9btSgVfeY6uGCOsdy9E=]"
    }
 }
--- a/.gitbook.yaml
+++ b/.gitbook.yaml
@ -3,16 +3,3 @@ 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
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,5 @@
 /docs/html/
 /docs/src/tests.ok
-/docs/src/cli/usage.md
 /docs/src/.gitbook/assets/*.svg
 /farf/
 /solana-release/
--- a/.mergify.yml
+++ b/.mergify.yml
@ -19,27 +19,35 @@ pull_request_rules:
      label:
        add:
          - automerge
+  - name: v0.23 backport
+    conditions:
+      - base=master
+      - label=v0.23
+    actions:
+      backport:
+        branches:
+          - v0.23
  - name: v1.0 backport
    conditions:
+      - base=master
      - label=v1.0
    actions:
      backport:
-        ignore_conflicts: true
        branches:
          - v1.0
  - name: v1.1 backport
    conditions:
+      - base=master
      - label=v1.1
    actions:
      backport:
-        ignore_conflicts: true
        branches:
          - v1.1
  - name: v1.2 backport
    conditions:
+      - base=master
      - label=v1.2
    actions:
      backport:
-        ignore_conflicts: true
        branches:
          - v1.2
--- a/.travis.yml
+++ b/.travis.yml
@ -1,6 +1,5 @@
 os:
  - osx
-  - windows

 language: rust
 rust:
@ -13,14 +12,11 @@ script:
  - source ci/env.sh
  - ci/publish-tarball.sh

-
 branches:
  only:
    - master
    - /^v\d+\.\d+/

-if: type IN (api, cron) OR tag IS present
-
 notifications:
  slack:
    on_success: change
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -45,7 +45,7 @@ $ git pull --rebase upstream master

 If there are no functional changes, PRs can be very large and that's no
 problem. If, however, your changes are making meaningful changes or additions,
-then about 1,000 lines of changes is about the most you should ask a Solana
+then about 1.0.2 lines of changes is about the most you should ask a Solana
 maintainer to review.

 ### Should I send small PRs as I develop large, new components?
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -3,13 +3,13 @@ members = [
    "bench-exchange",
    "bench-streamer",
    "bench-tps",
-    "accounts-bench",
    "banking-bench",
+    "chacha",
+    "chacha-cuda",
+    "chacha-sys",
    "cli-config",
    "client",
    "core",
-    "dos",
-    "download-utils",
    "faucet",
    "perf",
    "validator",
@ -24,12 +24,9 @@ members = [
    "logger",
    "log-analyzer",
    "merkle-tree",
-    "stake-o-matic",
-    "streamer",
    "measure",
    "metrics",
    "net-shaper",
-    "notifier",
    "programs/bpf_loader",
    "programs/budget",
    "programs/btc_spv",
@ -40,21 +37,20 @@ members = [
    "programs/noop",
    "programs/ownable",
    "programs/stake",
+    "programs/storage",
    "programs/vest",
    "programs/vote",
+    "archiver",
+    "archiver-lib",
+    "archiver-utils",
    "remote-wallet",
-    "ramp-tps",
    "runtime",
    "sdk",
+    "sdk-c",
    "scripts",
-    "stake-accounts",
-    "stake-monitor",
    "sys-tuner",
-    "tokens",
-    "transaction-status",
    "upload-perf",
    "net-utils",
-    "version",
    "vote-signer",
    "cli",
    "rayon-threadlimit",
--- a/README.md
+++ b/README.md
@ -1,17 +1,76 @@
-<p align="center">
-  <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
-  </a>
-</p>
-
 [![Solana crate](https://img.shields.io/crates/v/solana-core.svg)](https://crates.io/crates/solana-core)
 [![Solana documentation](https://docs.rs/solana-core/badge.svg)](https://docs.rs/solana-core)
 [![Build status](https://badge.buildkite.com/8cc350de251d61483db98bdfc895b9ea0ac8ffa4a32ee850ed.svg?branch=master)](https://buildkite.com/solana-labs/solana/builds?branch=master)
 [![codecov](https://codecov.io/gh/solana-labs/solana/branch/master/graph/badge.svg)](https://codecov.io/gh/solana-labs/solana)

-# Building
+Blockchain Rebuilt for Scale
+===

-## **1. Install rustc, cargo and rustfmt.**
+Solana&trade; is a new blockchain architecture built from the ground up for scale. The architecture supports
+up to 710 thousand transactions per second on a gigabit network.
+
+Disclaimer
+===
+
+All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
+
+Introduction
+===
+
+It's possible for a centralized database to process 710,000 transactions per second on a standard gigabit network if the transactions are, on average, no more than 176 bytes. A centralized database can also replicate itself and maintain high availability without significantly compromising that transaction rate using the distributed system technique known as Optimistic Concurrency Control [\[H.T.Kung, J.T.Robinson (1981)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.65.4735). At Solana, we're demonstrating that these same theoretical limits apply just as well to blockchain on an adversarial network. The key ingredient? Finding a way to share time when nodes can't trust one-another. Once nodes can trust time, suddenly ~40 years of distributed systems research becomes applicable to blockchain!
+
+> Perhaps the most striking difference between algorithms obtained by our method and ones based upon timeout is that using timeout produces a traditional distributed algorithm in which the processes operate asynchronously, while our method produces a globally synchronous one in which every process does the same thing at (approximately) the same time. Our method seems to contradict the whole purpose of distributed processing, which is to permit different processes to operate independently and perform different functions. However, if a distributed system is really a single system, then the processes must be synchronized in some way. Conceptually, the easiest way to synchronize processes is to get them all to do the same thing at the same time. Therefore, our method is used to implement a kernel that performs the necessary synchronization--for example, making sure that two different processes do not try to modify a file at the same time. Processes might spend only a small fraction of their time executing the synchronizing kernel; the rest of the time, they can operate independently--e.g., accessing different files. This is an approach we have advocated even when fault-tolerance is not required. The method's basic simplicity makes it easier to understand the precise properties of a system, which is crucial if one is to know just how fault-tolerant the system is. [\[L.Lamport (1984)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.71.1078)
+
+Furthermore, and much to our surprise, it can be implemented using a mechanism that has existed in Bitcoin since day one. The Bitcoin feature is called nLocktime and it can be used to postdate transactions using block height instead of a timestamp. As a Bitcoin client, you'd use block height instead of a timestamp if you don't trust the network. Block height turns out to be an instance of what's being called a Verifiable Delay Function in cryptography circles. It's a cryptographically secure way to say time has passed. In Solana, we use a far more granular verifiable delay function, a SHA 256 hash chain, to checkpoint the ledger and coordinate consensus. With it, we implement Optimistic Concurrency Control and are now well en route towards that theoretical limit of 710,000 transactions per second.
+
+Documentation
+===
+
+Before you jump into the code, review the documentation [Solana: Blockchain Rebuilt for Scale](https://docs.solana.com).
+
+(The _latest_ development version of the docs is [available here](https://docs.solana.com/v/master).)
+
+Release Binaries
+===
+Official release binaries are available at [Github Releases](https://github.com/solana-labs/solana/releases).
+
+Additionally we provide pre-release binaries for the latest code on the edge and
+beta channels.  Note that these pre-release binaries may be less stable than an
+official release.
+
+### Edge channel
+#### Linux (x86_64-unknown-linux-gnu)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-unknown-linux-gnu.tar.bz2)
+* [solana-install-init](http://release.solana.com/edge/solana-install-init-x86_64-unknown-linux-gnu) as a stand-alone executable
+#### mac OS (x86_64-apple-darwin)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-apple-darwin.tar.bz2)
+* [solana-install-init](http://release.solana.com/edge/solana-install-init-x86_64-apple-darwin) as a stand-alone executable
+#### Windows (x86_64-pc-windows-msvc)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-pc-windows-msvc.tar.bz2)
+* [solana-install-init.exe](http://release.solana.com/edge/solana-install-init-x86_64-pc-windows-msvc.exe) as a stand-alone executable
+#### All platforms
+* [solana-metrics.tar.bz2](http://release.solana.com.s3.amazonaws.com/edge/solana-metrics.tar.bz2)
+
+### Beta channel
+#### Linux (x86_64-unknown-linux-gnu)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-unknown-linux-gnu.tar.bz2)
+* [solana-install-init](http://release.solana.com/beta/solana-install-init-x86_64-unknown-linux-gnu) as a stand-alone executable
+#### mac OS (x86_64-apple-darwin)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-apple-darwin.tar.bz2)
+* [solana-install-init](http://release.solana.com/beta/solana-install-init-x86_64-apple-darwin) as a stand-alone executable
+#### Windows (x86_64-pc-windows-msvc)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-pc-windows-msvc.tar.bz2)
+* [solana-install-init.exe](http://release.solana.com/beta/solana-install-init-x86_64-pc-windows-msvc.exe) as a stand-alone executable
+#### All platforms
+* [solana-metrics.tar.bz2](http://release.solana.com.s3.amazonaws.com/beta/solana-metrics.tar.bz2)
+
+Developing
+===
+
+Building
+---
+
+Install rustc, cargo and rustfmt:

 ```bash
 $ curl https://sh.rustup.rs -sSf | sh
@ -32,39 +91,112 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```

-## **2. Download the source code.**
+Download the source code:

 ```bash
 $ git clone https://github.com/solana-labs/solana.git
 $ cd solana
 ```

-## **3. Build.**
+Build

 ```bash
 $ cargo build
 ```

-## **4. Run a minimal local cluster.**
+Then to run a minimal local cluster
 ```bash
 $ ./run.sh
 ```

-# Testing
+Testing
+---

-**Run the test suite:**
+Run the test suite:

 ```bash
 $ cargo test
 ```

-### Starting a local testnet
-Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/bench-tps).
+Local Testnet
+---
+
+Start your own testnet locally, instructions are in the online docs [Solana: Blockchain Rebuild for Scale: Getting Started](https://docs.solana.com/building-from-source).
+
+Remote Testnets
+---

-### Accessing the remote testnet
 * `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7

-# Benchmarking
+
+## Deploy process
+
+They are deployed with the `ci/testnet-manager.sh` script through a list of [scheduled
+buildkite jobs](https://buildkite.com/solana-labs/testnet-management/settings/schedules).
+Each testnet can be manually manipulated from buildkite as well.
+
+## How do I reset the testnet?
+Manually trigger the [testnet-management](https://buildkite.com/solana-labs/testnet-management) pipeline
+and when prompted select the desired testnet
+
+## How can I scale the tx generation rate?
+
+Increase the TX rate by increasing the number of cores on the client machine which is running
+`bench-tps` or run multiple clients. Decrease by lowering cores or using the rayon env
+variable `RAYON_NUM_THREADS=<xx>`
+
+## How can I test a change on the testnet?
+
+Currently, a merged PR is the only way to test a change on the testnet.  But you
+can run your own testnet using the scripts in the `net/` directory.
+
+## Adjusting the number of clients or validators on the testnet
+Edit `ci/testnet-manager.sh`
+
+
+## Metrics Server Maintenance
+Sometimes the dashboard becomes unresponsive. This happens due to glitch in the metrics server.
+The current solution is to reset the metrics server. Use the following steps.
+
+1. The server is hosted in a GCP VM instance. Check if the VM instance is down by trying to SSH
+ into it from the GCP console. The name of the VM is ```metrics-solana-com```.
+2. If the VM is inaccessible, reset it from the GCP console.
+3. Once VM is up (or, was already up), the metrics services can be restarted from build automation.
+    1. Navigate to https://buildkite.com/solana-labs/metrics-dot-solana-dot-com in your web browser
+    2. Click on ```New Build```
+    3. This will show a pop up dialog. Click on ```options``` drop down.
+    4. Type in ```FORCE_START=true``` in ```Environment Variables``` text box.
+    5. Click ```Create Build```
+    6. This will restart the metrics services, and the dashboards should be accessible afterwards.
+
+## Debugging Testnet
+Testnet may exhibit different symptoms of failures. Primary statistics to check are
+1. Rise in Confirmation Time
+2. Nodes are not voting
+3. Panics, and OOM notifications
+
+Check the following if there are any signs of failure.
+1. Did testnet deployment fail?
+    1. View buildkite logs for the last deployment: https://buildkite.com/solana-labs/testnet-management
+    2. Use the relevant branch
+    3. If the deployment failed, look at the build logs. The build artifacts for each remote node is uploaded.
+       It's a good first step to triage from these logs.
+2. You may have to log into remote node if the deployment succeeded, but something failed during runtime.
+    1. Get the private key for the testnet deployment from ```metrics-solana-com``` GCP instance.
+    2. SSH into ```metrics-solana-com``` using GCP console and do the following.
+    ```bash
+    sudo bash
+    cd ~buildkite-agent/.ssh
+    ls
+    ```
+    3. Copy the relevant private key to your local machine
+    4. Find the public IP address of the AWS instance for the remote node using AWS console
+    5. ```ssh -i <private key file> ubuntu@<ip address of remote node>```
+    6. The logs are in ```~solana\solana``` folder
+
+
+Benchmarking
+---

 First install the nightly build of rustc. `cargo bench` requires use of the
 unstable features only available in the nightly build.
@ -79,11 +211,13 @@ Run the benchmarks:
 $ cargo +nightly bench
 ```

-# Release Process
-
+Release Process
+---
 The release process for this project is described [here](RELEASE.md).

-# Code coverage
+
+Code coverage
+---

 To generate code coverage statistics:

@ -92,6 +226,7 @@ $ scripts/coverage.sh
 $ open target/cov/lcov-local/index.html
 ```

+
 Why coverage? While most see coverage as a code quality metric, we see it primarily as a developer
 productivity metric. When a developer makes a change to the codebase, presumably it's a *solution* to
 some problem.  Our unit-test suite is how we encode the set of *problems* the codebase solves. Running
@ -103,7 +238,3 @@ problem is solved by this code?" On the other hand, if a test does fail and you
 better way to solve the same problem, a Pull Request with your solution would most certainly be
 welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please
 send us that patch!
-
-# Disclaimer
-
-All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
--- a/accounts-bench/Cargo.toml
+++ b/accounts-bench/Cargo.toml
@ -1,22 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
-edition = "2018"
-name = "solana-accounts-bench"
-version = "1.2.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.2" }
-solana-runtime = { path = "../runtime", version = "1.2.2" }
-solana-measure = { path = "../measure", version = "1.2.2" }
-solana-sdk = { path = "../sdk", version = "1.2.2" }
-rand = "0.7.0"
-clap = "2.33.1"
-crossbeam-channel = "0.4"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/accounts-bench/src/main.rs
+++ b/accounts-bench/src/main.rs
@ -1,105 +0,0 @@
-use clap::{value_t, App, Arg};
-use rayon::prelude::*;
-use solana_measure::measure::Measure;
-use solana_runtime::{
-    accounts::{create_test_accounts, update_accounts, Accounts},
-    accounts_index::Ancestors,
-};
-use solana_sdk::pubkey::Pubkey;
-use std::fs;
-use std::path::PathBuf;
-
-fn main() {
-    solana_logger::setup();
-
-    let matches = App::new("crate")
-        .about("about")
-        .version("version")
-        .arg(
-            Arg::with_name("num_slots")
-                .long("num_slots")
-                .takes_value(true)
-                .value_name("SLOTS")
-                .help("Number of slots to store to."),
-        )
-        .arg(
-            Arg::with_name("num_accounts")
-                .long("num_accounts")
-                .takes_value(true)
-                .value_name("NUM_ACCOUNTS")
-                .help("Total number of accounts"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .value_name("ITERATIONS")
-                .help("Number of bench iterations"),
-        )
-        .arg(
-            Arg::with_name("clean")
-                .long("clean")
-                .takes_value(false)
-                .help("Run clean"),
-        )
-        .get_matches();
-
-    let num_slots = value_t!(matches, "num_slots", usize).unwrap_or(4);
-    let num_accounts = value_t!(matches, "num_accounts", usize).unwrap_or(10_000);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(20);
-    let clean = matches.is_present("clean");
-    println!("clean: {:?}", clean);
-
-    let path = PathBuf::from("farf/accounts-bench");
-    if fs::remove_dir_all(path.clone()).is_err() {
-        println!("Warning: Couldn't remove {:?}", path);
-    }
-    let accounts = Accounts::new(vec![path]);
-    println!("Creating {} accounts", num_accounts);
-    let mut create_time = Measure::start("create accounts");
-    let pubkeys: Vec<_> = (0..num_slots)
-        .into_par_iter()
-        .map(|slot| {
-            let mut pubkeys: Vec<Pubkey> = vec![];
-            create_test_accounts(
-                &accounts,
-                &mut pubkeys,
-                num_accounts / num_slots,
-                slot as u64,
-            );
-            pubkeys
-        })
-        .collect();
-    let pubkeys: Vec<_> = pubkeys.into_iter().flatten().collect();
-    create_time.stop();
-    println!(
-        "created {} accounts in {} slots {}",
-        (num_accounts / num_slots) * num_slots,
-        num_slots,
-        create_time
-    );
-    let mut ancestors: Ancestors = vec![(0, 0)].into_iter().collect();
-    for i in 1..num_slots {
-        ancestors.insert(i as u64, i - 1);
-        accounts.add_root(i as u64);
-    }
-    for x in 0..iterations {
-        if clean {
-            let mut time = Measure::start("clean");
-            accounts.accounts_db.clean_accounts();
-            time.stop();
-            println!("{}", time);
-            for slot in 0..num_slots {
-                update_accounts(&accounts, &pubkeys, ((x + 1) * num_slots + slot) as u64);
-                accounts.add_root((x * num_slots + slot) as u64);
-            }
-        } else {
-            let mut pubkeys: Vec<Pubkey> = vec![];
-            let mut time = Measure::start("hash");
-            let hash = accounts.accounts_db.update_accounts_hash(0, &ancestors);
-            time.stop();
-            println!("hash: {} {}", hash, time);
-            create_test_accounts(&accounts, &mut pubkeys, 1, 0);
-        }
-    }
-}
--- a/archiver-lib/Cargo.toml
+++ b/archiver-lib/Cargo.toml
@ -0,0 +1,39 @@
+[package]
+name = "solana-archiver-lib"
+version = "1.0.2"
+description = "Solana Archiver Library"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+bincode = "1.2.1"
+crossbeam-channel = "0.3"
+ed25519-dalek = "=1.0.0-pre.1"
+log = "0.4.8"
+rand = "0.6.5"
+rand_chacha = "0.1.1"
+solana-client = { path = "../client", version = "1.0.2" }
+solana-storage-program = { path = "../programs/storage", version = "1.0.2" }
+thiserror = "1.0"
+serde = "1.0.104"
+serde_json = "1.0.46"
+serde_derive = "1.0.103"
+solana-net-utils = { path = "../net-utils", version = "1.0.2" }
+solana-chacha = { path = "../chacha", version = "1.0.2" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.0.2" }
+solana-ledger = { path = "../ledger", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-perf = { path = "../perf", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+solana-core = { path = "../core", version = "1.0.2" }
+solana-archiver-utils = { path = "../archiver-utils", version = "1.0.2" }
+solana-metrics = { path = "../metrics", version = "1.0.2" }
+
+[dev-dependencies]
+hex = "0.4.0"
+
+[lib]
+name = "solana_archiver_lib"
--- a/archiver-lib/src/archiver.rs
+++ b/archiver-lib/src/archiver.rs
@ -0,0 +1,944 @@
+use crate::result::ArchiverError;
+use crossbeam_channel::unbounded;
+use rand::{thread_rng, Rng, SeedableRng};
+use rand_chacha::ChaChaRng;
+use solana_archiver_utils::sample_file;
+use solana_chacha::chacha::{chacha_cbc_encrypt_ledger, CHACHA_BLOCK_SIZE};
+use solana_client::{
+    rpc_client::RpcClient, rpc_request::RpcRequest, rpc_response::RpcStorageTurn,
+    thin_client::ThinClient,
+};
+use solana_core::{
+    cluster_info::{ClusterInfo, Node, VALIDATOR_PORT_RANGE},
+    contact_info::ContactInfo,
+    gossip_service::GossipService,
+    packet::{limited_deserialize, PACKET_DATA_SIZE},
+    repair_service,
+    repair_service::{RepairService, RepairSlotRange, RepairStrategy},
+    serve_repair::ServeRepair,
+    shred_fetch_stage::ShredFetchStage,
+    sigverify_stage::{DisabledSigVerifier, SigVerifyStage},
+    storage_stage::NUM_STORAGE_SAMPLES,
+    streamer::{receiver, responder, PacketReceiver},
+    window_service::WindowService,
+};
+use solana_ledger::{
+    blockstore::Blockstore, leader_schedule_cache::LeaderScheduleCache, shred::Shred,
+};
+use solana_net_utils::bind_in_range;
+use solana_perf::packet::Packets;
+use solana_perf::recycler::Recycler;
+use solana_sdk::packet::Packet;
+use solana_sdk::{
+    account_utils::StateMut,
+    client::{AsyncClient, SyncClient},
+    clock::{get_complete_segment_from_slot, get_segment_from_slot, Slot},
+    commitment_config::CommitmentConfig,
+    hash::Hash,
+    message::Message,
+    signature::{Keypair, Signature, Signer},
+    timing::timestamp,
+    transaction::Transaction,
+    transport::TransportError,
+};
+use solana_storage_program::{
+    storage_contract::StorageContract,
+    storage_instruction::{self, StorageAccountType},
+};
+use std::{
+    io::{self, ErrorKind},
+    net::{SocketAddr, UdpSocket},
+    path::{Path, PathBuf},
+    result,
+    sync::atomic::{AtomicBool, Ordering},
+    sync::mpsc::{channel, Receiver, Sender},
+    sync::{Arc, RwLock},
+    thread::{sleep, spawn, JoinHandle},
+    time::Duration,
+};
+
+type Result<T> = std::result::Result<T, ArchiverError>;
+
+static ENCRYPTED_FILENAME: &str = "ledger.enc";
+
+#[derive(Serialize, Deserialize)]
+pub enum ArchiverRequest {
+    GetSlotHeight(SocketAddr),
+}
+
+pub struct Archiver {
+    thread_handles: Vec<JoinHandle<()>>,
+    exit: Arc<AtomicBool>,
+}
+
+// Shared Archiver Meta struct used internally
+#[derive(Default)]
+struct ArchiverMeta {
+    slot: Slot,
+    slots_per_segment: u64,
+    ledger_path: PathBuf,
+    signature: Signature,
+    ledger_data_file_encrypted: PathBuf,
+    sampling_offsets: Vec<u64>,
+    blockhash: Hash,
+    sha_state: Hash,
+    num_chacha_blocks: usize,
+    client_commitment: CommitmentConfig,
+}
+
+fn get_slot_from_signature(
+    signature: &Signature,
+    storage_turn: u64,
+    slots_per_segment: u64,
+) -> u64 {
+    let signature_vec = signature.as_ref();
+    let mut segment_index = u64::from(signature_vec[0])
+        | (u64::from(signature_vec[1]) << 8)
+        | (u64::from(signature_vec[1]) << 16)
+        | (u64::from(signature_vec[2]) << 24);
+    let max_segment_index =
+        get_complete_segment_from_slot(storage_turn, slots_per_segment).unwrap();
+    segment_index %= max_segment_index as u64;
+    segment_index * slots_per_segment
+}
+
+fn create_request_processor(
+    socket: UdpSocket,
+    exit: &Arc<AtomicBool>,
+    slot_receiver: Receiver<u64>,
+) -> Vec<JoinHandle<()>> {
+    let mut thread_handles = vec![];
+    let (s_reader, r_reader) = channel();
+    let (s_responder, r_responder) = channel();
+    let storage_socket = Arc::new(socket);
+    let recycler = Recycler::default();
+    let t_receiver = receiver(storage_socket.clone(), exit, s_reader, recycler, "archiver");
+    thread_handles.push(t_receiver);
+
+    let t_responder = responder("archiver-responder", storage_socket, r_responder);
+    thread_handles.push(t_responder);
+
+    let exit = exit.clone();
+    let t_processor = spawn(move || {
+        let slot = poll_for_slot(slot_receiver, &exit);
+
+        loop {
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+
+            let packets = r_reader.recv_timeout(Duration::from_secs(1));
+
+            if let Ok(packets) = packets {
+                for packet in &packets.packets {
+                    let req: result::Result<ArchiverRequest, Box<bincode::ErrorKind>> =
+                        limited_deserialize(&packet.data[..packet.meta.size]);
+                    match req {
+                        Ok(ArchiverRequest::GetSlotHeight(from)) => {
+                            let packet = Packet::from_data(&from, slot);
+                            let _ = s_responder.send(Packets::new(vec![packet]));
+                        }
+                        Err(e) => {
+                            info!("invalid request: {:?}", e);
+                        }
+                    }
+                }
+            }
+        }
+    });
+    thread_handles.push(t_processor);
+    thread_handles
+}
+
+fn poll_for_slot(receiver: Receiver<u64>, exit: &Arc<AtomicBool>) -> u64 {
+    loop {
+        let slot = receiver.recv_timeout(Duration::from_secs(1));
+        if let Ok(slot) = slot {
+            return slot;
+        }
+        if exit.load(Ordering::Relaxed) {
+            return 0;
+        }
+    }
+}
+
+impl Archiver {
+    /// Returns a Result that contains an archiver on success
+    ///
+    /// # Arguments
+    /// * `ledger_path` - path to where the ledger will be stored.
+    /// Causes panic if none
+    /// * `node` - The archiver node
+    /// * `cluster_entrypoint` - ContactInfo representing an entry into the network
+    /// * `keypair` - Keypair for this archiver
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new(
+        ledger_path: &Path,
+        node: Node,
+        cluster_entrypoint: ContactInfo,
+        keypair: Arc<Keypair>,
+        storage_keypair: Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) -> Result<Self> {
+        let exit = Arc::new(AtomicBool::new(false));
+
+        info!("Archiver: id: {}", keypair.pubkey());
+        info!("Creating cluster info....");
+        let mut cluster_info = ClusterInfo::new(node.info.clone(), keypair.clone());
+        cluster_info.set_entrypoint(cluster_entrypoint.clone());
+        let cluster_info = Arc::new(RwLock::new(cluster_info));
+
+        // Note for now, this ledger will not contain any of the existing entries
+        // in the ledger located at ledger_path, and will only append on newly received
+        // entries after being passed to window_service
+        let blockstore = Arc::new(
+            Blockstore::open(ledger_path).expect("Expected to be able to open database ledger"),
+        );
+
+        let gossip_service = GossipService::new(&cluster_info, None, node.sockets.gossip, &exit);
+
+        info!("Connecting to the cluster via {:?}", cluster_entrypoint);
+        let (nodes, _) =
+            match solana_core::gossip_service::discover_cluster(&cluster_entrypoint.gossip, 1) {
+                Ok(nodes_and_archivers) => nodes_and_archivers,
+                Err(e) => {
+                    //shutdown services before exiting
+                    exit.store(true, Ordering::Relaxed);
+                    gossip_service.join()?;
+                    return Err(e.into());
+                }
+            };
+        let client = solana_core::gossip_service::get_client(&nodes);
+
+        info!("Setting up mining account...");
+        if let Err(e) = Self::setup_mining_account(
+            &client,
+            &keypair,
+            &storage_keypair,
+            client_commitment.clone(),
+        ) {
+            //shutdown services before exiting
+            exit.store(true, Ordering::Relaxed);
+            gossip_service.join()?;
+            return Err(e);
+        };
+
+        let repair_socket = Arc::new(node.sockets.repair);
+        let shred_sockets: Vec<Arc<UdpSocket>> =
+            node.sockets.tvu.into_iter().map(Arc::new).collect();
+        let shred_forward_sockets: Vec<Arc<UdpSocket>> = node
+            .sockets
+            .tvu_forwards
+            .into_iter()
+            .map(Arc::new)
+            .collect();
+        let (shred_fetch_sender, shred_fetch_receiver) = channel();
+        let fetch_stage = ShredFetchStage::new(
+            shred_sockets,
+            shred_forward_sockets,
+            repair_socket.clone(),
+            &shred_fetch_sender,
+            &exit,
+        );
+        let (slot_sender, slot_receiver) = channel();
+        let request_processor =
+            create_request_processor(node.sockets.storage.unwrap(), &exit, slot_receiver);
+
+        let t_archiver = {
+            let exit = exit.clone();
+            let node_info = node.info.clone();
+            let mut meta = ArchiverMeta {
+                ledger_path: ledger_path.to_path_buf(),
+                client_commitment,
+                ..ArchiverMeta::default()
+            };
+            spawn(move || {
+                // setup archiver
+                let window_service = match Self::setup(
+                    &mut meta,
+                    cluster_info.clone(),
+                    &blockstore,
+                    &exit,
+                    &node_info,
+                    &storage_keypair,
+                    repair_socket,
+                    shred_fetch_receiver,
+                    slot_sender,
+                ) {
+                    Ok(window_service) => window_service,
+                    Err(e) => {
+                        //shutdown services before exiting
+                        error!("setup failed {:?}; archiver thread exiting...", e);
+                        exit.store(true, Ordering::Relaxed);
+                        request_processor
+                            .into_iter()
+                            .for_each(|t| t.join().unwrap());
+                        fetch_stage.join().unwrap();
+                        gossip_service.join().unwrap();
+                        return;
+                    }
+                };
+
+                info!("setup complete");
+                // run archiver
+                Self::run(
+                    &mut meta,
+                    &blockstore,
+                    cluster_info,
+                    &keypair,
+                    &storage_keypair,
+                    &exit,
+                );
+                // wait until exit
+                request_processor
+                    .into_iter()
+                    .for_each(|t| t.join().unwrap());
+                fetch_stage.join().unwrap();
+                gossip_service.join().unwrap();
+                window_service.join().unwrap()
+            })
+        };
+
+        Ok(Self {
+            thread_handles: vec![t_archiver],
+            exit,
+        })
+    }
+
+    fn run(
+        meta: &mut ArchiverMeta,
+        blockstore: &Arc<Blockstore>,
+        cluster_info: Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        exit: &Arc<AtomicBool>,
+    ) {
+        // encrypt segment
+        Self::encrypt_ledger(meta, blockstore).expect("ledger encrypt not successful");
+        let enc_file_path = meta.ledger_data_file_encrypted.clone();
+        // do replicate
+        loop {
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+
+            // TODO check if more segments are available - based on space constraints
+            Self::create_sampling_offsets(meta);
+            let sampling_offsets = &meta.sampling_offsets;
+            meta.sha_state =
+                match Self::sample_file_to_create_mining_hash(&enc_file_path, sampling_offsets) {
+                    Ok(hash) => hash,
+                    Err(err) => {
+                        warn!("Error sampling file, exiting: {:?}", err);
+                        break;
+                    }
+                };
+
+            Self::submit_mining_proof(meta, &cluster_info, archiver_keypair, storage_keypair);
+
+            // TODO make this a lot more frequent by picking a "new" blockhash instead of picking a storage blockhash
+            // prep the next proof
+            let (storage_blockhash, _) = match Self::poll_for_blockhash_and_slot(
+                &cluster_info,
+                meta.slots_per_segment,
+                &meta.blockhash,
+                exit,
+            ) {
+                Ok(blockhash_and_slot) => blockhash_and_slot,
+                Err(e) => {
+                    warn!(
+                        "Error couldn't get a newer blockhash than {:?}. {:?}",
+                        meta.blockhash, e
+                    );
+                    break;
+                }
+            };
+            meta.blockhash = storage_blockhash;
+            Self::redeem_rewards(
+                &cluster_info,
+                archiver_keypair,
+                storage_keypair,
+                meta.client_commitment.clone(),
+            );
+        }
+        exit.store(true, Ordering::Relaxed);
+    }
+
+    fn redeem_rewards(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) {
+        let nodes = cluster_info.read().unwrap().tvu_peers();
+        let client = solana_core::gossip_service::get_client(&nodes);
+
+        if let Ok(Some(account)) =
+            client.get_account_with_commitment(&storage_keypair.pubkey(), client_commitment.clone())
+        {
+            if let Ok(StorageContract::ArchiverStorage { validations, .. }) = account.state() {
+                if !validations.is_empty() {
+                    let ix = storage_instruction::claim_reward(
+                        &archiver_keypair.pubkey(),
+                        &storage_keypair.pubkey(),
+                    );
+                    let message =
+                        Message::new_with_payer(vec![ix], Some(&archiver_keypair.pubkey()));
+                    if let Err(e) = client.send_message(&[archiver_keypair.as_ref()], message) {
+                        error!("unable to redeem reward, tx failed: {:?}", e);
+                    } else {
+                        info!(
+                            "collected mining rewards: Account balance {:?}",
+                            client.get_balance_with_commitment(
+                                &archiver_keypair.pubkey(),
+                                client_commitment
+                            )
+                        );
+                    }
+                }
+            }
+        } else {
+            info!("Redeem mining reward: No account data found");
+        }
+    }
+
+    // Find a segment to replicate and download it.
+    fn setup(
+        meta: &mut ArchiverMeta,
+        cluster_info: Arc<RwLock<ClusterInfo>>,
+        blockstore: &Arc<Blockstore>,
+        exit: &Arc<AtomicBool>,
+        node_info: &ContactInfo,
+        storage_keypair: &Arc<Keypair>,
+        repair_socket: Arc<UdpSocket>,
+        shred_fetch_receiver: PacketReceiver,
+        slot_sender: Sender<u64>,
+    ) -> Result<WindowService> {
+        let slots_per_segment =
+            match Self::get_segment_config(&cluster_info, meta.client_commitment.clone()) {
+                Ok(slots_per_segment) => slots_per_segment,
+                Err(e) => {
+                    error!("unable to get segment size configuration, exiting...");
+                    //shutdown services before exiting
+                    exit.store(true, Ordering::Relaxed);
+                    return Err(e);
+                }
+            };
+        let (segment_blockhash, segment_slot) = match Self::poll_for_segment(
+            &cluster_info,
+            slots_per_segment,
+            &Hash::default(),
+            exit,
+        ) {
+            Ok(blockhash_and_slot) => blockhash_and_slot,
+            Err(e) => {
+                //shutdown services before exiting
+                exit.store(true, Ordering::Relaxed);
+                return Err(e);
+            }
+        };
+        let signature = storage_keypair.sign_message(segment_blockhash.as_ref());
+        let slot = get_slot_from_signature(&signature, segment_slot, slots_per_segment);
+        info!("replicating slot: {}", slot);
+        slot_sender.send(slot)?;
+        meta.slot = slot;
+        meta.slots_per_segment = slots_per_segment;
+        meta.signature = signature;
+        meta.blockhash = segment_blockhash;
+
+        let mut repair_slot_range = RepairSlotRange::default();
+        repair_slot_range.end = slot + slots_per_segment;
+        repair_slot_range.start = slot;
+
+        let (retransmit_sender, _) = channel();
+
+        let (verified_sender, verified_receiver) = unbounded();
+
+        let _sigverify_stage = SigVerifyStage::new(
+            shred_fetch_receiver,
+            verified_sender,
+            DisabledSigVerifier::default(),
+        );
+
+        let window_service = WindowService::new(
+            blockstore.clone(),
+            cluster_info.clone(),
+            verified_receiver,
+            retransmit_sender,
+            repair_socket,
+            &exit,
+            RepairStrategy::RepairRange(repair_slot_range),
+            &Arc::new(LeaderScheduleCache::default()),
+            |_, _, _, _| true,
+        );
+        info!("waiting for ledger download");
+        Self::wait_for_segment_download(
+            slot,
+            slots_per_segment,
+            &blockstore,
+            &exit,
+            &node_info,
+            cluster_info,
+        );
+        Ok(window_service)
+    }
+
+    fn wait_for_segment_download(
+        start_slot: Slot,
+        slots_per_segment: u64,
+        blockstore: &Arc<Blockstore>,
+        exit: &Arc<AtomicBool>,
+        node_info: &ContactInfo,
+        cluster_info: Arc<RwLock<ClusterInfo>>,
+    ) {
+        info!(
+            "window created, waiting for ledger download starting at slot {:?}",
+            start_slot
+        );
+        let mut current_slot = start_slot;
+        'outer: loop {
+            while blockstore.is_full(current_slot) {
+                current_slot += 1;
+                info!("current slot: {}", current_slot);
+                if current_slot >= start_slot + slots_per_segment {
+                    break 'outer;
+                }
+            }
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+            sleep(Duration::from_secs(1));
+        }
+
+        info!("Done receiving entries from window_service");
+
+        // Remove archiver from the data plane
+        let mut contact_info = node_info.clone();
+        contact_info.tvu = "0.0.0.0:0".parse().unwrap();
+        contact_info.wallclock = timestamp();
+        // copy over the adopted shred_version from the entrypoint
+        contact_info.shred_version = cluster_info.read().unwrap().my_data().shred_version;
+        {
+            let mut cluster_info_w = cluster_info.write().unwrap();
+            cluster_info_w.insert_self(contact_info);
+        }
+    }
+
+    fn encrypt_ledger(meta: &mut ArchiverMeta, blockstore: &Arc<Blockstore>) -> Result<()> {
+        meta.ledger_data_file_encrypted = meta.ledger_path.join(ENCRYPTED_FILENAME);
+
+        {
+            let mut ivec = [0u8; 64];
+            ivec.copy_from_slice(&meta.signature.as_ref());
+
+            let num_encrypted_bytes = chacha_cbc_encrypt_ledger(
+                blockstore,
+                meta.slot,
+                meta.slots_per_segment,
+                &meta.ledger_data_file_encrypted,
+                &mut ivec,
+            )?;
+
+            meta.num_chacha_blocks = num_encrypted_bytes / CHACHA_BLOCK_SIZE;
+        }
+
+        info!(
+            "Done encrypting the ledger: {:?}",
+            meta.ledger_data_file_encrypted
+        );
+        Ok(())
+    }
+
+    fn create_sampling_offsets(meta: &mut ArchiverMeta) {
+        meta.sampling_offsets.clear();
+        let mut rng_seed = [0u8; 32];
+        rng_seed.copy_from_slice(&meta.blockhash.as_ref());
+        let mut rng = ChaChaRng::from_seed(rng_seed);
+        for _ in 0..NUM_STORAGE_SAMPLES {
+            meta.sampling_offsets
+                .push(rng.gen_range(0, meta.num_chacha_blocks) as u64);
+        }
+    }
+
+    fn sample_file_to_create_mining_hash(
+        enc_file_path: &Path,
+        sampling_offsets: &[u64],
+    ) -> Result<Hash> {
+        let sha_state = sample_file(enc_file_path, sampling_offsets)?;
+        info!("sampled sha_state: {}", sha_state);
+        Ok(sha_state)
+    }
+
+    fn setup_mining_account(
+        client: &ThinClient,
+        keypair: &Keypair,
+        storage_keypair: &Keypair,
+        client_commitment: CommitmentConfig,
+    ) -> Result<()> {
+        // make sure archiver has some balance
+        info!("checking archiver keypair...");
+        if client.poll_balance_with_timeout_and_commitment(
+            &keypair.pubkey(),
+            &Duration::from_millis(100),
+            &Duration::from_secs(5),
+            client_commitment.clone(),
+        )? == 0
+        {
+            return Err(ArchiverError::EmptyStorageAccountBalance);
+        }
+
+        info!("checking storage account keypair...");
+        // check if the storage account exists
+        let balance = client
+            .poll_get_balance_with_commitment(&storage_keypair.pubkey(), client_commitment.clone());
+        if balance.is_err() || balance.unwrap() == 0 {
+            let blockhash =
+                match client.get_recent_blockhash_with_commitment(client_commitment.clone()) {
+                    Ok((blockhash, _)) => blockhash,
+                    Err(e) => {
+                        return Err(ArchiverError::TransportError(e));
+                    }
+                };
+
+            let ix = storage_instruction::create_storage_account(
+                &keypair.pubkey(),
+                &keypair.pubkey(),
+                &storage_keypair.pubkey(),
+                1,
+                StorageAccountType::Archiver,
+            );
+            let tx = Transaction::new_signed_instructions(&[keypair], ix, blockhash);
+            let signature = client.async_send_transaction(tx)?;
+            client
+                .poll_for_signature_with_commitment(&signature, client_commitment)
+                .map_err(|err| match err {
+                    TransportError::IoError(e) => e,
+                    TransportError::TransactionError(_) => io::Error::new(
+                        ErrorKind::Other,
+                        "setup_mining_account: signature not found",
+                    ),
+                })?;
+        }
+        Ok(())
+    }
+
+    fn submit_mining_proof(
+        meta: &ArchiverMeta,
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+    ) {
+        // No point if we've got no storage account...
+        let nodes = cluster_info.read().unwrap().tvu_peers();
+        let client = solana_core::gossip_service::get_client(&nodes);
+        let storage_balance = client.poll_get_balance_with_commitment(
+            &storage_keypair.pubkey(),
+            meta.client_commitment.clone(),
+        );
+        if storage_balance.is_err() || storage_balance.unwrap() == 0 {
+            error!("Unable to submit mining proof, no storage account");
+            return;
+        }
+        // ...or no lamports for fees
+        let balance = client.poll_get_balance_with_commitment(
+            &archiver_keypair.pubkey(),
+            meta.client_commitment.clone(),
+        );
+        if balance.is_err() || balance.unwrap() == 0 {
+            error!("Unable to submit mining proof, insufficient Archiver Account balance");
+            return;
+        }
+
+        let blockhash =
+            match client.get_recent_blockhash_with_commitment(meta.client_commitment.clone()) {
+                Ok((blockhash, _)) => blockhash,
+                Err(_) => {
+                    error!("unable to get recent blockhash, can't submit proof");
+                    return;
+                }
+            };
+        let instruction = storage_instruction::mining_proof(
+            &storage_keypair.pubkey(),
+            meta.sha_state,
+            get_segment_from_slot(meta.slot, meta.slots_per_segment),
+            Signature::new(&meta.signature.as_ref()),
+            meta.blockhash,
+        );
+        let message = Message::new_with_payer(vec![instruction], Some(&archiver_keypair.pubkey()));
+        let mut transaction = Transaction::new(
+            &[archiver_keypair.as_ref(), storage_keypair.as_ref()],
+            message,
+            blockhash,
+        );
+        if let Err(err) = client.send_and_confirm_transaction(
+            &[archiver_keypair.as_ref(), storage_keypair.as_ref()],
+            &mut transaction,
+            10,
+            0,
+        ) {
+            error!("Error: {:?}; while sending mining proof", err);
+        }
+    }
+
+    pub fn close(self) {
+        self.exit.store(true, Ordering::Relaxed);
+        self.join()
+    }
+
+    pub fn join(self) {
+        for handle in self.thread_handles {
+            handle.join().unwrap();
+        }
+    }
+
+    fn get_segment_config(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        client_commitment: CommitmentConfig,
+    ) -> Result<u64> {
+        let rpc_peers = {
+            let cluster_info = cluster_info.read().unwrap();
+            cluster_info.all_rpc_peers()
+        };
+        debug!("rpc peers: {:?}", rpc_peers);
+        if !rpc_peers.is_empty() {
+            let rpc_client = {
+                let node_index = thread_rng().gen_range(0, rpc_peers.len());
+                RpcClient::new_socket(rpc_peers[node_index].rpc)
+            };
+            Ok(rpc_client
+                .send(
+                    &RpcRequest::GetSlotsPerSegment,
+                    serde_json::json!([client_commitment]),
+                    0,
+                )
+                .map_err(|err| {
+                    warn!("Error while making rpc request {:?}", err);
+                    ArchiverError::ClientError(err)
+                })?
+                .as_u64()
+                .unwrap())
+        } else {
+            Err(ArchiverError::NoRpcPeers)
+        }
+    }
+
+    /// Waits until the first segment is ready, and returns the current segment
+    fn poll_for_segment(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        loop {
+            let (blockhash, turn_slot) = Self::poll_for_blockhash_and_slot(
+                cluster_info,
+                slots_per_segment,
+                previous_blockhash,
+                exit,
+            )?;
+            if get_complete_segment_from_slot(turn_slot, slots_per_segment).is_some() {
+                return Ok((blockhash, turn_slot));
+            }
+        }
+    }
+
+    /// Poll for a different blockhash and associated max_slot than `previous_blockhash`
+    fn poll_for_blockhash_and_slot(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        info!("waiting for the next turn...");
+        loop {
+            let rpc_peers = {
+                let cluster_info = cluster_info.read().unwrap();
+                cluster_info.all_rpc_peers()
+            };
+            debug!("rpc peers: {:?}", rpc_peers);
+            if !rpc_peers.is_empty() {
+                let rpc_client = {
+                    let node_index = thread_rng().gen_range(0, rpc_peers.len());
+                    RpcClient::new_socket(rpc_peers[node_index].rpc)
+                };
+                let response = rpc_client
+                    .send(
+                        &RpcRequest::GetStorageTurn,
+                        serde_json::value::Value::Null,
+                        0,
+                    )
+                    .map_err(|err| {
+                        warn!("Error while making rpc request {:?}", err);
+                        ArchiverError::ClientError(err)
+                    })?;
+                let RpcStorageTurn {
+                    blockhash: storage_blockhash,
+                    slot: turn_slot,
+                } = serde_json::from_value::<RpcStorageTurn>(response)
+                    .map_err(ArchiverError::JsonError)?;
+                let turn_blockhash = storage_blockhash.parse().map_err(|err| {
+                    io::Error::new(
+                        io::ErrorKind::Other,
+                        format!(
+                            "Blockhash parse failure: {:?} on {:?}",
+                            err, storage_blockhash
+                        ),
+                    )
+                })?;
+                if turn_blockhash != *previous_blockhash {
+                    info!("turn slot: {}", turn_slot);
+                    if get_segment_from_slot(turn_slot, slots_per_segment) != 0 {
+                        return Ok((turn_blockhash, turn_slot));
+                    }
+                }
+            }
+            if exit.load(Ordering::Relaxed) {
+                return Err(ArchiverError::IO(io::Error::new(
+                    ErrorKind::Other,
+                    "exit signalled...",
+                )));
+            }
+            sleep(Duration::from_secs(5));
+        }
+    }
+
+    /// Ask an archiver to populate a given blockstore with its segment.
+    /// Return the slot at the start of the archiver's segment
+    ///
+    /// It is recommended to use a temporary blockstore for this since the download will not verify
+    /// shreds received and might impact the chaining of shreds across slots
+    pub fn download_from_archiver(
+        serve_repair: &ServeRepair,
+        archiver_info: &ContactInfo,
+        blockstore: &Arc<Blockstore>,
+        slots_per_segment: u64,
+    ) -> Result<u64> {
+        // Create a client which downloads from the archiver and see that it
+        // can respond with shreds.
+        let start_slot = Self::get_archiver_segment_slot(archiver_info.storage_addr);
+        info!("Archiver download: start at {}", start_slot);
+
+        let exit = Arc::new(AtomicBool::new(false));
+        let (s_reader, r_reader) = channel();
+        let repair_socket = Arc::new(bind_in_range(VALIDATOR_PORT_RANGE).unwrap().1);
+        let t_receiver = receiver(
+            repair_socket.clone(),
+            &exit,
+            s_reader,
+            Recycler::default(),
+            "archiver_reeciver",
+        );
+        let id = serve_repair.keypair().pubkey();
+        info!(
+            "Sending repair requests from: {} to: {}",
+            serve_repair.my_info().id,
+            archiver_info.gossip
+        );
+        let repair_slot_range = RepairSlotRange {
+            start: start_slot,
+            end: start_slot + slots_per_segment,
+        };
+        // try for upto 180 seconds //TODO needs tuning if segments are huge
+        for _ in 0..120 {
+            // Strategy used by archivers
+            let repairs = RepairService::generate_repairs_in_range(
+                blockstore,
+                repair_service::MAX_REPAIR_LENGTH,
+                &repair_slot_range,
+            );
+            //iter over the repairs and send them
+            if let Ok(repairs) = repairs {
+                let reqs: Vec<_> = repairs
+                    .into_iter()
+                    .filter_map(|repair_request| {
+                        serve_repair
+                            .map_repair_request(&repair_request)
+                            .map(|result| ((archiver_info.gossip, result), repair_request))
+                            .ok()
+                    })
+                    .collect();
+
+                for ((to, req), repair_request) in reqs {
+                    if let Ok(local_addr) = repair_socket.local_addr() {
+                        datapoint_info!(
+                            "archiver_download",
+                            ("repair_request", format!("{:?}", repair_request), String),
+                            ("to", to.to_string(), String),
+                            ("from", local_addr.to_string(), String),
+                            ("id", id.to_string(), String)
+                        );
+                    }
+                    repair_socket
+                        .send_to(&req, archiver_info.gossip)
+                        .unwrap_or_else(|e| {
+                            error!("{} repair req send_to({}) error {:?}", id, to, e);
+                            0
+                        });
+                }
+            }
+            let res = r_reader.recv_timeout(Duration::new(1, 0));
+            if let Ok(mut packets) = res {
+                while let Ok(mut more) = r_reader.try_recv() {
+                    packets.packets.append_pinned(&mut more.packets);
+                }
+                let shreds: Vec<Shred> = packets
+                    .packets
+                    .into_iter()
+                    .filter_map(|p| Shred::new_from_serialized_shred(p.data.to_vec()).ok())
+                    .collect();
+                blockstore.insert_shreds(shreds, None, false)?;
+            }
+            // check if all the slots in the segment are complete
+            if Self::segment_complete(start_slot, slots_per_segment, blockstore) {
+                break;
+            }
+            sleep(Duration::from_millis(500));
+        }
+        exit.store(true, Ordering::Relaxed);
+        t_receiver.join().unwrap();
+
+        // check if all the slots in the segment are complete
+        if !Self::segment_complete(start_slot, slots_per_segment, blockstore) {
+            return Err(ArchiverError::SegmentDownloadError);
+        }
+        Ok(start_slot)
+    }
+
+    fn segment_complete(
+        start_slot: Slot,
+        slots_per_segment: u64,
+        blockstore: &Arc<Blockstore>,
+    ) -> bool {
+        for slot in start_slot..(start_slot + slots_per_segment) {
+            if !blockstore.is_full(slot) {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn get_archiver_segment_slot(to: SocketAddr) -> u64 {
+        let (_port, socket) = bind_in_range(VALIDATOR_PORT_RANGE).unwrap();
+        socket
+            .set_read_timeout(Some(Duration::from_secs(5)))
+            .unwrap();
+
+        let req = ArchiverRequest::GetSlotHeight(socket.local_addr().unwrap());
+        let serialized_req = bincode::serialize(&req).unwrap();
+        for _ in 0..10 {
+            socket.send_to(&serialized_req, to).unwrap();
+            let mut buf = [0; 1024];
+            if let Ok((size, _addr)) = socket.recv_from(&mut buf) {
+                // Ignore bad packet and try again
+                if let Ok(slot) = bincode::config()
+                    .limit(PACKET_DATA_SIZE as u64)
+                    .deserialize(&buf[..size])
+                {
+                    return slot;
+                }
+            }
+            sleep(Duration::from_millis(500));
+        }
+        panic!("Couldn't get segment slot from archiver!");
+    }
+}
--- a/archiver-lib/src/lib.rs
+++ b/archiver-lib/src/lib.rs
@ -1,10 +1,11 @@
-pub mod packet;
-pub mod recvmmsg;
-pub mod sendmmsg;
-pub mod streamer;
-
 #[macro_use]
 extern crate log;

+#[macro_use]
+extern crate serde_derive;
+
 #[macro_use]
 extern crate solana_metrics;
+
+pub mod archiver;
+mod result;
--- a/archiver-lib/src/result.rs
+++ b/archiver-lib/src/result.rs
@ -0,0 +1,48 @@
+use serde_json;
+use solana_client::client_error;
+use solana_ledger::blockstore;
+use solana_sdk::transport;
+use std::any::Any;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ArchiverError {
+    #[error("IO error")]
+    IO(#[from] std::io::Error),
+
+    #[error("blockstore error")]
+    BlockstoreError(#[from] blockstore::BlockstoreError),
+
+    #[error("crossbeam error")]
+    CrossbeamSendError(#[from] crossbeam_channel::SendError<u64>),
+
+    #[error("send error")]
+    SendError(#[from] std::sync::mpsc::SendError<u64>),
+
+    #[error("join error")]
+    JoinError(Box<dyn Any + Send + 'static>),
+
+    #[error("transport error")]
+    TransportError(#[from] transport::TransportError),
+
+    #[error("client error")]
+    ClientError(#[from] client_error::ClientError),
+
+    #[error("Json parsing error")]
+    JsonError(#[from] serde_json::error::Error),
+
+    #[error("Storage account has no balance")]
+    EmptyStorageAccountBalance,
+
+    #[error("No RPC peers..")]
+    NoRpcPeers,
+
+    #[error("Couldn't download full segment")]
+    SegmentDownloadError,
+}
+
+impl std::convert::From<Box<dyn Any + Send + 'static>> for ArchiverError {
+    fn from(e: Box<dyn Any + Send + 'static>) -> ArchiverError {
+        ArchiverError::JoinError(e)
+    }
+}
--- a/archiver-utils/Cargo.toml
+++ b/archiver-utils/Cargo.toml
@ -0,0 +1,25 @@
+[package]
+name = "solana-archiver-utils"
+version = "1.0.2"
+description = "Solana Archiver Utils"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+rand = "0.6.5"
+solana-chacha = { path = "../chacha", version = "1.0.2" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.0.2" }
+solana-ledger = { path = "../ledger", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-perf = { path = "../perf", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+
+[dev-dependencies]
+hex = "0.4.0"
+
+[lib]
+name = "solana_archiver_utils"
--- a/archiver-utils/src/lib.rs
+++ b/archiver-utils/src/lib.rs
@ -0,0 +1,120 @@
+#[macro_use]
+extern crate log;
+
+use solana_sdk::hash::{Hash, Hasher};
+use std::fs::File;
+use std::io::{self, BufReader, ErrorKind, Read, Seek, SeekFrom};
+use std::mem::size_of;
+use std::path::Path;
+
+pub fn sample_file(in_path: &Path, sample_offsets: &[u64]) -> io::Result<Hash> {
+    let in_file = File::open(in_path)?;
+    let metadata = in_file.metadata()?;
+    let mut buffer_file = BufReader::new(in_file);
+
+    let mut hasher = Hasher::default();
+    let sample_size = size_of::<Hash>();
+    let sample_size64 = sample_size as u64;
+    let mut buf = vec![0; sample_size];
+
+    let file_len = metadata.len();
+    if file_len < sample_size64 {
+        return Err(io::Error::new(ErrorKind::Other, "file too short!"));
+    }
+    for offset in sample_offsets {
+        if *offset > (file_len - sample_size64) / sample_size64 {
+            return Err(io::Error::new(ErrorKind::Other, "offset too large"));
+        }
+        buffer_file.seek(SeekFrom::Start(*offset * sample_size64))?;
+        trace!("sampling @ {} ", *offset);
+        match buffer_file.read(&mut buf) {
+            Ok(size) => {
+                assert_eq!(size, buf.len());
+                hasher.hash(&buf);
+            }
+            Err(e) => {
+                warn!("Error sampling file");
+                return Err(e);
+            }
+        }
+    }
+
+    Ok(hasher.result())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::{thread_rng, Rng};
+    use std::fs::{create_dir_all, remove_file};
+    use std::io::Write;
+    use std::path::PathBuf;
+
+    extern crate hex;
+
+    fn tmp_file_path(name: &str) -> PathBuf {
+        use std::env;
+        let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let mut rand_bits = [0u8; 32];
+        thread_rng().fill(&mut rand_bits[..]);
+
+        let mut path = PathBuf::new();
+        path.push(out_dir);
+        path.push("tmp");
+        create_dir_all(&path).unwrap();
+
+        path.push(format!("{}-{:?}", name, hex::encode(rand_bits)));
+        println!("path: {:?}", path);
+        path
+    }
+
+    #[test]
+    fn test_sample_file() {
+        solana_logger::setup();
+        let in_path = tmp_file_path("test_sample_file_input.txt");
+        let num_strings = 4096;
+        let string = "12foobar";
+        {
+            let mut in_file = File::create(&in_path).unwrap();
+            for _ in 0..num_strings {
+                in_file.write(string.as_bytes()).unwrap();
+            }
+        }
+        let num_samples = (string.len() * num_strings / size_of::<Hash>()) as u64;
+        let samples: Vec<_> = (0..num_samples).collect();
+        let res = sample_file(&in_path, samples.as_slice());
+        let ref_hash: Hash = Hash::new(&[
+            173, 251, 182, 165, 10, 54, 33, 150, 133, 226, 106, 150, 99, 192, 179, 1, 230, 144,
+            151, 126, 18, 191, 54, 67, 249, 140, 230, 160, 56, 30, 170, 52,
+        ]);
+        let res = res.unwrap();
+        assert_eq!(res, ref_hash);
+
+        // Sample just past the end
+        assert!(sample_file(&in_path, &[num_samples]).is_err());
+        remove_file(&in_path).unwrap();
+    }
+
+    #[test]
+    fn test_sample_file_invalid_offset() {
+        let in_path = tmp_file_path("test_sample_file_invalid_offset_input.txt");
+        {
+            let mut in_file = File::create(&in_path).unwrap();
+            for _ in 0..4096 {
+                in_file.write("123456foobar".as_bytes()).unwrap();
+            }
+        }
+        let samples = [0, 200000];
+        let res = sample_file(&in_path, &samples);
+        assert!(res.is_err());
+        remove_file(in_path).unwrap();
+    }
+
+    #[test]
+    fn test_sample_file_missing_file() {
+        let in_path = tmp_file_path("test_sample_file_that_doesnt_exist.txt");
+        let samples = [0, 5];
+        let res = sample_file(&in_path, &samples);
+        assert!(res.is_err());
+    }
+}
--- a/archiver/.gitignore
+++ b/archiver/.gitignore
--- a/archiver/Cargo.toml
+++ b/archiver/Cargo.toml
@ -0,0 +1,20 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-archiver"
+version = "1.0.2"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+
+[dependencies]
+clap = "2.33.0"
+console = "0.9.2"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.2" }
+solana-core = { path = "../core", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-metrics = { path = "../metrics", version = "1.0.2" }
+solana-archiver-lib = { path = "../archiver-lib", version = "1.0.2" }
+solana-net-utils = { path = "../net-utils", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+
--- a/archiver/src/main.rs
+++ b/archiver/src/main.rs
@ -0,0 +1,147 @@
+use clap::{crate_description, crate_name, App, Arg};
+use console::style;
+use solana_archiver_lib::archiver::Archiver;
+use solana_clap_utils::{
+    input_validators::is_keypair,
+    keypair::{
+        self, keypair_input, KeypairWithSource, ASK_SEED_PHRASE_ARG,
+        SKIP_SEED_PHRASE_VALIDATION_ARG,
+    },
+};
+use solana_core::{
+    cluster_info::{Node, VALIDATOR_PORT_RANGE},
+    contact_info::ContactInfo,
+};
+use solana_sdk::{commitment_config::CommitmentConfig, signature::Signer};
+use std::{net::SocketAddr, path::PathBuf, process::exit, sync::Arc};
+
+fn main() {
+    solana_logger::setup();
+
+    let matches = App::new(crate_name!())
+        .about(crate_description!())
+        .version(solana_clap_utils::version!())
+        .arg(
+            Arg::with_name("identity_keypair")
+                .short("i")
+                .long("identity-keypair")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair)
+                .help("File containing an identity (keypair)"),
+        )
+        .arg(
+            Arg::with_name("entrypoint")
+                .short("n")
+                .long("entrypoint")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .required(true)
+                .validator(solana_net_utils::is_host_port)
+                .help("Rendezvous with the cluster at this entry point"),
+        )
+        .arg(
+            Arg::with_name("ledger")
+                .short("l")
+                .long("ledger")
+                .value_name("DIR")
+                .takes_value(true)
+                .required(true)
+                .help("use DIR as persistent ledger location"),
+        )
+        .arg(
+            Arg::with_name("storage_keypair")
+                .short("s")
+                .long("storage-keypair")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair)
+                .help("File containing the storage account keypair"),
+        )
+        .arg(
+            Arg::with_name(ASK_SEED_PHRASE_ARG.name)
+                .long(ASK_SEED_PHRASE_ARG.long)
+                .value_name("KEYPAIR NAME")
+                .multiple(true)
+                .takes_value(true)
+                .possible_values(&["identity-keypair", "storage-keypair"])
+                .help(ASK_SEED_PHRASE_ARG.help),
+        )
+        .arg(
+            Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
+                .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
+                .requires(ASK_SEED_PHRASE_ARG.name)
+                .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
+        )
+        .get_matches();
+
+    let ledger_path = PathBuf::from(matches.value_of("ledger").unwrap());
+
+    let identity_keypair = keypair_input(&matches, "identity_keypair")
+        .unwrap_or_else(|err| {
+            eprintln!("Identity keypair input failed: {}", err);
+            exit(1);
+        })
+        .keypair;
+    let KeypairWithSource {
+        keypair: storage_keypair,
+        source: storage_keypair_source,
+    } = keypair_input(&matches, "storage_keypair").unwrap_or_else(|err| {
+        eprintln!("Storage keypair input failed: {}", err);
+        exit(1);
+    });
+    if storage_keypair_source == keypair::Source::Generated {
+        clap::Error::with_description(
+            "The `storage-keypair` argument was not found",
+            clap::ErrorKind::ArgumentNotFound,
+        )
+        .exit();
+    }
+
+    let entrypoint_addr = matches
+        .value_of("entrypoint")
+        .map(|entrypoint| {
+            solana_net_utils::parse_host_port(entrypoint)
+                .expect("failed to parse entrypoint address")
+        })
+        .unwrap();
+
+    let gossip_addr = {
+        let ip = solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap();
+        let mut addr = SocketAddr::new(ip, 0);
+        addr.set_ip(solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap());
+        addr
+    };
+    let node = Node::new_archiver_with_external_ip(
+        &identity_keypair.pubkey(),
+        &gossip_addr,
+        VALIDATOR_PORT_RANGE,
+    );
+
+    println!(
+        "{} version {} (branch={}, commit={})",
+        style(crate_name!()).bold(),
+        solana_clap_utils::version!(),
+        option_env!("CI_BRANCH").unwrap_or("unknown"),
+        option_env!("CI_COMMIT").unwrap_or("unknown")
+    );
+    solana_metrics::set_host_id(identity_keypair.pubkey().to_string());
+    println!(
+        "replicating the data with identity_keypair={:?} gossip_addr={:?}",
+        identity_keypair.pubkey(),
+        gossip_addr
+    );
+
+    let entrypoint_info = ContactInfo::new_gossip_entry_point(&entrypoint_addr);
+    let archiver = Archiver::new(
+        &ledger_path,
+        node,
+        entrypoint_info,
+        Arc::new(identity_keypair),
+        Arc::new(storage_keypair),
+        CommitmentConfig::recent(),
+    )
+    .unwrap();
+
+    archiver.join();
+}
--- a/banking-bench/Cargo.toml
+++ b/banking-bench/Cargo.toml
@ -2,27 +2,19 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.2.2"
+version = "1.0.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"

 [dependencies]
-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.2" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.2" }
-solana-streamer = { path = "../streamer", version = "1.2.2" }
-solana-perf = { path = "../perf", version = "1.2.2" }
-solana-ledger = { path = "../ledger", version = "1.2.2" }
-solana-logger = { path = "../logger", version = "1.2.2" }
-solana-runtime = { path = "../runtime", version = "1.2.2" }
-solana-measure = { path = "../measure", version = "1.2.2" }
-solana-sdk = { path = "../sdk", version = "1.2.2" }
-solana-version = { path = "../version", version = "1.2.2" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+rayon = "1.2.0"
+solana-core = { path = "../core", version = "1.0.2" }
+solana-ledger = { path = "../ledger", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-runtime = { path = "../runtime", version = "1.0.2" }
+solana-measure = { path = "../measure", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+rand = "0.6.5"
+crossbeam-channel = "0.3"
--- a/banking-bench/src/main.rs
+++ b/banking-bench/src/main.rs
@ -1,38 +1,30 @@
-use clap::{crate_description, crate_name, value_t, App, Arg};
 use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
 use rayon::prelude::*;
-use solana_core::{
-    banking_stage::{create_test_recorder, BankingStage},
-    cluster_info::ClusterInfo,
-    cluster_info::Node,
-    poh_recorder::PohRecorder,
-    poh_recorder::WorkingBankEntry,
-};
-use solana_ledger::{
-    bank_forks::BankForks,
-    blockstore::Blockstore,
-    genesis_utils::{create_genesis_config, GenesisConfigInfo},
-    get_tmp_ledger_path,
-};
+use solana_core::banking_stage::{create_test_recorder, BankingStage};
+use solana_core::cluster_info::ClusterInfo;
+use solana_core::cluster_info::Node;
+use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
+use solana_core::packet::to_packets_chunked;
+use solana_core::poh_recorder::PohRecorder;
+use solana_core::poh_recorder::WorkingBankEntry;
+use solana_ledger::bank_forks::BankForks;
+use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
 use solana_measure::measure::Measure;
-use solana_perf::packet::to_packets_chunked;
 use solana_runtime::bank::Bank;
-use solana_sdk::{
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Keypair,
-    signature::Signature,
-    system_transaction,
-    timing::{duration_as_us, timestamp},
-    transaction::Transaction,
-};
-use std::{
-    sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex},
-    thread::sleep,
-    time::{Duration, Instant},
-};
+use solana_sdk::hash::Hash;
+use solana_sdk::pubkey::Pubkey;
+use solana_sdk::signature::Keypair;
+use solana_sdk::signature::Signature;
+use solana_sdk::system_transaction;
+use solana_sdk::timing::{duration_as_us, timestamp};
+use solana_sdk::transaction::Transaction;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc::Receiver;
+use std::sync::{Arc, Mutex, RwLock};
+use std::thread::sleep;
+use std::time::{Duration, Instant};

 fn check_txs(
    receiver: &Arc<Receiver<WorkingBankEntry>>,
@ -65,22 +57,15 @@ fn check_txs(
    no_bank
 }

-fn make_accounts_txs(
-    total_num_transactions: usize,
-    hash: Hash,
-    same_payer: bool,
-) -> Vec<Transaction> {
+fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> {
    let to_pubkey = Pubkey::new_rand();
-    let payer_key = Keypair::new();
-    let dummy = system_transaction::transfer(&payer_key, &to_pubkey, 1, hash);
-    (0..total_num_transactions)
+    let dummy = system_transaction::transfer(mint_keypair, &to_pubkey, 1, hash);
+    (0..txes)
        .into_par_iter()
        .map(|_| {
            let mut new = dummy.clone();
            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            if !same_payer {
-                new.message.account_keys[0] = Pubkey::new_rand();
-            }
+            new.message.account_keys[0] = Pubkey::new_rand();
            new.message.account_keys[1] = Pubkey::new_rand();
            new.signatures = vec![Signature::new(&sig[0..64])];
            new
@ -104,61 +89,13 @@ fn bytes_as_usize(bytes: &[u8]) -> usize {
    bytes[0] as usize | (bytes[1] as usize) << 8
 }

-#[allow(clippy::cognitive_complexity)]
 fn main() {
    solana_logger::setup();
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("num_chunks")
-                .long("num-chunks")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Number of transaction chunks."),
-        )
-        .arg(
-            Arg::with_name("packets_per_chunk")
-                .long("packets-per-chunk")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Packets per chunk"),
-        )
-        .arg(
-            Arg::with_name("skip_sanity")
-                .long("skip-sanity")
-                .takes_value(false)
-                .help("Skip transaction sanity execution"),
-        )
-        .arg(
-            Arg::with_name("same_payer")
-                .long("same-payer")
-                .takes_value(false)
-                .help("Use the same payer for transfers"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .arg(
-            Arg::with_name("num_threads")
-                .long("num-threads")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .get_matches();
-
-    let num_threads =
-        value_t!(matches, "num_threads", usize).unwrap_or(BankingStage::num_threads() as usize);
+    let num_threads = BankingStage::num_threads() as usize;
    //   a multiple of packet chunk duplicates to avoid races
-    let num_chunks = value_t!(matches, "num_chunks", usize).unwrap_or(16);
-    let packets_per_chunk = value_t!(matches, "packets_per_chunk", usize).unwrap_or(192);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(1000);
-
-    let total_num_transactions = num_chunks * num_threads * packets_per_chunk;
+    const CHUNKS: usize = 8 * 2;
+    const PACKETS_PER_BATCH: usize = 192;
+    let txes = PACKETS_PER_BATCH * num_threads * CHUNKS;
    let mint_total = 1_000_000_000_000;
    let GenesisConfigInfo {
        genesis_config,
@ -169,47 +106,37 @@ fn main() {
    let (verified_sender, verified_receiver) = unbounded();
    let (vote_sender, vote_receiver) = unbounded();
    let bank0 = Bank::new(&genesis_config);
-    let mut bank_forks = BankForks::new(bank0);
+    let mut bank_forks = BankForks::new(0, bank0);
    let mut bank = bank_forks.working_bank();

-    info!("threads: {} txs: {}", num_threads, total_num_transactions);
+    info!("threads: {} txs: {}", num_threads, txes);

-    let same_payer = matches.is_present("same_payer");
-    let mut transactions =
-        make_accounts_txs(total_num_transactions, genesis_config.hash(), same_payer);
+    let mut transactions = make_accounts_txs(txes, &mint_keypair, genesis_config.hash());

    // fund all the accounts
    transactions.iter().for_each(|tx| {
-        let mut fund = system_transaction::transfer(
+        let fund = system_transaction::transfer(
            &mint_keypair,
            &tx.message.account_keys[0],
-            mint_total / total_num_transactions as u64,
+            mint_total / txes as u64,
            genesis_config.hash(),
        );
-        // Ignore any pesky duplicate signature errors in the case we are using single-payer
-        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-        fund.signatures = vec![Signature::new(&sig[0..64])];
        let x = bank.process_transaction(&fund);
        x.unwrap();
    });
-
-    let skip_sanity = matches.is_present("skip_sanity");
-    if !skip_sanity {
-        //sanity check, make sure all the transactions can execute sequentially
-        transactions.iter().for_each(|tx| {
-            let res = bank.process_transaction(&tx);
-            assert!(res.is_ok(), "sanity test transactions error: {:?}", res);
-        });
-        bank.clear_signatures();
-        //sanity check, make sure all the transactions can execute in parallel
-        let res = bank.process_transactions(&transactions);
-        for r in res {
-            assert!(r.is_ok(), "sanity parallel execution error: {:?}", r);
-        }
-        bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute sequentially
+    transactions.iter().for_each(|tx| {
+        let res = bank.process_transaction(&tx);
+        assert!(res.is_ok(), "sanity test transactions");
+    });
+    bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute in parallel
+    let res = bank.process_transactions(&transactions);
+    for r in res {
+        assert!(r.is_ok(), "sanity parallel execution");
    }
-
-    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), packets_per_chunk);
+    bank.clear_signatures();
+    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
    let ledger_path = get_tmp_ledger_path!();
    {
        let blockstore = Arc::new(
@ -218,7 +145,7 @@ fn main() {
        let (exit, poh_recorder, poh_service, signal_receiver) =
            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 cluster_info = Arc::new(RwLock::new(cluster_info));
        let banking_stage = BankingStage::new(
            &cluster_info,
            &poh_recorder,
@ -228,7 +155,7 @@ fn main() {
        );
        poh_recorder.lock().unwrap().set_bank(&bank);

-        let chunk_len = verified.len() / num_chunks;
+        let chunk_len = verified.len() / CHUNKS;
        let mut start = 0;

        // This is so that the signal_receiver does not go out of scope after the closure.
@ -237,17 +164,17 @@ fn main() {
        let signal_receiver = Arc::new(signal_receiver);
        let mut total_us = 0;
        let mut tx_total_us = 0;
-        let base_tx_count = bank.transaction_count();
        let mut txs_processed = 0;
        let mut root = 1;
        let collector = Pubkey::new_rand();
+        const ITERS: usize = 1_000;
        let config = Config {
-            packets_per_batch: packets_per_chunk,
+            packets_per_batch: PACKETS_PER_BATCH,
            chunk_len,
            num_threads,
        };
        let mut total_sent = 0;
-        for _ in 0..iterations {
+        for _ in 0..ITERS {
            let now = Instant::now();
            let mut sent = 0;

@ -288,11 +215,7 @@ fn main() {
                    sleep(Duration::from_millis(5));
                }
            }
-            if check_txs(
-                &signal_receiver,
-                total_num_transactions / num_chunks,
-                &poh_recorder,
-            ) {
+            if check_txs(&signal_receiver, txes / CHUNKS, &poh_recorder) {
                debug!(
                    "resetting bank {} tx count: {} txs_proc: {}",
                    bank.slot(),
@ -323,7 +246,7 @@ fn main() {
                poh_recorder.lock().unwrap().set_bank(&bank);
                assert!(poh_recorder.lock().unwrap().bank().is_some());
                if bank.slot() > 32 {
-                    bank_forks.set_root(root, &None, None);
+                    bank_forks.set_root(root, &None);
                    root += 1;
                }
                debug!(
@ -344,7 +267,7 @@ fn main() {
            debug!(
                "time: {} us checked: {} sent: {}",
                duration_as_us(&now.elapsed()),
-                total_num_transactions / num_chunks,
+                txes / CHUNKS,
                sent,
            );
            total_sent += sent;
@ -355,26 +278,20 @@ fn main() {
                    let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
                    tx.signatures[0] = Signature::new(&sig[0..64]);
                }
-                verified = to_packets_chunked(&transactions.clone(), packets_per_chunk);
+                verified = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
            }

            start += chunk_len;
            start %= verified.len();
        }
-        let txs_processed = bank_forks.working_bank().transaction_count();
-        debug!("processed: {} base: {}", txs_processed, base_tx_count);
        eprintln!(
-            "{{'name': 'banking_bench_total', 'median': '{:.2}'}}",
+            "{{'name': 'banking_bench_total', 'median': '{}'}}",
            (1000.0 * 1000.0 * total_sent as f64) / (total_us as f64),
        );
        eprintln!(
-            "{{'name': 'banking_bench_tx_total', 'median': '{:.2}'}}",
+            "{{'name': 'banking_bench_tx_total', 'median': '{}'}}",
            (1000.0 * 1000.0 * total_sent as f64) / (tx_total_us as f64),
        );
-        eprintln!(
-            "{{'name': 'banking_bench_success_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * (txs_processed - base_tx_count) as f64) / (total_us as f64),
-        );

        drop(verified_sender);
        drop(vote_sender);
--- a/bench-exchange/Cargo.toml
+++ b/bench-exchange/Cargo.toml
@ -2,37 +2,33 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.2.2"
+version = "1.0.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 publish = false

 [dependencies]
-clap = "2.33.1"
-itertools = "0.9.0"
+clap = "2.32.0"
+itertools = "0.8.2"
 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.2" }
-solana-core = { path = "../core", version = "1.2.2" }
-solana-genesis = { path = "../genesis", version = "1.2.2" }
-solana-client = { path = "../client", version = "1.2.2" }
-solana-faucet = { path = "../faucet", version = "1.2.2" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.2.2" }
-solana-logger = { path = "../logger", version = "1.2.2" }
-solana-metrics = { path = "../metrics", version = "1.2.2" }
-solana-net-utils = { path = "../net-utils", version = "1.2.2" }
-solana-runtime = { path = "../runtime", version = "1.2.2" }
-solana-sdk = { path = "../sdk", version = "1.2.2" }
-solana-version = { path = "../version", version = "1.2.2" }
+rand = "0.6.5"
+rayon = "1.2.0"
+serde_json = "1.0.46"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.2" }
+solana-core = { path = "../core", version = "1.0.2" }
+solana-genesis = { path = "../genesis", version = "1.0.2" }
+solana-client = { path = "../client", version = "1.0.2" }
+solana-faucet = { path = "../faucet", version = "1.0.2" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-metrics = { path = "../metrics", version = "1.0.2" }
+solana-net-utils = { path = "../net-utils", version = "1.0.2" }
+solana-runtime = { path = "../runtime", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }

 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.2.2" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+solana-local-cluster = { path = "../local-cluster", version = "1.0.2" }
--- a/bench-exchange/src/bench.rs
+++ b/bench-exchange/src/bench.rs
@ -449,7 +449,7 @@ fn swapper<T>(
            }
            account_group = (account_group + 1) % account_groups as usize;

-            let (blockhash, _fee_calculator, _last_valid_slot) = client
+            let (blockhash, _fee_calculator) = client
                .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                .expect("Failed to get blockhash");
            let to_swap_txs: Vec<_> = to_swap
@ -459,7 +459,7 @@ fn swapper<T>(
                    let owner = &signer.pubkey();
                    Transaction::new_signed_instructions(
                        &[s],
-                        &[exchange_instruction::swap_request(
+                        vec![exchange_instruction::swap_request(
                            owner,
                            &swap.0.pubkey,
                            &swap.1.pubkey,
@ -577,7 +577,7 @@ fn trader<T>(
        }
        account_group = (account_group + 1) % account_groups as usize;

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

@ -590,7 +590,7 @@ fn trader<T>(
                    let space = mem::size_of::<ExchangeState>() as u64;
                    Transaction::new_signed_instructions(
                        &[owner.as_ref(), trade],
-                        &[
+                        vec![
                            system_instruction::create_account(
                                owner_pubkey,
                                trade_pubkey,
@ -749,7 +749,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                .map(|(k, m)| {
                    (
                        k.clone(),
-                        Transaction::new_unsigned_instructions(&system_instruction::transfer_many(
+                        Transaction::new_unsigned_instructions(system_instruction::transfer_many(
                            &k.pubkey(),
                            &m,
                        )),
@ -760,10 +760,9 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
            let mut retries = 0;
            let amount = chunk[0].1[0].1;
            while !to_fund_txs.is_empty() {
-                let receivers: usize = to_fund_txs
+                let receivers = to_fund_txs
                    .iter()
-                    .map(|(_, tx)| tx.message().instructions.len())
-                    .sum();
+                    .fold(0, |len, (_, tx)| len + tx.message().instructions.len());

                debug!(
                    "  {} to {} in {} txs",
@ -776,7 +775,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                    to_fund_txs.len(),
                );

-                let (blockhash, _fee_calculator, _last_valid_slot) = client
+                let (blockhash, _fee_calculator) = client
                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                    .expect("blockhash");
                to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
@ -850,15 +849,14 @@ pub fn create_token_accounts<T: Client>(
                        exchange_instruction::account_request(owner_pubkey, &new_keypair.pubkey());
                    (
                        (from_keypair, new_keypair),
-                        Transaction::new_unsigned_instructions(&[create_ix, request_ix]),
+                        Transaction::new_unsigned_instructions(vec![create_ix, request_ix]),
                    )
                })
                .collect();

-            let accounts: usize = to_create_txs
+            let accounts = to_create_txs
                .iter()
-                .map(|(_, tx)| tx.message().instructions.len() / 2)
-                .sum();
+                .fold(0, |len, (_, tx)| len + tx.message().instructions.len() / 2);

            debug!(
                "  Creating {} accounts in {} txs",
@ -868,7 +866,7 @@ pub fn create_token_accounts<T: Client>(

            let mut retries = 0;
            while !to_create_txs.is_empty() {
-                let (blockhash, _fee_calculator, _last_valid_slot) = client
+                let (blockhash, _fee_calculator) = client
                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                    .expect("Failed to get blockhash");
                to_create_txs
@ -997,7 +995,7 @@ pub fn airdrop_lamports<T: Client>(

    let mut tries = 0;
    loop {
-        let (blockhash, _fee_calculator, _last_valid_slot) = client
+        let (blockhash, _fee_calculator) = 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) {
--- a/bench-exchange/src/main.rs
+++ b/bench-exchange/src/main.rs
@ -11,7 +11,7 @@ fn main() {
    solana_logger::setup();
    solana_metrics::set_panic_hook("bench-exchange");

-    let matches = cli::build_args(solana_version::version!()).get_matches();
+    let matches = cli::build_args(solana_clap_utils::version!()).get_matches();
    let cli_config = cli::extract_args(&matches);

    let cli::Config {
@ -54,9 +54,10 @@ fn main() {
        );
    } else {
        info!("Connecting to the cluster");
-        let nodes = discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
-            panic!("Failed to discover nodes");
-        });
+        let (nodes, _archivers) =
+            discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
+                panic!("Failed to discover nodes");
+            });

        let (client, num_clients) = get_multi_client(&nodes);

--- a/bench-exchange/tests/bench_exchange.rs
+++ b/bench-exchange/tests/bench_exchange.rs
@ -59,7 +59,7 @@ fn test_exchange_local_cluster() {
    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();

    info!("Connecting to the cluster");
-    let nodes =
+    let (nodes, _) =
        discover_cluster(&cluster.entry_point_info.gossip, NUM_NODES).unwrap_or_else(|err| {
            error!("Failed to discover {} nodes: {:?}", NUM_NODES, err);
            exit(1);
@ -86,7 +86,7 @@ fn test_exchange_bank_client() {
    solana_logger::setup();
    let (genesis_config, identity) = create_genesis_config(100_000_000_000_000);
    let mut bank = Bank::new(&genesis_config);
-    bank.add_builtin_program("exchange_program", id(), process_instruction);
+    bank.add_instruction_processor(id(), process_instruction);
    let clients = vec![BankClient::new(bank)];

    let mut config = Config::default();
--- a/bench-streamer/Cargo.toml
+++ b/bench-streamer/Cargo.toml
@ -2,18 +2,14 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.2.2"
+version = "1.0.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.2" }
-solana-streamer = { path = "../streamer", version = "1.2.2" }
-solana-logger = { path = "../logger", version = "1.2.2" }
-solana-net-utils = { path = "../net-utils", version = "1.2.2" }
-solana-version = { path = "../version", version = "1.2.2" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+clap = "2.33.0"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.2" }
+solana-core = { path = "../core", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-net-utils = { path = "../net-utils", version = "1.0.2" }
--- a/bench-streamer/src/main.rs
+++ b/bench-streamer/src/main.rs
@ -1,6 +1,6 @@
 use clap::{crate_description, crate_name, App, Arg};
-use solana_streamer::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE};
-use solana_streamer::streamer::{receiver, PacketReceiver};
+use solana_core::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE};
+use solana_core::streamer::{receiver, PacketReceiver};
 use std::cmp::max;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
@ -52,7 +52,7 @@ fn main() -> Result<()> {

    let matches = App::new(crate_name!())
        .about(crate_description!())
-        .version(solana_version::version!())
+        .version(solana_clap_utils::version!())
        .arg(
            Arg::with_name("num-recv-sockets")
                .long("num-recv-sockets")
@ -67,8 +67,7 @@ fn main() -> Result<()> {
    }

    let mut port = 0;
-    let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
-    let mut addr = SocketAddr::new(ip_addr, 0);
+    let mut addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);

    let exit = Arc::new(AtomicBool::new(false));

@ -76,7 +75,7 @@ fn main() -> Result<()> {
    let mut read_threads = Vec::new();
    let recycler = PacketsRecycler::default();
    for _ in 0..num_sockets {
-        let read = solana_net_utils::bind_to(ip_addr, port, false).unwrap();
+        let read = solana_net_utils::bind_to(port, false).unwrap();
        read.set_read_timeout(Some(Duration::new(1, 0))).unwrap();

        addr = read.local_addr().unwrap();
--- a/bench-tps/Cargo.toml
+++ b/bench-tps/Cargo.toml
@ -2,40 +2,36 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.2.2"
+version = "1.0.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"

 [dependencies]
 bincode = "1.2.1"
-clap = "2.33.1"
+clap = "2.33.0"
 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.2" }
-solana-core = { path = "../core", version = "1.2.2" }
-solana-genesis = { path = "../genesis", version = "1.2.2" }
-solana-client = { path = "../client", version = "1.2.2" }
-solana-faucet = { path = "../faucet", version = "1.2.2" }
-solana-librapay = { path = "../programs/librapay", version = "1.2.2", optional = true }
-solana-logger = { path = "../logger", version = "1.2.2" }
-solana-metrics = { path = "../metrics", version = "1.2.2" }
-solana-measure = { path = "../measure", version = "1.2.2" }
-solana-net-utils = { path = "../net-utils", version = "1.2.2" }
-solana-runtime = { path = "../runtime", version = "1.2.2" }
-solana-sdk = { path = "../sdk", version = "1.2.2" }
-solana-move-loader-program = { path = "../programs/move_loader", version = "1.2.2", optional = true }
-solana-version = { path = "../version", version = "1.2.2" }
+rayon = "1.2.0"
+serde_json = "1.0.46"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.2" }
+solana-core = { path = "../core", version = "1.0.2" }
+solana-genesis = { path = "../genesis", version = "1.0.2" }
+solana-client = { path = "../client", version = "1.0.2" }
+solana-faucet = { path = "../faucet", version = "1.0.2" }
+solana-librapay = { path = "../programs/librapay", version = "1.0.2", optional = true }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-metrics = { path = "../metrics", version = "1.0.2" }
+solana-measure = { path = "../measure", version = "1.0.2" }
+solana-net-utils = { path = "../net-utils", version = "1.0.2" }
+solana-runtime = { path = "../runtime", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+solana-move-loader-program = { path = "../programs/move_loader", version = "1.0.2", optional = true }

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

 [features]
 move = ["solana-librapay", "solana-move-loader-program"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/bench-tps/src/bench.rs
+++ b/bench-tps/src/bench.rs
@ -26,9 +26,9 @@ use std::{
    process::exit,
    sync::{
        atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering},
-        Arc, Mutex, RwLock,
+        Arc, RwLock,
    },
-    thread::{sleep, Builder, JoinHandle},
+    thread::{sleep, Builder},
    time::{Duration, Instant},
 };

@ -55,9 +55,7 @@ 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, _last_valid_slot)) => {
-                return (blockhash, fee_calculator)
-            }
+            Ok((blockhash, fee_calculator)) => return (blockhash, fee_calculator),
            Err(err) => {
                info!("Couldn't get recent blockhash: {:?}", err);
                sleep(Duration::from_secs(1));
@ -66,63 +64,105 @@ fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
    }
 }

-fn wait_for_target_slots_per_epoch<T>(target_slots_per_epoch: u64, client: &Arc<T>)
-where
-    T: 'static + Client + Send + Sync,
-{
-    if target_slots_per_epoch != 0 {
-        info!(
-            "Waiting until epochs are {} slots long..",
-            target_slots_per_epoch
-        );
-        loop {
-            if let Ok(epoch_info) = client.get_epoch_info() {
-                if epoch_info.slots_in_epoch >= target_slots_per_epoch {
-                    info!("Done epoch_info: {:?}", epoch_info);
-                    break;
-                }
-                info!(
-                    "Waiting for epoch: {} now: {}",
-                    target_slots_per_epoch, epoch_info.slots_in_epoch
-                );
-            }
-            sleep(Duration::from_secs(3));
-        }
-    }
-}
-
-fn create_sampler_thread<T>(
-    client: &Arc<T>,
-    exit_signal: &Arc<AtomicBool>,
-    sample_period: u64,
-    maxes: &Arc<RwLock<Vec<(String, SampleStats)>>>,
-) -> JoinHandle<()>
-where
-    T: 'static + Client + Send + Sync,
-{
-    info!("Sampling TPS every {} second...", sample_period);
-    let exit_signal = exit_signal.clone();
-    let maxes = maxes.clone();
-    let client = client.clone();
-    Builder::new()
-        .name("solana-client-sample".to_string())
-        .spawn(move || {
-            sample_txs(&exit_signal, &maxes, sample_period, &client);
-        })
-        .unwrap()
-}
-
-fn generate_chunked_transfers(
-    recent_blockhash: Arc<RwLock<Hash>>,
-    shared_txs: &SharedTransactions,
-    shared_tx_active_thread_count: Arc<AtomicIsize>,
-    source_keypair_chunks: Vec<Vec<&Keypair>>,
-    dest_keypair_chunks: &mut Vec<VecDeque<&Keypair>>,
-    threads: usize,
-    duration: Duration,
-    sustained: bool,
+pub fn do_bench_tps<T>(
+    client: Arc<T>,
+    config: Config,
+    gen_keypairs: Vec<Keypair>,
    libra_args: Option<LibraKeys>,
-) {
+) -> u64
+where
+    T: 'static + Client + Send + Sync,
+{
+    let Config {
+        id,
+        threads,
+        thread_batch_sleep_ms,
+        duration,
+        tx_count,
+        sustained,
+        ..
+    } = config;
+
+    let mut source_keypair_chunks: Vec<Vec<&Keypair>> = Vec::new();
+    let mut dest_keypair_chunks: Vec<VecDeque<&Keypair>> = Vec::new();
+    assert!(gen_keypairs.len() >= 2 * tx_count);
+    for chunk in gen_keypairs.chunks_exact(2 * tx_count) {
+        source_keypair_chunks.push(chunk[..tx_count].iter().collect());
+        dest_keypair_chunks.push(chunk[tx_count..].iter().collect());
+    }
+
+    let first_tx_count = loop {
+        match client.get_transaction_count() {
+            Ok(count) => break count,
+            Err(err) => {
+                info!("Couldn't get transaction count: {:?}", err);
+                sleep(Duration::from_secs(1));
+            }
+        }
+    };
+    info!("Initial transaction count {}", first_tx_count);
+
+    let exit_signal = Arc::new(AtomicBool::new(false));
+
+    // Setup a thread per validator to sample every period
+    // collect the max transaction rate and total tx count seen
+    let maxes = Arc::new(RwLock::new(Vec::new()));
+    let sample_period = 1; // in seconds
+    info!("Sampling TPS every {} second...", sample_period);
+    let sample_thread = {
+        let exit_signal = exit_signal.clone();
+        let maxes = maxes.clone();
+        let client = client.clone();
+        Builder::new()
+            .name("solana-client-sample".to_string())
+            .spawn(move || {
+                sample_txs(&exit_signal, &maxes, sample_period, &client);
+            })
+            .unwrap()
+    };
+
+    let shared_txs: SharedTransactions = Arc::new(RwLock::new(VecDeque::new()));
+
+    let recent_blockhash = Arc::new(RwLock::new(get_recent_blockhash(client.as_ref()).0));
+    let shared_tx_active_thread_count = Arc::new(AtomicIsize::new(0));
+    let total_tx_sent_count = Arc::new(AtomicUsize::new(0));
+
+    let blockhash_thread = {
+        let exit_signal = exit_signal.clone();
+        let recent_blockhash = recent_blockhash.clone();
+        let client = client.clone();
+        let id = id.pubkey();
+        Builder::new()
+            .name("solana-blockhash-poller".to_string())
+            .spawn(move || {
+                poll_blockhash(&exit_signal, &recent_blockhash, &client, &id);
+            })
+            .unwrap()
+    };
+
+    let s_threads: Vec<_> = (0..threads)
+        .map(|_| {
+            let exit_signal = exit_signal.clone();
+            let shared_txs = shared_txs.clone();
+            let shared_tx_active_thread_count = shared_tx_active_thread_count.clone();
+            let total_tx_sent_count = total_tx_sent_count.clone();
+            let client = client.clone();
+            Builder::new()
+                .name("solana-client-sender".to_string())
+                .spawn(move || {
+                    do_tx_transfers(
+                        &exit_signal,
+                        &shared_txs,
+                        &shared_tx_active_thread_count,
+                        &total_tx_sent_count,
+                        thread_batch_sleep_ms,
+                        &client,
+                    );
+                })
+                .unwrap()
+        })
+        .collect();
+
    // generate and send transactions for the specified duration
    let start = Instant::now();
    let keypair_chunks = source_keypair_chunks.len();
@ -130,7 +170,7 @@ fn generate_chunked_transfers(
    let mut chunk_index = 0;
    while start.elapsed() < duration {
        generate_txs(
-            shared_txs,
+            &shared_txs,
            &recent_blockhash,
            &source_keypair_chunks[chunk_index],
            &dest_keypair_chunks[chunk_index],
@ -166,135 +206,6 @@ fn generate_chunked_transfers(
            reclaim_lamports_back_to_source_account = !reclaim_lamports_back_to_source_account;
        }
    }
-}
-
-fn create_sender_threads<T>(
-    client: &Arc<T>,
-    shared_txs: &SharedTransactions,
-    thread_batch_sleep_ms: usize,
-    total_tx_sent_count: &Arc<AtomicUsize>,
-    threads: usize,
-    exit_signal: &Arc<AtomicBool>,
-    shared_tx_active_thread_count: &Arc<AtomicIsize>,
-) -> Vec<JoinHandle<()>>
-where
-    T: 'static + Client + Send + Sync,
-{
-    (0..threads)
-        .map(|_| {
-            let exit_signal = exit_signal.clone();
-            let shared_txs = shared_txs.clone();
-            let shared_tx_active_thread_count = shared_tx_active_thread_count.clone();
-            let total_tx_sent_count = total_tx_sent_count.clone();
-            let client = client.clone();
-            Builder::new()
-                .name("solana-client-sender".to_string())
-                .spawn(move || {
-                    do_tx_transfers(
-                        &exit_signal,
-                        &shared_txs,
-                        &shared_tx_active_thread_count,
-                        &total_tx_sent_count,
-                        thread_batch_sleep_ms,
-                        &client,
-                    );
-                })
-                .unwrap()
-        })
-        .collect()
-}
-
-pub fn do_bench_tps<T>(
-    client: Arc<T>,
-    config: Config,
-    gen_keypairs: Vec<Keypair>,
-    libra_args: Option<LibraKeys>,
-) -> u64
-where
-    T: 'static + Client + Send + Sync,
-{
-    let Config {
-        id,
-        threads,
-        thread_batch_sleep_ms,
-        duration,
-        tx_count,
-        sustained,
-        target_slots_per_epoch,
-        ..
-    } = config;
-
-    let mut source_keypair_chunks: Vec<Vec<&Keypair>> = Vec::new();
-    let mut dest_keypair_chunks: Vec<VecDeque<&Keypair>> = Vec::new();
-    assert!(gen_keypairs.len() >= 2 * tx_count);
-    for chunk in gen_keypairs.chunks_exact(2 * tx_count) {
-        source_keypair_chunks.push(chunk[..tx_count].iter().collect());
-        dest_keypair_chunks.push(chunk[tx_count..].iter().collect());
-    }
-
-    let first_tx_count = loop {
-        match client.get_transaction_count() {
-            Ok(count) => break count,
-            Err(err) => {
-                info!("Couldn't get transaction count: {:?}", err);
-                sleep(Duration::from_secs(1));
-            }
-        }
-    };
-    info!("Initial transaction count {}", first_tx_count);
-
-    let exit_signal = Arc::new(AtomicBool::new(false));
-
-    // Setup a thread per validator to sample every period
-    // collect the max transaction rate and total tx count seen
-    let maxes = Arc::new(RwLock::new(Vec::new()));
-    let sample_period = 1; // in seconds
-    let sample_thread = create_sampler_thread(&client, &exit_signal, sample_period, &maxes);
-
-    let shared_txs: SharedTransactions = Arc::new(RwLock::new(VecDeque::new()));
-
-    let recent_blockhash = Arc::new(RwLock::new(get_recent_blockhash(client.as_ref()).0));
-    let shared_tx_active_thread_count = Arc::new(AtomicIsize::new(0));
-    let total_tx_sent_count = Arc::new(AtomicUsize::new(0));
-
-    let blockhash_thread = {
-        let exit_signal = exit_signal.clone();
-        let recent_blockhash = recent_blockhash.clone();
-        let client = client.clone();
-        let id = id.pubkey();
-        Builder::new()
-            .name("solana-blockhash-poller".to_string())
-            .spawn(move || {
-                poll_blockhash(&exit_signal, &recent_blockhash, &client, &id);
-            })
-            .unwrap()
-    };
-
-    let s_threads = create_sender_threads(
-        &client,
-        &shared_txs,
-        thread_batch_sleep_ms,
-        &total_tx_sent_count,
-        threads,
-        &exit_signal,
-        &shared_tx_active_thread_count,
-    );
-
-    wait_for_target_slots_per_epoch(target_slots_per_epoch, &client);
-
-    let start = Instant::now();
-
-    generate_chunked_transfers(
-        recent_blockhash,
-        &shared_txs,
-        shared_tx_active_thread_count,
-        source_keypair_chunks,
-        &mut dest_keypair_chunks,
-        threads,
-        duration,
-        sustained,
-        libra_args,
-    );

    // Stop the sampling threads so it will collect the stats
    exit_signal.store(true, Ordering::Relaxed);
@ -652,9 +563,10 @@ 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),
-                );
+                let tx = Transaction::new_unsigned_instructions(system_instruction::transfer_many(
+                    &k.pubkey(),
+                    &t,
+                ));
                (*k, tx)
            })
            .collect();
@ -691,9 +603,7 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
        let too_many_failures = Arc::new(AtomicBool::new(false));
        let loops = if starting_txs < 1000 { 3 } else { 1 };
        // Only loop multiple times for small (quick) transaction batches
-        let time = Arc::new(Mutex::new(Instant::now()));
        for _ in 0..loops {
-            let time = time.clone();
            let failed_verify = Arc::new(AtomicUsize::new(0));
            let client = client.clone();
            let verified_txs = &verified_txs;
@ -724,15 +634,11 @@ impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
                            remaining_count, verified_txs, failed_verify
                        );
                    }
-                    if remaining_count > 0 {
-                        let mut time_l = time.lock().unwrap();
-                        if time_l.elapsed().as_secs() > 2 {
-                            info!(
-                                "Verifying transfers... {} remaining, {} verified, {} failures",
-                                remaining_count, verified_txs, failed_verify
-                            );
-                            *time_l = Instant::now();
-                        }
+                    if remaining_count % 100 == 0 {
+                        info!(
+                            "Verifying transfers... {} remaining, {} verified, {} failures",
+                            remaining_count, verified_txs, failed_verify
+                        );
                    }

                    verified
@ -1025,7 +931,7 @@ fn fund_move_keys<T: Client>(
        .collect();
    let tx = Transaction::new_signed_instructions(
        &[funding_key],
-        &system_instruction::transfer_many(&funding_key.pubkey(), &pubkey_amounts),
+        system_instruction::transfer_many(&funding_key.pubkey(), &pubkey_amounts),
        blockhash,
    );
    client.send_message(&[funding_key], tx.message).unwrap();
@ -1153,8 +1059,8 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
    //   pay for the transaction fees in a new run.
    let enough_lamports = 8 * lamports_per_account / 10;
    if first_keypair_balance < enough_lamports || last_keypair_balance < enough_lamports {
-        let fee_rate_governor = client.get_fee_rate_governor().unwrap();
-        let max_fee = fee_rate_governor.max_lamports_per_signature;
+        let (_blockhash, fee_calculator) = get_recent_blockhash(client.as_ref());
+        let max_fee = fee_calculator.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;
@ -1228,7 +1134,7 @@ mod tests {
    use solana_runtime::bank::Bank;
    use solana_runtime::bank_client::BankClient;
    use solana_sdk::client::SyncClient;
-    use solana_sdk::fee_calculator::FeeRateGovernor;
+    use solana_sdk::fee_calculator::FeeCalculator;
    use solana_sdk::genesis_config::create_genesis_config;

    #[test]
@ -1275,8 +1181,8 @@ mod tests {
    #[test]
    fn test_bench_tps_fund_keys_with_fees() {
        let (mut genesis_config, id) = create_genesis_config(10_000);
-        let fee_rate_governor = FeeRateGovernor::new(11, 0);
-        genesis_config.fee_rate_governor = fee_rate_governor;
+        let fee_calculator = FeeCalculator::new(11, 0);
+        genesis_config.fee_calculator = fee_calculator;
        let bank = Bank::new(&genesis_config);
        let client = Arc::new(BankClient::new(bank));
        let keypair_count = 20;
--- a/bench-tps/src/cli.rs
+++ b/bench-tps/src/cli.rs
@ -1,6 +1,6 @@
 use clap::{crate_description, crate_name, App, Arg, ArgMatches};
 use solana_faucet::faucet::FAUCET_PORT;
-use solana_sdk::fee_calculator::FeeRateGovernor;
+use solana_sdk::fee_calculator::FeeCalculator;
 use solana_sdk::signature::{read_keypair_file, Keypair};
 use std::{net::SocketAddr, process::exit, time::Duration};

@ -25,7 +25,6 @@ pub struct Config {
    pub multi_client: bool,
    pub use_move: bool,
    pub num_lamports_per_account: u64,
-    pub target_slots_per_epoch: u64,
 }

 impl Default for Config {
@ -44,11 +43,10 @@ impl Default for Config {
            client_ids_and_stake_file: String::new(),
            write_to_client_file: false,
            read_from_client_file: false,
-            target_lamports_per_signature: FeeRateGovernor::default().target_lamports_per_signature,
+            target_lamports_per_signature: FeeCalculator::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,
        }
    }
 }
@ -174,15 +172,6 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                    "Number of lamports per account.",
                ),
        )
-        .arg(
-            Arg::with_name("target_slots_per_epoch")
-                .long("target-slots-per-epoch")
-                .value_name("SLOTS")
-                .takes_value(true)
-                .help(
-                    "Wait until epochs are this many slots long.",
-                ),
-        )
 }

 /// Parses a clap `ArgMatches` structure into a `Config`
@ -270,12 +259,5 @@ pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
        args.num_lamports_per_account = v.to_string().parse().expect("can't parse lamports");
    }

-    if let Some(t) = matches.value_of("target_slots_per_epoch") {
-        args.target_slots_per_epoch = t
-            .to_string()
-            .parse()
-            .expect("can't parse target slots per epoch");
-    }
-
    args
 }
--- a/bench-tps/src/main.rs
+++ b/bench-tps/src/main.rs
@ -3,7 +3,7 @@ use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate
 use solana_bench_tps::cli;
 use solana_core::gossip_service::{discover_cluster, get_client, get_multi_client};
 use solana_genesis::Base64Account;
-use solana_sdk::fee_calculator::FeeRateGovernor;
+use solana_sdk::fee_calculator::FeeCalculator;
 use solana_sdk::signature::{Keypair, Signer};
 use solana_sdk::system_program;
 use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc};
@ -15,7 +15,7 @@ fn main() {
    solana_logger::setup_with_default("solana=info");
    solana_metrics::set_panic_hook("bench-tps");

-    let matches = cli::build_args(solana_version::version!()).get_matches();
+    let matches = cli::build_args(solana_clap_utils::version!()).get_matches();
    let cli_config = cli::extract_args(&matches);

    let cli::Config {
@ -41,7 +41,7 @@ fn main() {
        let (keypairs, _) = generate_keypairs(&id, keypair_count as u64);
        let num_accounts = keypairs.len() as u64;
        let max_fee =
-            FeeRateGovernor::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
+            FeeCalculator::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
        let num_lamports_per_account = (num_accounts - 1 + NUM_SIGNATURES_FOR_TXS * max_fee)
            / num_accounts
            + num_lamports_per_account;
@ -67,10 +67,11 @@ fn main() {
    }

    info!("Connecting to the cluster");
-    let nodes = discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
-        eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
-        exit(1);
-    });
+    let (nodes, _archivers) =
+        discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
+            eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
+            exit(1);
+        });

    let client = if *multi_client {
        let (client, num_clients) = get_multi_client(&nodes);
--- a/chacha-cuda/Cargo.toml
+++ b/chacha-cuda/Cargo.toml
@ -0,0 +1,24 @@
+[package]
+name = "solana-chacha-cuda"
+version = "1.0.2"
+description = "Solana Chacha Cuda APIs"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+solana-archiver-utils = { path = "../archiver-utils", version = "1.0.2" }
+solana-chacha = { path = "../chacha", version = "1.0.2" }
+solana-ledger = { path = "../ledger", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-perf = { path = "../perf", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha_cuda"
--- a/chacha-cuda/src/chacha_cuda.rs
+++ b/chacha-cuda/src/chacha_cuda.rs
@ -0,0 +1,280 @@
+// Module used by validators to approve storage mining proofs in parallel using the GPU
+
+use solana_chacha::chacha::{CHACHA_BLOCK_SIZE, CHACHA_KEY_SIZE};
+use solana_ledger::blockstore::Blockstore;
+use solana_perf::perf_libs;
+use solana_sdk::hash::Hash;
+use std::io;
+use std::mem::size_of;
+use std::sync::Arc;
+
+// Encrypt a file with multiple starting IV states, determined by ivecs.len()
+//
+// Then sample each block at the offsets provided by samples argument with sha256
+// and return the vec of sha states
+pub fn chacha_cbc_encrypt_file_many_keys(
+    blockstore: &Arc<Blockstore>,
+    segment: u64,
+    slots_per_segment: u64,
+    ivecs: &mut [u8],
+    samples: &[u64],
+) -> io::Result<Vec<Hash>> {
+    let api = perf_libs::api().expect("no perf libs");
+    if ivecs.len() % CHACHA_BLOCK_SIZE != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!(
+                "bad IV length({}) not divisible by {} ",
+                ivecs.len(),
+                CHACHA_BLOCK_SIZE,
+            ),
+        ));
+    }
+
+    const BUFFER_SIZE: usize = 8 * 1024;
+    let mut buffer = [0; BUFFER_SIZE];
+    let num_keys = ivecs.len() / CHACHA_BLOCK_SIZE;
+    let mut sha_states = vec![0; num_keys * size_of::<Hash>()];
+    let mut int_sha_states = vec![0; num_keys * 112];
+    let keys: Vec<u8> = vec![0; num_keys * CHACHA_KEY_SIZE]; // keys not used ATM, uniqueness comes from IV
+    let mut current_slot = segment * slots_per_segment;
+    let mut start_index = 0;
+    let start_slot = current_slot;
+    let mut total_size = 0;
+    let mut time: f32 = 0.0;
+    unsafe {
+        (api.chacha_init_sha_state)(int_sha_states.as_mut_ptr(), num_keys as u32);
+    }
+    loop {
+        match blockstore.get_data_shreds(current_slot, start_index, std::u64::MAX, &mut buffer) {
+            Ok((last_index, mut size)) => {
+                debug!(
+                    "chacha_cuda: encrypting segment: {} num_shreds: {} data_len: {}",
+                    segment,
+                    last_index.saturating_sub(start_index),
+                    size
+                );
+
+                if size == 0 {
+                    if current_slot.saturating_sub(start_slot) < slots_per_segment {
+                        current_slot += 1;
+                        start_index = 0;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                if size < BUFFER_SIZE {
+                    // round to the nearest key_size boundary
+                    size = (size + CHACHA_KEY_SIZE - 1) & !(CHACHA_KEY_SIZE - 1);
+                }
+
+                unsafe {
+                    (api.chacha_cbc_encrypt_many_sample)(
+                        buffer[..size].as_ptr(),
+                        int_sha_states.as_mut_ptr(),
+                        size,
+                        keys.as_ptr(),
+                        ivecs.as_mut_ptr(),
+                        num_keys as u32,
+                        samples.as_ptr(),
+                        samples.len() as u32,
+                        total_size,
+                        &mut time,
+                    );
+                }
+
+                total_size += size as u64;
+                start_index = last_index + 1;
+            }
+            Err(e) => {
+                info!("Error encrypting file: {:?}", e);
+                break;
+            }
+        }
+    }
+    unsafe {
+        (api.chacha_end_sha_state)(
+            int_sha_states.as_ptr(),
+            sha_states.as_mut_ptr(),
+            num_keys as u32,
+        );
+    }
+    let mut res = Vec::new();
+    for x in 0..num_keys {
+        let start = x * size_of::<Hash>();
+        let end = start + size_of::<Hash>();
+        res.push(Hash::new(&sha_states[start..end]));
+    }
+    Ok(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_archiver_utils::sample_file;
+    use solana_chacha::chacha::chacha_cbc_encrypt_ledger;
+    use solana_ledger::entry::create_ticks;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_sdk::clock::DEFAULT_SLOTS_PER_SEGMENT;
+    use solana_sdk::signature::Keypair;
+    use std::fs::{remove_dir_all, remove_file};
+    use std::path::Path;
+
+    #[test]
+    fn test_encrypt_file_many_keys_single() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let slots_per_segment = 32;
+        let entries = create_ticks(slots_per_segment, 0, Hash::default());
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 16;
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                Some(0),
+                true,
+                &Arc::new(Keypair::new()),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let out_path = Path::new("test_chacha_encrypt_file_many_keys_single_output.txt.enc");
+
+        let samples = [0];
+        let mut ivecs = hex!(
+            "abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234
+                              abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234"
+        );
+
+        let mut cpu_iv = ivecs.clone();
+        chacha_cbc_encrypt_ledger(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            out_path,
+            &mut cpu_iv,
+        )
+        .unwrap();
+
+        let ref_hash = sample_file(&out_path, &samples).unwrap();
+
+        let hashes = chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            &mut ivecs,
+            &samples,
+        )
+        .unwrap();
+
+        assert_eq!(hashes[0], ref_hash);
+
+        let _ignored = remove_dir_all(&ledger_path);
+        let _ignored = remove_file(out_path);
+    }
+
+    #[test]
+    fn test_encrypt_file_many_keys_multiple_keys() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 90;
+        let entries = create_ticks(2 * ticks_per_slot, 0, Hash::default());
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                Some(0),
+                true,
+                &Arc::new(Keypair::new()),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let out_path = Path::new("test_chacha_encrypt_file_many_keys_multiple_output.txt.enc");
+
+        let samples = [0, 1, 3, 4, 5, 150];
+        let mut ivecs = Vec::new();
+        let mut ref_hashes: Vec<Hash> = vec![];
+        for i in 0..2 {
+            let mut ivec = hex!(
+                "abc123abc123abc123abc123abc123abc123abababababababababababababab
+                                 abc123abc123abc123abc123abc123abc123abababababababababababababab"
+            );
+            ivec[0] = i;
+            ivecs.extend(ivec.clone().iter());
+            chacha_cbc_encrypt_ledger(
+                &blockstore.clone(),
+                0,
+                DEFAULT_SLOTS_PER_SEGMENT,
+                out_path,
+                &mut ivec,
+            )
+            .unwrap();
+
+            ref_hashes.push(sample_file(&out_path, &samples).unwrap());
+            info!(
+                "ivec: {:?} hash: {:?} ivecs: {:?}",
+                ivec.to_vec(),
+                ref_hashes.last(),
+                ivecs
+            );
+        }
+
+        let hashes = chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            DEFAULT_SLOTS_PER_SEGMENT,
+            &mut ivecs,
+            &samples,
+        )
+        .unwrap();
+
+        assert_eq!(hashes, ref_hashes);
+
+        let _ignored = remove_dir_all(&ledger_path);
+        let _ignored = remove_file(out_path);
+    }
+
+    #[test]
+    fn test_encrypt_file_many_keys_bad_key_length() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let mut keys = hex!("abc123");
+        let ledger_path = get_tmp_ledger_path!();
+        let samples = [0];
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        assert!(chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            DEFAULT_SLOTS_PER_SEGMENT,
+            &mut keys,
+            &samples,
+        )
+        .is_err());
+    }
+}
--- a/chacha-cuda/src/lib.rs
+++ b/chacha-cuda/src/lib.rs
@ -0,0 +1,8 @@
+#[macro_use]
+extern crate log;
+
+#[cfg(test)]
+#[macro_use]
+extern crate hex_literal;
+
+pub mod chacha_cuda;
--- a/stake-monitor/.gitignore
+++ b/stake-monitor/.gitignore
--- a/chacha-sys/Cargo.toml
+++ b/chacha-sys/Cargo.toml
@ -0,0 +1,12 @@
+[package]
+name = "solana-chacha-sys"
+version = "1.0.2"
+description = "Solana chacha-sys"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+homepage = "https://solana.com/"
+license = "Apache-2.0"
+edition = "2018"
+
+[build-dependencies]
+cc = "1.0.49"
--- a/chacha-sys/build.rs
+++ b/chacha-sys/build.rs
@ -0,0 +1,8 @@
+extern crate cc;
+
+fn main() {
+    cc::Build::new()
+        .file("cpu-crypt/chacha20_core.c")
+        .file("cpu-crypt/chacha_cbc.c")
+        .compile("libcpu-crypt");
+}
--- a/chacha-sys/cpu-crypt/.gitignore
+++ b/chacha-sys/cpu-crypt/.gitignore
@ -0,0 +1 @@
+release/
--- a/chacha-sys/cpu-crypt/Makefile
+++ b/chacha-sys/cpu-crypt/Makefile
@ -0,0 +1,25 @@
+V:=debug
+
+LIB:=cpu-crypt
+
+CFLAGS_common:=-Wall -Werror -pedantic -fPIC
+CFLAGS_release:=-march=native -O3 $(CFLAGS_common)
+CFLAGS_debug:=-g $(CFLAGS_common)
+CFLAGS:=$(CFLAGS_$V)
+
+all: $V/lib$(LIB).a
+
+$V/chacha20_core.o: chacha20_core.c chacha.h
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$V/chacha_cbc.o: chacha_cbc.c chacha.h
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$V/lib$(LIB).a: $V/chacha20_core.o $V/chacha_cbc.o
+	$(AR) rcs $@ $^
+
+.PHONY:clean
+clean:
+	rm -rf $V
--- a/chacha-sys/cpu-crypt/chacha.h
+++ b/chacha-sys/cpu-crypt/chacha.h
@ -0,0 +1,35 @@
+#ifndef HEADER_CHACHA_H
+# define HEADER_CHACHA_H
+
+#include <string.h>
+#include <inttypes.h>
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef unsigned int u32;
+
+#define CHACHA_KEY_SIZE 32
+#define CHACHA_NONCE_SIZE 12
+#define CHACHA_BLOCK_SIZE 64
+#define CHACHA_ROUNDS 500
+
+void chacha20_encrypt(const u32 input[16],
+                      unsigned char output[64],
+                      int num_rounds);
+
+void chacha20_encrypt_ctr(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE], const uint8_t nonce[CHACHA_NONCE_SIZE],
+                          uint32_t counter);
+
+void chacha20_cbc128_encrypt(const unsigned char* in, unsigned char* out,
+                             uint32_t len, const uint8_t* key,
+                             unsigned char* ivec);
+
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
--- a/chacha-sys/cpu-crypt/chacha20_core.c
+++ b/chacha-sys/cpu-crypt/chacha20_core.c
@ -0,0 +1,102 @@
+#include "chacha.h"
+
+#define ROTL32(v, n) (((v) << (n)) | ((v) >> (32 - (n))))
+
+#define ROTATE(v, c) ROTL32((v), (c))
+
+#define XOR(v, w) ((v) ^ (w))
+
+#define PLUS(x, y) ((x) + (y))
+
+#define U32TO8_LITTLE(p, v) \
+{ (p)[0] = ((v)      ) & 0xff; (p)[1] = ((v) >>  8) & 0xff; \
+  (p)[2] = ((v) >> 16) & 0xff; (p)[3] = ((v) >> 24) & 0xff; }
+
+#define U8TO32_LITTLE(p)   \
+     (((u32)((p)[0])      ) | ((u32)((p)[1]) <<  8) | \
+      ((u32)((p)[2]) << 16) | ((u32)((p)[3]) << 24)   )
+
+#define QUARTERROUND(a,b,c,d) \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]),16); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]),12); \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]), 8); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]), 7);
+
+// sigma contains the ChaCha constants, which happen to be an ASCII string.
+static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3',
+                                   '2', '-', 'b', 'y', 't', 'e', ' ', 'k' };
+
+void chacha20_encrypt(const u32 input[16],
+                      unsigned char output[64],
+                      int num_rounds)
+{
+    u32 x[16];
+    int i;
+    memcpy(x, input, sizeof(u32) * 16);
+    for (i = num_rounds; i > 0; i -= 2) {
+        QUARTERROUND( 0, 4, 8,12)
+        QUARTERROUND( 1, 5, 9,13)
+        QUARTERROUND( 2, 6,10,14)
+        QUARTERROUND( 3, 7,11,15)
+        QUARTERROUND( 0, 5,10,15)
+        QUARTERROUND( 1, 6,11,12)
+        QUARTERROUND( 2, 7, 8,13)
+        QUARTERROUND( 3, 4, 9,14)
+    }
+    for (i = 0; i < 16; ++i) {
+        x[i] = PLUS(x[i], input[i]);
+    }
+    for (i = 0; i < 16; ++i) {
+        U32TO8_LITTLE(output + 4 * i, x[i]);
+    }
+}
+
+void chacha20_encrypt_ctr(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE],
+                          const uint8_t nonce[CHACHA_NONCE_SIZE],
+                          uint32_t counter)
+{
+  uint32_t input[16];
+  uint8_t buf[64];
+  size_t todo, i;
+
+  input[0] = U8TO32_LITTLE(sigma + 0);
+  input[1] = U8TO32_LITTLE(sigma + 4);
+  input[2] = U8TO32_LITTLE(sigma + 8);
+  input[3] = U8TO32_LITTLE(sigma + 12);
+
+  input[4] = U8TO32_LITTLE(key + 0);
+  input[5] = U8TO32_LITTLE(key + 4);
+  input[6] = U8TO32_LITTLE(key + 8);
+  input[7] = U8TO32_LITTLE(key + 12);
+
+  input[8] = U8TO32_LITTLE(key + 16);
+  input[9] = U8TO32_LITTLE(key + 20);
+  input[10] = U8TO32_LITTLE(key + 24);
+  input[11] = U8TO32_LITTLE(key + 28);
+
+  input[12] = counter;
+  input[13] = U8TO32_LITTLE(nonce + 0);
+  input[14] = U8TO32_LITTLE(nonce + 4);
+  input[15] = U8TO32_LITTLE(nonce + 8);
+
+  while (in_len > 0) {
+    todo = sizeof(buf);
+    if (in_len < todo) {
+      todo = in_len;
+    }
+
+    chacha20_encrypt(input, buf, 20);
+    for (i = 0; i < todo; i++) {
+      out[i] = in[i] ^ buf[i];
+    }
+
+    out += todo;
+    in += todo;
+    in_len -= todo;
+
+    input[12]++;
+  }
+}
+
+
--- a/chacha-sys/cpu-crypt/chacha_cbc.c
+++ b/chacha-sys/cpu-crypt/chacha_cbc.c
@ -0,0 +1,72 @@
+#include "chacha.h"
+
+#if !defined(STRICT_ALIGNMENT) && !defined(PEDANTIC)
+# define STRICT_ALIGNMENT 0
+#endif
+
+void chacha20_cbc128_encrypt(const unsigned char* in, unsigned char* out,
+                             uint32_t len, const uint8_t* key,
+                             unsigned char* ivec)
+{
+    size_t n;
+    unsigned char *iv = ivec;
+    (void)key;
+
+    if (len == 0) {
+        return;
+    }
+
+#if !defined(OPENSSL_SMALL_FOOTPRINT)
+    if (STRICT_ALIGNMENT &&
+        ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) != 0) {
+        while (len >= CHACHA_BLOCK_SIZE) {
+            for (n = 0; n < CHACHA_BLOCK_SIZE; ++n) {
+                out[n] = in[n] ^ iv[n];
+                //printf("%x ", out[n]);
+            }
+            chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+            iv = out;
+            len -= CHACHA_BLOCK_SIZE;
+            in += CHACHA_BLOCK_SIZE;
+            out += CHACHA_BLOCK_SIZE;
+        }
+    } else {
+        while (len >= CHACHA_BLOCK_SIZE) {
+            for (n = 0; n < CHACHA_BLOCK_SIZE; n += sizeof(size_t)) {
+                *(size_t *)(out + n) =
+                    *(size_t *)(in + n) ^ *(size_t *)(iv + n);
+                //printf("%zu ", *(size_t *)(iv + n));
+            }
+            chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+            iv = out;
+            len -= CHACHA_BLOCK_SIZE;
+            in += CHACHA_BLOCK_SIZE;
+            out += CHACHA_BLOCK_SIZE;
+        }
+    }
+#endif
+    while (len) {
+        for (n = 0; n < CHACHA_BLOCK_SIZE && n < len; ++n) {
+            out[n] = in[n] ^ iv[n];
+        }
+        for (; n < CHACHA_BLOCK_SIZE; ++n) {
+            out[n] = iv[n];
+        }
+        chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+        iv = out;
+        if (len <= CHACHA_BLOCK_SIZE) {
+            break;
+        }
+        len -= CHACHA_BLOCK_SIZE;
+        in += CHACHA_BLOCK_SIZE;
+        out += CHACHA_BLOCK_SIZE;
+    }
+    memcpy(ivec, iv, CHACHA_BLOCK_SIZE);
+
+}
+
+void chacha20_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE], uint8_t* ivec)
+{
+    chacha20_cbc128_encrypt(in, out, in_len, key, ivec);
+}
--- a/chacha-sys/src/lib.rs
+++ b/chacha-sys/src/lib.rs
@ -0,0 +1,21 @@
+extern "C" {
+    fn chacha20_cbc_encrypt(
+        input: *const u8,
+        output: *mut u8,
+        in_len: usize,
+        key: *const u8,
+        ivec: *mut u8,
+    );
+}
+
+pub fn chacha_cbc_encrypt(input: &[u8], output: &mut [u8], key: &[u8], ivec: &mut [u8]) {
+    unsafe {
+        chacha20_cbc_encrypt(
+            input.as_ptr(),
+            output.as_mut_ptr(),
+            input.len(),
+            key.as_ptr(),
+            ivec.as_mut_ptr(),
+        );
+    }
+}
--- a/chacha/.gitignore
+++ b/chacha/.gitignore
@ -0,0 +1 @@
+/farf/
--- a/chacha/Cargo.toml
+++ b/chacha/Cargo.toml
@ -0,0 +1,25 @@
+[package]
+name = "solana-chacha"
+version = "1.0.2"
+description = "Solana Chacha APIs"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+rand = "0.6.5"
+rand_chacha = "0.1.1"
+solana-chacha-sys = { path = "../chacha-sys", version = "1.0.2" }
+solana-ledger = { path = "../ledger", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-perf = { path = "../perf", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha"
--- a/chacha/src/chacha.rs
+++ b/chacha/src/chacha.rs
@ -0,0 +1,185 @@
+use solana_ledger::blockstore::Blockstore;
+use solana_sdk::clock::Slot;
+use std::fs::File;
+use std::io;
+use std::io::{BufWriter, Write};
+use std::path::Path;
+use std::sync::Arc;
+
+pub use solana_chacha_sys::chacha_cbc_encrypt;
+
+pub const CHACHA_BLOCK_SIZE: usize = 64;
+pub const CHACHA_KEY_SIZE: usize = 32;
+
+pub fn chacha_cbc_encrypt_ledger(
+    blockstore: &Arc<Blockstore>,
+    start_slot: Slot,
+    slots_per_segment: u64,
+    out_path: &Path,
+    ivec: &mut [u8; CHACHA_BLOCK_SIZE],
+) -> io::Result<usize> {
+    let mut out_file =
+        BufWriter::new(File::create(out_path).expect("Can't open ledger encrypted data file"));
+    const BUFFER_SIZE: usize = 8 * 1024;
+    let mut buffer = [0; BUFFER_SIZE];
+    let mut encrypted_buffer = [0; BUFFER_SIZE];
+    let key = [0; CHACHA_KEY_SIZE];
+    let mut total_size = 0;
+    let mut current_slot = start_slot;
+    let mut start_index = 0;
+    loop {
+        match blockstore.get_data_shreds(current_slot, start_index, std::u64::MAX, &mut buffer) {
+            Ok((last_index, mut size)) => {
+                debug!(
+                    "chacha: encrypting slice: {} num_shreds: {} data_len: {}",
+                    current_slot,
+                    last_index.saturating_sub(start_index),
+                    size
+                );
+                debug!("read {} bytes", size);
+
+                if size == 0 {
+                    if current_slot.saturating_sub(start_slot) < slots_per_segment {
+                        current_slot += 1;
+                        start_index = 0;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                if size < BUFFER_SIZE {
+                    // round to the nearest key_size boundary
+                    size = (size + CHACHA_KEY_SIZE - 1) & !(CHACHA_KEY_SIZE - 1);
+                }
+                total_size += size;
+
+                chacha_cbc_encrypt(&buffer[..size], &mut encrypted_buffer[..size], &key, ivec);
+                if let Err(res) = out_file.write(&encrypted_buffer[..size]) {
+                    warn!("Error writing file! {:?}", res);
+                    return Err(res);
+                }
+
+                start_index = last_index + 1;
+            }
+            Err(e) => {
+                info!("Error encrypting file: {:?}", e);
+                break;
+            }
+        }
+    }
+    Ok(total_size)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::chacha::chacha_cbc_encrypt_ledger;
+    use rand::SeedableRng;
+    use rand_chacha::ChaChaRng;
+    use solana_ledger::blockstore::Blockstore;
+    use solana_ledger::entry::Entry;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_sdk::hash::{hash, Hash, Hasher};
+    use solana_sdk::pubkey::Pubkey;
+    use solana_sdk::signature::{Keypair, Signer};
+    use solana_sdk::system_transaction;
+    use std::fs::remove_file;
+    use std::fs::File;
+    use std::io::Read;
+    use std::sync::Arc;
+
+    fn make_tiny_deterministic_test_entries(num: usize) -> Vec<Entry> {
+        let zero = Hash::default();
+        let one = hash(&zero.as_ref());
+
+        let seed = [2u8; 32];
+
+        let mut generator = ChaChaRng::from_seed(seed);
+        let keypair = Keypair::generate(&mut generator);
+
+        let mut id = one;
+        let mut num_hashes = 0;
+        (0..num)
+            .map(|_| {
+                Entry::new_mut(
+                    &mut id,
+                    &mut num_hashes,
+                    vec![system_transaction::transfer(
+                        &keypair,
+                        &keypair.pubkey(),
+                        1,
+                        one,
+                    )],
+                )
+            })
+            .collect()
+    }
+
+    use std::{env, fs::create_dir_all, path::PathBuf};
+    fn tmp_file_path(name: &str) -> PathBuf {
+        let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let mut path = PathBuf::new();
+        path.push(out_dir);
+        path.push("tmp");
+        create_dir_all(&path).unwrap();
+
+        path.push(format!("{}-{}", name, Pubkey::new_rand()));
+        path
+    }
+
+    #[test]
+    fn test_encrypt_ledger() {
+        solana_logger::setup();
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 16;
+        let slots_per_segment = 32;
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        let out_path = tmp_file_path("test_encrypt_ledger");
+
+        let seed = [2u8; 32];
+
+        let mut generator = ChaChaRng::from_seed(seed);
+        let keypair = Keypair::generate(&mut generator);
+
+        let entries = make_tiny_deterministic_test_entries(slots_per_segment);
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                None,
+                true,
+                &Arc::new(keypair),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let mut key = hex!(
+            "abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234
+                            abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234"
+        );
+        chacha_cbc_encrypt_ledger(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            &out_path,
+            &mut key,
+        )
+        .unwrap();
+        let mut out_file = File::open(&out_path).unwrap();
+        let mut buf = vec![];
+        let size = out_file.read_to_end(&mut buf).unwrap();
+        let mut hasher = Hasher::default();
+        hasher.hash(&buf[..size]);
+
+        //  golden needs to be updated if shred structure changes....
+        let golden: Hash = "2rq8nR6rns2T5zsbQAGBDZb41NVtacneLgkCH17CVxZm"
+            .parse()
+            .unwrap();
+
+        assert_eq!(hasher.result(), golden);
+        remove_file(&out_path).unwrap();
+    }
+}
--- a/chacha/src/lib.rs
+++ b/chacha/src/lib.rs
@ -0,0 +1,8 @@
+#[macro_use]
+extern crate log;
+
+#[cfg(test)]
+#[macro_use]
+extern crate hex_literal;
+
+pub mod chacha;
--- a/ci/README.md
+++ b/ci/README.md
@ -2,7 +2,7 @@
 Our CI infrastructure is built around [BuildKite](https://buildkite.com) with some
 additional GitHub integration provided by https://github.com/mvines/ci-gate

-# Agent Queues
+## Agent Queues

 We define two [Agent Queues](https://buildkite.com/docs/agent/v3/queues):
 `queue=default` and `queue=cuda`.  The `default` queue should be favored and
@ -12,52 +12,9 @@ be run on the `default` queue, and the [buildkite artifact
 system](https://buildkite.com/docs/builds/artifacts) used to transfer build
 products over to a GPU instance for testing.

-# Buildkite Agent Management
+## Buildkite Agent Management

-## Manual Node Setup for Colocated Hardware
-
-This section describes how to set up a new machine that does not have a
-pre-configured image with all the requirements installed.  Used for custom-built
-hardware at a colocation or office facility.  Also works for vanilla Ubuntu cloud
-instances.
-
-### Pre-Requisites
-
- - Install Ubuntu 18.04 LTS Server
- - Log in as a local or remote user with `sudo` privileges
-
-### Install Core Requirements
-
-##### Non-GPU enabled machines
-```bash
-sudo ./setup-new-buildkite-agent/setup-new-machine.sh
-```
-
-##### GPU-enabled machines
- - 1 or more NVIDIA GPUs should be installed in the machine (tested with 2080Ti)
-```bash
-sudo CUDA=1 ./setup-new-buildkite-agent/setup-new-machine.sh
-```
-
-### Configure Node for Buildkite-agent based CI
-
- Install `buildkite-agent` and set up it user environment with:
-```bash
-sudo ./setup-new-buildkite-agent/setup-buildkite.sh
-```
- Copy the pubkey contents from `~buildkite-agent/.ssh/id_ecdsa.pub` and
-add the pubkey as an authorized SSH key on github.
- Edit `/etc/buildkite-agent/buildkite-agent.cfg` and/or `/etc/systemd/system/buildkite-agent@*` to the desired configuration of the agent(s)
- Copy `ejson` keys from another CI node at `/opt/ejson/keys/`
-to the same location on the new node.
- Start the new agent(s) with `sudo systemctl enable --now buildkite-agent`
-
-# Reference
-
-This section contains details regarding previous CI setups that have been used,
-and that we may return to one day.
-
-## Buildkite Azure Setup
+### Buildkite Azure Setup

 Create a new Azure-based "queue=default" agent by running the following command:
 ```
@ -78,7 +35,7 @@ Creating a "queue=cuda" agent follows the same process but additionally:
 2. Edit the tags field in /etc/buildkite-agent/buildkite-agent.cfg to `tags="queue=cuda,queue=default"`
   and decrease the value of the priority field by one

-### Updating the CI Disk Image
+#### Updating the CI Disk Image

 1. Create a new VM Instance as described above
 1. Modify it as required
@ -91,7 +48,12 @@ Creating a "queue=cuda" agent follows the same process but additionally:
 1. Goto the `ci` resource group in the Azure portal and remove all resources
   with the XYZ name in them

-## Buildkite AWS CloudFormation Setup
+## Reference
+
+This section contains details regarding previous CI setups that have been used,
+and that we may return to one day.
+
+### Buildkite AWS CloudFormation Setup

 **AWS CloudFormation is currently inactive, although it may be restored in the
 future**
@ -100,7 +62,7 @@ AWS CloudFormation can be used to scale machines up and down based on the
 current CI load.  If no machine is currently running it can take up to 60
 seconds to spin up a new instance, please remain calm during this time.

-### AMI
+#### AMI
 We use a custom AWS AMI built via https://github.com/solana-labs/elastic-ci-stack-for-aws/tree/solana/cuda.

 Use the following process to update this AMI as dependencies change:
@ -122,13 +84,13 @@ The new AMI should also now be visible in your EC2 Dashboard.  Go to the desired
 AWS CloudFormation stack, update the **ImageId** field to the new AMI id, and
 *apply* the stack changes.

-## Buildkite GCP Setup
+### Buildkite GCP Setup

 CI runs on Google Cloud Platform via two Compute Engine Instance groups:
 `ci-default` and `ci-cuda`.  Autoscaling is currently disabled and the number of
 VM Instances in each group is manually adjusted.

-### Updating a CI Disk Image
+#### Updating a CI Disk Image

 Each Instance group has its own disk image, `ci-default-vX` and
 `ci-cuda-vY`, where *X* and *Y* are incremented each time the image is changed.
--- a/ci/_
+++ b/ci/_
@ -5,13 +5,7 @@
 # |source| me
 #

-base_dir=$(realpath --strip "$(dirname "$0")/..")
-
 _() {
-  if [[ $(pwd) = $base_dir ]]; then
-    echo "--- $*"
-  else
-    echo "--- $* (wd: $(pwd))"
-  fi
+  echo "--- $*"
  "$@"
 }
--- a/ci/buildkite-secondary.yml
+++ b/ci/buildkite-secondary.yml
@ -2,16 +2,6 @@
 # Build steps that run after the primary pipeline on pushes and tags.
 # Pull requests to not run these steps.
 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"
-  - wait
  - command: "sdk/docker-solana/build.sh"
    timeout_in_minutes: 60
    name: "publish docker"
@ -19,6 +9,12 @@ 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
+  - command: "ci/publish-bpf-sdk.sh"
+    timeout_in_minutes: 5
+    name: "publish bpf sdk"
+  - command: "ci/publish-tarball.sh"
+    timeout_in_minutes: 60
+    name: "publish tarball"
+  - command: "ci/publish-docs.sh"
+    timeout_in_minutes: 15
+    name: "publish docs"
--- a/ci/buildkite-tests.yml
+++ b/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"
--- a/ci/buildkite.yml
+++ b/ci/buildkite.yml
@ -1,35 +1,38 @@
 # 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/test-sanity.sh"
-    name: "sanity"
-    timeout_in_minutes: 5
-  - 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
-
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-checks.sh"
+    name: "checks"
+    timeout_in_minutes: 20
  - wait
-
-  - command: "ci/maybe-trigger-tests.sh"
-    name: "maybe-trigger-tests"
-    timeout_in_minutes: 2
-
+  - 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-stable.sh"
+    name: "stable"
+    timeout_in_minutes: 60
+    artifact_paths: "log-*.txt"
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-move.sh"
+    name: "move"
+    timeout_in_minutes: 20
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-local-cluster.sh"
+    name: "local-cluster"
+    timeout_in_minutes: 30
+    artifact_paths: "log-*.txt"
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-coverage.sh"
+    name: "coverage"
+    timeout_in_minutes: 30
  - wait
-
  - trigger: "solana-secondary"
    branches: "!pull/*"
    async: true
--- a/ci/dependabot-pr.sh
+++ b/ci/dependabot-pr.sh
@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-cd "$(dirname "$0")/.."
-
-if ! echo "$BUILDKITE_BRANCH" | grep -E '^pull/[0-9]+/head$'; then
-  echo "not pull request!?" >&2
-  exit 1
-fi
-
-source ci/rust-version.sh stable
-
-ci/docker-run.sh $rust_nightly_docker_image ci/dependabot-updater.sh
-
-if [[ $(git status --short :**/Cargo.lock | wc -l) -eq 0 ]]; then
-  echo --- ok
-  exit 0
-fi
-
-echo --- "(FAILING) Backpropagating dependabot-triggered Cargo.lock updates"
-
-name="dependabot-buildkite"
-api_base="https://api.github.com/repos/solana-labs/solana/pulls"
-pr_num=$(echo "$BUILDKITE_BRANCH" | grep -Eo '[0-9]+')
-branch=$(curl -s "$api_base/$pr_num" | python -c 'import json,sys;print json.load(sys.stdin)["head"]["ref"]')
-
-git add :**/Cargo.lock
-EMAIL="dependabot-buildkite@noreply.solana.com" \
-  GIT_AUTHOR_NAME="$name" \
-  GIT_COMMITTER_NAME="$name" \
-  git commit -m "[auto-commit] Update all Cargo lock files"
-git push origin "HEAD:$branch"
-
-echo "Source branch is updated; failing this build for the next"
-exit 1
--- a/ci/dependabot-updater.sh
+++ b/ci/dependabot-updater.sh
@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")/.."
-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/'
-)"
-# 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/'
-)"
-package=$(echo "$parsed_update_args" | awk '{print $2}' | grep -o "^[^:]*")
-if [[ -n $parsed_update_args ]]; then
-  # find other Cargo.lock files and update them, excluding the default Cargo.lock
-  # shellcheck disable=SC2086
-  for lock in $(git grep --files-with-matches '^name = "'$package'"$' :**/Cargo.lock); do
-    # it's possible our current versions are out of sync across lock files,
-    # in that case try to sync them up with $relaxed_parsed_update_args
-    _ scripts/cargo-for-all-lock-files.sh \
-      "$lock" -- \
-      update $parsed_update_args ||
-      _ scripts/cargo-for-all-lock-files.sh \
-        "$lock" -- \
-        update $relaxed_parsed_update_args
-  done
-fi
-
-echo --- ok
--- a/ci/docker-run.sh
+++ b/ci/docker-run.sh
@ -49,7 +49,7 @@ else
  # ~/.cargo
  ARGS+=(--volume "$PWD:/home")
 fi
-ARGS+=(--env "HOME=/home" --env "CARGO_HOME=/home/.cargo")
+ARGS+=(--env "CARGO_HOME=/home/.cargo")

 # kcov tries to set the personality of the binary which docker
 # doesn't allow by default.
@ -67,7 +67,6 @@ ARGS+=(
  --env BUILDKITE_JOB_ID
  --env CI
  --env CI_BRANCH
-  --env CI_TAG
  --env CI_BUILD_ID
  --env CI_COMMIT
  --env CI_JOB_ID
--- a/ci/docker-rust-nightly/Dockerfile
+++ b/ci/docker-rust-nightly/Dockerfile
@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.43.0
+FROM solanalabs/rust:1.41.1
 ARG date

 RUN set -x \
--- a/ci/docker-rust-nightly/README.md
+++ b/ci/docker-rust-nightly/README.md
@ -15,8 +15,6 @@ To update the pinned version:
 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`
   to confirm the new nightly image builds.  Fix any issues as needed
--- a/ci/docker-rust/Dockerfile
+++ b/ci/docker-rust/Dockerfile
@ -1,6 +1,6 @@
 # Note: when the rust version is changed also modify
 # ci/rust-version.sh to pick up the new image tag
-FROM rust:1.43.0
+FROM rust:1.41.1

 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0
@ -32,7 +32,6 @@ RUN set -x \
 && cargo install cargo-audit \
 && cargo install svgbob_cli \
 && cargo install mdbook \
- && cargo install mdbook-linkcheck \
 && rustc --version \
 && cargo --version \
 && curl -OL https://github.com/google/protobuf/releases/download/v$PROTOC_VERSION/$PROTOC_ZIP \
--- a/ci/iterations-localnet.sh
+++ b/ci/iterations-localnet.sh
@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -e
+
+testCmd="$*"
+genPipeline=false
+
+cd "$(dirname "$0")/.."
+
+# Clear cached json keypair files
+rm -rf "$HOME/.config/solana"
+
+source ci/_
+export RUST_BACKTRACE=1
+export RUSTFLAGS="-D warnings"
+export PATH=$PWD/target/debug:$PATH
+export USE_INSTALL=1
+
+if [[ -n $BUILDKITE && -z $testCmd ]]; then
+  genPipeline=true
+  echo "
+steps:
+  "
+fi
+
+build() {
+  $genPipeline && return
+  source ci/rust-version.sh stable
+  source scripts/ulimit-n.sh
+  _ cargo +$rust_stable build
+}
+
+runTest() {
+  declare runTestName="$1"
+  declare runTestCmd="$2"
+  if $genPipeline; then
+    echo "
+  - command: \"$0 '$runTestCmd'\"
+    name: \"$runTestName\"
+    timeout_in_minutes: 45
+"
+    return
+  fi
+
+  if [[ -n $testCmd && "$testCmd" != "$runTestCmd" ]]; then
+    echo Skipped "$runTestName"...
+    return
+  fi
+  #shellcheck disable=SC2068 # Don't want to double quote $runTestCmd
+  $runTestCmd
+}
+
+build
+
+runTest "basic" \
+  "ci/localnet-sanity.sh -i 128"
+
+runTest "restart" \
+  "ci/localnet-sanity.sh -i 128 -k 16"
+
+runTest "incremental restart, extra node" \
+  "ci/localnet-sanity.sh -i 128 -k 16 -R -x"
--- a/ci/localnet-sanity.sh
+++ b/ci/localnet-sanity.sh
@ -73,15 +73,16 @@ source scripts/configure-metrics.sh
 source multinode-demo/common.sh

 nodes=(
+  "multinode-demo/faucet.sh"
  "multinode-demo/bootstrap-validator.sh \
    --no-restart \
-    --init-complete-file init-complete-node0.log \
+    --init-complete-file init-complete-node1.log \
    --dynamic-port-range 8000-8050"
  "multinode-demo/validator.sh \
    --enable-rpc-exit \
    --no-restart \
    --dynamic-port-range 8050-8100
-    --init-complete-file init-complete-node1.log \
+    --init-complete-file init-complete-node2.log \
    --rpc-port 18899"
 )

@ -94,7 +95,7 @@ if [[ extraNodes -gt 0 ]]; then
        --no-restart \
        --dynamic-port-range $portStart-$portEnd
        --label dyn$i \
-        --init-complete-file init-complete-node$((1 + i)).log"
+        --init-complete-file init-complete-node$((2 + i)).log"
    )
  done
 fi
@ -159,10 +160,11 @@ startNodes() {
  for i in $(seq 0 $((${#nodes[@]} - 1))); do
    declare cmd=${nodes[$i]}

-    declare initCompleteFile="init-complete-node$i.log"
-    rm -f "$initCompleteFile"
-    initCompleteFiles+=("$initCompleteFile")
-
+    if [[ "$i" -ne 0 ]]; then # 0 == faucet, skip it
+      declare initCompleteFile="init-complete-node$i.log"
+      rm -f "$initCompleteFile"
+      initCompleteFiles+=("$initCompleteFile")
+    fi
    startNode "$i" "$cmd $maybeExpectedGenesisHash"
    if $addLogs; then
      logs+=("$(getNodeLogFile "$i" "$cmd")")
@ -176,7 +178,7 @@ startNodes() {

      (
        set -x
-        $solana_cli --keypair config/bootstrap-validator/identity.json \
+        $solana_cli --keypair config/bootstrap-validator/identity-keypair.json \
          --url http://127.0.0.1:8899 genesis-hash
      ) | tee genesis-hash.log
      maybeExpectedGenesisHash="--expected-genesis-hash $(tail -n1 genesis-hash.log)"
--- a/ci/maybe-trigger-tests.sh
+++ b/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
--- a/ci/publish-docs.sh
+++ b/ci/publish-docs.sh
@ -3,22 +3,21 @@ 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
-)
+me=$(basename "$0")

 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
+    (
+      . ci/rust-version.sh stable
+      ci/docker-run.sh "$rust_stable_docker_image" make -C docs -B svg
+    )
+    # make a local commit for the svgs
+    git add -A -f docs/src/.gitbook/assets/.
    if ! git diff-index --quiet HEAD; then
      git config user.email maintainers@solana.com
-      git config user.name "$(basename "$0")"
+      git config user.name "$me"
      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
--- a/ci/publish-tarball.sh
+++ b/ci/publish-tarball.sh
@ -45,7 +45,7 @@ linux)
  TARGET=x86_64-unknown-linux-gnu
  ;;
 windows)
-  TARGET=x86_64-pc-windows-gnu
+  TARGET=x86_64-pc-windows-msvc
  ;;
 *)
  echo CI_OS_NAME unset
@ -71,7 +71,16 @@ echo --- Creating release tarball
  export CHANNEL

  source ci/rust-version.sh stable
-  scripts/cargo-install-all.sh +"$rust_stable" solana-release
+  scripts/cargo-install-all.sh +"$rust_stable" --use-move solana-release
+
+  # Reduce the Windows archive size until
+  # https://github.com/appveyor/ci/issues/2997 is fixed
+  if [[ -n $APPVEYOR ]]; then
+    rm -f \
+      solana-release/bin/solana-validator.exe \
+      solana-release/bin/solana-bench-exchange.exe \
+
+  fi

  tar cvf solana-release-$TARGET.tar solana-release
  bzip2 solana-release-$TARGET.tar
@ -95,8 +104,9 @@ 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
+  upload-ci-artifact "$file"
+
  if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
-    upload-ci-artifact "$file"
    echo "Skipped $file due to DO_NOT_PUBLISH_TAR"
    continue
  fi
--- a/ci/run-sanity.sh
+++ b/ci/run-sanity.sh
@ -2,10 +2,8 @@
 set -e

 cd "$(dirname "$0")/.."
-# shellcheck source=multinode-demo/common.sh
-source multinode-demo/common.sh

-rm -rf config/run/init-completed config/ledger config/snapshot-ledger
+rm -f config/run/init-completed

 timeout 15 ./run.sh &
 pid=$!
@ -19,13 +17,6 @@ while [[ ! -f config/run/init-completed ]]; do
  fi
 done

-while [[ $($solana_cli --url http://localhost:8899 slot --commitment recent) -eq 0 ]]; 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
-cp config/ledger/genesis.tar.bz2 config/snapshot-ledger
-$solana_ledger_tool verify --ledger config/snapshot-ledger
--- a/ci/rust-version.sh
+++ b/ci/rust-version.sh
@ -1,30 +1,28 @@
 #
 # This file maintains the rust versions for use by CI.
 #
+# Build with stable rust, updating the stable toolchain if necessary:
+#   $ source ci/rust-version.sh stable
+#   $ cargo +"$rust_stable" build
+#
+# Build with nightly rust, updating the nightly toolchain if necessary:
+#   $ source ci/rust-version.sh nightly
+#   $ cargo +"$rust_nightly" build
+#
 # Obtain the environment variables without any automatic toolchain updating:
 #   $ source ci/rust-version.sh
 #
-# Obtain the environment variables updating both stable and nightly, only stable, or
-# only nightly:
-#   $ source ci/rust-version.sh all
-#   $ source ci/rust-version.sh stable
-#   $ source ci/rust-version.sh nightly
-
-# Then to build with either stable or nightly:
-#   $ cargo +"$rust_stable" build
-#   $ cargo +"$rust_nightly" build
-#

 if [[ -n $RUST_STABLE_VERSION ]]; then
  stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.43.0
+  stable_version=1.41.1
 fi

 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
  nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2020-04-23
+  nightly_version=2020-02-27
 fi


@ -53,10 +51,6 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
  nightly)
     rustup_install "$rust_nightly"
    ;;
-  all)
-     rustup_install "$rust_stable"
-     rustup_install "$rust_nightly"
-    ;;
  *)
    echo "Note: ignoring unknown argument: $1"
    ;;
--- a/ci/setup-new-buildkite-agent/enable-buildkite.sh
+++ b/ci/setup-new-buildkite-agent/enable-buildkite.sh
@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-
-sudo systemctl daemon-reload
-sudo systemctl enable --now buildkite-agent
--- a/ci/setup-new-buildkite-agent/setup-buildkite.sh
+++ b/ci/setup-new-buildkite-agent/setup-buildkite.sh
@ -1,84 +0,0 @@
-#!/usr/bin/env bash
-
-HERE="$(dirname "$0")"
-
-# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
-source "$HERE"/utils.sh
-
-ensure_env || exit 1
-
-set -e
-
-# Install buildkite-agent
-echo "deb https://apt.buildkite.com/buildkite-agent stable main" | tee /etc/apt/sources.list.d/buildkite-agent.list
-apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 32A37959C2FA5C3C99EFBC32A79206696452D198
-apt-get update
-apt-get install -y buildkite-agent
-
-
-# Configure the installation
-echo "Go to https://buildkite.com/organizations/solana-labs/agents"
-echo "Click Reveal Agent Token"
-echo "Paste the Agent Token, then press Enter:"
-
-read -r agent_token
-sudo sed -i "s/xxx/$agent_token/g" /etc/buildkite-agent/buildkite-agent.cfg
-
-cat > /etc/buildkite-agent/hooks/environment <<EOF
-set -e
-
-export BUILDKITE_GIT_CLEAN_FLAGS="-ffdqx"
-
-# Hack for non-docker rust builds
-export PATH='$PATH':~buildkite-agent/.cargo/bin
-
-# Add path to snaps
-source /etc/profile.d/apps-bin-path.sh
-
-if [[ '$BUILDKITE_BRANCH' =~ pull/* ]]; then
-  export BUILDKITE_REFSPEC="+'$BUILDKITE_BRANCH':refs/remotes/origin/'$BUILDKITE_BRANCH'"
-fi
-EOF
-
-chown buildkite-agent:buildkite-agent /etc/buildkite-agent/hooks/environment
-
-# Create SSH key
-sudo -u buildkite-agent mkdir -p ~buildkite-agent/.ssh
-sudo -u buildkite-agent ssh-keygen -t ecdsa -q -N "" -f ~buildkite-agent/.ssh/id_ecdsa
-
-# Set buildkite-agent user's shell
-sudo usermod --shell /bin/bash buildkite-agent
-
-# Install Rust for buildkite-agent
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o /tmp/rustup-init.sh
-sudo -u buildkite-agent HOME=~buildkite-agent sh /tmp/rustup-init.sh -y
-
-# Add to docker and sudoers group
-addgroup buildkite-agent docker
-addgroup buildkite-agent sudo
-
-# Edit the systemd unit file to include LimitNOFILE
-cat > /lib/systemd/system/buildkite-agent.service <<EOF
-[Unit]
-Description=Buildkite Agent
-Documentation=https://buildkite.com/agent
-After=syslog.target
-After=network.target
-
-[Service]
-Type=simple
-User=buildkite-agent
-Environment=HOME=/var/lib/buildkite-agent
-ExecStart=/usr/bin/buildkite-agent start
-RestartSec=5
-Restart=on-failure
-RestartForceExitStatus=SIGPIPE
-TimeoutStartSec=10
-TimeoutStopSec=0
-KillMode=process
-LimitNOFILE=65536
-
-[Install]
-WantedBy=multi-user.target
-DefaultInstance=1
-EOF
--- a/ci/setup-new-buildkite-agent/setup-new-machine.sh
+++ b/ci/setup-new-buildkite-agent/setup-new-machine.sh
@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-
-HERE="$(dirname "$0")"
-SOLANA_ROOT="$HERE"/../..
-
-# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
-source "$HERE"/utils.sh
-
-ensure_env || exit 1
-
-set -ex
-
-apt update
-apt upgrade -y
-
-cat >/etc/apt/apt.conf.d/99-solana <<'EOF'
-// Set and persist extra caps on iftop binary
-Dpkg::Post-Invoke { "which iftop 2>&1 >/dev/null && setcap cap_net_raw=eip $(which iftop) || true"; };
-EOF
-
-apt install -y build-essential pkg-config clang cmake sysstat linux-tools-common \
-  linux-generic-hwe-18.04-edge linux-tools-generic-hwe-18.04-edge \
-  iftop heaptrack jq ruby python3-venv gcc-multilib libudev-dev
-
-gem install ejson ejson2env
-mkdir -p /opt/ejson/keys
-
-"$SOLANA_ROOT"/net/scripts/install-docker.sh
-usermod -aG docker "$SETUP_USER"
-"$SOLANA_ROOT"/net/scripts/install-certbot.sh
-"$HERE"/setup-sudoers.sh
-"$HERE"/setup-ssh.sh
-
-"$HERE"/disable-nouveau.sh
-"$HERE"/disable-networkd-wait.sh
-
-"$SOLANA_ROOT"/net/scripts/install-earlyoom.sh
-"$SOLANA_ROOT"/net/scripts/install-nodejs.sh
-"$SOLANA_ROOT"/net/scripts/localtime.sh
-"$SOLANA_ROOT"/net/scripts/install-redis.sh
-"$SOLANA_ROOT"/net/scripts/install-rsync.sh
-"$SOLANA_ROOT"/net/scripts/install-libssl-compatability.sh
-
-"$HERE"/setup-procfs-knobs.sh
-"$HERE"/setup-limits.sh
-
-[[ -n $CUDA ]] && "$HERE"/setup-cuda.sh
-
-exit 0
--- a/ci/test-bench.sh
+++ b/ci/test-bench.sh
@ -25,7 +25,7 @@ source ci/_
 source ci/upload-ci-artifact.sh

 eval "$(ci/channel-info.sh)"
-source ci/rust-version.sh all
+source ci/rust-version.sh nightly

 set -o pipefail
 export RUST_BACKTRACE=1
@ -67,9 +67,8 @@ _ cargo +$rust_nightly bench --manifest-path core/Cargo.toml ${V:+--verbose} \
 _ cargo +$rust_nightly bench --manifest-path programs/bpf/Cargo.toml ${V:+--verbose} --features=bpf_c \
  -- -Z unstable-options --format=json --nocapture | tee -a "$BENCH_FILE"

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

 # `solana-upload-perf` disabled as it can take over 30 minutes to complete for some
 # reason
--- a/ci/test-checks.sh
+++ b/ci/test-checks.sh
@ -10,24 +10,23 @@ source ci/rust-version.sh nightly
 export RUST_BACKTRACE=1
 export RUSTFLAGS="-D warnings"

-if _ scripts/cargo-for-all-lock-files.sh +"$rust_nightly" check --locked --all-targets; then
-  true
-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"
-fi
+# Look for failed mergify.io backports
+_ git show HEAD --check --oneline

 _ cargo +"$rust_stable" fmt --all -- --check

+# Clippy gets stuck for unknown reasons if sdk-c is included in the build, so check it separately.
+# See https://github.com/solana-labs/solana/issues/5503
 _ cargo +"$rust_stable" clippy --version
-_ cargo +"$rust_stable" clippy --workspace -- --deny=warnings
+_ cargo +"$rust_stable" clippy --all --exclude solana-sdk-c -- --deny=warnings
+_ cargo +"$rust_stable" clippy --manifest-path sdk-c/Cargo.toml -- --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
+_ cargo +"$rust_stable" audit --ignore RUSTSEC-2020-0002
+_ ci/nits.sh
 _ ci/order-crates-for-publishing.py
 _ docs/build.sh
+_ ci/check-ssh-keys.sh

 {
  cd programs/bpf
--- a/ci/test-sanity.sh
+++ b/ci/test-sanity.sh
@ -1,27 +0,0 @@
-#!/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!
-  if [[ -n $BUILDKITE_PULL_REQUEST_BASE_BRANCH ]]; then
-    base_branch=$BUILDKITE_PULL_REQUEST_BASE_BRANCH
-  else
-    base_branch=$BUILDKITE_BRANCH
-  fi
-  git fetch origin "$base_branch"
-  git diff "$(git merge-base HEAD "origin/$base_branch")..HEAD" --check --oneline
-)
-
-echo
-
-_ ci/nits.sh
-_ ci/check-ssh-keys.sh
-
-echo --- ok
--- a/ci/test-stable.sh
+++ b/ci/test-stable.sh
@ -38,15 +38,10 @@ test -d target/release/bpf && find target/release/bpf -name '*.d' -delete
 # Clear the BPF sysroot files, they are not automatically rebuilt
 rm -rf target/xargo # Issue #3105

-# Limit compiler jobs to reduce memory usage
-# on machines with 2gb/thread of memory
-NPROC=$(nproc)
-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 --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)
@ -91,7 +86,7 @@ test-stable-perf)
  fi

  _ cargo +"$rust_stable" build --bins ${V:+--verbose}
-  _ cargo +"$rust_stable" test --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
+  _ cargo +"$rust_stable" test --package solana-chacha-cuda --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
  ;;
 test-move)
  ci/affects-files.sh \
--- a/ci/testnet-deploy.sh
+++ b/ci/testnet-deploy.sh
@ -0,0 +1,429 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"/..
+source ci/upload-ci-artifact.sh
+
+zone=
+bootstrapValidatorAddress=
+bootstrapValidatorMachineType=
+clientNodeCount=0
+idleClients=false
+additionalValidatorCount=10
+publicNetwork=false
+stopNetwork=false
+reuseLedger=false
+skipCreate=false
+skipStart=false
+externalNode=false
+failOnValidatorBootupFailure=true
+tarChannelOrTag=edge
+delete=false
+enableGpu=false
+bootDiskType=""
+blockstreamer=false
+fetchLogs=true
+maybeHashesPerTick=
+maybeDisableAirdrops=
+maybeInternalNodesStakeLamports=
+maybeInternalNodesLamports=
+maybeExternalPrimordialAccountsFile=
+maybeSlotsPerEpoch=
+maybeTargetLamportsPerSignature=
+maybeSlotsPerEpoch=
+maybeLetsEncrypt=
+maybeValidatorAdditionalDiskSize=
+maybeNoSnapshot=
+maybeLimitLedgerSize=
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 -p network-name -C cloud -z zone1 [-z zone2] ... [-z zoneN] [options...]
+
+Deploys a CD testnet
+
+  mandatory arguments:
+  -p [network-name]  - name of the network
+  -C [cloud] - cloud provider to use (gce, ec2)
+  -z [zone]  - cloud provider zone to deploy the network into.  Must specify at least one zone
+
+  options:
+   -t edge|beta|stable|vX.Y.Z  - Deploy the latest tarball release for the
+                                 specified release channel (edge|beta|stable) or release tag
+                                 (vX.Y.Z)
+                                 (default: $tarChannelOrTag)
+   -n [number]          - Number of additional validators (default: $additionalValidatorCount)
+   -c [number]          - Number of client bencher nodes (default: $clientNodeCount)
+   -u                   - Include a Blockstreamer (default: $blockstreamer)
+   -P                   - Use public network IP addresses (default: $publicNetwork)
+   -G                   - Enable GPU, and set count/type of GPUs to use (e.g n1-standard-16 --accelerator count=2,type=nvidia-tesla-v100)
+   -g                   - Enable GPU (default: $enableGpu)
+   -a [address]         - Set the bootstrap validator's external IP address to this GCE address
+   -d [disk-type]       - Specify a boot disk type (default None) Use pd-ssd to get ssd on GCE.
+   -D                   - Delete the network
+   -r                   - Reuse existing node/ledger configuration from a
+                          previous |start| (ie, don't run ./multinode-demo/setup.sh).
+   -x                   - External node.  Default: false
+   -e                   - Skip create.  Assume the nodes have already been created
+   -s                   - Skip start.  Nodes will still be created or configured, but network software will not be started.
+   -S                   - Stop network software without tearing down nodes.
+   -f                   - Discard validator nodes that didn't bootup successfully
+   --no-airdrop
+                        - If set, disables airdrops.  Nodes must be funded in genesis config when airdrops are disabled.
+   --internal-nodes-stake-lamports NUM_LAMPORTS
+                        - Amount to stake internal nodes.
+   --internal-nodes-lamports NUM_LAMPORTS
+                        - Amount to fund internal nodes in genesis config
+   --external-accounts-file FILE_PATH
+                        - Path to external Primordial Accounts file, if it exists.
+   --hashes-per-tick NUM_HASHES|sleep|auto
+                        - Override the default --hashes-per-tick for the cluster
+   --lamports NUM_LAMPORTS
+                        - Specify the number of lamports to mint (default 500000000000000000)
+   --skip-deploy-update
+                        - If set, will skip software update deployment
+   --skip-remote-log-retrieval
+                        - If set, will not fetch logs from remote nodes
+   --letsencrypt [dns name]
+                        - Attempt to generate a TLS certificate using this DNS name
+   --validator-additional-disk-size-gb [number]
+                        - Size of additional disk in GB for all validators
+   --no-snapshot-fetch
+                        - If set, disables booting validators from a snapshot
+
+   Note: the SOLANA_METRICS_CONFIG environment variable is used to configure
+         metrics
+EOF
+  exit $exitcode
+}
+
+zone=()
+
+shortArgs=()
+while [[ -n $1 ]]; do
+  if [[ ${1:0:2} = -- ]]; then
+    if [[ $1 = --hashes-per-tick ]]; then
+      maybeHashesPerTick="$1 $2"
+      shift 2
+    elif [[ $1 = --slots-per-epoch ]]; then
+      maybeSlotsPerEpoch="$1 $2"
+      shift 2
+    elif [[ $1 = --target-lamports-per-signature ]]; then
+      maybeTargetLamportsPerSignature="$1 $2"
+      shift 2
+    elif [[ $1 = --no-airdrop ]]; then
+      maybeDisableAirdrops=$1
+      shift 1
+    elif [[ $1 = --internal-nodes-stake-lamports ]]; then
+      maybeInternalNodesStakeLamports="$1 $2"
+      shift 2
+    elif [[ $1 = --internal-nodes-lamports ]]; then
+      maybeInternalNodesLamports="$1 $2"
+      shift 2
+    elif [[ $1 = --external-accounts-file ]]; then
+      maybeExternalPrimordialAccountsFile="$1 $2"
+      shift 2
+    elif [[ $1 = --skip-remote-log-retrieval ]]; then
+      fetchLogs=false
+      shift 1
+    elif [[ $1 = --letsencrypt ]]; then
+      maybeLetsEncrypt="$1 $2"
+      shift 2
+    elif [[ $1 = --validator-additional-disk-size-gb ]]; then
+      maybeValidatorAdditionalDiskSize="$1 $2"
+      shift 2
+    elif [[ $1 == --machine-type* ]]; then # Bypass quoted long args for GPUs
+      shortArgs+=("$1")
+      shift
+    elif [[ $1 = --no-snapshot-fetch ]]; then
+      maybeNoSnapshot=$1
+      shift 1
+    elif [[ $1 = --limit-ledger-size ]]; then
+      maybeLimitLedgerSize=$1
+      shift 1
+    elif [[ $1 = --idle-clients ]]; then
+      idleClients=true
+      shift 1
+    else
+      usage "Unknown long option: $1"
+    fi
+  else
+    shortArgs+=("$1")
+    shift
+  fi
+done
+
+while getopts "h?p:Pn:c:t:gG:a:Dd:rusxz:p:C:Sfe" opt "${shortArgs[@]}"; do
+  case $opt in
+  h | \?)
+    usage
+    ;;
+  p)
+    netName=$OPTARG
+    ;;
+  C)
+    cloudProvider=$OPTARG
+    ;;
+  z)
+    zone+=("$OPTARG")
+    ;;
+  P)
+    publicNetwork=true
+    ;;
+  n)
+    additionalValidatorCount=$OPTARG
+    ;;
+  c)
+    clientNodeCount=$OPTARG
+    ;;
+  t)
+    case $OPTARG in
+    edge|beta|stable|v*)
+      tarChannelOrTag=$OPTARG
+      ;;
+    *)
+      usage "Invalid release channel: $OPTARG"
+      ;;
+    esac
+    ;;
+  g)
+    enableGpu=true
+    ;;
+  G)
+    enableGpu=true
+    bootstrapValidatorMachineType=$OPTARG
+    ;;
+  a)
+    bootstrapValidatorAddress=$OPTARG
+    ;;
+  d)
+    bootDiskType=$OPTARG
+    ;;
+  D)
+    delete=true
+    ;;
+  r)
+    reuseLedger=true
+    ;;
+  e)
+    skipCreate=true
+    ;;
+  s)
+    skipStart=true
+    ;;
+  x)
+    externalNode=true
+    ;;
+  f)
+    failOnValidatorBootupFailure=false
+    ;;
+  u)
+    blockstreamer=true
+    ;;
+  S)
+    stopNetwork=true
+    ;;
+  *)
+    usage "Unknown option: $opt"
+    ;;
+  esac
+done
+
+[[ -n $netName ]] || usage
+[[ -n $cloudProvider ]] || usage "Cloud provider not specified"
+[[ -n ${zone[*]} ]] || usage "At least one zone must be specified"
+
+shutdown() {
+  exitcode=$?
+
+  set +e
+  if [[ -d net/log ]]; then
+    mv net/log net/log-deploy
+    for logfile in net/log-deploy/*; do
+      if [[ -f $logfile ]]; then
+        upload-ci-artifact "$logfile"
+        tail "$logfile"
+      fi
+    done
+  fi
+  exit $exitcode
+}
+rm -rf net/{log,-deploy}
+trap shutdown EXIT INT
+
+set -x
+
+# Fetch reusable testnet keypairs
+if [[ ! -d net/keypairs ]]; then
+  git clone git@github.com:solana-labs/testnet-keypairs.git net/keypairs
+fi
+
+# Build a string to pass zone opts to $cloudProvider.sh: "-z zone1 -z zone2 ..."
+zone_args=()
+for val in "${zone[@]}"; do
+  zone_args+=("-z $val")
+done
+
+if $stopNetwork; then
+  skipCreate=true
+fi
+
+if $delete; then
+  skipCreate=false
+fi
+
+# Create the network
+if ! $skipCreate; then
+  echo "--- $cloudProvider.sh delete"
+  # shellcheck disable=SC2068
+  time net/"$cloudProvider".sh delete ${zone_args[@]} -p "$netName" ${externalNode:+-x}
+  if $delete; then
+    exit 0
+  fi
+
+  echo "--- $cloudProvider.sh create"
+  create_args=(
+    -p "$netName"
+    -c "$clientNodeCount"
+    -n "$additionalValidatorCount"
+    --dedicated
+    --self-destruct-hours 0
+  )
+
+  if [[ -n $bootstrapValidatorAddress ]]; then
+    create_args+=(-a "$bootstrapValidatorAddress")
+  fi
+
+  # shellcheck disable=SC2206
+  create_args+=(${zone_args[@]})
+
+  if [[ -n $maybeLetsEncrypt ]]; then
+    # shellcheck disable=SC2206 # Do not want to quote $maybeLetsEncrypt
+    create_args+=($maybeLetsEncrypt)
+  fi
+
+  if $blockstreamer; then
+    create_args+=(-u)
+  fi
+
+  if [[ -n $bootDiskType ]]; then
+    create_args+=(-d "$bootDiskType")
+  fi
+
+  if $enableGpu; then
+    if [[ -z $bootstrapValidatorMachineType ]]; then
+      create_args+=(-g)
+    else
+      create_args+=(-G "$bootstrapValidatorMachineType")
+    fi
+  fi
+
+  if $publicNetwork; then
+    create_args+=(-P)
+  fi
+
+  if $externalNode; then
+    create_args+=(-x)
+  fi
+
+  if ! $failOnValidatorBootupFailure; then
+    create_args+=(-f)
+  fi
+
+  if [[ -n $maybeValidatorAdditionalDiskSize ]]; then
+    # shellcheck disable=SC2206 # Do not want to quote
+    create_args+=($maybeValidatorAdditionalDiskSize)
+  fi
+
+  time net/"$cloudProvider".sh create "${create_args[@]}"
+else
+  echo "--- $cloudProvider.sh config"
+  config_args=(
+    -p "$netName"
+  )
+  # shellcheck disable=SC2206
+  config_args+=(${zone_args[@]})
+  if $publicNetwork; then
+    config_args+=(-P)
+  fi
+
+  if $externalNode; then
+    config_args+=(-x)
+  fi
+
+  if ! $failOnValidatorBootupFailure; then
+    config_args+=(-f)
+  fi
+
+  time net/"$cloudProvider".sh config "${config_args[@]}"
+fi
+net/init-metrics.sh -e
+
+echo "+++ $cloudProvider.sh info"
+net/"$cloudProvider".sh info
+
+if $stopNetwork; then
+  echo --- net.sh stop
+  time net/net.sh stop
+  exit 0
+fi
+
+ok=true
+if ! $skipStart; then
+  (
+    if $skipCreate; then
+      op=restart
+    else
+      op=start
+    fi
+    echo "--- net.sh $op"
+    args=(
+      "$op"
+      -t "$tarChannelOrTag"
+    )
+
+    if ! $publicNetwork; then
+      args+=(-o rejectExtraNodes)
+    fi
+    if [[ -n $NO_INSTALL_CHECK ]]; then
+      args+=(-o noInstallCheck)
+    fi
+    if $reuseLedger; then
+      args+=(-r)
+    fi
+
+    if ! $failOnValidatorBootupFailure; then
+      args+=(-F)
+    fi
+
+    # shellcheck disable=SC2206 # Do not want to quote
+    args+=(
+      $maybeHashesPerTick
+      $maybeDisableAirdrops
+      $maybeInternalNodesStakeLamports
+      $maybeInternalNodesLamports
+      $maybeExternalPrimordialAccountsFile
+      $maybeSlotsPerEpoch
+      $maybeTargetLamportsPerSignature
+      $maybeNoSnapshot
+      $maybeLimitLedgerSize
+    )
+
+    if $idleClients; then
+      args+=(-c "idle=$clientNodeCount=")
+    fi
+
+    time net/net.sh "${args[@]}"
+  ) || ok=false
+
+  if $fetchLogs; then
+    net/net.sh logs
+  fi
+fi
+
+$ok
--- a/ci/testnet-manager.sh
+++ b/ci/testnet-manager.sh
@ -0,0 +1,401 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"/..
+
+if [[ -z $BUILDKITE ]]; then
+  echo BUILDKITE not defined
+  exit 1
+fi
+
+if [[ -z $SOLANA_METRICS_PARTIAL_CONFIG ]]; then
+  echo SOLANA_METRICS_PARTIAL_CONFIG not defined
+  exit 1
+fi
+
+if [[ -z $TESTNET ]]; then
+  TESTNET=$(buildkite-agent meta-data get "testnet" --default "")
+fi
+
+if [[ -z $TESTNET_OP ]]; then
+  TESTNET_OP=$(buildkite-agent meta-data get "testnet-operation" --default "")
+fi
+
+if [[ -z $TESTNET || -z $TESTNET_OP ]]; then
+  (
+    cat <<EOF
+steps:
+  - block: "Manage Testnet"
+    fields:
+      - select: "Network"
+        key: "testnet"
+        options:
+          - label: "testnet"
+            value: "testnet"
+          - label: "testnet-edge"
+            value: "testnet-edge"
+          - label: "testnet-beta"
+            value: "testnet-beta"
+      - select: "Operation"
+        key: "testnet-operation"
+        default: "sanity-or-restart"
+        options:
+          - label: "Create testnet and then start software.  If the testnet already exists it will be deleted and re-created"
+            value: "create-and-start"
+          - label: "Create testnet, but do not start software.  If the testnet already exists it will be deleted and re-created"
+            value: "create"
+          - label: "Start network software on an existing testnet.  If software is already running it will be restarted"
+            value: "start"
+          - label: "Stop network software without deleting testnet nodes"
+            value: "stop"
+          - label: "Update the network software.  Restart network software on failure"
+            value: "update-or-restart"
+          - label: "Sanity check.  Restart network software on failure"
+            value: "sanity-or-restart"
+          - label: "Sanity check only"
+            value: "sanity"
+          - label: "Delete the testnet"
+            value: "delete"
+          - label: "Enable/unlock the testnet"
+            value: "enable"
+          - label: "Delete and then lock the testnet from further operation until it is re-enabled"
+            value: "disable"
+  - command: "ci/$(basename "$0")"
+    agents:
+      - "queue=$BUILDKITE_AGENT_META_DATA_QUEUE"
+EOF
+  ) | buildkite-agent pipeline upload
+  exit 0
+fi
+
+ci/channel-info.sh
+eval "$(ci/channel-info.sh)"
+
+
+EC2_ZONES=(
+  us-west-1a
+  us-west-2a
+  us-east-1a
+  us-east-2a
+  sa-east-1a
+  eu-west-1a
+  eu-west-2a
+  eu-central-1a
+  ap-northeast-2a
+  ap-southeast-2a
+  ap-south-1a
+  ca-central-1a
+)
+
+# GCE zones with _lots_ of quota
+GCE_ZONES=(
+  us-west1-a
+  us-central1-a
+  us-east1-b
+  europe-west4-a
+
+  us-west1-b
+  us-central1-b
+  us-east1-c
+  europe-west4-b
+
+  us-west1-c
+  us-east1-d
+  europe-west4-c
+)
+
+# GCE zones with enough quota for one CPU-only validator
+GCE_LOW_QUOTA_ZONES=(
+  asia-east2-a
+  asia-northeast1-b
+  asia-northeast2-b
+  asia-south1-c
+  asia-southeast1-b
+  australia-southeast1-b
+  europe-north1-a
+  europe-west2-b
+  europe-west3-c
+  europe-west6-a
+  northamerica-northeast1-a
+  southamerica-east1-b
+)
+
+case $TESTNET in
+testnet-edge)
+  CHANNEL_OR_TAG=edge
+  CHANNEL_BRANCH=$EDGE_CHANNEL
+  ;;
+testnet-beta)
+  CHANNEL_OR_TAG=beta
+  CHANNEL_BRANCH=$BETA_CHANNEL
+  ;;
+testnet)
+  CHANNEL_OR_TAG=$STABLE_CHANNEL_LATEST_TAG
+  CHANNEL_BRANCH=$STABLE_CHANNEL
+  export CLOUDSDK_CORE_PROJECT=testnet-solana-com
+  ;;
+*)
+  echo "Error: Invalid TESTNET=$TESTNET"
+  exit 1
+  ;;
+esac
+
+EC2_ZONE_ARGS=()
+for val in "${EC2_ZONES[@]}"; do
+  EC2_ZONE_ARGS+=("-z $val")
+done
+GCE_ZONE_ARGS=()
+for val in "${GCE_ZONES[@]}"; do
+  GCE_ZONE_ARGS+=("-z $val")
+done
+GCE_LOW_QUOTA_ZONE_ARGS=()
+for val in "${GCE_LOW_QUOTA_ZONES[@]}"; do
+  GCE_LOW_QUOTA_ZONE_ARGS+=("-z $val")
+done
+
+if [[ -z $TESTNET_DB_HOST ]]; then
+  TESTNET_DB_HOST="https://metrics.solana.com:8086"
+fi
+
+export SOLANA_METRICS_CONFIG="db=$TESTNET,host=$TESTNET_DB_HOST,$SOLANA_METRICS_PARTIAL_CONFIG"
+echo "SOLANA_METRICS_CONFIG: $SOLANA_METRICS_CONFIG"
+source scripts/configure-metrics.sh
+
+if [[ -n $TESTNET_TAG ]]; then
+  CHANNEL_OR_TAG=$TESTNET_TAG
+else
+
+  if [[ $CI_BRANCH != "$CHANNEL_BRANCH" ]]; then
+    (
+      cat <<EOF
+steps:
+  - trigger: "$BUILDKITE_PIPELINE_SLUG"
+    async: true
+    build:
+      message: "$BUILDKITE_MESSAGE"
+      branch: "$CHANNEL_BRANCH"
+      env:
+        TESTNET: "$TESTNET"
+        TESTNET_OP: "$TESTNET_OP"
+        TESTNET_DB_HOST: "$TESTNET_DB_HOST"
+        GCE_NODE_COUNT: "$GCE_NODE_COUNT"
+        GCE_LOW_QUOTA_NODE_COUNT: "$GCE_LOW_QUOTA_NODE_COUNT"
+        RUST_LOG: "$RUST_LOG"
+EOF
+    ) | buildkite-agent pipeline upload
+    exit 0
+  fi
+fi
+
+maybe_deploy_software() {
+  declare arg=$1
+  declare ok=true
+  (
+    echo "--- net.sh restart"
+    set -x
+    time net/net.sh restart --skip-setup -t "$CHANNEL_OR_TAG" --skip-poh-verify "$arg"
+  ) || ok=false
+  if ! $ok; then
+    net/net.sh logs
+  fi
+  $ok
+}
+
+sanity() {
+  echo "--- sanity $TESTNET"
+  case $TESTNET in
+  testnet-edge)
+    (
+      set -x
+      NO_INSTALL_CHECK=1 \
+        ci/testnet-sanity.sh edge-devnet-solana-com gce -P us-west1-b
+      maybe_deploy_software
+    )
+    ;;
+  testnet-beta)
+    (
+      set -x
+      NO_INSTALL_CHECK=1 \
+        ci/testnet-sanity.sh beta-devnet-solana-com gce -P us-west1-b
+      maybe_deploy_software --deploy-if-newer
+    )
+    ;;
+  testnet)
+    (
+      set -x
+      ci/testnet-sanity.sh devnet-solana-com gce -P us-west1-b
+    )
+    ;;
+  *)
+    echo "Error: Invalid TESTNET=$TESTNET"
+    exit 1
+    ;;
+  esac
+}
+
+deploy() {
+  declare maybeCreate=$1
+  declare maybeStart=$2
+  declare maybeStop=$3
+  declare maybeDelete=$4
+
+  echo "--- deploy \"$maybeCreate\" \"$maybeStart\" \"$maybeStop\" \"$maybeDelete\""
+
+  # Create or recreate the nodes
+  if [[ -z $maybeCreate ]]; then
+    skipCreate=skip
+  else
+    skipCreate=""
+  fi
+
+  # Start or restart the network software on the nodes
+  if [[ -z $maybeStart ]]; then
+    skipStart=skip
+  else
+    skipStart=""
+  fi
+
+  case $TESTNET in
+  testnet-edge)
+    (
+      set -x
+      ci/testnet-deploy.sh -p edge-devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 3 -c 0 -u -P \
+        -a edge-devnet-solana-com --letsencrypt edge.devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    ;;
+  testnet-beta)
+    (
+      set -x
+      ci/testnet-deploy.sh -p beta-devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 3 -c 0 -u -P \
+        -a beta-devnet-solana-com --letsencrypt beta.devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    ;;
+  testnet)
+    (
+      set -x
+      ci/testnet-deploy.sh -p devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 0 -c 0 -u -P \
+        -a testnet-solana-com --letsencrypt devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    (
+      echo "--- net.sh update"
+      set -x
+      time net/net.sh update -t "$CHANNEL_OR_TAG" --platform linux --platform osx #--platform windows
+    )
+    ;;
+  *)
+    echo "Error: Invalid TESTNET=$TESTNET"
+    exit 1
+    ;;
+  esac
+}
+
+ENABLED_LOCKFILE="${HOME}/${TESTNET}.is_enabled"
+
+create-and-start() {
+  deploy create start
+}
+create() {
+  deploy create
+}
+start() {
+  deploy "" start
+}
+stop() {
+  deploy "" ""
+}
+delete() {
+  deploy "" "" "" delete
+}
+enable_testnet() {
+  touch "${ENABLED_LOCKFILE}"
+  echo "+++ $TESTNET now enabled"
+}
+disable_testnet() {
+  rm -f "${ENABLED_LOCKFILE}"
+  echo "+++ $TESTNET now disabled"
+}
+is_testnet_enabled() {
+  if [[ ! -f ${ENABLED_LOCKFILE} ]]; then
+    echo "+++ ${TESTNET} is currently disabled.  Enable ${TESTNET} by running ci/testnet-manager.sh with \$TESTNET_OP=enable, then re-run with current settings."
+    exit 0
+  fi
+}
+
+case $TESTNET_OP in
+enable)
+  enable_testnet
+  ;;
+disable)
+  disable_testnet
+  delete
+  ;;
+create-and-start)
+  is_testnet_enabled
+  create-and-start
+  ;;
+create)
+  is_testnet_enabled
+  create
+  ;;
+start)
+  is_testnet_enabled
+  start
+  ;;
+stop)
+  is_testnet_enabled
+  stop
+  ;;
+sanity)
+  is_testnet_enabled
+  sanity
+  ;;
+delete)
+  is_testnet_enabled
+  delete
+  ;;
+update-or-restart)
+  is_testnet_enabled
+  if start; then
+    echo Update successful
+  else
+    echo "+++ Update failed, restarting the network"
+    $metricsWriteDatapoint "testnet-manager update-failure=1"
+    create-and-start
+  fi
+  ;;
+sanity-or-restart)
+  is_testnet_enabled
+  if sanity; then
+    echo Pass
+  else
+    echo "+++ Sanity failed, updating the network"
+    $metricsWriteDatapoint "testnet-manager sanity-failure=1"
+    create-and-start
+  fi
+  ;;
+*)
+  echo "Error: Invalid TESTNET_OP=$TESTNET_OP"
+  exit 1
+  ;;
+esac
+
+echo --- fin
+exit 0
--- a/ci/testnet-sanity.sh
+++ b/ci/testnet-sanity.sh
@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")/.."
+source ci/upload-ci-artifact.sh
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 [name] [cloud] [zone1] ... [zoneN]
+
+Sanity check a testnet
+
+  name            - name of the network
+  cloud           - cloud provider to use (gce, ec2)
+  zone1 .. zoneN  - cloud provider zones to check
+
+  Note: the SOLANA_METRICS_CONFIG environment variable is used to configure
+        metrics
+EOF
+  exit $exitcode
+}
+
+netName=$1
+cloudProvider=$2
+[[ -n $netName ]] || usage ""
+[[ -n $cloudProvider ]] || usage "Cloud provider not specified"
+shift 2
+
+maybePublicNetwork=
+if [[ $1 = -P ]]; then
+  maybePublicNetwork=-P
+  shift
+fi
+[[ -n $1 ]] || usage "zone1 not specified"
+
+shutdown() {
+  exitcode=$?
+
+  set +e
+  if [[ -d net/log ]]; then
+    mv net/log net/log-sanity
+    for logfile in net/log-sanity/*; do
+      if [[ -f $logfile ]]; then
+        upload-ci-artifact "$logfile"
+        tail "$logfile"
+      fi
+    done
+  fi
+  exit $exitcode
+}
+rm -rf net/{log,-sanity}
+rm -f net/config/config
+trap shutdown EXIT INT
+
+set -x
+for zone in "$@"; do
+  echo "--- $cloudProvider config [$zone]"
+  timeout 5m net/"$cloudProvider".sh config $maybePublicNetwork -n 1 -p "$netName" -z "$zone"
+  net/init-metrics.sh -e
+  echo "+++ $cloudProvider.sh info"
+  net/"$cloudProvider".sh info
+  echo "--- net.sh sanity [$cloudProvider:$zone]"
+  ok=true
+  timeout 5m net/net.sh sanity \
+    ${REJECT_EXTRA_NODES:+-o rejectExtraNodes} \
+    ${NO_INSTALL_CHECK:+-o noInstallCheck} \
+    $zone || ok=false
+
+  if ! $ok; then
+    net/net.sh logs
+  fi
+  $ok
+done
--- a/ci/upload-github-release-asset.sh
+++ b/ci/upload-github-release-asset.sh
@ -23,14 +23,10 @@ if [[ -z $CI_TAG ]]; then
  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
+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" \
--- a/clap-utils/Cargo.toml
+++ b/clap-utils/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "solana-clap-utils"
-version = "1.2.2"
+version = "1.0.2"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@ -11,15 +11,11 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.2" }
-solana-sdk = { path = "../sdk", version = "1.2.2" }
-thiserror = "1.0.11"
+solana-remote-wallet = { path = "../remote-wallet", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
 tiny-bip39 = "0.7.0"
 url = "2.1.0"
 chrono = "0.4"

 [lib]
 name = "solana_clap_utils"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/clap-utils/src/commitment.rs
+++ b/clap-utils/src/commitment.rs
@ -1,22 +0,0 @@
-use crate::ArgConstant;
-use clap::Arg;
-
-pub const COMMITMENT_ARG: ArgConstant<'static> = ArgConstant {
-    name: "commitment",
-    long: "commitment",
-    help: "Return information at the selected commitment level",
-};
-
-pub fn commitment_arg<'a, 'b>() -> Arg<'a, 'b> {
-    commitment_arg_with_default("recent")
-}
-
-pub fn commitment_arg_with_default<'a, 'b>(default_value: &'static str) -> Arg<'a, 'b> {
-    Arg::with_name(COMMITMENT_ARG.name)
-        .long(COMMITMENT_ARG.long)
-        .takes_value(true)
-        .possible_values(&["recent", "single", "root", "max"])
-        .default_value(default_value)
-        .value_name("COMMITMENT_LEVEL")
-        .help(COMMITMENT_ARG.help)
-}
--- a/clap-utils/src/input_parsers.rs
+++ b/clap-utils/src/input_parsers.rs
@ -1,13 +1,11 @@
 use crate::keypair::{
-    keypair_from_seed_phrase, pubkey_from_path, resolve_signer_from_path, signer_from_path,
-    ASK_KEYWORD, SKIP_SEED_PHRASE_VALIDATION_ARG,
+    keypair_from_seed_phrase, signer_from_path, ASK_KEYWORD, SKIP_SEED_PHRASE_VALIDATION_ARG,
 };
 use chrono::DateTime;
 use clap::ArgMatches;
-use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_remote_wallet::remote_wallet::{DerivationPath, RemoteWalletManager};
 use solana_sdk::{
    clock::UnixTimestamp,
-    commitment_config::CommitmentConfig,
    native_token::sol_to_lamports,
    pubkey::Pubkey,
    signature::{read_keypair_file, Keypair, Signature, Signer},
@ -63,21 +61,6 @@ pub fn keypair_of(matches: &ArgMatches<'_>, name: &str) -> Option<Keypair> {
    }
 }

-pub fn keypairs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<Keypair>> {
-    matches.values_of(name).map(|values| {
-        values
-            .filter_map(|value| {
-                if value == ASK_KEYWORD {
-                    let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-                    keypair_from_seed_phrase(name, skip_validation, true).ok()
-                } else {
-                    read_keypair_file(value).ok()
-                }
-            })
-            .collect()
-    })
-}
-
 // Return a pubkey for an argument that can itself be parsed into a pubkey,
 // or is a filename that can be read as a keypair
 pub fn pubkey_of(matches: &ArgMatches<'_>, name: &str) -> Option<Pubkey> {
@ -117,7 +100,7 @@ pub fn pubkeys_sigs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<(Pubk
 pub fn signer_of(
    matches: &ArgMatches<'_>,
    name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<(Option<Box<dyn Signer>>, Option<Pubkey>), Box<dyn std::error::Error>> {
    if let Some(location) = matches.value_of(name) {
        let signer = signer_from_path(matches, location, name, wallet_manager)?;
@ -128,63 +111,17 @@ pub fn signer_of(
    }
 }

-pub fn pubkey_of_signer(
-    matches: &ArgMatches<'_>,
-    name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<Option<Pubkey>, Box<dyn std::error::Error>> {
-    if let Some(location) = matches.value_of(name) {
-        Ok(Some(pubkey_from_path(
-            matches,
-            location,
-            name,
-            wallet_manager,
-        )?))
-    } else {
-        Ok(None)
-    }
-}
-
-pub fn pubkeys_of_multiple_signers(
-    matches: &ArgMatches<'_>,
-    name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<Option<Vec<Pubkey>>, Box<dyn std::error::Error>> {
-    if let Some(pubkey_matches) = matches.values_of(name) {
-        let mut pubkeys: Vec<Pubkey> = vec![];
-        for signer in pubkey_matches {
-            pubkeys.push(pubkey_from_path(matches, signer, name, wallet_manager)?);
-        }
-        Ok(Some(pubkeys))
-    } else {
-        Ok(None)
-    }
-}
-
-pub fn resolve_signer(
-    matches: &ArgMatches<'_>,
-    name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<Option<String>, Box<dyn std::error::Error>> {
-    Ok(resolve_signer_from_path(
-        matches,
-        matches.value_of(name).unwrap(),
-        name,
-        wallet_manager,
-    )?)
-}
-
 pub fn lamports_of_sol(matches: &ArgMatches<'_>, name: &str) -> Option<u64> {
    value_of(matches, name).map(sol_to_lamports)
 }

-pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentConfig> {
-    matches.value_of(name).map(|value| match value {
-        "max" => CommitmentConfig::max(),
-        "recent" => CommitmentConfig::recent(),
-        "root" => CommitmentConfig::root(),
-        "single" => CommitmentConfig::single(),
-        _ => CommitmentConfig::default(),
+pub fn derivation_of(matches: &ArgMatches<'_>, name: &str) -> Option<DerivationPath> {
+    matches.value_of(name).map(|derivation_str| {
+        let derivation_str = derivation_str.replace("'", "");
+        let mut parts = derivation_str.split('/');
+        let account = parts.next().map(|account| account.parse::<u32>().unwrap());
+        let change = parts.next().map(|change| change.parse::<u32>().unwrap());
+        DerivationPath { account, change }
    })
 }

@ -350,16 +287,52 @@ mod tests {
        let matches = app()
            .clone()
            .get_matches_from(vec!["test", "--single", "50"]);
-        assert_eq!(lamports_of_sol(&matches, "single"), Some(50_000_000_000));
+        assert_eq!(lamports_of_sol(&matches, "single"), Some(50000000000));
        assert_eq!(lamports_of_sol(&matches, "multiple"), None);
        let matches = app()
            .clone()
            .get_matches_from(vec!["test", "--single", "1.5"]);
-        assert_eq!(lamports_of_sol(&matches, "single"), Some(1_500_000_000));
+        assert_eq!(lamports_of_sol(&matches, "single"), Some(1500000000));
        assert_eq!(lamports_of_sol(&matches, "multiple"), None);
        let matches = app()
            .clone()
            .get_matches_from(vec!["test", "--single", "0.03"]);
-        assert_eq!(lamports_of_sol(&matches, "single"), Some(30_000_000));
+        assert_eq!(lamports_of_sol(&matches, "single"), Some(30000000));
+    }
+
+    #[test]
+    fn test_derivation_of() {
+        let matches = app()
+            .clone()
+            .get_matches_from(vec!["test", "--single", "2/3"]);
+        assert_eq!(
+            derivation_of(&matches, "single"),
+            Some(DerivationPath {
+                account: Some(2),
+                change: Some(3)
+            })
+        );
+        assert_eq!(derivation_of(&matches, "another"), None);
+        let matches = app()
+            .clone()
+            .get_matches_from(vec!["test", "--single", "2"]);
+        assert_eq!(
+            derivation_of(&matches, "single"),
+            Some(DerivationPath {
+                account: Some(2),
+                change: None
+            })
+        );
+        assert_eq!(derivation_of(&matches, "another"), None);
+        let matches = app()
+            .clone()
+            .get_matches_from(vec!["test", "--single", "2'/3'"]);
+        assert_eq!(
+            derivation_of(&matches, "single"),
+            Some(DerivationPath {
+                account: Some(2),
+                change: Some(3)
+            })
+        );
    }
 }
--- a/clap-utils/src/input_validators.rs
+++ b/clap-utils/src/input_validators.rs
@ -12,7 +12,7 @@ use std::str::FromStr;
 pub fn is_pubkey(string: String) -> Result<(), String> {
    match string.parse::<Pubkey>() {
        Ok(_) => Ok(()),
-        Err(err) => Err(format!("{}", err)),
+        Err(err) => Err(format!("{:?}", err)),
    }
 }

@ -20,7 +20,7 @@ pub fn is_pubkey(string: String) -> Result<(), String> {
 pub fn is_hash(string: String) -> Result<(), String> {
    match string.parse::<Hash>() {
        Ok(_) => Ok(()),
-        Err(err) => Err(format!("{}", err)),
+        Err(err) => Err(format!("{:?}", err)),
    }
 }

@ -28,7 +28,7 @@ pub fn is_hash(string: String) -> Result<(), String> {
 pub fn is_keypair(string: String) -> Result<(), String> {
    read_keypair_file(&string)
        .map(|_| ())
-        .map_err(|err| format!("{}", err))
+        .map_err(|err| format!("{:?}", err))
 }

 // Return an error if a keypair file cannot be parsed
@ -38,7 +38,7 @@ pub fn is_keypair_or_ask_keyword(string: String) -> Result<(), String> {
    }
    read_keypair_file(&string)
        .map(|_| ())
-        .map_err(|err| format!("{}", err))
+        .map_err(|err| format!("{:?}", err))
 }

 // Return an error if string cannot be parsed as pubkey string or keypair file location
@ -46,27 +46,18 @@ pub fn is_pubkey_or_keypair(string: String) -> Result<(), String> {
    is_pubkey(string.clone()).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> {
+// Return an error if string cannot be parsed as pubkey or keypair file or keypair ask keyword
+pub fn is_pubkey_or_keypair_or_ask_keyword(string: String) -> Result<(), String> {
+    is_pubkey(string.clone()).or_else(|_| is_keypair_or_ask_keyword(string))
+}
+
+pub fn is_valid_signer(string: String) -> Result<(), String> {
    match parse_keypair_path(&string) {
        KeypairUrl::Filepath(path) => is_keypair(path),
        _ => Ok(()),
    }
 }

-// Return an error if string cannot be parsed as a valid Signer. This is an alias of
-// `is_valid_pubkey`, and does accept pubkey strings, even though a Pubkey is not by itself
-// sufficient to sign a transaction.
-//
-// In the current offline-signing implementation, a pubkey is the valid input for a signer field
-// 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> {
-    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('=');
@ -82,10 +73,10 @@ pub fn is_pubkey_sig(string: String) -> Result<(), String> {
                    .ok_or_else(|| "Malformed signer string".to_string())?,
            ) {
                Ok(_) => Ok(()),
-                Err(err) => Err(format!("{}", err)),
+                Err(err) => Err(format!("{:?}", err)),
            }
        }
-        Err(err) => Err(format!("{}", err)),
+        Err(err) => Err(format!("{:?}", err)),
    }
 }

@ -99,20 +90,20 @@ pub fn is_url(string: String) -> Result<(), String> {
                Err("no host provided".to_string())
            }
        }
-        Err(err) => Err(format!("{}", err)),
+        Err(err) => Err(format!("{:?}", err)),
    }
 }

 pub fn is_slot(slot: String) -> Result<(), String> {
    slot.parse::<Slot>()
        .map(|_| ())
-        .map_err(|e| format!("{}", e))
+        .map_err(|e| format!("{:?}", e))
 }

 pub fn is_port(port: String) -> Result<(), String> {
    port.parse::<u16>()
        .map(|_| ())
-        .map_err(|e| format!("{}", e))
+        .map_err(|e| format!("{:?}", e))
 }

 pub fn is_valid_percentage(percentage: String) -> Result<(), String> {
@ -120,7 +111,7 @@ pub fn is_valid_percentage(percentage: String) -> Result<(), String> {
        .parse::<u8>()
        .map_err(|e| {
            format!(
-                "Unable to parse input percentage, provided: {}, err: {}",
+                "Unable to parse input percentage, provided: {}, err: {:?}",
                percentage, e
            )
        })
@ -147,21 +138,10 @@ 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" {
-        Ok(())
-    } else {
-        Err(format!(
-            "Unable to parse input amount as integer or float, provided: {}",
-            amount
-        ))
-    }
-}
-
 pub fn is_rfc3339_datetime(value: String) -> Result<(), String> {
    DateTime::parse_from_rfc3339(&value)
        .map(|_| ())
-        .map_err(|e| format!("{}", e))
+        .map_err(|e| format!("{:?}", e))
 }

 pub fn is_derivation(value: String) -> Result<(), String> {
@ -172,7 +152,7 @@ pub fn is_derivation(value: String) -> Result<(), String> {
        .parse::<u32>()
        .map_err(|e| {
            format!(
-                "Unable to parse derivation, provided: {}, err: {}",
+                "Unable to parse derivation, provided: {}, err: {:?}",
                account, e
            )
        })
@ -180,7 +160,7 @@ pub fn is_derivation(value: String) -> Result<(), String> {
            if let Some(change) = parts.next() {
                change.parse::<u32>().map_err(|e| {
                    format!(
-                        "Unable to parse derivation, provided: {}, err: {}",
+                        "Unable to parse derivation, provided: {}, err: {:?}",
                        change, e
                    )
                })
--- a/clap-utils/src/keypair.rs
+++ b/clap-utils/src/keypair.rs
@ -1,20 +1,20 @@
 use crate::{
-    input_parsers::pubkeys_sigs_of,
-    offline::{SIGNER_ARG, SIGN_ONLY_ARG},
+    input_parsers::{derivation_of, pubkeys_sigs_of},
+    offline::SIGNER_ARG,
    ArgConstant,
 };
 use bip39::{Language, Mnemonic, Seed};
-use clap::ArgMatches;
+use clap::{values_t, ArgMatches, Error, ErrorKind};
 use rpassword::prompt_password_stderr;
 use solana_remote_wallet::{
    remote_keypair::generate_remote_keypair,
-    remote_wallet::{maybe_wallet_manager, RemoteWalletError, RemoteWalletManager},
+    remote_wallet::{RemoteWalletError, RemoteWalletManager},
 };
 use solana_sdk::{
    pubkey::Pubkey,
    signature::{
        keypair_from_seed, keypair_from_seed_phrase_and_passphrase, read_keypair,
-        read_keypair_file, Keypair, NullSigner, Presigner, Signature, Signer,
+        read_keypair_file, Keypair, Presigner, Signature, Signer,
    },
 };
 use std::{
@ -64,7 +64,7 @@ pub fn signer_from_path(
    matches: &ArgMatches,
    path: &str,
    keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<Box<dyn Signer>, Box<dyn error::Error>> {
    match parse_keypair_path(path) {
        KeypairUrl::Ask => {
@ -75,28 +75,18 @@ pub fn signer_from_path(
                false,
            )?))
        }
-        KeypairUrl::Filepath(path) => match read_keypair_file(&path) {
-            Err(e) => Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!("could not find keypair file: {} error: {}", path, e),
-            )
-            .into()),
-            Ok(file) => Ok(Box::new(file)),
-        },
+        KeypairUrl::Filepath(path) => Ok(Box::new(read_keypair_file(&path)?)),
        KeypairUrl::Stdin => {
            let mut stdin = std::io::stdin();
            Ok(Box::new(read_keypair(&mut stdin)?))
        }
        KeypairUrl::Usb(path) => {
-            if wallet_manager.is_none() {
-                *wallet_manager = maybe_wallet_manager()?;
-            }
            if let Some(wallet_manager) = wallet_manager {
                Ok(Box::new(generate_remote_keypair(
                    path,
+                    derivation_of(matches, "derivation_path"),
                    wallet_manager,
                    matches.is_present("confirm_key"),
-                    keypair_name,
                )?))
            } else {
                Err(RemoteWalletError::NoDeviceFound.into())
@ -108,12 +98,10 @@ pub fn signer_from_path(
                .and_then(|presigners| presigner_from_pubkey_sigs(&pubkey, presigners));
            if let Some(presigner) = presigner {
                Ok(Box::new(presigner))
-            } else if matches.is_present(SIGN_ONLY_ARG.name) {
-                Ok(Box::new(NullSigner::new(&pubkey)))
            } else {
-                Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!("missing signature for supplied pubkey: {}", pubkey),
+                Err(Error::with_description(
+                    "Missing signature for supplied pubkey",
+                    ErrorKind::MissingRequiredArgument,
                )
                .into())
            }
@ -121,75 +109,39 @@ pub fn signer_from_path(
    }
 }

-pub fn pubkey_from_path(
-    matches: &ArgMatches,
-    path: &str,
-    keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<Pubkey, Box<dyn error::Error>> {
-    match parse_keypair_path(path) {
-        KeypairUrl::Pubkey(pubkey) => Ok(pubkey),
-        _ => Ok(signer_from_path(matches, path, keypair_name, wallet_manager)?.pubkey()),
-    }
-}
-
-pub fn resolve_signer_from_path(
-    matches: &ArgMatches,
-    path: &str,
-    keypair_name: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<Option<String>, Box<dyn error::Error>> {
-    match parse_keypair_path(path) {
-        KeypairUrl::Ask => {
-            let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
-            // This method validates the seed phrase, but returns `None` because there is no path
-            // on disk or to a device
-            keypair_from_seed_phrase(keypair_name, skip_validation, false).map(|_| None)
-        }
-        KeypairUrl::Filepath(path) => match read_keypair_file(&path) {
-            Err(e) => Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!("could not find keypair file: {} error: {}", path, e),
-            )
-            .into()),
-            Ok(_) => Ok(Some(path.to_string())),
-        },
-        KeypairUrl::Stdin => {
-            let mut stdin = std::io::stdin();
-            // This method validates the keypair from stdin, but returns `None` because there is no
-            // path on disk or to a device
-            read_keypair(&mut stdin).map(|_| None)
-        }
-        KeypairUrl::Usb(path) => {
-            if wallet_manager.is_none() {
-                *wallet_manager = maybe_wallet_manager()?;
-            }
-            if let Some(wallet_manager) = wallet_manager {
-                let path = generate_remote_keypair(
-                    path,
-                    wallet_manager,
-                    matches.is_present("confirm_key"),
-                    keypair_name,
-                )
-                .map(|keypair| keypair.path)?;
-                Ok(Some(path))
-            } else {
-                Err(RemoteWalletError::NoDeviceFound.into())
-            }
-        }
-        _ => Ok(Some(path.to_string())),
-    }
-}
-
 // Keyword used to indicate that the user should be asked for a keypair seed phrase
 pub const ASK_KEYWORD: &str = "ASK";

+pub const ASK_SEED_PHRASE_ARG: ArgConstant<'static> = ArgConstant {
+    long: "ask-seed-phrase",
+    name: "ask_seed_phrase",
+    help: "Recover a keypair using a seed phrase and optional passphrase",
+};
+
 pub const SKIP_SEED_PHRASE_VALIDATION_ARG: ArgConstant<'static> = ArgConstant {
    long: "skip-seed-phrase-validation",
    name: "skip_seed_phrase_validation",
    help: "Skip validation of seed phrases. Use this if your phrase does not use the BIP39 official English word list",
 };

+#[derive(Debug, PartialEq)]
+pub enum Source {
+    Generated,
+    Path,
+    SeedPhrase,
+}
+
+pub struct KeypairWithSource {
+    pub keypair: Keypair,
+    pub source: Source,
+}
+
+impl KeypairWithSource {
+    fn new(keypair: Keypair, source: Source) -> Self {
+        Self { keypair, source }
+    }
+}
+
 /// Prompts user for a passphrase and then asks for confirmirmation to check for mistakes
 pub fn prompt_passphrase(prompt: &str) -> Result<String, Box<dyn error::Error>> {
    let passphrase = prompt_password_stderr(&prompt)?;
@ -243,6 +195,47 @@ pub fn keypair_from_seed_phrase(
    Ok(keypair)
 }

+/// Checks CLI arguments to determine whether a keypair should be:
+///   - inputted securely via stdin,
+///   - read in from a file,
+///   - or newly generated
+pub fn keypair_input(
+    matches: &clap::ArgMatches,
+    keypair_name: &str,
+) -> Result<KeypairWithSource, Box<dyn error::Error>> {
+    let ask_seed_phrase_matches =
+        values_t!(matches.values_of(ASK_SEED_PHRASE_ARG.name), String).unwrap_or_default();
+    let keypair_match_name = keypair_name.replace('-', "_");
+    if ask_seed_phrase_matches
+        .iter()
+        .any(|s| s.as_str() == keypair_name)
+    {
+        if matches.value_of(keypair_match_name).is_some() {
+            clap::Error::with_description(
+                &format!(
+                    "`--{} {}` cannot be used with `{} <PATH>`",
+                    ASK_SEED_PHRASE_ARG.long, keypair_name, keypair_name
+                ),
+                clap::ErrorKind::ArgumentConflict,
+            )
+            .exit();
+        }
+
+        let skip_validation = matches.is_present(SKIP_SEED_PHRASE_VALIDATION_ARG.name);
+        keypair_from_seed_phrase(keypair_name, skip_validation, true)
+            .map(|keypair| KeypairWithSource::new(keypair, Source::SeedPhrase))
+    } else if let Some(keypair_file) = matches.value_of(keypair_match_name) {
+        if keypair_file.starts_with("usb://") {
+            Ok(KeypairWithSource::new(Keypair::new(), Source::Path))
+        } else {
+            read_keypair_file(keypair_file)
+                .map(|keypair| KeypairWithSource::new(keypair, Source::Path))
+        }
+    } else {
+        Ok(KeypairWithSource::new(Keypair::new(), Source::Generated))
+    }
+}
+
 fn sanitize_seed_phrase(seed_phrase: &str) -> String {
    seed_phrase
        .split_whitespace()
@ -253,6 +246,14 @@ fn sanitize_seed_phrase(seed_phrase: &str) -> String {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use clap::ArgMatches;
+
+    #[test]
+    fn test_keypair_input() {
+        let arg_matches = ArgMatches::default();
+        let KeypairWithSource { source, .. } = keypair_input(&arg_matches, "").unwrap();
+        assert_eq!(source, Source::Generated);
+    }

    #[test]
    fn test_sanitize_seed_phrase() {
--- a/clap-utils/src/lib.rs
+++ b/clap-utils/src/lib.rs
@ -1,4 +1,21 @@
-use thiserror::Error;
+#[macro_export]
+macro_rules! version {
+    () => {
+        &*format!(
+            "{}{}",
+            env!("CARGO_PKG_VERSION"),
+            if option_env!("CI_TAG").unwrap_or("").is_empty() {
+                format!(
+                    " [channel={} commit={}]",
+                    option_env!("CHANNEL").unwrap_or("unknown"),
+                    option_env!("CI_COMMIT").unwrap_or("unknown"),
+                )
+            } else {
+                "".to_string()
+            },
+        )
+    };
+}

 pub struct ArgConstant<'a> {
    pub long: &'a str,
@ -6,24 +23,6 @@ pub struct ArgConstant<'a> {
    pub help: &'a str,
 }

-/// Error type for forwarding Errors out of `main()` of a `clap` app
-/// and still using the `Display` formatter
-#[derive(Error)]
-#[error("{0}")]
-pub struct DisplayError(Box<dyn std::error::Error>);
-impl DisplayError {
-    pub fn new_as_boxed(inner: Box<dyn std::error::Error>) -> Box<Self> {
-        DisplayError(inner).into()
-    }
-}
-
-impl std::fmt::Debug for DisplayError {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(fmt, "{}", self.0)
-    }
-}
-
-pub mod commitment;
 pub mod input_parsers;
 pub mod input_validators;
 pub mod keypair;
--- a/cli-config/Cargo.toml
+++ b/cli-config/Cargo.toml
@ -3,7 +3,7 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-cli-config"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.2"
+version = "1.0.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
@ -11,10 +11,6 @@ homepage = "https://solana.com/"
 [dependencies]
 dirs = "2.0.2"
 lazy_static = "1.4.0"
-serde = "1.0.110"
+serde = "1.0.104"
 serde_derive = "1.0.103"
-serde_yaml = "0.8.12"
-url = "2.1.1"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+serde_yaml = "0.8.11"
--- a/cli-config/src/config.rs
+++ b/cli-config/src/config.rs
@ -1,7 +1,10 @@
 // Wallet settings that can be configured for long-term use
 use serde_derive::{Deserialize, Serialize};
-use std::io;
-use url::Url;
+use std::{
+    fs::{create_dir_all, File},
+    io::{self, Write},
+    path::Path,
+};

 lazy_static! {
    pub static ref CONFIG_FILE: Option<String> = {
@ -12,86 +15,39 @@ lazy_static! {
    };
 }

-#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Default, Debug, PartialEq)]
 pub struct Config {
-    pub json_rpc_url: String,
+    pub url: String,
    pub websocket_url: String,
    pub keypair_path: String,
 }

-impl Default for Config {
-    fn default() -> Self {
-        let keypair_path = {
-            let mut keypair_path = dirs::home_dir().expect("home directory");
-            keypair_path.extend(&[".config", "solana", "id.json"]);
-            keypair_path.to_str().unwrap().to_string()
-        };
-        let json_rpc_url = "https://api.mainnet-beta.solana.com".to_string();
-
-        // Empty websocket_url string indicates the client should
-        // `Config::compute_websocket_url(&json_rpc_url)`
-        let websocket_url = "".to_string();
-
+impl Config {
+    pub fn new(url: &str, websocket_url: &str, keypair_path: &str) -> Self {
        Self {
-            json_rpc_url,
-            websocket_url,
-            keypair_path,
+            url: url.to_string(),
+            websocket_url: websocket_url.to_string(),
+            keypair_path: keypair_path.to_string(),
        }
    }
-}

-impl Config {
    pub fn load(config_file: &str) -> Result<Self, io::Error> {
-        crate::load_config_file(config_file)
+        let file = File::open(config_file.to_string())?;
+        let config = serde_yaml::from_reader(file)
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))?;
+        Ok(config)
    }

    pub fn save(&self, config_file: &str) -> Result<(), io::Error> {
-        crate::save_config_file(self, config_file)
-    }
+        let serialized = serde_yaml::to_string(self)
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))?;

-    pub fn compute_websocket_url(json_rpc_url: &str) -> String {
-        let json_rpc_url: Option<Url> = json_rpc_url.parse().ok();
-        if json_rpc_url.is_none() {
-            return "".to_string();
+        if let Some(outdir) = Path::new(&config_file).parent() {
+            create_dir_all(outdir)?;
        }
-        let json_rpc_url = json_rpc_url.unwrap();
-        let is_secure = json_rpc_url.scheme().to_ascii_lowercase() == "https";
-        let mut ws_url = json_rpc_url.clone();
-        ws_url
-            .set_scheme(if is_secure { "wss" } else { "ws" })
-            .expect("unable to set scheme");
-        if let Some(port) = json_rpc_url.port() {
-            ws_url.set_port(Some(port + 1)).expect("unable to set port");
-        }
-        ws_url.to_string()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn compute_websocket_url() {
-        assert_eq!(
-            Config::compute_websocket_url(&"http://devnet.solana.com"),
-            "ws://devnet.solana.com/".to_string()
-        );
-
-        assert_eq!(
-            Config::compute_websocket_url(&"https://devnet.solana.com"),
-            "wss://devnet.solana.com/".to_string()
-        );
-
-        assert_eq!(
-            Config::compute_websocket_url(&"http://example.com:8899"),
-            "ws://example.com:8900/".to_string()
-        );
-        assert_eq!(
-            Config::compute_websocket_url(&"https://example.com:1234"),
-            "wss://example.com:1235/".to_string()
-        );
-
-        assert_eq!(Config::compute_websocket_url(&"garbage"), String::new());
+        let mut file = File::create(config_file)?;
+        file.write_all(&serialized.into_bytes())?;
+
+        Ok(())
    }
 }
--- a/cli-config/src/lib.rs
+++ b/cli-config/src/lib.rs
@ -1,39 +1,4 @@
 #[macro_use]
 extern crate lazy_static;

-mod config;
-pub use config::{Config, CONFIG_FILE};
-
-use std::{
-    fs::{create_dir_all, File},
-    io::{self, Write},
-    path::Path,
-};
-
-pub fn load_config_file<T, P>(config_file: P) -> Result<T, io::Error>
-where
-    T: serde::de::DeserializeOwned,
-    P: AsRef<Path>,
-{
-    let file = File::open(config_file)?;
-    let config = serde_yaml::from_reader(file)
-        .map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))?;
-    Ok(config)
-}
-
-pub fn save_config_file<T, P>(config: &T, config_file: P) -> Result<(), io::Error>
-where
-    T: serde::ser::Serialize,
-    P: AsRef<Path>,
-{
-    let serialized = serde_yaml::to_string(config)
-        .map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))?;
-
-    if let Some(outdir) = config_file.as_ref().parent() {
-        create_dir_all(outdir)?;
-    }
-    let mut file = File::create(config_file)?;
-    file.write_all(&serialized.into_bytes())?;
-
-    Ok(())
-}
+pub mod config;
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@ -3,57 +3,52 @@ authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-cli"
 description = "Blockchain, Rebuilt for Scale"
-version = "1.2.2"
+version = "1.0.2"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"

 [dependencies]
 bincode = "1.2.1"
-bs58 = "0.3.1"
-chrono = { version = "0.4.11", features = ["serde"] }
-clap = "2.33.1"
+bs58 = "0.3.0"
+chrono = { version = "0.4.10", features = ["serde"] }
+clap = "2.33.0"
 criterion-stats = "0.3.0"
 ctrlc = { version = "3.1.4", features = ["termination"] }
-console = "0.10.1"
+console = "0.9.2"
 dirs = "2.0.2"
 log = "0.4.8"
-Inflector = "0.11.4"
 indicatif = "0.14.0"
 humantime = "2.0.0"
 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.1", default-features = false, features = ["blocking", "rustls-tls"] }
+serde = "1.0.104"
 serde_derive = "1.0.103"
-serde_json = "1.0.53"
-solana-budget-program = { path = "../programs/budget", version = "1.2.2" }
-solana-clap-utils = { path = "../clap-utils", version = "1.2.2" }
-solana-cli-config = { path = "../cli-config", version = "1.2.2" }
-solana-client = { path = "../client", version = "1.2.2" }
-solana-config-program = { path = "../programs/config", version = "1.2.2" }
-solana-faucet = { path = "../faucet", version = "1.2.2" }
-solana-logger = { path = "../logger", version = "1.2.2" }
-solana-net-utils = { path = "../net-utils", version = "1.2.2" }
-solana-remote-wallet = { path = "../remote-wallet", version = "1.2.2" }
-solana-runtime = { path = "../runtime", version = "1.2.2" }
-solana-sdk = { path = "../sdk", version = "1.2.2" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.2" }
-solana-transaction-status = { path = "../transaction-status", version = "1.2.2" }
-solana-version = { path = "../version", version = "1.2.2" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.2" }
-solana-vote-signer = { path = "../vote-signer", version = "1.2.2" }
-thiserror = "1.0.19"
+serde_json = "1.0.46"
+solana-budget-program = { path = "../programs/budget", version = "1.0.2" }
+solana-clap-utils = { path = "../clap-utils", version = "1.0.2" }
+solana-cli-config = { path = "../cli-config", version = "1.0.2" }
+solana-client = { path = "../client", version = "1.0.2" }
+solana-config-program = { path = "../programs/config", version = "1.0.2" }
+solana-faucet = { path = "../faucet", version = "1.0.2" }
+solana-logger = { path = "../logger", version = "1.0.2" }
+solana-net-utils = { path = "../net-utils", version = "1.0.2" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.0.2" }
+solana-runtime = { path = "../runtime", version = "1.0.2" }
+solana-sdk = { path = "../sdk", version = "1.0.2" }
+solana-stake-program = { path = "../programs/stake", version = "1.0.2" }
+solana-storage-program = { path = "../programs/storage", version = "1.0.2" }
+solana-vote-program = { path = "../programs/vote", version = "1.0.2" }
+solana-vote-signer = { path = "../vote-signer", version = "1.0.2" }
+titlecase = "1.1.0"
 url = "2.1.1"

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

 [[bin]]
 name = "solana"
 path = "src/main.rs"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
--- a/cli/src/checks.rs
+++ b/cli/src/checks.rs
@ -1,206 +0,0 @@
-use crate::cli::CliError;
-use solana_client::{
-    client_error::{ClientError, Result as ClientResult},
-    rpc_client::RpcClient,
-};
-use solana_sdk::{
-    fee_calculator::FeeCalculator, message::Message, native_token::lamports_to_sol, pubkey::Pubkey,
-};
-
-pub fn check_account_for_fee(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    fee_calculator: &FeeCalculator,
-    message: &Message,
-) -> Result<(), CliError> {
-    check_account_for_multiple_fees(rpc_client, account_pubkey, fee_calculator, &[message])
-}
-
-pub fn check_account_for_multiple_fees(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    fee_calculator: &FeeCalculator,
-    messages: &[&Message],
-) -> Result<(), CliError> {
-    let fee = calculate_fee(fee_calculator, messages);
-    if !check_account_for_balance(rpc_client, account_pubkey, fee)
-        .map_err(Into::<ClientError>::into)?
-    {
-        return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
-    }
-    Ok(())
-}
-
-pub fn calculate_fee(fee_calculator: &FeeCalculator, messages: &[&Message]) -> u64 {
-    messages
-        .iter()
-        .map(|message| fee_calculator.calculate_fee(message))
-        .sum()
-}
-
-pub fn check_account_for_balance(
-    rpc_client: &RpcClient,
-    account_pubkey: &Pubkey,
-    balance: u64,
-) -> ClientResult<bool> {
-    let lamports = rpc_client.get_balance(account_pubkey)?;
-    if lamports != 0 && lamports >= balance {
-        return Ok(true);
-    }
-    Ok(false)
-}
-
-pub fn check_unique_pubkeys(
-    pubkey0: (&Pubkey, String),
-    pubkey1: (&Pubkey, String),
-) -> Result<(), CliError> {
-    if pubkey0.0 == pubkey1.0 {
-        Err(CliError::BadParameter(format!(
-            "Identical pubkeys found: `{}` and `{}` must be unique",
-            pubkey0.1, pubkey1.1
-        )))
-    } else {
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-    use solana_client::{
-        rpc_request::RpcRequest,
-        rpc_response::{Response, RpcResponseContext},
-    };
-    use solana_sdk::system_instruction;
-    use std::collections::HashMap;
-
-    #[test]
-    fn test_check_account_for_fees() {
-        let account_balance = 1;
-        let account_balance_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(account_balance),
-        });
-        let pubkey = Pubkey::new_rand();
-        let fee_calculator = FeeCalculator::new(1);
-
-        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 ix0 = system_instruction::transfer(&pubkey0, &pubkey1, 1);
-        let ix1 = system_instruction::transfer(&pubkey1, &pubkey0, 1);
-        let message1 = Message::new(&[ix0, ix1]);
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response.clone());
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        check_account_for_fee(&rpc_client, &pubkey, &fee_calculator, &message0)
-            .expect("unexpected result");
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response.clone());
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert!(check_account_for_fee(&rpc_client, &pubkey, &fee_calculator, &message1).is_err());
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert!(check_account_for_multiple_fees(
-            &rpc_client,
-            &pubkey,
-            &fee_calculator,
-            &[&message0, &message0]
-        )
-        .is_err());
-
-        let account_balance = 2;
-        let account_balance_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(account_balance),
-        });
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-
-        check_account_for_multiple_fees(
-            &rpc_client,
-            &pubkey,
-            &fee_calculator,
-            &[&message0, &message0],
-        )
-        .expect("unexpected result");
-    }
-
-    #[test]
-    fn test_check_account_for_balance() {
-        let account_balance = 50;
-        let account_balance_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(account_balance),
-        });
-        let pubkey = Pubkey::new_rand();
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetBalance, account_balance_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-
-        assert_eq!(
-            check_account_for_balance(&rpc_client, &pubkey, 1).unwrap(),
-            true
-        );
-        assert_eq!(
-            check_account_for_balance(&rpc_client, &pubkey, account_balance).unwrap(),
-            true
-        );
-        assert_eq!(
-            check_account_for_balance(&rpc_client, &pubkey, account_balance + 1).unwrap(),
-            false
-        );
-    }
-
-    #[test]
-    fn test_calculate_fee() {
-        let fee_calculator = FeeCalculator::new(1);
-        // No messages, no fee.
-        assert_eq!(calculate_fee(&fee_calculator, &[]), 0);
-
-        // No signatures, no fee.
-        let message = Message::default();
-        assert_eq!(calculate_fee(&fee_calculator, &[&message, &message]), 0);
-
-        // One message w/ one signature, a fee.
-        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]);
-        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]);
-        assert_eq!(calculate_fee(&fee_calculator, &[&message0, &message1]), 3);
-    }
-
-    #[test]
-    fn test_check_unique_pubkeys() {
-        let pubkey0 = Pubkey::new_rand();
-        let pubkey_clone = pubkey0;
-        let pubkey1 = Pubkey::new_rand();
-
-        check_unique_pubkeys((&pubkey0, "foo".to_string()), (&pubkey1, "bar".to_string()))
-            .expect("unexpected result");
-        check_unique_pubkeys((&pubkey0, "foo".to_string()), (&pubkey1, "foo".to_string()))
-            .expect("unexpected result");
-
-        assert!(check_unique_pubkeys(
-            (&pubkey0, "foo".to_string()),
-            (&pubkey_clone, "bar".to_string())
-        )
-        .is_err());
-    }
-}
--- a/cli/src/cli.rs
+++ b/cli/src/cli.rs
--- a/cli/src/cli_output.rs
+++ b/cli/src/cli_output.rs
--- a/cli/src/cluster_query.rs
+++ b/cli/src/cluster_query.rs
--- a/cli/src/display.rs
+++ b/cli/src/display.rs
@ -1,12 +1,6 @@
 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_sdk::transaction::Transaction;

 // Pretty print a "name value"
 pub fn println_name_value(name: &str, value: &str) {
@ -18,15 +12,6 @@ pub fn println_name_value(name: &str, value: &str) {
    println!("{} {}", style(name).bold(), styled_value);
 }

-pub fn writeln_name_value(f: &mut fmt::Formatter, name: &str, value: &str) -> fmt::Result {
-    let styled_value = if value == "" {
-        style("(not set)").italic()
-    } else {
-        style(value)
-    };
-    writeln!(f, "{} {}", style(name).bold(), styled_value)
-}
-
 pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) {
    let description = match setting_type {
        SettingType::Explicit => "",
@ -42,171 +27,13 @@ pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType)
    );
 }

-pub fn println_signers(
-    blockhash: &Hash,
-    signers: &[String],
-    absent: &[String],
-    bad_sig: &[String],
-) {
+pub fn println_signers(tx: &Transaction) {
    println!();
-    println!("Blockhash: {}", blockhash);
-    if !signers.is_empty() {
-        println!("Signers (Pubkey=Signature):");
-        signers.iter().for_each(|signer| println!("  {}", signer))
-    }
-    if !absent.is_empty() {
-        println!("Absent Signers (Pubkey):");
-        absent.iter().for_each(|pubkey| println!("  {}", pubkey))
-    }
-    if !bad_sig.is_empty() {
-        println!("Bad Signatures (Pubkey):");
-        bad_sig.iter().for_each(|pubkey| println!("  {}", pubkey))
-    }
+    println!("Blockhash: {}", tx.message.recent_blockhash);
+    println!("Signers (Pubkey=Signature):");
+    tx.signatures
+        .iter()
+        .zip(tx.message.account_keys.clone())
+        .for_each(|(signature, pubkey)| println!("  {:?}={:?}", pubkey, signature));
    println!();
 }
-
-pub fn write_transaction<W: io::Write>(
-    w: &mut W,
-    transaction: &Transaction,
-    transaction_status: &Option<RpcTransactionStatusMeta>,
-    prefix: &str,
-) -> io::Result<()> {
-    let message = &transaction.message;
-    writeln!(
-        w,
-        "{}Recent Blockhash: {:?}",
-        prefix, message.recent_blockhash
-    )?;
-    for (signature_index, signature) in transaction.signatures.iter().enumerate() {
-        writeln!(
-            w,
-            "{}Signature {}: {:?}",
-            prefix, signature_index, signature
-        )?;
-    }
-    writeln!(w, "{}{:?}", prefix, message.header)?;
-    for (account_index, account) in message.account_keys.iter().enumerate() {
-        writeln!(w, "{}Account {}: {:?}", prefix, account_index, account)?;
-    }
-    for (instruction_index, instruction) in message.instructions.iter().enumerate() {
-        let program_pubkey = message.account_keys[instruction.program_id_index as usize];
-        writeln!(w, "{}Instruction {}", prefix, instruction_index)?;
-        writeln!(
-            w,
-            "{}  Program: {} ({})",
-            prefix, program_pubkey, instruction.program_id_index
-        )?;
-        for (account_index, account) in instruction.accounts.iter().enumerate() {
-            let account_pubkey = message.account_keys[*account as usize];
-            writeln!(
-                w,
-                "{}  Account {}: {} ({})",
-                prefix, account_index, account_pubkey, account
-            )?;
-        }
-
-        let mut raw = true;
-        if program_pubkey == solana_vote_program::id() {
-            if let Ok(vote_instruction) = limited_deserialize::<
-                solana_vote_program::vote_instruction::VoteInstruction,
-            >(&instruction.data)
-            {
-                writeln!(w, "{}  {:?}", prefix, vote_instruction)?;
-                raw = false;
-            }
-        } else if program_pubkey == solana_stake_program::id() {
-            if let Ok(stake_instruction) = limited_deserialize::<
-                solana_stake_program::stake_instruction::StakeInstruction,
-            >(&instruction.data)
-            {
-                writeln!(w, "{}  {:?}", prefix, stake_instruction)?;
-                raw = false;
-            }
-        } else if program_pubkey == solana_sdk::system_program::id() {
-            if let Ok(system_instruction) = limited_deserialize::<
-                solana_sdk::system_instruction::SystemInstruction,
-            >(&instruction.data)
-            {
-                writeln!(w, "{}  {:?}", prefix, system_instruction)?;
-                raw = false;
-            }
-        }
-
-        if raw {
-            writeln!(w, "{}  Data: {:?}", prefix, instruction.data)?;
-        }
-    }
-
-    if let Some(transaction_status) = transaction_status {
-        writeln!(
-            w,
-            "{}Status: {}",
-            prefix,
-            match &transaction_status.status {
-                Ok(_) => "Ok".into(),
-                Err(err) => err.to_string(),
-            }
-        )?;
-        writeln!(
-            w,
-            "{}  Fee: {} SOL",
-            prefix,
-            lamports_to_sol(transaction_status.fee)
-        )?;
-        assert_eq!(
-            transaction_status.pre_balances.len(),
-            transaction_status.post_balances.len()
-        );
-        for (i, (pre, post)) in transaction_status
-            .pre_balances
-            .iter()
-            .zip(transaction_status.post_balances.iter())
-            .enumerate()
-        {
-            if pre == post {
-                writeln!(
-                    w,
-                    "{}  Account {} balance: {} SOL",
-                    prefix,
-                    i,
-                    lamports_to_sol(*pre)
-                )?;
-            } else {
-                writeln!(
-                    w,
-                    "{}  Account {} balance: {} SOL -> {} SOL",
-                    prefix,
-                    i,
-                    lamports_to_sol(*pre),
-                    lamports_to_sol(*post)
-                )?;
-            }
-        }
-    } else {
-        writeln!(w, "{}Status: Unavailable", prefix)?;
-    }
-
-    Ok(())
-}
-
-pub fn println_transaction(
-    transaction: &Transaction,
-    transaction_status: &Option<RpcTransactionStatusMeta>,
-    prefix: &str,
-) {
-    let mut w = Vec::new();
-    if write_transaction(&mut w, transaction, transaction_status, prefix).is_ok() {
-        if let Ok(s) = String::from_utf8(w) {
-            print!("{}", s);
-        }
-    }
-}
-
-/// 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
-}
--- a/cli/src/lib.rs
+++ b/cli/src/lib.rs
@ -1,35 +1,9 @@
-macro_rules! ACCOUNT_STRING {
-    () => {
-        r#", one of:
-  * a base58-encoded public key
-  * a path to a keypair file
-  * a hyphen; signals a JSON-encoded keypair on stdin
-  * the 'ASK' keyword; to recover a keypair via its seed phrase
-  * a hardware wallet keypair URL (i.e. usb://ledger)"#
-    };
-}
-
-#[macro_use]
-macro_rules! pubkey {
-    ($arg:expr, $help:expr) => {
-        $arg.takes_value(true)
-            .validator(is_valid_pubkey)
-            .help(concat!($help, ACCOUNT_STRING!()))
-    };
-}
-
-#[macro_use]
-extern crate serde_derive;
-
-pub mod checks;
 pub mod cli;
-pub mod cli_output;
 pub mod cluster_query;
 pub mod display;
 pub mod nonce;
 pub mod offline;
-pub mod spend_utils;
 pub mod stake;
-pub mod test_utils;
+pub mod storage;
 pub mod validator_info;
 pub mod vote;
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@ -2,15 +2,16 @@ use clap::{crate_description, crate_name, AppSettings, Arg, ArgGroup, ArgMatches
 use console::style;

 use solana_clap_utils::{
-    input_validators::is_url, keypair::SKIP_SEED_PHRASE_VALIDATION_ARG, DisplayError,
+    input_parsers::derivation_of,
+    input_validators::{is_derivation, is_url},
+    keypair::SKIP_SEED_PHRASE_VALIDATION_ARG,
 };
 use solana_cli::{
    cli::{app, parse_command, process_command, CliCommandInfo, CliConfig, CliSigners},
-    cli_output::OutputFormat,
    display::{println_name_value, println_name_value_or},
 };
-use solana_cli_config::{Config, CONFIG_FILE};
-use solana_remote_wallet::remote_wallet::RemoteWalletManager;
+use solana_cli_config::config::{Config, CONFIG_FILE};
+use solana_remote_wallet::remote_wallet::{maybe_wallet_manager, RemoteWalletManager};
 use std::{error, sync::Arc};

 fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error>> {
@ -21,12 +22,12 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    let config = Config::load(config_file).unwrap_or_default();

                    let (url_setting_type, json_rpc_url) =
-                        CliConfig::compute_json_rpc_url_setting("", &config.json_rpc_url);
+                        CliConfig::compute_json_rpc_url_setting("", &config.url);
                    let (ws_setting_type, websocket_url) = CliConfig::compute_websocket_url_setting(
                        "",
                        &config.websocket_url,
                        "",
-                        &config.json_rpc_url,
+                        &config.url,
                    );
                    let (keypair_setting_type, keypair_path) =
                        CliConfig::compute_keypair_path_setting("", &config.keypair_path);
@ -34,7 +35,7 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    if let Some(field) = subcommand_matches.value_of("specific_setting") {
                        let (field_name, value, setting_type) = match field {
                            "json_rpc_url" => ("RPC URL", json_rpc_url, url_setting_type),
-                            "websocket_url" => ("WebSocket URL", websocket_url, ws_setting_type),
+                            "websocket_url" => ("WS URL", websocket_url, ws_setting_type),
                            "keypair" => ("Key Path", keypair_path, keypair_setting_type),
                            _ => unreachable!(),
                        };
@ -42,7 +43,7 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    } else {
                        println_name_value("Config File:", config_file);
                        println_name_value_or("RPC URL:", &json_rpc_url, url_setting_type);
-                        println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
+                        println_name_value_or("WS URL:", &websocket_url, ws_setting_type);
                        println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
                    }
                } else {
@ -57,10 +58,7 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                if let Some(config_file) = matches.value_of("config_file") {
                    let mut config = Config::load(config_file).unwrap_or_default();
                    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
-                        // changed
-                        config.websocket_url = "".to_string();
+                        config.url = url.to_string();
                    }
                    if let Some(url) = subcommand_matches.value_of("websocket_url") {
                        config.websocket_url = url.to_string();
@ -71,19 +69,19 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error
                    config.save(config_file)?;

                    let (url_setting_type, json_rpc_url) =
-                        CliConfig::compute_json_rpc_url_setting("", &config.json_rpc_url);
+                        CliConfig::compute_json_rpc_url_setting("", &config.url);
                    let (ws_setting_type, websocket_url) = CliConfig::compute_websocket_url_setting(
                        "",
                        &config.websocket_url,
                        "",
-                        &config.json_rpc_url,
+                        &config.url,
                    );
                    let (keypair_setting_type, keypair_path) =
                        CliConfig::compute_keypair_path_setting("", &config.keypair_path);

                    println_name_value("Config File:", config_file);
                    println_name_value_or("RPC URL:", &json_rpc_url, url_setting_type);
-                    println_name_value_or("WebSocket URL:", &websocket_url, ws_setting_type);
+                    println_name_value_or("WS URL:", &websocket_url, ws_setting_type);
                    println_name_value_or("Keypair Path:", &keypair_path, keypair_setting_type);
                } else {
                    println!(
@ -102,7 +100,7 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error

 pub fn parse_args<'a>(
    matches: &ArgMatches<'_>,
-    mut wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<Arc<RemoteWalletManager>>,
 ) -> Result<(CliConfig<'a>, CliSigners), Box<dyn error::Error>> {
    let config = if let Some(config_file) = matches.value_of("config_file") {
        Config::load(config_file).unwrap_or_default()
@ -111,13 +109,13 @@ pub fn parse_args<'a>(
    };
    let (_, json_rpc_url) = CliConfig::compute_json_rpc_url_setting(
        matches.value_of("json_rpc_url").unwrap_or(""),
-        &config.json_rpc_url,
+        &config.url,
    );
    let (_, websocket_url) = CliConfig::compute_websocket_url_setting(
        matches.value_of("websocket_url").unwrap_or(""),
        &config.websocket_url,
        matches.value_of("json_rpc_url").unwrap_or(""),
-        &config.json_rpc_url,
+        &config.url,
    );
    let (_, default_signer_path) = CliConfig::compute_keypair_path_setting(
        matches.value_of("keypair").unwrap_or(""),
@ -125,16 +123,7 @@ pub fn parse_args<'a>(
    );

    let CliCommandInfo { command, signers } =
-        parse_command(&matches, &default_signer_path, &mut wallet_manager)?;
-
-    let output_format = matches
-        .value_of("output_format")
-        .map(|value| match value {
-            "json" => OutputFormat::Json,
-            "json-compact" => OutputFormat::JsonCompact,
-            _ => unreachable!(),
-        })
-        .unwrap_or(OutputFormat::Display);
+        parse_command(&matches, &default_signer_path, wallet_manager.as_ref())?;

    Ok((
        CliConfig {
@ -143,9 +132,9 @@ pub fn parse_args<'a>(
            websocket_url,
            signers: vec![],
            keypair_path: default_signer_path,
+            derivation_path: derivation_of(matches, "derivation_path"),
            rpc_client: None,
            verbose: matches.is_present("verbose"),
-            output_format,
        },
        signers,
    ))
@ -156,13 +145,13 @@ fn main() -> Result<(), Box<dyn error::Error>> {
    let matches = app(
        crate_name!(),
        crate_description!(),
-        solana_version::version!(),
+        solana_clap_utils::version!(),
    )
    .arg({
        let arg = Arg::with_name("config_file")
            .short("C")
            .long("config")
-            .value_name("FILEPATH")
+            .value_name("PATH")
            .takes_value(true)
            .global(true)
            .help("Configuration file to use");
@ -195,26 +184,26 @@ fn main() -> Result<(), Box<dyn error::Error>> {
        Arg::with_name("keypair")
            .short("k")
            .long("keypair")
-            .value_name("KEYPAIR")
+            .value_name("PATH")
            .global(true)
            .takes_value(true)
-            .help("Filepath or URL to a keypair"),
+            .help("/path/to/id.json or usb://remote/wallet/path"),
+    )
+    .arg(
+        Arg::with_name("derivation_path")
+            .long("derivation-path")
+            .value_name("ACCOUNT or ACCOUNT/CHANGE")
+            .global(true)
+            .takes_value(true)
+            .validator(is_derivation)
+            .help("Derivation path to use: m/44'/501'/ACCOUNT'/CHANGE'; default key is device base pubkey: m/44'/501'/0'")
    )
    .arg(
        Arg::with_name("verbose")
            .long("verbose")
            .short("v")
            .global(true)
-            .help("Show additional information"),
-    )
-    .arg(
-        Arg::with_name("output_format")
-            .long("output")
-            .value_name("FORMAT")
-            .global(true)
-            .takes_value(true)
-            .possible_values(&["json", "json-compact"])
-            .help("Return information in specified output format"),
+            .help("Show extra information header"),
    )
    .arg(
        Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
@ -252,17 +241,13 @@ fn main() -> Result<(), Box<dyn error::Error>> {
    )
    .get_matches();

-    do_main(&matches).map_err(|err| DisplayError::new_as_boxed(err).into())
-}
-
-fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
    if parse_settings(&matches)? {
-        let mut wallet_manager = None;
+        let wallet_manager = maybe_wallet_manager()?;

-        let (mut config, signers) = parse_args(&matches, &mut wallet_manager)?;
+        let (mut config, signers) = parse_args(&matches, wallet_manager)?;
        config.signers = signers.iter().map(|s| s.as_ref()).collect();
        let result = process_command(&config)?;
        println!("{}", result);
-    };
+    }
    Ok(())
 }
--- a/cli/src/nonce.rs
+++ b/cli/src/nonce.rs
@ -1,11 +1,7 @@
-use crate::{
-    checks::{check_account_for_fee, check_unique_pubkeys},
-    cli::{
-        generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
-        CliConfig, CliError, ProcessResult, SignerIndex,
-    },
-    cli_output::CliNonceAccount,
-    spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
+use crate::cli::{
+    build_balance_message, check_account_for_fee, check_unique_pubkeys, generate_unique_signers,
+    log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
+    SignerIndex,
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{
@ -18,38 +14,25 @@ use solana_sdk::{
    account_utils::StateMut,
    hash::Hash,
    message::Message,
-    nonce::{
-        self,
-        state::{Data, Versions},
-        State,
-    },
+    nonce_state::{Meta, NonceState},
    pubkey::Pubkey,
    system_instruction::{
-        advance_nonce_account, authorize_nonce_account, create_nonce_account,
-        create_nonce_account_with_seed, withdraw_nonce_account, NonceError, SystemError,
+        advance_nonce_account, authorize_nonce_account, create_address_with_seed,
+        create_nonce_account, create_nonce_account_with_seed, withdraw_nonce_account, NonceError,
+        SystemError,
    },
    system_program,
    transaction::Transaction,
 };
 use std::sync::Arc;
-use thiserror::Error;

-#[derive(Debug, Error, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum CliNonceError {
-    #[error("invalid account owner")]
    InvalidAccountOwner,
-    #[error("invalid account data")]
    InvalidAccountData,
-    #[error("unexpected account data size")]
-    UnexpectedDataSize,
-    #[error("query hash does not match stored hash")]
    InvalidHash,
-    #[error("query authority does not match account authority")]
    InvalidAuthority,
-    #[error("invalid state for requested operation")]
-    InvalidStateForOperation,
-    #[error("client error: {0}")]
-    Client(String),
+    InvalidState,
 }

 pub const NONCE_ARG: ArgConstant<'static> = ArgConstant {
@ -77,7 +60,7 @@ pub fn nonce_arg<'a, 'b>() -> Arg<'a, 'b> {
        .takes_value(true)
        .value_name("PUBKEY")
        .requires(BLOCKHASH_ARG.name)
-        .validator(is_valid_pubkey)
+        .validator(is_pubkey)
        .help(NONCE_ARG.help)
 }

@ -85,7 +68,7 @@ pub fn nonce_authority_arg<'a, 'b>() -> Arg<'a, 'b> {
    Arg::with_name(NONCE_AUTHORITY_ARG.name)
        .long(NONCE_AUTHORITY_ARG.long)
        .takes_value(true)
-        .value_name("KEYPAIR")
+        .value_name("KEYPAIR or PUBKEY or REMOTE WALLET PATH")
        .validator(is_valid_signer)
        .help(NONCE_AUTHORITY_ARG.help)
 }
@ -96,18 +79,29 @@ impl NonceSubCommands for App<'_, '_> {
            SubCommand::with_name("authorize-nonce-account")
                .about("Assign account authority to a new entity")
                .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_keypair")
                        .index(1)
-                        .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account. "),
+                        .value_name("NONCE_ACCOUNT")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("Address of the nonce account"),
                )
                .arg(
-                    pubkey!(Arg::with_name("new_authority")
+                    Arg::with_name("new_authority")
                        .index(2)
-                        .value_name("AUTHORITY_PUBKEY")
-                        .required(true),
-                        "Account to be granted authority of the nonce account. "),
+                        .value_name("NEW_AUTHORITY_PUBKEY")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("Account to be granted authority of the nonce account"),
+                )
+                .arg(
+                    Arg::with_name("seed")
+                        .long("seed")
+                        .value_name("SEED STRING")
+                        .takes_value(true)
+                        .help("Seed for address generation; if specified, the resulting account will be at a derived address of the NONCE_ACCOUNT pubkey")
                )
                .arg(nonce_authority_arg()),
        )
@ -117,10 +111,10 @@ impl NonceSubCommands for App<'_, '_> {
                .arg(
                    Arg::with_name("nonce_account_keypair")
                        .index(1)
-                        .value_name("ACCOUNT_KEYPAIR")
+                        .value_name("NONCE ACCOUNT")
                        .takes_value(true)
                        .required(true)
-                        .validator(is_valid_signer)
+                        .validator(is_pubkey_or_keypair)
                        .help("Keypair of the nonce account to fund"),
                )
                .arg(
@ -129,21 +123,16 @@ impl NonceSubCommands for App<'_, '_> {
                        .value_name("AMOUNT")
                        .takes_value(true)
                        .required(true)
-                        .validator(is_amount_or_all)
-                        .help("The amount to load the nonce account with, in SOL; accepts keyword ALL"),
+                        .validator(is_amount)
+                        .help("The amount to load the nonce account with, in SOL"),
                )
                .arg(
-                    pubkey!(Arg::with_name(NONCE_AUTHORITY_ARG.name)
+                    Arg::with_name(NONCE_AUTHORITY_ARG.name)
                        .long(NONCE_AUTHORITY_ARG.long)
-                        .value_name("PUBKEY"),
-                        "Assign noncing authority to another entity. "),
-                )
-                .arg(
-                    Arg::with_name("seed")
-                        .long("seed")
-                        .value_name("STRING")
                        .takes_value(true)
-                        .help("Seed for address generation; if specified, the resulting account will be at a derived address of the NONCE_ACCOUNT pubkey")
+                        .value_name("BASE58_PUBKEY")
+                        .validator(is_pubkey_or_keypair)
+                        .help("Assign noncing authority to another entity"),
                ),
        )
        .subcommand(
@ -151,22 +140,26 @@ impl NonceSubCommands for App<'_, '_> {
                .about("Get the current nonce value")
                .alias("get-nonce")
                .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                        .index(1)
-                        .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account to display. "),
+                        .value_name("NONCE ACCOUNT")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("Address of the nonce account to display"),
                ),
        )
        .subcommand(
            SubCommand::with_name("new-nonce")
                .about("Generate a new nonce, rendering the existing nonce useless")
                .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_keypair")
                        .index(1)
-                        .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account. "),
+                        .value_name("NONCE ACCOUNT")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("Address of the nonce account"),
                )
                .arg(nonce_authority_arg()),
        )
@ -175,11 +168,13 @@ impl NonceSubCommands for App<'_, '_> {
                .about("Show the contents of a nonce account")
                .alias("show-nonce-account")
                .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_pubkey")
                        .index(1)
-                        .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Address of the nonce account to display. "),
+                        .value_name("NONCE ACCOUNT")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("Address of the nonce account to display"),
                )
                .arg(
                    Arg::with_name("lamports")
@ -190,20 +185,24 @@ impl NonceSubCommands for App<'_, '_> {
        )
        .subcommand(
            SubCommand::with_name("withdraw-from-nonce-account")
-                .about("Withdraw SOL from the nonce account")
+                .about("Withdraw lamports from the nonce account")
                .arg(
-                    pubkey!(Arg::with_name("nonce_account_pubkey")
+                    Arg::with_name("nonce_account_keypair")
                        .index(1)
-                        .value_name("NONCE_ACCOUNT_ADDRESS")
-                        .required(true),
-                        "Nonce account to withdraw from. "),
+                        .value_name("NONCE ACCOUNT")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_keypair_or_ask_keyword)
+                        .help("Nonce account from to withdraw from"),
                )
                .arg(
-                    pubkey!(Arg::with_name("destination_account_pubkey")
+                    Arg::with_name("destination_account_pubkey")
                        .index(2)
-                        .value_name("RECIPIENT_ADDRESS")
-                        .required(true),
-                        "The account to which the SOL should be transferred. "),
+                        .value_name("DESTINATION ACCOUNT")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("The account to which the lamports should be transferred"),
                )
                .arg(
                    Arg::with_name("amount")
@ -219,55 +218,13 @@ impl NonceSubCommands for App<'_, '_> {
    }
 }

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

@ -292,13 +249,13 @@ pub fn parse_authorize_nonce_account(
 pub fn parse_nonce_create_account(
    matches: &ArgMatches<'_>,
    default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
    let (nonce_account, nonce_account_pubkey) =
        signer_of(matches, "nonce_account_keypair", wallet_manager)?;
    let seed = matches.value_of("seed").map(|s| s.to_string());
-    let amount = SpendAmount::new_from_matches(matches, "amount");
-    let nonce_authority = pubkey_of_signer(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
+    let lamports = lamports_of_sol(matches, "amount").unwrap();
+    let nonce_authority = pubkey_of(matches, NONCE_AUTHORITY_ARG.name);

    let payer_provided = None;
    let signer_info = generate_unique_signers(
@ -313,18 +270,14 @@ pub fn parse_nonce_create_account(
            nonce_account: signer_info.index_of(nonce_account_pubkey).unwrap(),
            seed,
            nonce_authority,
-            amount,
+            lamports,
        },
        signers: signer_info.signers,
    })
 }

-pub fn parse_get_nonce(
-    matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let nonce_account_pubkey =
-        pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
+pub fn parse_get_nonce(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
+    let nonce_account_pubkey = pubkey_of(matches, "nonce_account_pubkey").unwrap();

    Ok(CliCommandInfo {
        command: CliCommand::GetNonce(nonce_account_pubkey),
@ -335,9 +288,9 @@ pub fn parse_get_nonce(
 pub fn parse_new_nonce(
    matches: &ArgMatches<'_>,
    default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
-    let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
+    let nonce_account = pubkey_of(matches, "nonce_account_keypair").unwrap();
    let (nonce_authority, nonce_authority_pubkey) =
        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;

@ -358,12 +311,8 @@ pub fn parse_new_nonce(
    })
 }

-pub fn parse_show_nonce_account(
-    matches: &ArgMatches<'_>,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
-) -> Result<CliCommandInfo, CliError> {
-    let nonce_account_pubkey =
-        pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
+pub fn parse_show_nonce_account(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
+    let nonce_account_pubkey = pubkey_of(matches, "nonce_account_pubkey").unwrap();
    let use_lamports_unit = matches.is_present("lamports");

    Ok(CliCommandInfo {
@ -378,11 +327,10 @@ pub fn parse_show_nonce_account(
 pub fn parse_withdraw_from_nonce_account(
    matches: &ArgMatches<'_>,
    default_signer_path: &str,
-    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
-    let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
-    let destination_account_pubkey =
-        pubkey_of_signer(matches, "destination_account_pubkey", wallet_manager)?.unwrap();
+    let nonce_account = pubkey_of(matches, "nonce_account_keypair").unwrap();
+    let destination_account_pubkey = pubkey_of(matches, "destination_account_pubkey").unwrap();
    let lamports = lamports_of_sol(matches, "amount").unwrap();
    let (nonce_authority, nonce_authority_pubkey) =
        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
@ -411,18 +359,26 @@ pub fn check_nonce_account(
    nonce_account: &Account,
    nonce_authority: &Pubkey,
    nonce_hash: &Hash,
-) -> Result<(), CliError> {
-    match state_from_account(nonce_account)? {
-        State::Initialized(ref data) => {
-            if &data.blockhash != nonce_hash {
-                Err(CliNonceError::InvalidHash.into())
-            } else if nonce_authority != &data.authority {
-                Err(CliNonceError::InvalidAuthority.into())
+) -> Result<(), Box<CliError>> {
+    if nonce_account.owner != system_program::ID {
+        return Err(CliError::InvalidNonce(CliNonceError::InvalidAccountOwner).into());
+    }
+    let nonce_state: NonceState = nonce_account
+        .state()
+        .map_err(|_| Box::new(CliError::InvalidNonce(CliNonceError::InvalidAccountData)))?;
+    match nonce_state {
+        NonceState::Initialized(meta, hash) => {
+            if &hash != nonce_hash {
+                Err(CliError::InvalidNonce(CliNonceError::InvalidHash).into())
+            } else if nonce_authority != &meta.nonce_authority {
+                Err(CliError::InvalidNonce(CliNonceError::InvalidAuthority).into())
            } else {
                Ok(())
            }
        }
-        State::Uninitialized => Err(CliNonceError::InvalidStateForOperation.into()),
+        NonceState::Uninitialized => {
+            Err(CliError::InvalidNonce(CliNonceError::InvalidState).into())
+        }
    }
 }

@ -437,7 +393,7 @@ pub fn process_authorize_nonce_account(

    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_with_payer(vec![ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;

@ -447,8 +403,8 @@ pub fn process_authorize_nonce_account(
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<NonceError>(result, &config)
+    let result = rpc_client.send_and_confirm_transaction(&mut tx, &config.signers);
+    log_instruction_custom_error::<NonceError>(result)
 }

 pub fn process_create_nonce_account(
@ -457,11 +413,11 @@ pub fn process_create_nonce_account(
    nonce_account: SignerIndex,
    seed: Option<String>,
    nonce_authority: Option<Pubkey>,
-    amount: SpendAmount,
+    lamports: u64,
 ) -> ProcessResult {
    let nonce_account_pubkey = config.signers[nonce_account].pubkey();
-    let nonce_account_address = if let Some(ref seed) = seed {
-        Pubkey::create_with_seed(&nonce_account_pubkey, seed, &system_program::id())?
+    let nonce_account_address = if let Some(seed) = seed.clone() {
+        create_address_with_seed(&nonce_account_pubkey, &seed, &system_program::id())?
    } else {
        nonce_account_pubkey
    };
@ -471,42 +427,10 @@ pub fn process_create_nonce_account(
        (&nonce_account_address, "nonce_account".to_string()),
    )?;

-    let nonce_authority = nonce_authority.unwrap_or_else(|| config.signers[0].pubkey());
-
-    let build_message = |lamports| {
-        let ixs = if let Some(seed) = seed.clone() {
-            create_nonce_account_with_seed(
-                &config.signers[0].pubkey(), // from
-                &nonce_account_address,      // to
-                &nonce_account_pubkey,       // base
-                &seed,                       // seed
-                &nonce_authority,
-                lamports,
-            )
-        } else {
-            create_nonce_account(
-                &config.signers[0].pubkey(),
-                &nonce_account_pubkey,
-                &nonce_authority,
-                lamports,
-            )
-        };
-        Message::new_with_payer(&ixs, Some(&config.signers[0].pubkey()))
-    };
-
-    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-
-    let (message, lamports) = resolve_spend_tx_and_check_account_balance(
-        rpc_client,
-        false,
-        amount,
-        &fee_calculator,
-        &config.signers[0].pubkey(),
-        build_message,
-    )?;
-
-    if let Ok(nonce_account) = get_account(rpc_client, &nonce_account_address) {
-        let err_msg = if state_from_account(&nonce_account).is_ok() {
+    if let Ok(nonce_account) = rpc_client.get_account(&nonce_account_address) {
+        let err_msg = if nonce_account.owner == system_program::id()
+            && StateMut::<NonceState>::state(&nonce_account).is_ok()
+        {
            format!("Nonce account {} already exists", nonce_account_address)
        } else {
            format!(
@ -517,7 +441,7 @@ pub fn process_create_nonce_account(
        return Err(CliError::BadParameter(err_msg).into());
    }

-    let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(State::size())?;
+    let minimum_balance = rpc_client.get_minimum_balance_for_rent_exemption(NonceState::size())?;
    if lamports < minimum_balance {
        return Err(CliError::BadParameter(format!(
            "need at least {} lamports for nonce account to be rent exempt, provided lamports: {}",
@ -526,16 +450,59 @@ pub fn process_create_nonce_account(
        .into());
    }

+    let nonce_authority = nonce_authority.unwrap_or_else(|| config.signers[0].pubkey());
+
+    let ixs = if let Some(seed) = seed {
+        create_nonce_account_with_seed(
+            &config.signers[0].pubkey(), // from
+            &nonce_account_address,      // to
+            &nonce_account_pubkey,       // base
+            &seed,                       // seed
+            &nonce_authority,
+            lamports,
+        )
+    } else {
+        create_nonce_account(
+            &config.signers[0].pubkey(),
+            &nonce_account_pubkey,
+            &nonce_authority,
+            lamports,
+        )
+    };
+
+    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
+
+    let message = Message::new_with_payer(ixs, Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<SystemError>(result, &config)
+
+    check_account_for_fee(
+        rpc_client,
+        &config.signers[0].pubkey(),
+        &fee_calculator,
+        &tx.message,
+    )?;
+    let result = rpc_client.send_and_confirm_transaction(&mut tx, &config.signers);
+    log_instruction_custom_error::<SystemError>(result)
 }

 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))? {
-        State::Uninitialized => Ok("Nonce account is uninitialized".to_string()),
-        State::Initialized(ref data) => Ok(format!("{:?}", data.blockhash)),
+    let nonce_account = rpc_client.get_account(nonce_account_pubkey)?;
+    if nonce_account.owner != system_program::id() {
+        return Err(CliError::RpcRequestError(format!(
+            "{:?} is not a nonce account",
+            nonce_account_pubkey
+        ))
+        .into());
+    }
+    match nonce_account.state() {
+        Ok(NonceState::Uninitialized) => Ok("Nonce account is uninitialized".to_string()),
+        Ok(NonceState::Initialized(_, hash)) => Ok(format!("{:?}", hash)),
+        Err(err) => Err(CliError::RpcRequestError(format!(
+            "Account data could not be deserialized to nonce state: {:?}",
+            err
+        ))
+        .into()),
    }
 }

@ -560,7 +527,7 @@ 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 message = Message::new_with_payer(vec![ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;
    check_account_for_fee(
@ -569,36 +536,57 @@ pub fn process_new_nonce(
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<SystemError>(result, &config)
+    let result =
+        rpc_client.send_and_confirm_transaction(&mut tx, &[config.signers[0], nonce_authority]);
+    log_instruction_custom_error::<SystemError>(result)
 }

 pub fn process_show_nonce_account(
    rpc_client: &RpcClient,
-    config: &CliConfig,
    nonce_account_pubkey: &Pubkey,
    use_lamports_unit: bool,
 ) -> ProcessResult {
-    let nonce_account = get_account(rpc_client, nonce_account_pubkey)?;
-    let print_account = |data: Option<&nonce::state::Data>| {
-        let mut nonce_account = CliNonceAccount {
-            balance: nonce_account.lamports,
-            minimum_balance_for_rent_exemption: rpc_client
-                .get_minimum_balance_for_rent_exemption(State::size())?,
-            use_lamports_unit,
-            ..CliNonceAccount::default()
-        };
-        if let Some(ref data) = data {
-            nonce_account.nonce = Some(data.blockhash.to_string());
-            nonce_account.lamports_per_signature = Some(data.fee_calculator.lamports_per_signature);
-            nonce_account.authority = Some(data.authority.to_string());
+    let nonce_account = rpc_client.get_account(nonce_account_pubkey)?;
+    if nonce_account.owner != system_program::id() {
+        return Err(CliError::RpcRequestError(format!(
+            "{:?} is not a nonce account",
+            nonce_account_pubkey
+        ))
+        .into());
+    }
+    let print_account = |data: Option<(Meta, Hash)>| {
+        println!(
+            "Balance: {}",
+            build_balance_message(nonce_account.lamports, use_lamports_unit, true)
+        );
+        println!(
+            "Minimum Balance Required: {}",
+            build_balance_message(
+                rpc_client.get_minimum_balance_for_rent_exemption(NonceState::size())?,
+                use_lamports_unit,
+                true
+            )
+        );
+        match data {
+            Some((meta, hash)) => {
+                println!("Nonce: {}", hash);
+                println!("Authority: {}", meta.nonce_authority);
+            }
+            None => {
+                println!("Nonce: uninitialized");
+                println!("Authority: uninitialized");
+            }
        }
-
-        Ok(config.output_format.formatted_string(&nonce_account))
+        Ok("".to_string())
    };
-    match state_from_account(&nonce_account)? {
-        State::Uninitialized => print_account(None),
-        State::Initialized(ref data) => print_account(Some(data)),
+    match nonce_account.state() {
+        Ok(NonceState::Uninitialized) => print_account(None),
+        Ok(NonceState::Initialized(meta, hash)) => print_account(Some((meta, hash))),
+        Err(err) => Err(CliError::RpcRequestError(format!(
+            "Account data could not be deserialized to nonce state: {:?}",
+            err
+        ))
+        .into()),
    }
 }

@ -619,7 +607,7 @@ 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_with_payer(vec![ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;
    check_account_for_fee(
@ -628,8 +616,8 @@ pub fn process_withdraw_from_nonce_account(
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
-    log_instruction_custom_error::<NonceError>(result, &config)
+    let result = rpc_client.send_and_confirm_transaction(&mut tx, &config.signers);
+    log_instruction_custom_error::<NonceError>(result)
 }

 #[cfg(test)]
@ -638,9 +626,8 @@ mod tests {
    use crate::cli::{app, parse_command};
    use solana_sdk::{
        account::Account,
-        fee_calculator::FeeCalculator,
        hash::hash,
-        nonce::{self, State},
+        nonce_state::{Meta as NonceMeta, NonceState},
        signature::{read_keypair_file, write_keypair, Keypair, Signer},
        system_program,
    };
@ -675,12 +662,7 @@ mod tests {
            &Pubkey::default().to_string(),
        ]);
        assert_eq!(
-            parse_command(
-                &test_authorize_nonce_account,
-                &default_keypair_file,
-                &mut None
-            )
-            .unwrap(),
+            parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::AuthorizeNonceAccount {
                    nonce_account: nonce_account_pubkey,
@ -701,12 +683,7 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(
-                &test_authorize_nonce_account,
-                &default_keypair_file,
-                &mut None
-            )
-            .unwrap(),
+            parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::AuthorizeNonceAccount {
                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
@ -728,13 +705,13 @@ mod tests {
            "50",
        ]);
        assert_eq!(
-            parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateNonceAccount {
                    nonce_account: 1,
                    seed: None,
                    nonce_authority: None,
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                },
                signers: vec![
                    read_keypair_file(&default_keypair_file).unwrap().into(),
@ -753,13 +730,13 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateNonceAccount {
                    nonce_account: 1,
                    seed: None,
                    nonce_authority: Some(nonce_authority_keypair.pubkey()),
-                    amount: SpendAmount::Some(50_000_000_000),
+                    lamports: 50_000_000_000,
                },
                signers: vec![
                    read_keypair_file(&default_keypair_file).unwrap().into(),
@ -775,7 +752,7 @@ mod tests {
            &nonce_account_string,
        ]);
        assert_eq!(
-            parse_command(&test_get_nonce, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_get_nonce, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::GetNonce(nonce_account_keypair.pubkey()),
                signers: vec![],
@ -789,7 +766,7 @@ mod tests {
                .get_matches_from(vec!["test", "new-nonce", &keypair_file]);
        let nonce_account = read_keypair_file(&keypair_file).unwrap();
        assert_eq!(
-            parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::NewNonce {
                    nonce_account: nonce_account.pubkey(),
@ -809,7 +786,7 @@ mod tests {
        ]);
        let nonce_account = read_keypair_file(&keypair_file).unwrap();
        assert_eq!(
-            parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::NewNonce {
                    nonce_account: nonce_account.pubkey(),
@ -829,7 +806,7 @@ mod tests {
            &nonce_account_string,
        ]);
        assert_eq!(
-            parse_command(&test_show_nonce_account, &default_keypair_file, &mut None).unwrap(),
+            parse_command(&test_show_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::ShowNonceAccount {
                    nonce_account_pubkey: nonce_account_keypair.pubkey(),
@ -851,7 +828,7 @@ mod tests {
            parse_command(
                &test_withdraw_from_nonce_account,
                &default_keypair_file,
-                &mut None
+                None
            )
            .unwrap(),
            CliCommandInfo {
@ -865,6 +842,31 @@ mod tests {
            }
        );

+        let test_withdraw_from_nonce_account = test_commands.clone().get_matches_from(vec![
+            "test",
+            "withdraw-from-nonce-account",
+            &keypair_file,
+            &nonce_account_string,
+            "42",
+        ]);
+        assert_eq!(
+            parse_command(
+                &test_withdraw_from_nonce_account,
+                &default_keypair_file,
+                None
+            )
+            .unwrap(),
+            CliCommandInfo {
+                command: CliCommand::WithdrawFromNonceAccount {
+                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
+                    nonce_authority: 0,
+                    destination_account_pubkey: nonce_account_pubkey,
+                    lamports: 42000000000
+                },
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
+            }
+        );
+
        // Test WithdrawFromNonceAccount Subcommand with authority
        let test_withdraw_from_nonce_account = test_commands.clone().get_matches_from(vec![
            "test",
@ -879,7 +881,7 @@ mod tests {
            parse_command(
                &test_withdraw_from_nonce_account,
                &default_keypair_file,
-                &mut None
+                None
            )
            .unwrap(),
            CliCommandInfo {
@ -901,128 +903,61 @@ mod tests {
    fn test_check_nonce_account() {
        let blockhash = Hash::default();
        let nonce_pubkey = Pubkey::new_rand();
-        let data = Versions::new_current(State::Initialized(nonce::state::Data {
-            authority: nonce_pubkey,
-            blockhash,
-            fee_calculator: FeeCalculator::default(),
-        }));
-        let valid = Account::new_data(1, &data, &system_program::ID);
+        let valid = Account::new_data(
+            1,
+            &NonceState::Initialized(NonceMeta::new(&nonce_pubkey), blockhash),
+            &system_program::ID,
+        );
        assert!(check_nonce_account(&valid.unwrap(), &nonce_pubkey, &blockhash).is_ok());

-        let invalid_owner = Account::new_data(1, &data, &Pubkey::new(&[1u8; 32]));
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_owner.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidAccountOwner,);
-        }
+        let invalid_owner = Account::new_data(
+            1,
+            &NonceState::Initialized(NonceMeta::new(&nonce_pubkey), blockhash),
+            &Pubkey::new(&[1u8; 32]),
+        );
+        assert_eq!(
+            check_nonce_account(&invalid_owner.unwrap(), &nonce_pubkey, &blockhash),
+            Err(Box::new(CliError::InvalidNonce(
+                CliNonceError::InvalidAccountOwner
+            ))),
+        );

        let invalid_data = Account::new_data(1, &"invalid", &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_data.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidAccountData,);
-        }
-
-        let data = Versions::new_current(State::Initialized(nonce::state::Data {
-            authority: nonce_pubkey,
-            blockhash: hash(b"invalid"),
-            fee_calculator: FeeCalculator::default(),
-        }));
-        let invalid_hash = Account::new_data(1, &data, &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_hash.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidHash,);
-        }
-
-        let data = Versions::new_current(State::Initialized(nonce::state::Data {
-            authority: Pubkey::new_rand(),
-            blockhash,
-            fee_calculator: FeeCalculator::default(),
-        }));
-        let invalid_authority = Account::new_data(1, &data, &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidAuthority,);
-        }
-
-        let data = Versions::new_current(State::Uninitialized);
-        let invalid_state = Account::new_data(1, &data, &system_program::ID);
-        if let CliError::InvalidNonce(err) =
-            check_nonce_account(&invalid_state.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
-        {
-            assert_eq!(err, CliNonceError::InvalidStateForOperation,);
-        }
-    }
-
-    #[test]
-    fn test_account_identity_ok() {
-        let nonce_account = nonce::create_account(1).into_inner();
-        assert_eq!(account_identity_ok(&nonce_account), Ok(()));
-
-        let system_account = Account::new(1, 0, &system_program::id());
        assert_eq!(
-            account_identity_ok(&system_account),
-            Err(CliNonceError::UnexpectedDataSize),
+            check_nonce_account(&invalid_data.unwrap(), &nonce_pubkey, &blockhash),
+            Err(Box::new(CliError::InvalidNonce(
+                CliNonceError::InvalidAccountData
+            ))),
        );

-        let other_program = Pubkey::new(&[1u8; 32]);
-        let other_account_no_data = Account::new(1, 0, &other_program);
-        assert_eq!(
-            account_identity_ok(&other_account_no_data),
-            Err(CliNonceError::InvalidAccountOwner),
-        );
-    }
-
-    #[test]
-    fn test_state_from_account() {
-        let mut nonce_account = nonce::create_account(1).into_inner();
-        assert_eq!(state_from_account(&nonce_account), Ok(State::Uninitialized));
-
-        let data = nonce::state::Data {
-            authority: Pubkey::new(&[1u8; 32]),
-            blockhash: Hash::new(&[42u8; 32]),
-            fee_calculator: FeeCalculator::new(42),
-        };
-        nonce_account
-            .set_state(&Versions::new_current(State::Initialized(data.clone())))
-            .unwrap();
-        assert_eq!(
-            state_from_account(&nonce_account),
-            Ok(State::Initialized(data))
-        );
-
-        let wrong_data_size_account = Account::new(1, 1, &system_program::id());
-        assert_eq!(
-            state_from_account(&wrong_data_size_account),
-            Err(CliNonceError::InvalidAccountData),
-        );
-    }
-
-    #[test]
-    fn test_data_from_helpers() {
-        let mut nonce_account = nonce::create_account(1).into_inner();
-        let state = state_from_account(&nonce_account).unwrap();
-        assert_eq!(
-            data_from_state(&state),
-            Err(CliNonceError::InvalidStateForOperation)
+        let invalid_hash = Account::new_data(
+            1,
+            &NonceState::Initialized(NonceMeta::new(&nonce_pubkey), hash(b"invalid")),
+            &system_program::ID,
        );
        assert_eq!(
-            data_from_account(&nonce_account),
-            Err(CliNonceError::InvalidStateForOperation)
+            check_nonce_account(&invalid_hash.unwrap(), &nonce_pubkey, &blockhash),
+            Err(Box::new(CliError::InvalidNonce(CliNonceError::InvalidHash))),
        );

-        let data = nonce::state::Data {
-            authority: Pubkey::new(&[1u8; 32]),
-            blockhash: Hash::new(&[42u8; 32]),
-            fee_calculator: FeeCalculator::new(42),
-        };
-        nonce_account
-            .set_state(&Versions::new_current(State::Initialized(data.clone())))
-            .unwrap();
-        let state = state_from_account(&nonce_account).unwrap();
-        assert_eq!(data_from_state(&state), Ok(&data));
-        assert_eq!(data_from_account(&nonce_account), Ok(data));
+        let invalid_authority = Account::new_data(
+            1,
+            &NonceState::Initialized(NonceMeta::new(&Pubkey::new_rand()), blockhash),
+            &system_program::ID,
+        );
+        assert_eq!(
+            check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash),
+            Err(Box::new(CliError::InvalidNonce(
+                CliNonceError::InvalidAuthority
+            ))),
+        );
+
+        let invalid_state = Account::new_data(1, &NonceState::Uninitialized, &system_program::ID);
+        assert_eq!(
+            check_nonce_account(&invalid_state.unwrap(), &nonce_pubkey, &blockhash),
+            Err(Box::new(CliError::InvalidNonce(
+                CliNonceError::InvalidState
+            ))),
+        );
    }
 }
--- a/cli/src/offline.rs
+++ b/cli/src/offline.rs
@ -0,0 +1,253 @@
+use clap::{App, Arg, ArgMatches};
+use serde_json::Value;
+use solana_clap_utils::{
+    input_parsers::value_of,
+    input_validators::{is_hash, is_pubkey_sig},
+    offline::{BLOCKHASH_ARG, SIGNER_ARG, SIGN_ONLY_ARG},
+};
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::{fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey, signature::Signature};
+use std::str::FromStr;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum BlockhashQuery {
+    None(Hash, FeeCalculator),
+    FeeCalculator(Hash),
+    All,
+}
+
+impl BlockhashQuery {
+    pub fn new(blockhash: Option<Hash>, sign_only: bool) -> Self {
+        match blockhash {
+            Some(hash) if sign_only => Self::None(hash, FeeCalculator::default()),
+            Some(hash) if !sign_only => Self::FeeCalculator(hash),
+            None if !sign_only => Self::All,
+            _ => panic!("Cannot resolve blockhash"),
+        }
+    }
+
+    pub fn new_from_matches(matches: &ArgMatches<'_>) -> Self {
+        let blockhash = value_of(matches, BLOCKHASH_ARG.name);
+        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+        BlockhashQuery::new(blockhash, sign_only)
+    }
+
+    pub fn get_blockhash_fee_calculator(
+        &self,
+        rpc_client: &RpcClient,
+    ) -> Result<(Hash, FeeCalculator), Box<dyn std::error::Error>> {
+        let (hash, fee_calc) = match self {
+            BlockhashQuery::None(hash, fee_calc) => (Some(hash), Some(fee_calc)),
+            BlockhashQuery::FeeCalculator(hash) => (Some(hash), None),
+            BlockhashQuery::All => (None, None),
+        };
+        if None == fee_calc {
+            let (cluster_hash, fee_calc) = rpc_client.get_recent_blockhash()?;
+            Ok((*hash.unwrap_or(&cluster_hash), fee_calc))
+        } else {
+            Ok((*hash.unwrap(), fee_calc.unwrap().clone()))
+        }
+    }
+}
+
+impl Default for BlockhashQuery {
+    fn default() -> Self {
+        BlockhashQuery::All
+    }
+}
+
+fn blockhash_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(BLOCKHASH_ARG.name)
+        .long(BLOCKHASH_ARG.long)
+        .takes_value(true)
+        .value_name("BLOCKHASH")
+        .validator(is_hash)
+        .help(BLOCKHASH_ARG.help)
+}
+
+fn sign_only_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(SIGN_ONLY_ARG.name)
+        .long(SIGN_ONLY_ARG.long)
+        .takes_value(false)
+        .requires(BLOCKHASH_ARG.name)
+        .help(SIGN_ONLY_ARG.help)
+}
+
+fn signer_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(SIGNER_ARG.name)
+        .long(SIGNER_ARG.long)
+        .takes_value(true)
+        .value_name("BASE58_PUBKEY=BASE58_SIG")
+        .validator(is_pubkey_sig)
+        .requires(BLOCKHASH_ARG.name)
+        .multiple(true)
+        .help(SIGNER_ARG.help)
+}
+
+pub trait OfflineArgs {
+    fn offline_args(self) -> Self;
+}
+
+impl OfflineArgs for App<'_, '_> {
+    fn offline_args(self) -> Self {
+        self.arg(blockhash_arg())
+            .arg(sign_only_arg())
+            .arg(signer_arg())
+    }
+}
+
+pub fn parse_sign_only_reply_string(reply: &str) -> (Hash, Vec<(Pubkey, Signature)>) {
+    let object: Value = serde_json::from_str(&reply).unwrap();
+    let blockhash_str = object.get("blockhash").unwrap().as_str().unwrap();
+    let blockhash = blockhash_str.parse::<Hash>().unwrap();
+    let signer_strings = object.get("signers").unwrap().as_array().unwrap();
+    let signers = signer_strings
+        .iter()
+        .map(|signer_string| {
+            let mut signer = signer_string.as_str().unwrap().split('=');
+            let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
+            let sig = Signature::from_str(signer.next().unwrap()).unwrap();
+            (key, sig)
+        })
+        .collect();
+    (blockhash, signers)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::App;
+    use serde_json::{self, json, Value};
+    use solana_client::{
+        rpc_request::RpcRequest,
+        rpc_response::{Response, RpcResponseContext},
+    };
+    use solana_sdk::{fee_calculator::FeeCalculator, hash::hash};
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_blockhashspec_new_ok() {
+        let blockhash = hash(&[1u8]);
+
+        assert_eq!(
+            BlockhashQuery::new(Some(blockhash), true),
+            BlockhashQuery::None(blockhash, FeeCalculator::default()),
+        );
+        assert_eq!(
+            BlockhashQuery::new(Some(blockhash), false),
+            BlockhashQuery::FeeCalculator(blockhash),
+        );
+        assert_eq!(BlockhashQuery::new(None, false), BlockhashQuery::All,);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_blockhashspec_new_fail() {
+        BlockhashQuery::new(None, true);
+    }
+
+    #[test]
+    fn test_blockhashspec_new_from_matches_ok() {
+        let test_commands = App::new("blockhashspec_test").offline_args();
+        let blockhash = hash(&[1u8]);
+        let blockhash_string = blockhash.to_string();
+
+        let matches = test_commands.clone().get_matches_from(vec![
+            "blockhashspec_test",
+            "--blockhash",
+            &blockhash_string,
+            "--sign-only",
+        ]);
+        assert_eq!(
+            BlockhashQuery::new_from_matches(&matches),
+            BlockhashQuery::None(blockhash, FeeCalculator::default()),
+        );
+
+        let matches = test_commands.clone().get_matches_from(vec![
+            "blockhashspec_test",
+            "--blockhash",
+            &blockhash_string,
+        ]);
+        assert_eq!(
+            BlockhashQuery::new_from_matches(&matches),
+            BlockhashQuery::FeeCalculator(blockhash),
+        );
+
+        let matches = test_commands
+            .clone()
+            .get_matches_from(vec!["blockhashspec_test"]);
+        assert_eq!(
+            BlockhashQuery::new_from_matches(&matches),
+            BlockhashQuery::All,
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_blockhashspec_new_from_matches_fail() {
+        let test_commands = App::new("blockhashspec_test")
+            .arg(blockhash_arg())
+            // We can really only hit this case unless the arg requirements
+            // are broken, so unset the requires() to recreate that condition
+            .arg(sign_only_arg().requires(""));
+
+        let matches = test_commands
+            .clone()
+            .get_matches_from(vec!["blockhashspec_test", "--sign-only"]);
+        BlockhashQuery::new_from_matches(&matches);
+    }
+
+    #[test]
+    fn test_blockhashspec_get_blockhash_fee_calc() {
+        let test_blockhash = hash(&[0u8]);
+        let rpc_blockhash = hash(&[1u8]);
+        let rpc_fee_calc = FeeCalculator::new(42, 42);
+        let get_recent_blockhash_response = json!(Response {
+            context: RpcResponseContext { slot: 1 },
+            value: json!((
+                Value::String(rpc_blockhash.to_string()),
+                serde_json::to_value(rpc_fee_calc.clone()).unwrap()
+            )),
+        });
+        let mut mocks = HashMap::new();
+        mocks.insert(
+            RpcRequest::GetRecentBlockhash,
+            get_recent_blockhash_response.clone(),
+        );
+        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
+        assert_eq!(
+            BlockhashQuery::All
+                .get_blockhash_fee_calculator(&rpc_client)
+                .unwrap(),
+            (rpc_blockhash, rpc_fee_calc.clone()),
+        );
+        let mut mocks = HashMap::new();
+        mocks.insert(
+            RpcRequest::GetRecentBlockhash,
+            get_recent_blockhash_response.clone(),
+        );
+        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
+        assert_eq!(
+            BlockhashQuery::FeeCalculator(test_blockhash)
+                .get_blockhash_fee_calculator(&rpc_client)
+                .unwrap(),
+            (test_blockhash, rpc_fee_calc.clone()),
+        );
+        let mut mocks = HashMap::new();
+        mocks.insert(
+            RpcRequest::GetRecentBlockhash,
+            get_recent_blockhash_response.clone(),
+        );
+        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
+        assert_eq!(
+            BlockhashQuery::None(test_blockhash, FeeCalculator::default())
+                .get_blockhash_fee_calculator(&rpc_client)
+                .unwrap(),
+            (test_blockhash, FeeCalculator::default()),
+        );
+        let rpc_client = RpcClient::new_mock("fails".to_string());
+        assert!(BlockhashQuery::All
+            .get_blockhash_fee_calculator(&rpc_client)
+            .is_err());
+    }
+}
--- a/cli/src/offline/blockhash_query.rs
+++ b/cli/src/offline/blockhash_query.rs
@ -1,394 +0,0 @@
-use super::*;
-
-#[derive(Debug, PartialEq)]
-pub enum Source {
-    Cluster,
-    NonceAccount(Pubkey),
-}
-
-impl Source {
-    pub fn get_blockhash_and_fee_calculator(
-        &self,
-        rpc_client: &RpcClient,
-    ) -> Result<(Hash, FeeCalculator), Box<dyn std::error::Error>> {
-        match self {
-            Self::Cluster => {
-                let res = rpc_client.get_recent_blockhash()?;
-                Ok(res)
-            }
-            Self::NonceAccount(ref pubkey) => {
-                let data = nonce::get_account(rpc_client, pubkey)
-                    .and_then(|ref a| nonce::data_from_account(a))?;
-                Ok((data.blockhash, data.fee_calculator))
-            }
-        }
-    }
-
-    pub fn get_fee_calculator(
-        &self,
-        rpc_client: &RpcClient,
-        blockhash: &Hash,
-    ) -> Result<Option<FeeCalculator>, Box<dyn std::error::Error>> {
-        match self {
-            Self::Cluster => {
-                let res = rpc_client.get_fee_calculator_for_blockhash(blockhash)?;
-                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)
-            }
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum BlockhashQuery {
-    None(Hash),
-    FeeCalculator(Source, Hash),
-    All(Source),
-}
-
-impl BlockhashQuery {
-    pub fn new(blockhash: Option<Hash>, sign_only: bool, nonce_account: Option<Pubkey>) -> Self {
-        let source = nonce_account
-            .map(Source::NonceAccount)
-            .unwrap_or(Source::Cluster);
-        match blockhash {
-            Some(hash) if sign_only => Self::None(hash),
-            Some(hash) if !sign_only => Self::FeeCalculator(source, hash),
-            None if !sign_only => Self::All(source),
-            _ => panic!("Cannot resolve blockhash"),
-        }
-    }
-
-    pub fn new_from_matches(matches: &ArgMatches<'_>) -> Self {
-        let blockhash = value_of(matches, BLOCKHASH_ARG.name);
-        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        let nonce_account = pubkey_of(matches, nonce::NONCE_ARG.name);
-        BlockhashQuery::new(blockhash, sign_only, nonce_account)
-    }
-
-    pub fn get_blockhash_and_fee_calculator(
-        &self,
-        rpc_client: &RpcClient,
-    ) -> 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)?
-                    .ok_or(format!("Hash has expired {:?}", hash))?;
-                Ok((*hash, fee_calculator))
-            }
-            BlockhashQuery::All(source) => source.get_blockhash_and_fee_calculator(rpc_client),
-        }
-    }
-}
-
-impl Default for BlockhashQuery {
-    fn default() -> Self {
-        BlockhashQuery::All(Source::Cluster)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{nonce::nonce_arg, offline::blockhash_query::BlockhashQuery};
-    use clap::App;
-    use serde_json::{self, json, Value};
-    use solana_client::{
-        rpc_request::RpcRequest,
-        rpc_response::{Response, RpcAccount, RpcFeeCalculator, RpcResponseContext},
-    };
-    use solana_sdk::{
-        account::Account, fee_calculator::FeeCalculator, hash::hash, nonce, system_program,
-    };
-    use std::collections::HashMap;
-
-    #[test]
-    fn test_blockhash_query_new_ok() {
-        let blockhash = hash(&[1u8]);
-        let nonce_pubkey = Pubkey::new(&[1u8; 32]);
-
-        assert_eq!(
-            BlockhashQuery::new(Some(blockhash), true, None),
-            BlockhashQuery::None(blockhash),
-        );
-        assert_eq!(
-            BlockhashQuery::new(Some(blockhash), false, None),
-            BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
-        );
-        assert_eq!(
-            BlockhashQuery::new(None, false, None),
-            BlockhashQuery::All(blockhash_query::Source::Cluster)
-        );
-
-        assert_eq!(
-            BlockhashQuery::new(Some(blockhash), true, Some(nonce_pubkey)),
-            BlockhashQuery::None(blockhash),
-        );
-        assert_eq!(
-            BlockhashQuery::new(Some(blockhash), false, Some(nonce_pubkey)),
-            BlockhashQuery::FeeCalculator(
-                blockhash_query::Source::NonceAccount(nonce_pubkey),
-                blockhash
-            ),
-        );
-        assert_eq!(
-            BlockhashQuery::new(None, false, Some(nonce_pubkey)),
-            BlockhashQuery::All(blockhash_query::Source::NonceAccount(nonce_pubkey)),
-        );
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_blockhash_query_new_no_nonce_fail() {
-        BlockhashQuery::new(None, true, None);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_blockhash_query_new_nonce_fail() {
-        let nonce_pubkey = Pubkey::new(&[1u8; 32]);
-        BlockhashQuery::new(None, true, Some(nonce_pubkey));
-    }
-
-    #[test]
-    fn test_blockhash_query_new_from_matches_ok() {
-        let test_commands = App::new("blockhash_query_test")
-            .arg(nonce_arg())
-            .offline_args();
-        let blockhash = hash(&[1u8]);
-        let blockhash_string = blockhash.to_string();
-
-        let matches = test_commands.clone().get_matches_from(vec![
-            "blockhash_query_test",
-            "--blockhash",
-            &blockhash_string,
-            "--sign-only",
-        ]);
-        assert_eq!(
-            BlockhashQuery::new_from_matches(&matches),
-            BlockhashQuery::None(blockhash),
-        );
-
-        let matches = test_commands.clone().get_matches_from(vec![
-            "blockhash_query_test",
-            "--blockhash",
-            &blockhash_string,
-        ]);
-        assert_eq!(
-            BlockhashQuery::new_from_matches(&matches),
-            BlockhashQuery::FeeCalculator(blockhash_query::Source::Cluster, blockhash),
-        );
-
-        let matches = test_commands
-            .clone()
-            .get_matches_from(vec!["blockhash_query_test"]);
-        assert_eq!(
-            BlockhashQuery::new_from_matches(&matches),
-            BlockhashQuery::All(blockhash_query::Source::Cluster),
-        );
-
-        let nonce_pubkey = Pubkey::new(&[1u8; 32]);
-        let nonce_string = nonce_pubkey.to_string();
-        let matches = test_commands.clone().get_matches_from(vec![
-            "blockhash_query_test",
-            "--blockhash",
-            &blockhash_string,
-            "--sign-only",
-            "--nonce",
-            &nonce_string,
-        ]);
-        assert_eq!(
-            BlockhashQuery::new_from_matches(&matches),
-            BlockhashQuery::None(blockhash),
-        );
-
-        let matches = test_commands.clone().get_matches_from(vec![
-            "blockhash_query_test",
-            "--blockhash",
-            &blockhash_string,
-            "--nonce",
-            &nonce_string,
-        ]);
-        assert_eq!(
-            BlockhashQuery::new_from_matches(&matches),
-            BlockhashQuery::FeeCalculator(
-                blockhash_query::Source::NonceAccount(nonce_pubkey),
-                blockhash
-            ),
-        );
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_blockhash_query_new_from_matches_without_nonce_fail() {
-        let test_commands = App::new("blockhash_query_test")
-            .arg(blockhash_arg())
-            // We can really only hit this case if the arg requirements
-            // are broken, so unset the requires() to recreate that condition
-            .arg(sign_only_arg().requires(""));
-
-        let matches = test_commands
-            .clone()
-            .get_matches_from(vec!["blockhash_query_test", "--sign-only"]);
-        BlockhashQuery::new_from_matches(&matches);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_blockhash_query_new_from_matches_with_nonce_fail() {
-        let test_commands = App::new("blockhash_query_test")
-            .arg(blockhash_arg())
-            // We can really only hit this case if the arg requirements
-            // are broken, so unset the requires() to recreate that condition
-            .arg(sign_only_arg().requires(""));
-        let nonce_pubkey = Pubkey::new(&[1u8; 32]);
-        let nonce_string = nonce_pubkey.to_string();
-
-        let matches = test_commands.clone().get_matches_from(vec![
-            "blockhash_query_test",
-            "--sign-only",
-            "--nonce",
-            &nonce_string,
-        ]);
-        BlockhashQuery::new_from_matches(&matches);
-    }
-
-    #[test]
-    fn test_blockhash_query_get_blockhash_fee_calc() {
-        let test_blockhash = hash(&[0u8]);
-        let rpc_blockhash = hash(&[1u8]);
-        let rpc_fee_calc = FeeCalculator::new(42);
-        let get_recent_blockhash_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!((
-                Value::String(rpc_blockhash.to_string()),
-                serde_json::to_value(rpc_fee_calc.clone()).unwrap()
-            )),
-        });
-        let get_fee_calculator_for_blockhash_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(RpcFeeCalculator {
-                fee_calculator: rpc_fee_calc.clone()
-            }),
-        });
-        let mut mocks = HashMap::new();
-        mocks.insert(
-            RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response.clone(),
-        );
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert_eq!(
-            BlockhashQuery::default()
-                .get_blockhash_and_fee_calculator(&rpc_client)
-                .unwrap(),
-            (rpc_blockhash, rpc_fee_calc.clone()),
-        );
-        let mut mocks = HashMap::new();
-        mocks.insert(
-            RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response.clone(),
-        );
-        mocks.insert(
-            RpcRequest::GetFeeCalculatorForBlockhash,
-            get_fee_calculator_for_blockhash_response,
-        );
-        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)
-                .unwrap(),
-            (test_blockhash, rpc_fee_calc),
-        );
-        let mut mocks = HashMap::new();
-        mocks.insert(
-            RpcRequest::GetRecentBlockhash,
-            get_recent_blockhash_response,
-        );
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert_eq!(
-            BlockhashQuery::None(test_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
-                .unwrap(),
-            (test_blockhash, FeeCalculator::default()),
-        );
-        let rpc_client = RpcClient::new_mock("fails".to_string());
-        assert!(BlockhashQuery::default()
-            .get_blockhash_and_fee_calculator(&rpc_client)
-            .is_err());
-
-        let nonce_blockhash = Hash::new(&[2u8; 32]);
-        let nonce_fee_calc = FeeCalculator::new(4242);
-        let data = nonce::state::Data {
-            authority: Pubkey::new(&[3u8; 32]),
-            blockhash: nonce_blockhash,
-            fee_calculator: nonce_fee_calc.clone(),
-        };
-        let nonce_account = Account::new_data_with_space(
-            42,
-            &nonce::state::Versions::new_current(nonce::State::Initialized(data)),
-            nonce::State::size(),
-            &system_program::id(),
-        )
-        .unwrap();
-        let nonce_pubkey = Pubkey::new(&[4u8; 32]);
-        let rpc_nonce_account = RpcAccount::encode(nonce_account);
-        let get_account_response = json!(Response {
-            context: RpcResponseContext { slot: 1 },
-            value: json!(Some(rpc_nonce_account)),
-        });
-
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetAccountInfo, get_account_response.clone());
-        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)
-                .unwrap(),
-            (nonce_blockhash, nonce_fee_calc.clone()),
-        );
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetAccountInfo, get_account_response.clone());
-        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)
-                .unwrap(),
-            (nonce_blockhash, nonce_fee_calc),
-        );
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetAccountInfo, get_account_response.clone());
-        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)
-                .is_err()
-        );
-        let mut mocks = HashMap::new();
-        mocks.insert(RpcRequest::GetAccountInfo, get_account_response);
-        let rpc_client = RpcClient::new_mock_with_mocks("".to_string(), mocks);
-        assert_eq!(
-            BlockhashQuery::None(nonce_blockhash)
-                .get_blockhash_and_fee_calculator(&rpc_client)
-                .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)
-            .is_err());
-    }
-}
--- a/cli/src/offline/mod.rs
+++ b/cli/src/offline/mod.rs
@ -1,129 +0,0 @@
-pub mod blockhash_query;
-
-use crate::nonce;
-use clap::{App, Arg, ArgMatches};
-use serde_json::Value;
-use solana_clap_utils::{
-    input_parsers::{pubkey_of, value_of},
-    input_validators::{is_hash, is_pubkey_sig},
-    keypair::presigner_from_pubkey_sigs,
-    offline::{BLOCKHASH_ARG, SIGNER_ARG, SIGN_ONLY_ARG},
-};
-use solana_client::rpc_client::RpcClient;
-use solana_sdk::{
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::{Presigner, Signature},
-};
-use std::str::FromStr;
-
-fn blockhash_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(BLOCKHASH_ARG.name)
-        .long(BLOCKHASH_ARG.long)
-        .takes_value(true)
-        .value_name("BLOCKHASH")
-        .validator(is_hash)
-        .help(BLOCKHASH_ARG.help)
-}
-
-fn sign_only_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(SIGN_ONLY_ARG.name)
-        .long(SIGN_ONLY_ARG.long)
-        .takes_value(false)
-        .requires(BLOCKHASH_ARG.name)
-        .help(SIGN_ONLY_ARG.help)
-}
-
-fn signer_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(SIGNER_ARG.name)
-        .long(SIGNER_ARG.long)
-        .takes_value(true)
-        .value_name("PUBKEY=SIGNATURE")
-        .validator(is_pubkey_sig)
-        .requires(BLOCKHASH_ARG.name)
-        .multiple(true)
-        .help(SIGNER_ARG.help)
-}
-
-pub trait OfflineArgs {
-    fn offline_args(self) -> Self;
-}
-
-impl OfflineArgs for App<'_, '_> {
-    fn offline_args(self) -> Self {
-        self.arg(blockhash_arg())
-            .arg(sign_only_arg())
-            .arg(signer_arg())
-    }
-}
-
-pub struct SignOnly {
-    pub blockhash: Hash,
-    pub present_signers: Vec<(Pubkey, Signature)>,
-    pub absent_signers: Vec<Pubkey>,
-    pub bad_signers: Vec<Pubkey>,
-}
-
-impl SignOnly {
-    pub fn has_all_signers(&self) -> bool {
-        self.absent_signers.is_empty() && self.bad_signers.is_empty()
-    }
-
-    pub fn presigner_of(&self, pubkey: &Pubkey) -> Option<Presigner> {
-        presigner_from_pubkey_sigs(pubkey, &self.present_signers)
-    }
-}
-
-pub fn parse_sign_only_reply_string(reply: &str) -> SignOnly {
-    let object: Value = serde_json::from_str(&reply).unwrap();
-    let blockhash_str = object.get("blockhash").unwrap().as_str().unwrap();
-    let blockhash = blockhash_str.parse::<Hash>().unwrap();
-    let mut present_signers: Vec<(Pubkey, Signature)> = Vec::new();
-    let signer_strings = object.get("signers");
-    if let Some(sig_strings) = signer_strings {
-        present_signers = sig_strings
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|signer_string| {
-                let mut signer = signer_string.as_str().unwrap().split('=');
-                let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
-                let sig = Signature::from_str(signer.next().unwrap()).unwrap();
-                (key, sig)
-            })
-            .collect();
-    }
-    let mut absent_signers: Vec<Pubkey> = Vec::new();
-    let signer_strings = object.get("absent");
-    if let Some(sig_strings) = signer_strings {
-        absent_signers = sig_strings
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|val| {
-                let s = val.as_str().unwrap();
-                Pubkey::from_str(s).unwrap()
-            })
-            .collect();
-    }
-    let mut bad_signers: Vec<Pubkey> = Vec::new();
-    let signer_strings = object.get("badSig");
-    if let Some(sig_strings) = signer_strings {
-        bad_signers = sig_strings
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|val| {
-                let s = val.as_str().unwrap();
-                Pubkey::from_str(s).unwrap()
-            })
-            .collect();
-    }
-    SignOnly {
-        blockhash,
-        present_signers,
-        absent_signers,
-        bad_signers,
-    }
-}
--- a/cli/src/spend_utils.rs
+++ b/cli/src/spend_utils.rs
@ -1,158 +0,0 @@
-use crate::{
-    checks::{calculate_fee, check_account_for_balance},
-    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,
-};
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum SpendAmount {
-    All,
-    Some(u64),
-}
-
-impl Default for SpendAmount {
-    fn default() -> Self {
-        Self::Some(u64::default())
-    }
-}
-
-impl SpendAmount {
-    pub fn new(amount: Option<u64>, sign_only: bool) -> Self {
-        match amount {
-            Some(lamports) => Self::Some(lamports),
-            None if !sign_only => Self::All,
-            _ => panic!("ALL amount not supported for sign-only operations"),
-        }
-    }
-
-    pub fn new_from_matches(matches: &ArgMatches<'_>, name: &str) -> Self {
-        let amount = lamports_of_sol(matches, name);
-        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        SpendAmount::new(amount, sign_only)
-    }
-}
-
-struct SpendAndFee {
-    spend: u64,
-    fee: u64,
-}
-
-pub fn resolve_spend_tx_and_check_account_balance<F>(
-    rpc_client: &RpcClient,
-    sign_only: bool,
-    amount: SpendAmount,
-    fee_calculator: &FeeCalculator,
-    from_pubkey: &Pubkey,
-    build_message: F,
-) -> Result<(Message, u64), CliError>
-where
-    F: Fn(u64) -> Message,
-{
-    resolve_spend_tx_and_check_account_balances(
-        rpc_client,
-        sign_only,
-        amount,
-        fee_calculator,
-        from_pubkey,
-        from_pubkey,
-        build_message,
-    )
-}
-
-pub fn resolve_spend_tx_and_check_account_balances<F>(
-    rpc_client: &RpcClient,
-    sign_only: bool,
-    amount: SpendAmount,
-    fee_calculator: &FeeCalculator,
-    from_pubkey: &Pubkey,
-    fee_pubkey: &Pubkey,
-    build_message: F,
-) -> Result<(Message, u64), CliError>
-where
-    F: Fn(u64) -> Message,
-{
-    if sign_only {
-        let (message, SpendAndFee { spend, fee: _ }) = resolve_spend_message(
-            amount,
-            fee_calculator,
-            0,
-            from_pubkey,
-            fee_pubkey,
-            build_message,
-        );
-        Ok((message, spend))
-    } else {
-        let from_balance = rpc_client.get_balance(&from_pubkey)?;
-        let (message, SpendAndFee { spend, fee }) = resolve_spend_message(
-            amount,
-            fee_calculator,
-            from_balance,
-            from_pubkey,
-            fee_pubkey,
-            build_message,
-        );
-        if from_pubkey == fee_pubkey {
-            if from_balance == 0 || from_balance < spend + fee {
-                return Err(CliError::InsufficientFundsForSpendAndFee(
-                    lamports_to_sol(spend),
-                    lamports_to_sol(fee),
-                ));
-            }
-        } else {
-            if from_balance < spend {
-                return Err(CliError::InsufficientFundsForSpend(lamports_to_sol(spend)));
-            }
-            if !check_account_for_balance(rpc_client, fee_pubkey, fee)? {
-                return Err(CliError::InsufficientFundsForFee(lamports_to_sol(fee)));
-            }
-        }
-        Ok((message, spend))
-    }
-}
-
-fn resolve_spend_message<F>(
-    amount: SpendAmount,
-    fee_calculator: &FeeCalculator,
-    from_balance: u64,
-    from_pubkey: &Pubkey,
-    fee_pubkey: &Pubkey,
-    build_message: F,
-) -> (Message, SpendAndFee)
-where
-    F: Fn(u64) -> Message,
-{
-    match amount {
-        SpendAmount::Some(lamports) => {
-            let message = build_message(lamports);
-            let fee = calculate_fee(fee_calculator, &[&message]);
-            (
-                message,
-                SpendAndFee {
-                    spend: lamports,
-                    fee,
-                },
-            )
-        }
-        SpendAmount::All => {
-            let dummy_message = build_message(0);
-            let fee = calculate_fee(fee_calculator, &[&dummy_message]);
-            let lamports = if from_pubkey == fee_pubkey {
-                from_balance.saturating_sub(fee)
-            } else {
-                from_balance
-            };
-            (
-                build_message(lamports),
-                SpendAndFee {
-                    spend: lamports,
-                    fee,
-                },
-            )
-        }
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Michael Vines	8df4cf2895	Don't advertise the snapshot that the node was loaded from snapshot_packager_service will remove this snapshot hash from gossip when it starts	2020-03-02 19:16:06 -07:00
mergify[bot]	dad62e132e	Remove granularity from genesis (bp #8514 ) (#8518 ) automerge	2020-03-02 15:42:46 -08:00
Michael Vines	0d4131ae68	Bump version to 1.0.2	2020-03-02 15:38:26 -07:00
mergify[bot]	a2539e1892	Allow stake lockup fields to be updated independently (#8568 ) (#8574 ) automerge	2020-03-02 14:19:18 -08:00
Michael Vines	210659e6c3	Only gossip packaged snapshots (cherry picked from commit `42c5c59800`)	2020-03-02 14:21:04 -07:00
Michael Vines	15a0fb1fa9	--wait-for-supermajority now requires a SLOT (cherry picked from commit `13551885c2`)	2020-03-02 13:40:52 -07:00
Michael Vines	4db31f5b48	Add ---no-untrusted-rpc flag (cherry picked from commit `d677e83ed4`)	2020-03-02 11:53:15 -07:00
mergify[bot]	b38a535c63	Hack to skip cleanup_dead_slots upon snapshot load (#8562 ) automerge	2020-03-02 10:40:41 -08:00
Michael Vines	218b02aaf8	Demote gossip responder error log messages to info!	2020-03-01 10:42:32 -07:00
mergify[bot]	d6e7cbd4e8	feat: implement websocket_url as a get/set-able global parameter w/ value computation (#8553 ) automerge	2020-03-01 01:09:09 -08:00
mergify[bot]	f2fda14333	Reduce max snapshot hashes to stay under MTU (bp #8541 ) (#8544 ) automerge	2020-02-29 09:17:09 -08:00
Michael Vines	1c576d4a68	Upgrade to Rust 1.41.1 (cherry picked from commit `7d27be2a73`)	2020-02-29 09:27:11 -07:00
mergify[bot]	f6232e1b3c	Fix skipping own leader slots (#8533 ) (#8540 ) automerge	2020-02-29 01:27:46 -08:00
mergify[bot]	ad71fa3f12	rpc: GET for /snapshot.tar.bz2 now redirects to the latest snapshot (bp #8536 ) (#8538 ) automerge	2020-02-28 23:45:15 -08:00
mergify[bot]	9c326c7c71	Ensure the validator's identity pubkey is not provided as a --trusted-validator (#8525 ) (#8527 ) automerge	2020-02-27 22:07:07 -08:00
mergify[bot]	ac545cadaf	Add versioning (#8348 ) (#8524 ) automerge	2020-02-27 20:12:49 -08:00
mergify[bot]	082d8fff36	Use legit solana message in verify (#8513 ) (#8523 ) automerge	2020-02-27 19:36:37 -08:00
mergify[bot]	2c3632a042	Determine vote_state ahead of time (#8303 ) (#8521 ) automerge	2020-02-27 18:32:27 -08:00
mergify[bot]	7b23e79922	Add snapshot hash of full accounts state (#8295 ) (#8515 ) * Add snapshot hash of full accounts state * Use normal hashing for the accounts delta state * Add merkle (cherry picked from commit `947a339714`) Co-authored-by: sakridge <sakridge@gmail.com>	2020-02-27 17:36:28 -08:00
mergify[bot]	9afd14a0c6	Import Tour de SOL docs (#8516 ) (#8519 ) automerge	2020-02-27 17:15:36 -08:00
Michael Vines	f42aa34ab6	Reorder InstructionError to remain compatible with v0.23 (cherry picked from commit `7dac8e2dde`)	2020-02-27 18:07:00 -07:00
mergify[bot]	43af91ff4b	Ledger messaging cleanup (#8506 ) (#8508 ) automerge	2020-02-27 12:38:09 -08:00
mergify[bot]	a920a0f946	Fix cluster economics figures and spelling in docs (#8502 ) (#8505 ) automerge	2020-02-27 02:49:10 -08:00
mergify[bot]	4a8a6d0b3f	Remove loop (#8496 ) automerge	2020-02-27 00:38:27 -08:00
mergify[bot]	a64b8a2705	Rename snapshot.tar.bz2 to snapshot-<slot>-<hash>.tar.bz2 (bp #8482 ) (#8501 ) automerge	2020-02-26 23:31:44 -08:00
Michael Vines	0198f9e8af	Peg snapshot version to 1.0.0	2020-02-26 22:07:50 -07:00
Michael Vines	1582a3a927	Cargo.lock	2020-02-26 21:17:40 -07:00
mergify[bot]	e713f0e5fb	Update voting simulation (#8489 )	2020-02-26 20:00:20 -08:00
mergify[bot]	77031000c4	Choose more appropriate options for pubsub websocket server (#8354 ) (#8492 ) automerge	2020-02-26 18:23:50 -08:00
Michael Vines	635a962fba	Reference the v1.0.0 installer	2020-02-26 19:20:58 -07:00
mergify[bot]	c59ec2dcff	Add flag to confirm key on device (#8478 ) (#8490 ) automerge	2020-02-26 17:31:52 -08:00
mergify[bot]	abc6c5e264	Limit leader schedule search space (#8468 ) (#8486 ) automerge	2020-02-26 16:11:14 -08:00
mergify[bot]	87cfac12dd	Validate the genesis config downloaded over RPC before accepting it (bp #8474 ) (#8481 ) automerge	2020-02-26 15:12:06 -08:00
Tyera Eulberg	60b43e34b6	Ledger hardware wallet docs (#8472 ) (#8479 ) automerge	2020-02-26 14:42:08 -08:00
mergify[bot]	9ab6222f03	Move docs from book/ to docs/ (#8469 ) (#8471 ) automerge	2020-02-26 08:01:44 -08:00
mergify[bot]	2298dd5c07	Use runtime executor to send pubsub notifications (#8353 ) (#8465 ) automerge	2020-02-25 21:45:18 -08:00
mergify[bot]	822d166115	live-slots now displays the rate the root slot is advancing (#8464 ) automerge	2020-02-25 21:18:10 -08:00
mergify[bot]	8f71580615	Allow withdrawer to change the authorized stake key (#8456 ) (#8462 ) automerge	2020-02-25 19:30:59 -08:00
mergify[bot]	cc3352ff06	Ledger key path rework (#8453 ) (#8457 ) automerge	2020-02-25 18:00:53 -08:00
mergify[bot]	8f5928b7c7	Promote dangerous cond. from just warning to panic (#8439 ) (#8449 ) automerge	2020-02-25 15:31:06 -08:00
Michael Vines	888e9617ff	🐌🐌 Publish crates for even longer longer	2020-02-25 09:23:20 -07:00
mergify[bot]	4695c4cf7d	Add --no-check-vote-account argument (#8430 ) (#8435 ) automerge	2020-02-25 00:23:50 -08:00
mergify[bot]	bbfc56ff7f	Make solana root key accessible on Ledger (#8421 ) (#8431 ) automerge	2020-02-24 22:28:28 -08:00
Michael Vines	4103d99018	Bump version to 1.0.1	2020-02-24 23:24:27 -07:00
mergify[bot]	c375ce1fcd	CLI: collect and deduplicate signers (#8398 ) (#8423 ) automerge	2020-02-24 17:29:34 -08:00
Jack May	df813b31c5	Fix SDK deps	2020-02-24 17:30:46 -07:00
Michael Vines	7db92e2951	Drop print- prefix from slot/accounts command (cherry picked from commit `89baa94002`)	2020-02-24 17:28:36 -07:00
Michael Vines	6585518f78	Add genesis subcommand (cherry picked from commit `1ef3478709`)	2020-02-24 17:28:36 -07:00
Michael Vines	6398e256e4	Move shred_version module to sdk/ (cherry picked from commit `73063544bd`)	2020-02-24 17:28:36 -07:00
mergify[bot]	b64ebb45e7	validator: snapshot fetching cleanup (bp #8413 ) (#8417 ) automerge	2020-02-24 15:22:34 -08:00
mergify[bot]	307ac66d9c	Reinstate `create-stale-account` w/ seed test (#8401 ) (#8402 ) automerge	2020-02-22 10:56:39 -08:00