CI: Drop redundant cargo audit run

There is a Cargo.lock in this dir, so `scripts/cargo-for-all-lock-files.sh ...` covers it

.buildkite/hooks/post-command

@@ -3,16 +3,19 @@
 #
 # Save target/ for the next CI build on this machine
 #
-(
-  set -x
-  d=$HOME/cargo-target-cache/"$BUILDKITE_LABEL"
-  mkdir -p "$d"
-  set -x
-  rsync -a --delete --link-dest="$PWD" target "$d"
-  du -hs "$d"
-  read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$d")
-  echo "--- ${cacheSizeInGB}GB: $d"
-)
+if [[ -z $CARGO_TARGET_CACHE ]]; then
+  echo "+++ CARGO_TARGET_CACHE not defined" # pre-command should have defined it
+else
+  (
+    set -x
+    mkdir -p "$CARGO_TARGET_CACHE"
+    set -x
+    rsync -a --delete --link-dest="$PWD" target "$CARGO_TARGET_CACHE"
+    du -hs "$CARGO_TARGET_CACHE"
+    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$CARGO_TARGET_CACHE")
+    echo "--- ${cacheSizeInGB}GB: $CARGO_TARGET_CACHE"
+  )
+fi
 
 #
 # Add job_stats data point

.buildkite/hooks/pre-command

@@ -11,23 +11,24 @@ export PS4="++"
 #
 # Restore target/ from the previous CI build on this machine
 #
+eval "$(ci/channel-info.sh)"
+export CARGO_TARGET_CACHE=$HOME/cargo-target-cache/"$CHANNEL"-"$BUILDKITE_LABEL"
 (
   set -x
-  d=$HOME/cargo-target-cache/"$BUILDKITE_LABEL"
   MAX_CACHE_SIZE=18 # gigabytes
 
-  if [[ -d $d ]]; then
-    du -hs "$d"
-    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$d")
-    echo "--- ${cacheSizeInGB}GB: $d"
+  if [[ -d $CARGO_TARGET_CACHE ]]; then
+    du -hs "$CARGO_TARGET_CACHE"
+    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$CARGO_TARGET_CACHE")
+    echo "--- ${cacheSizeInGB}GB: $CARGO_TARGET_CACHE"
     if [[ $cacheSizeInGB -gt $MAX_CACHE_SIZE ]]; then
-      echo "--- $d is too large, removing it"
-      rm -rf "$d"
+      echo "--- $CARGO_TARGET_CACHE is too large, removing it"
+      rm -rf "$CARGO_TARGET_CACHE"
     fi
   else
-    echo "--- $d not present"
+    echo "--- $CARGO_TARGET_CACHE not present"
   fi
 
-  mkdir -p "$d"/target
-  rsync -a --delete --link-dest="$d" "$d"/target .
+  mkdir -p "$CARGO_TARGET_CACHE"/target
+  rsync -a --delete --link-dest="$CARGO_TARGET_CACHE" "$CARGO_TARGET_CACHE"/target .
 )

.gitbook.yaml

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

.gitignore

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

.mergify.yml

@@ -52,7 +52,6 @@ pull_request_rules:
           - automerge
   - name: v1.0 backport
     conditions:
-      - base=master
       - label=v1.0
     actions:
       backport:
@@ -61,7 +60,6 @@ pull_request_rules:
           - v1.0
   - name: v1.1 backport
     conditions:
-      - base=master
       - label=v1.1
     actions:
       backport:
@@ -70,7 +68,6 @@ pull_request_rules:
           - v1.1
   - name: v1.2 backport
     conditions:
-      - base=master
       - label=v1.2
     actions:
       backport:

.travis.yml

@@ -1,45 +1,73 @@
-os:
-  - osx
-  - windows
-
-language: rust
-rust:
-  - stable
-
-install:
-  - source ci/rust-version.sh
-
-script:
-  - source ci/env.sh
-  - ci/publish-tarball.sh
-
 branches:
   only:
     - master
     - /^v\d+\.\d+/
 
-if: type IN (api, cron) OR tag IS present
-
 notifications:
   slack:
     on_success: change
     secure: F4IjOE05MyaMOdPRL+r8qhs7jBvv4yDM3RmFKE1zNXnfUOqV4X38oQM1EI+YVsgpMQLj/pxnEB7wcTE4Bf86N6moLssEULCpvAuMVoXj4QbWdomLX+01WbFa6fLVeNQIg45NHrz2XzVBhoKOrMNnl+QI5mbR2AlS5oqsudHsXDnyLzZtd4Y5SDMdYG1zVWM01+oNNjgNfjcCGmOE/K0CnOMl6GPi3X9C34tJ19P2XT7MTDsz1/IfEF7fro2Q8DHEYL9dchJMoisXSkem5z7IDQkGzXsWdWT4NnndUvmd1MlTCE9qgoXDqRf95Qh8sB1Dz08HtvgfaosP2XjtNTfDI9BBYS15Ibw9y7PchAJE1luteNjF35EOy6OgmCLw/YpnweqfuNViBZz+yOPWXVC0kxnPIXKZ1wyH9ibeH6E4hr7a8o9SV/6SiWIlbYF+IR9jPXyTCLP/cc3sYljPWxDnhWFwFdRVIi3PbVAhVu7uWtVUO17Oc9gtGPgs/GrhOMkJfwQPXaudRJDpVZowxTX4x9kefNotlMAMRgq+Drbmgt4eEBiCNp0ITWgh17BiE1U09WS3myuduhoct85+FoVeaUkp1sxzHVtGsNQH0hcz7WcpZyOM+AwistJA/qzeEDQao5zi1eKWPbO2xAhi2rV1bDH6bPf/4lDBwLRqSiwvlWU=
 
-deploy:
-  - provider: s3
-    access_key_id: $AWS_ACCESS_KEY_ID
-    secret_access_key: $AWS_SECRET_ACCESS_KEY
-    bucket: release.solana.com
-    region: us-west-1
-    skip_cleanup: true
-    acl: public_read
-    local_dir: travis-s3-upload
-    on:
-      all_branches: true
-  - provider: releases
-    api_key: $GITHUB_TOKEN
-    skip_cleanup: true
-    file_glob: true
-    file: travis-release-upload/*
-    on:
-      tags: true
+os: linux
+dist: bionic
+language: minimal
+
+jobs:
+  include:
+    - &release-artifacts
+      if: type = push
+      name: "macOS release artifacts"
+      os: osx
+      language: rust
+      rust:
+        - stable
+      install:
+        - source ci/rust-version.sh
+      script:
+        - source ci/env.sh
+        - ci/publish-tarball.sh
+      deploy:
+        - provider: s3
+          access_key_id: $AWS_ACCESS_KEY_ID
+          secret_access_key: $AWS_SECRET_ACCESS_KEY
+          bucket: release.solana.com
+          region: us-west-1
+          skip_cleanup: true
+          acl: public_read
+          local_dir: travis-s3-upload
+          on:
+            all_branches: true
+        - provider: releases
+          token: $GITHUB_TOKEN
+          skip_cleanup: true
+          file_glob: true
+          file: travis-release-upload/*
+          on:
+            tags: true
+    - <<: *release-artifacts
+      name: "Windows release artifacts"
+      os: windows
+
+    # docs pull request or commit
+    - name: "docs"
+      if: type IN (push, pull_request) OR tag IS present
+      language: node_js
+      node_js:
+        - "node"
+
+      services:
+        - docker
+
+      cache:
+        directories:
+          - ~/.npm
+
+      before_install:
+        - source ci/env.sh
+        - .travis/channel_restriction.sh edge beta || travis_terminate 0
+        - .travis/affects.sh docs/ .travis || travis_terminate 0
+        - cd docs/
+        - source .travis/before_install.sh
+
+      script:
+        - source .travis/script.sh

.travis/affects.sh

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

.travis/channel_restriction.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+#
+# Only proceed if we are on one of the channels passed in when calling this file
+#
+
+set -ex
+
+eval "$(ci/channel-info.sh)"
+
+for acceptable_channel in "$@"; do
+  if [[ "$CHANNEL" == "$acceptable_channel" ]]; then
+    exit 0
+  fi
+done
+
+echo "Not running from one of the following channels: $*"
+exit 1

Cargo.toml

@@ -5,10 +5,8 @@ members = [
     "bench-tps",
     "accounts-bench",
     "banking-bench",
-    "chacha",
-    "chacha-cuda",
-    "chacha-sys",
     "cli-config",
+    "cli-output",
     "client",
     "core",
     "dos",
@@ -27,10 +25,13 @@ members = [
     "logger",
     "log-analyzer",
     "merkle-tree",
+    "stake-o-matic",
+    "storage-bigtable",
     "streamer",
     "measure",
     "metrics",
     "net-shaper",
+    "notifier",
     "programs/bpf_loader",
     "programs/budget",
     "programs/btc_spv",
@@ -41,21 +42,19 @@ 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",
+    "account-decoder",
     "upload-perf",
     "net-utils",
     "version",
@@ -67,6 +66,4 @@ members = [
 
 exclude = [
     "programs/bpf",
-    "programs/move_loader",
-    "programs/librapay",
 ]

README.md

@@ -1,23 +1,17 @@
+<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)
 
-Blockchain Rebuilt for Scale
-===
+# Building
 
-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.
-
-Read all about it at [Solana: Blockchain Rebuilt for Scale](https://docs.solana.com/v/master).
-
-Developing
-===
-
-Building
----
-
-Install rustc, cargo and rustfmt:
+## **1. Install rustc, cargo and rustfmt.**
 
 ```bash
 $ curl https://sh.rustup.rs -sSf | sh
@@ -38,112 +32,39 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```
 
-Download the source code:
+## **2. Download the source code.**
 
 ```bash
 $ git clone https://github.com/solana-labs/solana.git
 $ cd solana
 ```
 
-Build
+## **3. Build.**
 
 ```bash
 $ cargo build
 ```
 
-Then to run a minimal local cluster
+## **4. Run a minimal local cluster.**
 ```bash
 $ ./run.sh
 ```
 
-Testing
----
+# Testing
 
-Run the test suite:
+**Run the test suite:**
 
 ```bash
 $ cargo test
 ```
 
-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
----
+### Starting a local testnet
+Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/bench-tps).
 
+### Accessing the remote testnet
 * `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7
 
-
-## 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
----
+# Benchmarking
 
 First install the nightly build of rustc. `cargo bench` requires use of the
 unstable features only available in the nightly build.
@@ -158,13 +79,11 @@ 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:
 
@@ -173,7 +92,6 @@ $ 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
@@ -186,7 +104,6 @@ better way to solve the same problem, a Pull Request with your solution would mo
 welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please
 send us that patch!
 
-Disclaimer
-===
+# 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.

RELEASE.md

@@ -116,7 +116,8 @@ There are three release channels that map to branches as follows:
 
 1. After the new release has been tagged, update the Cargo.toml files on **release branch** to the next semantic version (e.g. 0.9.0 -> 0.9.1) with:
      ```
-     scripts/increment-cargo-version.sh patch
+     $ scripts/increment-cargo-version.sh patch
+     $ ./scripts/cargo-for-all-lock-files.sh tree
      ```
 1. Rebuild to get an updated version of `Cargo.lock`:
     ```

account-decoder/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "solana-account-decoder"
+version = "1.2.33"
+description = "Solana account decoder"
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+repository = "https://github.com/solana-labs/solana"
+homepage = "https://solana.com/"
+license = "Apache-2.0"
+edition = "2018"
+
+[dependencies]
+bincode = "1.3.1"
+base64 = "0.12.3"
+bs58 = "0.3.1"
+bv = "0.11.1"
+Inflector = "0.11.4"
+lazy_static = "1.4.0"
+serde = "1.0.112"
+serde_derive = "1.0.103"
+serde_json = "1.0.54"
+solana-config-program = { path = "../programs/config", version = "1.2.33" }
+solana-sdk = { path = "../sdk", version = "1.2.33" }
+solana-stake-program = { path = "../programs/stake", version = "1.2.33" }
+solana-vote-program = { path = "../programs/vote", version = "1.2.33" }
+spl-token-v2-0 = { package = "spl-token", version = "2.0.6", features = ["skip-no-mangle"] }
+thiserror = "1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

account-decoder/src/lib.rs

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

account-decoder/src/parse_account_data.rs

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

account-decoder/src/parse_config.rs

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

account-decoder/src/parse_nonce.rs

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

account-decoder/src/parse_stake.rs

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

account-decoder/src/parse_sysvar.rs

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

account-decoder/src/parse_token.rs

@@ -0,0 +1,299 @@
+use crate::{
+    parse_account_data::{ParsableAccount, ParseAccountError},
+    StringAmount,
+};
+use solana_sdk::pubkey::Pubkey;
+use spl_token_v2_0::{
+    solana_sdk::{program_option::COption, program_pack::Pack, pubkey::Pubkey as SplTokenPubkey},
+    state::{Account, AccountState, Mint, Multisig},
+};
+use std::str::FromStr;
+
+// A helper function to convert spl_token_v2_0::id() as spl_sdk::pubkey::Pubkey to
+// solana_sdk::pubkey::Pubkey
+pub fn spl_token_id_v2_0() -> Pubkey {
+    Pubkey::from_str(&spl_token_v2_0::id().to_string()).unwrap()
+}
+
+// A helper function to convert spl_token_v2_0::native_mint::id() as spl_sdk::pubkey::Pubkey to
+// solana_sdk::pubkey::Pubkey
+pub fn spl_token_v2_0_native_mint() -> Pubkey {
+    Pubkey::from_str(&spl_token_v2_0::native_mint::id().to_string()).unwrap()
+}
+
+pub fn parse_token(
+    data: &[u8],
+    mint_decimals: Option<u8>,
+) -> Result<TokenAccountType, ParseAccountError> {
+    if data.len() == Account::get_packed_len() {
+        let account = Account::unpack(data)
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
+        let decimals = mint_decimals.ok_or_else(|| {
+            ParseAccountError::AdditionalDataMissing(
+                "no mint_decimals provided to parse spl-token account".to_string(),
+            )
+        })?;
+        Ok(TokenAccountType::Account(UiTokenAccount {
+            mint: account.mint.to_string(),
+            owner: account.owner.to_string(),
+            token_amount: token_amount_to_ui_amount(account.amount, decimals),
+            delegate: match account.delegate {
+                COption::Some(pubkey) => Some(pubkey.to_string()),
+                COption::None => None,
+            },
+            state: account.state.into(),
+            is_native: account.is_native(),
+            rent_exempt_reserve: match account.is_native {
+                COption::Some(reserve) => Some(token_amount_to_ui_amount(reserve, decimals)),
+                COption::None => None,
+            },
+            delegated_amount: if account.delegate.is_none() {
+                None
+            } else {
+                Some(token_amount_to_ui_amount(
+                    account.delegated_amount,
+                    decimals,
+                ))
+            },
+            close_authority: match account.close_authority {
+                COption::Some(pubkey) => Some(pubkey.to_string()),
+                COption::None => None,
+            },
+        }))
+    } else if data.len() == Mint::get_packed_len() {
+        let mint = Mint::unpack(data)
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
+        Ok(TokenAccountType::Mint(UiMint {
+            mint_authority: match mint.mint_authority {
+                COption::Some(pubkey) => Some(pubkey.to_string()),
+                COption::None => None,
+            },
+            supply: mint.supply.to_string(),
+            decimals: mint.decimals,
+            is_initialized: mint.is_initialized,
+            freeze_authority: match mint.freeze_authority {
+                COption::Some(pubkey) => Some(pubkey.to_string()),
+                COption::None => None,
+            },
+        }))
+    } else if data.len() == Multisig::get_packed_len() {
+        let multisig = Multisig::unpack(data)
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
+        Ok(TokenAccountType::Multisig(UiMultisig {
+            num_required_signers: multisig.m,
+            num_valid_signers: multisig.n,
+            is_initialized: multisig.is_initialized,
+            signers: multisig
+                .signers
+                .iter()
+                .filter_map(|pubkey| {
+                    if pubkey != &SplTokenPubkey::default() {
+                        Some(pubkey.to_string())
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+        }))
+    } else {
+        Err(ParseAccountError::AccountNotParsable(
+            ParsableAccount::SplToken,
+        ))
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", tag = "type", content = "info")]
+pub enum TokenAccountType {
+    Account(UiTokenAccount),
+    Mint(UiMint),
+    Multisig(UiMultisig),
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiTokenAccount {
+    pub mint: String,
+    pub owner: String,
+    pub token_amount: UiTokenAmount,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delegate: Option<String>,
+    pub state: UiAccountState,
+    pub is_native: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rent_exempt_reserve: Option<UiTokenAmount>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delegated_amount: Option<UiTokenAmount>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub close_authority: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum UiAccountState {
+    Uninitialized,
+    Initialized,
+    Frozen,
+}
+
+impl From<AccountState> for UiAccountState {
+    fn from(state: AccountState) -> Self {
+        match state {
+            AccountState::Uninitialized => UiAccountState::Uninitialized,
+            AccountState::Initialized => UiAccountState::Initialized,
+            AccountState::Frozen => UiAccountState::Frozen,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiTokenAmount {
+    pub ui_amount: f64,
+    pub decimals: u8,
+    pub amount: StringAmount,
+}
+
+pub fn token_amount_to_ui_amount(amount: u64, decimals: u8) -> UiTokenAmount {
+    // Use `amount_to_ui_amount()` once spl_token is bumped to a version that supports it: https://github.com/solana-labs/solana-program-library/pull/211
+    let amount_decimals = amount as f64 / 10_usize.pow(decimals as u32) as f64;
+    UiTokenAmount {
+        ui_amount: amount_decimals,
+        decimals,
+        amount: amount.to_string(),
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiMint {
+    pub mint_authority: Option<String>,
+    pub supply: StringAmount,
+    pub decimals: u8,
+    pub is_initialized: bool,
+    pub freeze_authority: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiMultisig {
+    pub num_required_signers: u8,
+    pub num_valid_signers: u8,
+    pub is_initialized: bool,
+    pub signers: Vec<String>,
+}
+
+pub fn get_token_account_mint(data: &[u8]) -> Option<Pubkey> {
+    if data.len() == Account::get_packed_len() {
+        Some(Pubkey::new(&data[0..32]))
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_parse_token() {
+        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
+        let owner_pubkey = SplTokenPubkey::new(&[3; 32]);
+        let mut account_data = vec![0; Account::get_packed_len()];
+        let mut account = Account::unpack_unchecked(&account_data).unwrap();
+        account.mint = mint_pubkey;
+        account.owner = owner_pubkey;
+        account.amount = 42;
+        account.state = AccountState::Initialized;
+        account.is_native = COption::None;
+        account.close_authority = COption::Some(owner_pubkey);
+        Account::pack(account, &mut account_data).unwrap();
+
+        assert!(parse_token(&account_data, None).is_err());
+        assert_eq!(
+            parse_token(&account_data, Some(2)).unwrap(),
+            TokenAccountType::Account(UiTokenAccount {
+                mint: mint_pubkey.to_string(),
+                owner: owner_pubkey.to_string(),
+                token_amount: UiTokenAmount {
+                    ui_amount: 0.42,
+                    decimals: 2,
+                    amount: "42".to_string()
+                },
+                delegate: None,
+                state: UiAccountState::Initialized,
+                is_native: false,
+                rent_exempt_reserve: None,
+                delegated_amount: None,
+                close_authority: Some(owner_pubkey.to_string()),
+            }),
+        );
+
+        let mut mint_data = vec![0; Mint::get_packed_len()];
+        let mut mint = Mint::unpack_unchecked(&mint_data).unwrap();
+        mint.mint_authority = COption::Some(owner_pubkey);
+        mint.supply = 42;
+        mint.decimals = 3;
+        mint.is_initialized = true;
+        mint.freeze_authority = COption::Some(owner_pubkey);
+        Mint::pack(mint, &mut mint_data).unwrap();
+
+        assert_eq!(
+            parse_token(&mint_data, None).unwrap(),
+            TokenAccountType::Mint(UiMint {
+                mint_authority: Some(owner_pubkey.to_string()),
+                supply: 42.to_string(),
+                decimals: 3,
+                is_initialized: true,
+                freeze_authority: Some(owner_pubkey.to_string()),
+            }),
+        );
+
+        let signer1 = SplTokenPubkey::new(&[1; 32]);
+        let signer2 = SplTokenPubkey::new(&[2; 32]);
+        let signer3 = SplTokenPubkey::new(&[3; 32]);
+        let mut multisig_data = vec![0; Multisig::get_packed_len()];
+        let mut signers = [SplTokenPubkey::default(); 11];
+        signers[0] = signer1;
+        signers[1] = signer2;
+        signers[2] = signer3;
+        let mut multisig = Multisig::unpack_unchecked(&multisig_data).unwrap();
+        multisig.m = 2;
+        multisig.n = 3;
+        multisig.is_initialized = true;
+        multisig.signers = signers;
+        Multisig::pack(multisig, &mut multisig_data).unwrap();
+
+        assert_eq!(
+            parse_token(&multisig_data, None).unwrap(),
+            TokenAccountType::Multisig(UiMultisig {
+                num_required_signers: 2,
+                num_valid_signers: 3,
+                is_initialized: true,
+                signers: vec![
+                    signer1.to_string(),
+                    signer2.to_string(),
+                    signer3.to_string()
+                ],
+            }),
+        );
+
+        let bad_data = vec![0; 4];
+        assert!(parse_token(&bad_data, None).is_err());
+    }
+
+    #[test]
+    fn test_get_token_account_mint() {
+        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
+        let mut account_data = vec![0; Account::get_packed_len()];
+        let mut account = Account::unpack_unchecked(&account_data).unwrap();
+        account.mint = mint_pubkey;
+        Account::pack(account, &mut account_data).unwrap();
+
+        let expected_mint_pubkey = Pubkey::new(&[2; 32]);
+        assert_eq!(
+            get_token_account_mint(&account_data),
+            Some(expected_mint_pubkey)
+        );
+    }
+}

account-decoder/src/parse_vote.rs

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

account-decoder/src/validator_info.rs

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

accounts-bench/Cargo.toml

@@ -2,20 +2,20 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-accounts-bench"
-version = "1.1.24"
+version = "1.2.33"
 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.1.24" }
-solana-runtime = { path = "../runtime", version = "1.1.24" }
-solana-measure = { path = "../measure", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
+rayon = "1.4.0"
+solana-logger = { path = "../logger", version = "1.2.33" }
+solana-runtime = { path = "../runtime", version = "1.2.33" }
+solana-measure = { path = "../measure", version = "1.2.33" }
+solana-sdk = { path = "../sdk", version = "1.2.33" }
 rand = "0.7.0"
-clap = "2.33.0"
+clap = "2.33.1"
 crossbeam-channel = "0.4"
 
 [package.metadata.docs.rs]

accounts-bench/src/main.rs

@@ -5,7 +5,7 @@ use solana_runtime::{
     accounts::{create_test_accounts, update_accounts, Accounts},
     accounts_index::Ancestors,
 };
-use solana_sdk::pubkey::Pubkey;
+use solana_sdk::{genesis_config::OperatingMode, pubkey::Pubkey};
 use std::fs;
 use std::path::PathBuf;
 
@@ -54,7 +54,7 @@ fn main() {
     if fs::remove_dir_all(path.clone()).is_err() {
         println!("Warning: Couldn't remove {:?}", path);
     }
-    let accounts = Accounts::new(vec![path]);
+    let accounts = Accounts::new(vec![path], OperatingMode::Preview);
     println!("Creating {} accounts", num_accounts);
     let mut create_time = Measure::start("create accounts");
     let pubkeys: Vec<_> = (0..num_slots)

archiver-lib/Cargo.toml

@@ -1,43 +0,0 @@
-[package]
-name = "solana-archiver-lib"
-version = "1.1.24"
-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.4"
-ed25519-dalek = "=1.0.0-pre.3"
-log = "0.4.8"
-rand = "0.7.0"
-rand_chacha = "0.2.2"
-solana-client = { path = "../client", version = "1.1.24" }
-solana-storage-program = { path = "../programs/storage", version = "1.1.24" }
-thiserror = "1.0"
-serde = "1.0.105"
-serde_json = "1.0.48"
-serde_derive = "1.0.103"
-solana-net-utils = { path = "../net-utils", version = "1.1.24" }
-solana-chacha = { path = "../chacha", version = "1.1.24" }
-solana-chacha-sys = { path = "../chacha-sys", version = "1.1.24" }
-solana-ledger = { path = "../ledger", version = "1.1.24" }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-perf = { path = "../perf", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
-solana-core = { path = "../core", version = "1.1.24" }
-solana-streamer = { path = "../streamer", version = "1.1.24" }
-solana-archiver-utils = { path = "../archiver-utils", version = "1.1.24" }
-solana-metrics = { path = "../metrics", version = "1.1.24" }
-
-[dev-dependencies]
-hex = "0.4.2"
-
-[lib]
-name = "solana_archiver_lib"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

archiver-lib/src/archiver.rs

@@ -1,916 +0,0 @@
-use crate::result::ArchiverError;
-use crossbeam_channel::unbounded;
-use rand::{thread_rng, Rng};
-use rand_chacha::{rand_core::SeedableRng, 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},
-    cluster_slots::ClusterSlots,
-    contact_info::ContactInfo,
-    gossip_service::GossipService,
-    repair_service::{self, RepairService, RepairSlotRange, RepairStats, RepairStrategy},
-    serve_repair::ServeRepair,
-    shred_fetch_stage::ShredFetchStage,
-    sigverify_stage::{DisabledSigVerifier, SigVerifyStage},
-    storage_stage::NUM_STORAGE_SAMPLES,
-    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::packet::{limited_deserialize, PACKET_DATA_SIZE};
-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 solana_streamer::streamer::{receiver, responder, PacketReceiver};
-use std::{
-    io::{self, ErrorKind},
-    net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
-    path::{Path, PathBuf},
-    result,
-    sync::atomic::{AtomicBool, Ordering},
-    sync::mpsc::{channel, Receiver, Sender},
-    sync::Arc,
-    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 cluster_info = ClusterInfo::new(node.info.clone(), keypair.clone());
-        cluster_info.set_entrypoint(cluster_entrypoint.clone());
-        let cluster_info = Arc::new(cluster_info);
-        let cluster_slots = Arc::new(ClusterSlots::default());
-        // 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, 2) {
-                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)
-        {
-            //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,
-            None,
-            &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,
-                    cluster_slots,
-                ) {
-                    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<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,
-            );
-        }
-        exit.store(true, Ordering::Relaxed);
-    }
-
-    fn redeem_rewards(
-        cluster_info: &ClusterInfo,
-        archiver_keypair: &Arc<Keypair>,
-        storage_keypair: &Arc<Keypair>,
-        client_commitment: CommitmentConfig,
-    ) {
-        let nodes = cluster_info.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)
-        {
-            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(&[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.
-    #[allow(clippy::too_many_arguments)]
-    fn setup(
-        meta: &mut ArchiverMeta,
-        cluster_info: Arc<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>,
-        cluster_slots: Arc<ClusterSlots>,
-    ) -> Result<WindowService> {
-        let slots_per_segment =
-            match Self::get_segment_config(&cluster_info, meta.client_commitment) {
-                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,
-            cluster_slots,
-        );
-        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<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.my_shred_version();
-        cluster_info.update_contact_info(|current| *current = 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,
-        )? == 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);
-        if balance.is_err() || balance.unwrap() == 0 {
-            let blockhash = match client.get_recent_blockhash_with_commitment(client_commitment) {
-                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",
-                    ),
-                    TransportError::Custom(e) => io::Error::new(ErrorKind::Other, e),
-                })?;
-        }
-        Ok(())
-    }
-
-    fn submit_mining_proof(
-        meta: &ArchiverMeta,
-        cluster_info: &ClusterInfo,
-        archiver_keypair: &Arc<Keypair>,
-        storage_keypair: &Arc<Keypair>,
-    ) {
-        // No point if we've got no storage account...
-        let nodes = cluster_info.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);
-        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);
-        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) {
-            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(&[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: &ClusterInfo,
-        client_commitment: CommitmentConfig,
-    ) -> Result<u64> {
-        let rpc_peers = 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::<u64>(
-                    RpcRequest::GetSlotsPerSegment,
-                    serde_json::json!([client_commitment]),
-                )
-                .unwrap())
-        } else {
-            Err(ArchiverError::NoRpcPeers)
-        }
-    }
-
-    /// Waits until the first segment is ready, and returns the current segment
-    fn poll_for_segment(
-        cluster_info: &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: &ClusterInfo,
-        slots_per_segment: u64,
-        previous_blockhash: &Hash,
-        exit: &Arc<AtomicBool>,
-    ) -> Result<(Hash, u64)> {
-        info!("waiting for the next turn...");
-        loop {
-            let rpc_peers = 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 RpcStorageTurn {
-                    blockhash: storage_blockhash,
-                    slot: turn_slot,
-                } = rpc_client.send(RpcRequest::GetStorageTurn, serde_json::value::Value::Null)?;
-                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> {
-        let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
-        // Create a client which downloads from the archiver and see that it
-        // can respond with shreds.
-        let start_slot = Self::get_archiver_segment_slot(ip_addr, 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(ip_addr, 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,
-            );
-            let mut repair_stats = RepairStats::default();
-            //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, &mut repair_stats, Some(0))
-                            .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(bind_ip_addr: IpAddr, to: SocketAddr) -> u64 {
-        let (_port, socket) = bind_in_range(bind_ip_addr, 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!");
-    }
-}

archiver-lib/src/lib.rs

@@ -1,11 +0,0 @@
-#[macro_use]
-extern crate log;
-
-#[macro_use]
-extern crate serde_derive;
-
-#[macro_use]
-extern crate solana_metrics;
-
-pub mod archiver;
-mod result;

archiver-lib/src/result.rs

@@ -1,47 +0,0 @@
-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)
-    }
-}

archiver-utils/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "solana-archiver-utils"
-version = "1.1.24"
-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.7.0"
-solana-chacha = { path = "../chacha", version = "1.1.24" }
-solana-chacha-sys = { path = "../chacha-sys", version = "1.1.24" }
-solana-ledger = { path = "../ledger", version = "1.1.24" }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-perf = { path = "../perf", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
-
-[dev-dependencies]
-hex = "0.4.2"
-
-[lib]
-name = "solana_archiver_utils"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

archiver-utils/src/lib.rs

@@ -1,120 +0,0 @@
-#[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());
-    }
-}

archiver/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.com>"]
-edition = "2018"
-name = "solana-archiver"
-version = "1.1.24"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-
-[dependencies]
-clap = "2.33.0"
-console = "0.10.0"
-solana-clap-utils = { path = "../clap-utils", version = "1.1.24" }
-solana-core = { path = "../core", version = "1.1.24" }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-metrics = { path = "../metrics", version = "1.1.24" }
-solana-archiver-lib = { path = "../archiver-lib", version = "1.1.24" }
-solana-net-utils = { path = "../net-utils", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
-
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

archiver/src/main.rs

@@ -1,131 +0,0 @@
-use clap::{crate_description, crate_name, App, Arg};
-use console::style;
-use solana_archiver_lib::archiver::Archiver;
-use solana_clap_utils::{
-    input_parsers::keypair_of, input_validators::is_keypair_or_ask_keyword,
-    keypair::SKIP_SEED_PHRASE_VALIDATION_ARG,
-};
-use solana_core::{
-    cluster_info::{Node, VALIDATOR_PORT_RANGE},
-    contact_info::ContactInfo,
-};
-use solana_sdk::{
-    commitment_config::CommitmentConfig,
-    signature::{Keypair, Signer},
-};
-use std::{
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    path::PathBuf,
-    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")
-                .value_name("PATH")
-                .takes_value(true)
-                .validator(is_keypair_or_ask_keyword)
-                .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_or_ask_keyword)
-                .help("File containing the storage account keypair"),
-        )
-        .arg(
-            Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
-                .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
-                .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
-        )
-        .get_matches();
-
-    let ledger_path = PathBuf::from(matches.value_of("ledger").unwrap());
-
-    let identity_keypair = keypair_of(&matches, "identity_keypair").unwrap_or_else(Keypair::new);
-
-    let storage_keypair = keypair_of(&matches, "storage_keypair").unwrap_or_else(|| {
-        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,
-        IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
-    );
-
-    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();
-}

banking-bench/Cargo.toml

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

banking-bench/src/main.rs

@@ -169,7 +169,7 @@ 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(0, bank0);
+    let mut bank_forks = BankForks::new(bank0);
     let mut bank = bank_forks.working_bank();
 
     info!("threads: {} txs: {}", num_threads, total_num_transactions);

bench-exchange/Cargo.toml

@@ -2,36 +2,37 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-exchange"
-version = "1.1.24"
+version = "1.2.33"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 publish = false
 
 [dependencies]
-clap = "2.32.0"
+clap = "2.33.1"
 itertools = "0.9.0"
 log = "0.4.8"
 num-derive = "0.3"
 num-traits = "0.2"
 rand = "0.7.0"
-rayon = "1.3.0"
-serde_json = "1.0.48"
-serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "1.1.24" }
-solana-core = { path = "../core", version = "1.1.24" }
-solana-genesis = { path = "../genesis", version = "1.1.24" }
-solana-client = { path = "../client", version = "1.1.24" }
-solana-faucet = { path = "../faucet", version = "1.1.24" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.1.24" }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-metrics = { path = "../metrics", version = "1.1.24" }
-solana-net-utils = { path = "../net-utils", version = "1.1.24" }
-solana-runtime = { path = "../runtime", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
+rayon = "1.4.0"
+serde_json = "1.0.53"
+serde_yaml = "0.8.12"
+solana-clap-utils = { path = "../clap-utils", version = "1.2.33" }
+solana-core = { path = "../core", version = "1.2.33" }
+solana-genesis = { path = "../genesis", version = "1.2.33" }
+solana-client = { path = "../client", version = "1.2.33" }
+solana-faucet = { path = "../faucet", version = "1.2.33" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.2.33" }
+solana-logger = { path = "../logger", version = "1.2.33" }
+solana-metrics = { path = "../metrics", version = "1.2.33" }
+solana-net-utils = { path = "../net-utils", version = "1.2.33" }
+solana-runtime = { path = "../runtime", version = "1.2.33" }
+solana-sdk = { path = "../sdk", version = "1.2.33" }
+solana-version = { path = "../version", version = "1.2.33" }
 
 [dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.1.24" }
+solana-local-cluster = { path = "../local-cluster", version = "1.2.33" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-exchange/src/bench.rs

@@ -14,6 +14,7 @@ use solana_metrics::datapoint_info;
 use solana_sdk::{
     client::{Client, SyncClient},
     commitment_config::CommitmentConfig,
+    message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     timing::{duration_as_ms, duration_as_s},
@@ -449,7 +450,7 @@ fn swapper<T>(
             }
             account_group = (account_group + 1) % account_groups as usize;
 
-            let (blockhash, _fee_calculator) = client
+            let (blockhash, _fee_calculator, _last_valid_slot) = client
                 .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                 .expect("Failed to get blockhash");
             let to_swap_txs: Vec<_> = to_swap
@@ -457,16 +458,14 @@ fn swapper<T>(
                 .map(|(signer, swap, profit)| {
                     let s: &Keypair = &signer;
                     let owner = &signer.pubkey();
-                    Transaction::new_signed_instructions(
-                        &[s],
-                        vec![exchange_instruction::swap_request(
-                            owner,
-                            &swap.0.pubkey,
-                            &swap.1.pubkey,
-                            &profit,
-                        )],
-                        blockhash,
-                    )
+                    let instruction = exchange_instruction::swap_request(
+                        owner,
+                        &swap.0.pubkey,
+                        &swap.1.pubkey,
+                        &profit,
+                    );
+                    let message = Message::new(&[instruction], Some(&s.pubkey()));
+                    Transaction::new(&[s], message, blockhash)
                 })
                 .collect();
 
@@ -577,7 +576,7 @@ fn trader<T>(
         }
         account_group = (account_group + 1) % account_groups as usize;
 
-        let (blockhash, _fee_calculator) = client
+        let (blockhash, _fee_calculator, _last_valid_slot) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
 
@@ -588,28 +587,26 @@ fn trader<T>(
                     let owner_pubkey = &owner.pubkey();
                     let trade_pubkey = &trade.pubkey();
                     let space = mem::size_of::<ExchangeState>() as u64;
-                    Transaction::new_signed_instructions(
-                        &[owner.as_ref(), trade],
-                        vec![
-                            system_instruction::create_account(
-                                owner_pubkey,
-                                trade_pubkey,
-                                1,
-                                space,
-                                &id(),
-                            ),
-                            exchange_instruction::trade_request(
-                                owner_pubkey,
-                                trade_pubkey,
-                                *side,
-                                pair,
-                                tokens,
-                                price,
-                                src,
-                            ),
-                        ],
-                        blockhash,
-                    )
+                    let instructions = [
+                        system_instruction::create_account(
+                            owner_pubkey,
+                            trade_pubkey,
+                            1,
+                            space,
+                            &id(),
+                        ),
+                        exchange_instruction::trade_request(
+                            owner_pubkey,
+                            trade_pubkey,
+                            *side,
+                            pair,
+                            tokens,
+                            price,
+                            src,
+                        ),
+                    ];
+                    let message = Message::new(&instructions, Some(&owner_pubkey));
+                    Transaction::new(&[owner.as_ref(), trade], message, blockhash)
                 })
                 .collect();
 
@@ -747,22 +744,19 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
             let mut to_fund_txs: Vec<_> = chunk
                 .par_iter()
                 .map(|(k, m)| {
-                    (
-                        k.clone(),
-                        Transaction::new_unsigned_instructions(system_instruction::transfer_many(
-                            &k.pubkey(),
-                            &m,
-                        )),
-                    )
+                    let instructions = system_instruction::transfer_many(&k.pubkey(), &m);
+                    let message = Message::new(&instructions, Some(&k.pubkey()));
+                    (k.clone(), Transaction::new_unsigned(message))
                 })
                 .collect();
 
             let mut retries = 0;
             let amount = chunk[0].1[0].1;
             while !to_fund_txs.is_empty() {
-                let receivers = to_fund_txs
+                let receivers: usize = to_fund_txs
                     .iter()
-                    .fold(0, |len, (_, tx)| len + tx.message().instructions.len());
+                    .map(|(_, tx)| tx.message().instructions.len())
+                    .sum();
 
                 debug!(
                     "  {} to {} in {} txs",
@@ -775,7 +769,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
                     to_fund_txs.len(),
                 );
 
-                let (blockhash, _fee_calculator) = client
+                let (blockhash, _fee_calculator, _last_valid_slot) = client
                     .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("blockhash");
                 to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
@@ -847,16 +841,18 @@ pub fn create_token_accounts<T: Client>(
                     );
                     let request_ix =
                         exchange_instruction::account_request(owner_pubkey, &new_keypair.pubkey());
+                    let message = Message::new(&[create_ix, request_ix], Some(&owner_pubkey));
                     (
                         (from_keypair, new_keypair),
-                        Transaction::new_unsigned_instructions(vec![create_ix, request_ix]),
+                        Transaction::new_unsigned(message),
                     )
                 })
                 .collect();
 
-            let accounts = to_create_txs
+            let accounts: usize = to_create_txs
                 .iter()
-                .fold(0, |len, (_, tx)| len + tx.message().instructions.len() / 2);
+                .map(|(_, tx)| tx.message().instructions.len() / 2)
+                .sum();
 
             debug!(
                 "  Creating {} accounts in {} txs",
@@ -866,7 +862,7 @@ pub fn create_token_accounts<T: Client>(
 
             let mut retries = 0;
             while !to_create_txs.is_empty() {
-                let (blockhash, _fee_calculator) = client
+                let (blockhash, _fee_calculator, _last_valid_slot) = client
                     .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("Failed to get blockhash");
                 to_create_txs
@@ -995,7 +991,7 @@ pub fn airdrop_lamports<T: Client>(
 
     let mut tries = 0;
     loop {
-        let (blockhash, _fee_calculator) = client
+        let (blockhash, _fee_calculator, _last_valid_slot) = client
             .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
         match request_airdrop_transaction(&faucet_addr, &id.pubkey(), amount_to_drop, blockhash) {

bench-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_clap_utils::version!()).get_matches();
+    let matches = cli::build_args(solana_version::version!()).get_matches();
     let cli_config = cli::extract_args(&matches);
 
     let cli::Config {
@@ -54,10 +54,9 @@ fn main() {
         );
     } else {
         info!("Connecting to the cluster");
-        let (nodes, _archivers) =
-            discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
-                panic!("Failed to discover nodes");
-            });
+        let nodes = discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
+            panic!("Failed to discover nodes");
+        });
 
         let (client, num_clients) = get_multi_client(&nodes);
 

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_static_program("exchange_program", id(), process_instruction);
+    bank.add_builtin_program("exchange_program", id(), process_instruction);
     let clients = vec![BankClient::new(bank)];
 
     let mut config = Config::default();

bench-streamer/Cargo.toml

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

bench-streamer/src/main.rs

@@ -27,7 +27,7 @@ fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
         let mut num = 0;
         for p in &msgs.packets {
             let a = p.meta.addr();
-            assert!(p.meta.size < PACKET_DATA_SIZE);
+            assert!(p.meta.size <= PACKET_DATA_SIZE);
             send.send_to(&p.data[..p.meta.size], &a).unwrap();
             num += 1;
         }
@@ -52,7 +52,7 @@ fn main() -> Result<()> {
 
     let matches = App::new(crate_name!())
         .about(crate_description!())
-        .version(solana_clap_utils::version!())
+        .version(solana_version::version!())
         .arg(
             Arg::with_name("num-recv-sockets")
                 .long("num-recv-sockets")

bench-tps/Cargo.toml

@@ -2,39 +2,35 @@
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.1.24"
+version = "1.2.33"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
 
 [dependencies]
-bincode = "1.2.1"
-clap = "2.33.0"
+bincode = "1.3.1"
+clap = "2.33.1"
 log = "0.4.8"
-rayon = "1.3.0"
-serde_json = "1.0.48"
-serde_yaml = "0.8.11"
-solana-clap-utils = { path = "../clap-utils", version = "1.1.24" }
-solana-core = { path = "../core", version = "1.1.24" }
-solana-genesis = { path = "../genesis", version = "1.1.24" }
-solana-client = { path = "../client", version = "1.1.24" }
-solana-faucet = { path = "../faucet", version = "1.1.24" }
-#solana-librapay = { path = "../programs/librapay", version = "1.1.8", optional = true }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-metrics = { path = "../metrics", version = "1.1.24" }
-solana-measure = { path = "../measure", version = "1.1.24" }
-solana-net-utils = { path = "../net-utils", version = "1.1.24" }
-solana-runtime = { path = "../runtime", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
-#solana-move-loader-program = { path = "../programs/move_loader", version = "1.1.8", optional = true }
+rayon = "1.4.0"
+serde_json = "1.0.53"
+serde_yaml = "0.8.12"
+solana-clap-utils = { path = "../clap-utils", version = "1.2.33" }
+solana-core = { path = "../core", version = "1.2.33" }
+solana-genesis = { path = "../genesis", version = "1.2.33" }
+solana-client = { path = "../client", version = "1.2.33" }
+solana-faucet = { path = "../faucet", version = "1.2.33" }
+solana-logger = { path = "../logger", version = "1.2.33" }
+solana-metrics = { path = "../metrics", version = "1.2.33" }
+solana-measure = { path = "../measure", version = "1.2.33" }
+solana-net-utils = { path = "../net-utils", version = "1.2.33" }
+solana-runtime = { path = "../runtime", version = "1.2.33" }
+solana-sdk = { path = "../sdk", version = "1.2.33" }
+solana-version = { path = "../version", version = "1.2.33" }
 
 [dev-dependencies]
 serial_test = "0.4.0"
 serial_test_derive = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "1.1.24" }
-
-#[features]
-#move = ["solana-librapay", "solana-move-loader-program"]
+solana-local-cluster = { path = "../local-cluster", version = "1.2.33" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

bench-tps/src/bench.rs

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

bench-tps/src/cli.rs

@@ -23,8 +23,8 @@ pub struct Config {
     pub read_from_client_file: bool,
     pub target_lamports_per_signature: u64,
     pub multi_client: bool,
-    pub use_move: bool,
     pub num_lamports_per_account: u64,
+    pub target_slots_per_epoch: u64,
 }
 
 impl Default for Config {
@@ -45,8 +45,8 @@ impl Default for Config {
             read_from_client_file: false,
             target_lamports_per_signature: FeeRateGovernor::default().target_lamports_per_signature,
             multi_client: true,
-            use_move: false,
             num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
+            target_slots_per_epoch: 0,
         }
     }
 }
@@ -107,11 +107,6 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                 .long("sustained")
                 .help("Use sustained performance mode vs. peak mode. This overlaps the tx generation with transfers."),
         )
-        .arg(
-            Arg::with_name("use-move")
-                .long("use-move")
-                .help("Use Move language transactions to perform transfers."),
-        )
         .arg(
             Arg::with_name("no-multi-client")
                 .long("no-multi-client")
@@ -172,6 +167,15 @@ 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`
@@ -252,12 +256,18 @@ pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
         args.target_lamports_per_signature = v.to_string().parse().expect("can't parse lamports");
     }
 
-    args.use_move = matches.is_present("use-move");
     args.multi_client = !matches.is_present("no-multi-client");
 
     if let Some(v) = matches.value_of("num_lamports_per_account") {
         args.num_lamports_per_account = v.to_string().parse().expect("can't parse lamports");
     }
 
+    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
 }

bench-tps/src/main.rs

@@ -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_clap_utils::version!()).get_matches();
+    let matches = cli::build_args(solana_version::version!()).get_matches();
     let cli_config = cli::extract_args(&matches);
 
     let cli::Config {
@@ -29,7 +29,6 @@ fn main() {
         write_to_client_file,
         read_from_client_file,
         target_lamports_per_signature,
-        use_move,
         multi_client,
         num_lamports_per_account,
         ..
@@ -67,11 +66,10 @@ fn main() {
     }
 
     info!("Connecting to the cluster");
-    let (nodes, _archivers) =
-        discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
-            eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
-            exit(1);
-        });
+    let nodes = discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
+        eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
+        exit(1);
+    });
 
     let client = if *multi_client {
         let (client, num_clients) = get_multi_client(&nodes);
@@ -87,7 +85,7 @@ fn main() {
         Arc::new(get_client(&nodes))
     };
 
-    let (keypairs, move_keypairs) = if *read_from_client_file && !use_move {
+    let keypairs = if *read_from_client_file {
         let path = Path::new(&client_ids_and_stake_file);
         let file = File::open(path).unwrap();
 
@@ -116,8 +114,8 @@ fn main() {
         // Sort keypairs so that do_bench_tps() uses the same subset of accounts for each run.
         // This prevents the amount of storage needed for bench-tps accounts from creeping up
         // across multiple runs.
-        keypairs.sort_by(|x, y| x.pubkey().to_string().cmp(&y.pubkey().to_string()));
-        (keypairs, None)
+        keypairs.sort_by_key(|x| x.pubkey().to_string());
+        keypairs
     } else {
         generate_and_fund_keypairs(
             client.clone(),
@@ -125,7 +123,6 @@ fn main() {
             &id,
             keypair_count,
             *num_lamports_per_account,
-            *use_move,
         )
         .unwrap_or_else(|e| {
             eprintln!("Error could not fund keys: {:?}", e);
@@ -133,5 +130,5 @@ fn main() {
         })
     };
 
-    do_bench_tps(client, cli_config, keypairs, move_keypairs);
+    do_bench_tps(client, cli_config, keypairs);
 }

bench-tps/tests/bench_tps.rs

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

chacha-cuda/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "solana-chacha-cuda"
-version = "1.1.24"
-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.1.24" }
-solana-chacha = { path = "../chacha", version = "1.1.24" }
-solana-ledger = { path = "../ledger", version = "1.1.24" }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-perf = { path = "../perf", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
-
-[dev-dependencies]
-hex-literal = "0.2.1"
-
-[lib]
-name = "solana_chacha_cuda"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

chacha-cuda/src/chacha_cuda.rs

@@ -1,280 +0,0 @@
-// 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());
-    }
-}

chacha-cuda/src/lib.rs

@@ -1,8 +0,0 @@
-#[macro_use]
-extern crate log;
-
-#[cfg(test)]
-#[macro_use]
-extern crate hex_literal;
-
-pub mod chacha_cuda;

chacha-sys/.gitignore

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

chacha-sys/build.rs

@@ -1,8 +0,0 @@
-extern crate cc;
-
-fn main() {
-    cc::Build::new()
-        .file("cpu-crypt/chacha20_core.c")
-        .file("cpu-crypt/chacha_cbc.c")
-        .compile("libcpu-crypt");
-}

chacha-sys/cpu-crypt/.gitignore

@@ -1 +0,0 @@
-release/

chacha-sys/cpu-crypt/Makefile

@@ -1,25 +0,0 @@
-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

chacha-sys/cpu-crypt/chacha.h

@@ -1,35 +0,0 @@
-#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

chacha-sys/cpu-crypt/chacha20_core.c

@@ -1,102 +0,0 @@
-#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]++;
-  }
-}
-
-

chacha-sys/cpu-crypt/chacha_cbc.c

@@ -1,72 +0,0 @@
-#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);
-}

chacha-sys/src/lib.rs

@@ -1,21 +0,0 @@
-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(),
-        );
-    }
-}

chacha/.gitignore

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

chacha/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "solana-chacha"
-version = "1.1.24"
-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.7.0"
-rand_chacha = "0.2.2"
-solana-chacha-sys = { path = "../chacha-sys", version = "1.1.24" }
-solana-ledger = { path = "../ledger", version = "1.1.24" }
-solana-logger = { path = "../logger", version = "1.1.24" }
-solana-perf = { path = "../perf", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
-
-[dev-dependencies]
-hex-literal = "0.2.1"
-
-[lib]
-name = "solana_chacha"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

chacha/src/chacha.rs

@@ -1,185 +0,0 @@
-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();
-    }
-}

chacha/src/lib.rs

@@ -1,8 +0,0 @@
-#[macro_use]
-extern crate log;
-
-#[cfg(test)]
-#[macro_use]
-extern crate hex_literal;
-
-pub mod chacha;

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,9 +12,52 @@ 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
 
-### Buildkite Azure Setup
+## 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
 
 Create a new Azure-based "queue=default" agent by running the following command:
 ```
@@ -35,7 +78,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
@@ -48,12 +91,7 @@ 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
 
-## 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
+## Buildkite AWS CloudFormation Setup
 
 **AWS CloudFormation is currently inactive, although it may be restored in the
 future**
@@ -62,7 +100,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:
@@ -84,13 +122,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.

ci/buildkite-pipeline.sh

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

ci/buildkite-secondary.yml

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

ci/buildkite.yml

@@ -8,6 +8,19 @@ 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_audit_docker_image ci/test-audit.sh"
+    name: "audit"
+    timeout_in_minutes: 20
+
+  - wait
+
   - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-checks.sh"
     name: "checks"
     timeout_in_minutes: 20

ci/channel-info.sh

@@ -89,11 +89,17 @@ BETA_CHANNEL_LATEST_TAG=${beta_tag:+v$beta_tag}
 STABLE_CHANNEL_LATEST_TAG=${stable_tag:+v$stable_tag}
 
 
-if [[ $CI_BRANCH = "$STABLE_CHANNEL" ]]; then
+if [[ -n $CI_BASE_BRANCH ]]; then
+  BRANCH="$CI_BASE_BRANCH"
+elif [[ -n $CI_BRANCH ]]; then
+  BRANCH="$CI_BRANCH"
+fi
+
+if [[ $BRANCH = "$STABLE_CHANNEL" ]]; then
   CHANNEL=stable
-elif [[ $CI_BRANCH = "$EDGE_CHANNEL" ]]; then
+elif [[ $BRANCH = "$EDGE_CHANNEL" ]]; then
   CHANNEL=edge
-elif [[ $CI_BRANCH = "$BETA_CHANNEL" ]]; then
+elif [[ $BRANCH = "$BETA_CHANNEL" ]]; then
   CHANNEL=beta
 fi
 

ci/dependabot-pr.sh

@@ -0,0 +1,36 @@
+#!/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

ci/dependabot-updater.sh

@@ -0,0 +1,35 @@
+#!/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

ci/docker-run.sh

@@ -67,6 +67,7 @@ ARGS+=(
   --env BUILDKITE_JOB_ID
   --env CI
   --env CI_BRANCH
+  --env CI_BASE_BRANCH
   --env CI_TAG
   --env CI_BUILD_ID
   --env CI_COMMIT

ci/env.sh

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

ci/iterations-localnet.sh

@@ -1,61 +0,0 @@
-#!/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"

ci/localnet-sanity.sh

@@ -73,16 +73,15 @@ 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-node1.log \
+    --init-complete-file init-complete-node0.log \
     --dynamic-port-range 8000-8050"
   "multinode-demo/validator.sh \
     --enable-rpc-exit \
     --no-restart \
     --dynamic-port-range 8050-8100
-    --init-complete-file init-complete-node2.log \
+    --init-complete-file init-complete-node1.log \
     --rpc-port 18899"
 )
 
@@ -95,7 +94,7 @@ if [[ extraNodes -gt 0 ]]; then
         --no-restart \
         --dynamic-port-range $portStart-$portEnd
         --label dyn$i \
-        --init-complete-file init-complete-node$((2 + i)).log"
+        --init-complete-file init-complete-node$((1 + i)).log"
     )
   done
 fi
@@ -160,11 +159,10 @@ startNodes() {
   for i in $(seq 0 $((${#nodes[@]} - 1))); do
     declare cmd=${nodes[$i]}
 
-    if [[ "$i" -ne 0 ]]; then # 0 == faucet, skip it
-      declare initCompleteFile="init-complete-node$i.log"
-      rm -f "$initCompleteFile"
-      initCompleteFiles+=("$initCompleteFile")
-    fi
+    declare initCompleteFile="init-complete-node$i.log"
+    rm -f "$initCompleteFile"
+    initCompleteFiles+=("$initCompleteFile")
+
     startNode "$i" "$cmd $maybeExpectedGenesisHash"
     if $addLogs; then
       logs+=("$(getNodeLogFile "$i" "$cmd")")

ci/publish-docs.sh

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$0")/.."
-
-me=$(basename "$0")
-
-echo --- update gitbook-cage
-if [[ -n $CI_BRANCH ]]; then
-  (
-    set -x
-    (
-      . ci/rust-version.sh stable
-      ci/docker-run.sh "$rust_stable_docker_image" make -C docs
-    )
-    # make a local commit for the svgs and generated/updated markdown
-    git add -f docs/src
-    if ! git diff-index --quiet HEAD; then
-      git config user.email maintainers@solana.com
-      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
-      git reset --hard HEAD~
-    fi
-  )
-else
-  echo CI_BRANCH not set
-fi
-
-exit 0

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

ci/run-sanity.sh

@@ -7,7 +7,7 @@ source multinode-demo/common.sh
 
 rm -rf config/run/init-completed config/ledger config/snapshot-ledger
 
-timeout 15 ./run.sh &
+timeout 120 ./run.sh &
 pid=$!
 
 attempts=20

ci/rust-version.sh

@@ -34,6 +34,9 @@ export rust_stable_docker_image=solanalabs/rust:"$stable_version"
 export rust_nightly=nightly-"$nightly_version"
 export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
 
+export rust_audit="1.46.0"
+export rust_audit_docker_image=solanalabs/rust-nightly:2020-08-17
+
 [[ -z $1 ]] || (
 
   rustup_install() {
@@ -47,6 +50,9 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
   set -e
   cd "$(dirname "${BASH_SOURCE[0]}")"
   case $1 in
+  audit)
+     rustup_install "$rust_audit"
+     ;;
   stable)
      rustup_install "$rust_stable"
      ;;
@@ -56,6 +62,7 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
   all)
      rustup_install "$rust_stable"
      rustup_install "$rust_nightly"
+     rustup_install "$rust_audit"
     ;;
   *)
     echo "Note: ignoring unknown argument: $1"

ci/semver_bash/README.md

@@ -27,5 +27,5 @@ Alternatively, you can source it from within a script:
     local PATCH=0  
     local SPECIAL=""
     
-    semverParseInto "1.2.3" MAJOR MINOR PATCH SPECIAL  
+    semverParseInto "1.2.33" MAJOR MINOR PATCH SPECIAL
     semverParseInto "3.2.1" MAJOR MINOR PATCH SPECIAL

ci/setup-new-buildkite-agent/disable-networkd-wait.sh

@@ -2,7 +2,7 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1

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

@@ -2,7 +2,7 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1

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

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+sudo systemctl daemon-reload
+sudo systemctl enable --now buildkite-agent

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

@@ -2,7 +2,7 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1

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

@@ -0,0 +1,84 @@
+#!/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=500000
+
+[Install]
+WantedBy=multi-user.target
+DefaultInstance=1
+EOF

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

@@ -2,12 +2,13 @@
 
 # https://developer.nvidia.com/cuda-toolkit-archive
 VERSIONS=()
-VERSIONS+=("https://developer.nvidia.com/compute/cuda/10.0/Prod/local_installers/cuda_10.0.130_410.48_linux")
-VERSIONS+=("https://developer.nvidia.com/compute/cuda/10.1/Prod/local_installers/cuda_10.1.168_418.67_linux.run")
+#VERSIONS+=("https://developer.nvidia.com/compute/cuda/10.0/Prod/local_installers/cuda_10.0.130_410.48_linux")
+#VERSIONS+=("https://developer.nvidia.com/compute/cuda/10.1/Prod/local_installers/cuda_10.1.168_418.67_linux.run")
+VERSIONS+=("http://developer.download.nvidia.com/compute/cuda/10.2/Prod/local_installers/cuda_10.2.89_440.33.01_linux.run")
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1
@@ -51,3 +52,14 @@ done
 
 # Allow normal users to use CUDA profiler
 echo 'options nvidia "NVreg_RestrictProfilingToAdminUsers=0"' > /etc/modprobe.d/nvidia-enable-user-profiling.conf
+
+# setup persistence mode across reboots
+TMPDIR="$(mktemp -d)"
+if pushd "$TMPDIR"; then
+  tar -xvf /usr/share/doc/NVIDIA_GLX-1.0/samples/nvidia-persistenced-init.tar.bz2
+  ./nvidia-persistenced-init/install.sh systemd
+  popd
+  rm -rf "$TMPDIR"
+fi
+
+nvidia-smi -pm ENABLED

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+HERE="$(dirname "$0")"
+
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
+source "$HERE"/utils.sh
+
+ensure_env || exit 1
+
+# Allow more files to be opened by a user
+echo "* - nofile 500000" > /etc/security/limits.d/90-solana-nofiles.conf
+

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

@@ -0,0 +1,49 @@
+#!/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

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

@@ -2,12 +2,12 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1
 
-set -xe
+set -ex
 
 "$HERE"/disable-nouveau.sh
 "$HERE"/disable-networkd-wait.sh

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

@@ -2,7 +2,7 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1

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

@@ -2,7 +2,7 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1

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

@@ -2,7 +2,7 @@
 
 HERE="$(dirname "$0")"
 
-# shellcheck source=net/datacenter-node-install/utils.sh
+# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
 source "$HERE"/utils.sh
 
 ensure_env || exit 1

ci/test-audit.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -e
+
+source ci/_
+source ci/rust-version.sh audit
+
+export RUST_BACKTRACE=1
+export RUSTFLAGS="-D warnings"
+
+_ cargo +"$rust_audit" audit --version
+_ scripts/cargo-for-all-lock-files.sh +"$rust_audit" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008

ci/test-checks.sh

@@ -6,26 +6,35 @@ cd "$(dirname "$0")/.."
 source ci/_
 source ci/rust-version.sh stable
 source ci/rust-version.sh nightly
+eval "$(ci/channel-info.sh)"
 
 export RUST_BACKTRACE=1
 export RUSTFLAGS="-D warnings"
 
+
+# Only force up-to-date lock files on edge
+if [[ $CI_BASE_BRANCH = "$EDGE_CHANNEL" ]]; then
+  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
+else
+  echo "Note: cargo-for-all-lock-files.sh skipped because $CI_BASE_BRANCH != $EDGE_CHANNEL"
+fi
+
 _ 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 --all --exclude solana-sdk-c -- --deny=warnings
-_ cargo +"$rust_stable" clippy --manifest-path sdk-c/Cargo.toml -- --deny=warnings
+_ cargo +"$rust_stable" clippy --workspace -- --deny=warnings
 
-_ cargo +"$rust_stable" audit --version
-_ cargo +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008
 _ ci/order-crates-for-publishing.py
-_ docs/build.sh
 
 {
   cd programs/bpf
-  _ cargo +"$rust_stable" audit
   for project in rust/*/ ; do
     echo "+++ do_bpf_checks $project"
     (

ci/test-move.sh

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

ci/test-sanity.sh

@@ -10,13 +10,8 @@ source ci/_
   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
+  git fetch origin "$CI_BASE_BRANCH"
+  git diff "$(git merge-base HEAD "origin/$CI_BASE_BRANCH")..HEAD" --check --oneline
 )
 
 echo

ci/test-stable.sh

@@ -47,7 +47,6 @@ echo "Executing $testName"
 case $testName in
 test-stable)
   _ cargo +"$rust_stable" test --jobs "$NPROC" --all --exclude solana-local-cluster ${V:+--verbose} -- --nocapture
-  #_ cargo +"$rust_stable" test --manifest-path bench-tps/Cargo.toml --features=move ${V:+--verbose} test_bench_tps_local_cluster_move -- --nocapture
   ;;
 test-stable-perf)
   ci/affects-files.sh \
@@ -91,28 +90,7 @@ test-stable-perf)
   fi
 
   _ cargo +"$rust_stable" build --bins ${V:+--verbose}
-  _ 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 \
-    Cargo.lock$ \
-    Cargo.toml$ \
-    ^ci/rust-version.sh \
-    ^ci/test-stable.sh \
-    ^ci/test-move.sh \
-    ^programs/move_loader \
-    ^programs/librapay \
-    ^logger/ \
-    ^runtime/ \
-    ^sdk/ \
-  || {
-    annotate --style info \
-      "Skipped $testName as no relevant files were modified"
-    exit 0
-  }
-  _ cargo +"$rust_stable" test --manifest-path programs/move_loader/Cargo.toml ${V:+--verbose} -- --nocapture
-  _ cargo +"$rust_stable" test --manifest-path programs/librapay/Cargo.toml ${V:+--verbose} -- --nocapture
-  exit 0
+  _ cargo +"$rust_stable" test --package solana-perf --package solana-ledger --package solana-core --lib ${V:+--verbose} -- --nocapture
   ;;
 test-local-cluster)
   _ cargo +"$rust_stable" build --release --bins ${V:+--verbose}

ci/testnet-deploy.sh

@@ -1,429 +0,0 @@
-#!/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

ci/testnet-manager.sh

@@ -1,401 +0,0 @@
-#!/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

ci/testnet-sanity.sh

@@ -1,78 +0,0 @@
-#!/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

ci/upload-github-release-asset.sh

@@ -42,6 +42,7 @@ echo "Github release id for $CI_TAG is $releaseId"
 for file in "$@"; do
   echo "--- Uploading $file to tag $CI_TAG of $CI_REPO_SLUG"
   curl \
+    --verbose \
     --data-binary @"$file" \
     -H "Authorization: token $GITHUB_TOKEN" \
     -H "Content-Type: application/octet-stream" \

clap-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "solana-clap-utils"
-version = "1.1.24"
+version = "1.2.33"
 description = "Solana utilities for the clap"
 authors = ["Solana Maintainers <maintainers@solana.com>"]
 repository = "https://github.com/solana-labs/solana"
@@ -11,8 +11,8 @@ edition = "2018"
 [dependencies]
 clap = "2.33.0"
 rpassword = "4.0"
-solana-remote-wallet = { path = "../remote-wallet", version = "1.1.24" }
-solana-sdk = { path = "../sdk", version = "1.1.24" }
+solana-remote-wallet = { path = "../remote-wallet", version = "1.2.33" }
+solana-sdk = { path = "../sdk", version = "1.2.33" }
 thiserror = "1.0.11"
 tiny-bip39 = "0.7.0"
 url = "2.1.0"

clap-utils/src/commitment.rs

@@ -15,7 +15,7 @@ pub fn commitment_arg_with_default<'a, 'b>(default_value: &'static str) -> Arg<'
     Arg::with_name(COMMITMENT_ARG.name)
         .long(COMMITMENT_ARG.long)
         .takes_value(true)
-        .possible_values(&["recent", "root", "max"])
+        .possible_values(&["recent", "single", "root", "max"])
         .default_value(default_value)
         .value_name("COMMITMENT_LEVEL")
         .help(COMMITMENT_ARG.help)