Publish initial snapshot hash in gossip on validator startup (#8678)

automerge

.appveyor.yml

@@ -0,0 +1,42 @@
+version: '{build}'
+
+branches:
+  only:
+  - master
+  - /^v[0-9.]+\.[0-9.]+/
+
+cache:
+  - '%USERPROFILE%\.cargo'
+  - '%APPVEYOR_BUILD_FOLDER%\target'
+
+clone_folder: d:\projects\solana
+
+build_script:
+  - bash ci/publish-tarball.sh
+
+notifications:
+  - provider: Slack
+    incoming_webhook:
+      secure: GJsBey+F5apAtUm86MHVJ68Uqa6WN1SImcuIc4TsTZrDhA8K1QWUNw9FFQPybUWDyOcS5dly3kubnUqlGt9ux6Ad2efsfRIQYWv0tOVXKeY=
+    channel: ci-status
+    on_build_success: false
+    on_build_failure: true
+    on_build_status_changed: true
+
+deploy:
+  - provider: S3
+    access_key_id:
+      secure: fTbJl6JpFebR40J7cOWZ2mXBa3kIvEiXgzxAj6L3N7A=
+    secret_access_key:
+      secure: vItsBXb2rEFLvkWtVn/Rcxu5a5+2EwC+b7GsA0waJy9hXh6XuBAD0lnHd9re3g/4
+    bucket: release.solana.com
+    region: us-west-1
+    set_public: true
+
+  - provider: GitHub
+    auth_token:
+      secure: 81fEmPZ0cV1wLtNuUrcmtgxKF6ROQF1+/ft5m+fHX21z6PoeCbaNo8cTyLioWBj7
+    draft: false
+    prerelease: false
+    on:
+      appveyor_repo_tag: true

.buildkite/env/.gitignore

@@ -0,0 +1 @@
+/secrets_unencrypted.ejson

.buildkite/env/README.md

@@ -0,0 +1,31 @@
+
+[ejson](https://github.com/Shopify/ejson) and
+[ejson2env](https://github.com/Shopify/ejson2env) are used to manage access
+tokens and other secrets required for CI.
+
+#### Setup
+```bash
+$ sudo gem install ejson ejson2env
+```
+
+then obtain the necessary keypair and place it in `/opt/ejson/keys/`.
+
+#### Usage
+Run the following command to decrypt the secrets into the environment:
+```bash
+eval $(ejson2env secrets.ejson)
+```
+
+#### Managing secrets.ejson
+To decrypt `secrets.ejson` for modification, run:
+```bash
+$ ejson decrypt secrets.ejson -o secrets_unencrypted.ejson
+```
+
+Edit, then run the following to re-encrypt the file **BEFORE COMMITING YOUR
+CHANGES**:
+```bash
+$ ejson encrypt secrets_unencrypted.ejson
+$ mv secrets_unencrypted.ejson secrets.ejson
+```
+

.buildkite/env/secrets.ejson

@@ -0,0 +1,15 @@
+{
+    "_public_key": "ae29f4f7ad2fc92de70d470e411c8426d5d48db8817c9e3dae574b122192335f",
+    "environment": {
+      "CODECOV_TOKEN": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:JnxhrIxh09AvqdJgrVSYmb7PxSrh19aE:07WzVExCHEd1lJ1m8QizRRthGri+WBNeZRKjjEvsy5eo4gv3HD7zVEm42tVTGkqITKkBNQ==]",
+      "CRATES_IO_TOKEN": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:d0jJqC32/axwzq/N7kMRmpxKhnRrhtpt:zvcPHwkOzGnjhNkAQSejwdy1Jkr9wR1qXFFCnfIjyt/XQYubzB1tLkoly/qdmeb5]",
+      "GEOLOCATION_API_KEY": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:R4gfB6Ey4i50HyfLt4UZDLBqg3qHEUye:UfZCOgt8XI6Y2g+ivCRVoS1fjFycFs7/GSevvCqh1B50mG0+hzpEyzXQLuKG5OeI]",
+      "GITHUB_TOKEN": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:Vq2dkGTOzfEpRht0BAGHFp/hDogMvXJe:tFXHg1epVt2mq9hkuc5sRHe+KAnVREi/p8S+IZu67XRyzdiA/nGak1k860FXYuuzuaE0QWekaEc=]",
+      "INFLUX_DATABASE": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:5KI9WBkXx3R/W4m256mU5MJOE7N8aAT9:Cb8QFELZ9I60t5zhJ9h55Kcs]",
+      "INFLUX_PASSWORD": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:hQRMpLCrav+OYkNphkeM4hagdVoZv5Iw:AUO76rr6+gF1OLJA8ZLSG8wHKXgYCPNk6gRCV8rBhZBJ4KwDaxpvOhMl7bxxXG6jol7v4aRa/Lk=]",
+      "INFLUX_USERNAME": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:R7BNmQjfeqoGDAFTJu9bYTGHol2NgnYN:Q2tOT/EBcFvhFk+DKLKmVU7tLCpVC3Ui]",
+      "SOLANA_INSTALL_UPDATE_MANIFEST_KEYPAIR_x86_64_unknown_linux_gnu": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:Egc2dMrHDU0NcZ71LwGv/V66shUhwYUE:04VoIb8CKy7KYhQ5W4cEW9SDKZltxWBL5Hob106lMBbUOD/yUvKYcG3Ep8JfTMwO3K8zowW5HpU/IdGoilX0XWLiJJ6t+p05WWK0TA16nOEtwrEG+UK8wm3sN+xCO20i4jDhpNpgg3FYFHT5rKTHW8+zaBTNUX/SFxkN67Lm+92IM28CXYE43SU1WV6H99hGFFVpTK5JVM3JuYU1ex/dHRE+xCzTr4MYUB/F+nGoNFW8HUDV/y0e1jxT9to3x0SmnytEEuk+5RUzFuEt9cKNFeNml3fOCi4qL+sfj/Y5pjH9xDiUxsvH/8NL35jbLP244aFHgWcp]",
+      "SOLANA_INSTALL_UPDATE_MANIFEST_KEYPAIR_x86_64_apple_darwin": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:NeOxSoWCvXB9AL4H6OK26l/7bmsKd/oz:Ijfoxtvk2CHlN1ZXHup3Gg/914kbbAkEGWJfvozA8UIe+aUzUObMyTrKkVOeNAH8Q8YH9tNzk7RRnrTcpnzeCCBLlWcVEeruMxHox3mPRzmSeDLxtbzCl9VePlRO3T7jg90K5hW+ZAkd5J/WJNzpAcmr93ts/of3MbvGHSujId/efCTzJEcP6JInnBb8Vrj7TlgKbzUlnqpq1+NjYPSXN3maKa9pKeo2JWxZlGBMoy6QWUUY5GbYEylw9smwh1LJcHZjlaZNMuOl4gNKtaSr38IXQkAXaRUJDPAmPras00YObKzXU8RkTrP4EoP/jx5LPR7f]",
+      "SOLANA_INSTALL_UPDATE_MANIFEST_KEYPAIR_x86_64_pc_windows_msvc": "EJ[1:yGpTmjdbyjW2kjgIHkFoJv7Ue7EbUvUbqHyw6anGgWg=:7t+56twjW+jR7fpFNNeRFLPd7E4lbmyN:JuviDpkQrfVcNUGRGsa2e/UhvH6tTYyk1s4cHHE5xZH1NByL7Kpqx36VG/+o1AUGEeSQdsBnKgzYdMoFYbO8o50DoRPc86QIEVXCupD6J9avxLFtQgOWgJp+/mCdUVXlqXiFs/vQgS/L4psrcKdF6WHd77BeUr6ll8DjH+9m5FC9Rcai2pXno6VbPpunHQ0oUdYzhFR64+LiRacBaefQ9igZ+nSEWDLqbaZSyfm9viWkijoVFTq8gAgdXXEh7g0QdxVE5T6bPristJhT6jWBhWunPUCDNFFErWIsbRGctepl4pbCWqh2hNTw9btSgVfeY6uGCOsdy9E=]"
+    }
+}

.buildkite/hooks/post-checkout

@@ -1,2 +1,42 @@
 CI_BUILD_START=$(date +%s)
 export CI_BUILD_START
+
+source ci/env.sh
+
+#
+# Kill any running docker containers, which are potentially left over from the
+# previous CI job
+#
+(
+  containers=$(docker ps -q)
+  if [[ $(hostname) != metrics-solana-com && -n $containers ]]; then
+    echo "+++ Killing stale docker containers"
+    docker ps
+
+    # shellcheck disable=SC2086 # Don't want to double quote $containers
+    docker kill $containers
+  fi
+)
+
+# Processes from previously aborted CI jobs seem to loiter, unclear why as one
+# would expect the buildkite-agent to clean up all child processes of the
+# aborted CI job.
+# But as a workaround for now manually kill some known loiterers.  These
+# processes will all have the `init` process as their PPID:
+(
+  victims=
+  for name in bash cargo docker solana; do
+    victims="$victims $(pgrep -u "$(id -u)" -P 1 -d \  $name)"
+  done
+  for victim in $victims; do
+    echo "Killing pid $victim"
+    kill -9 "$victim" || true
+  done
+)
+
+# HACK: These are in our docker images, need to be removed from CARGO_HOME
+#  because we try to cache downloads across builds with CARGO_HOME
+# cargo lacks a facility for "system" tooling, always tries CARGO_HOME first
+cargo uninstall cargo-audit || true
+cargo uninstall svgbob_cli || true
+cargo uninstall mdbook || true

.buildkite/hooks/post-command

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

.buildkite/hooks/pre-command

@@ -1,4 +1,7 @@
-#!/bin/bash -e
+#!/usr/bin/env bash
+set -e
+
+eval "$(ejson2env .buildkite/env/secrets.ejson)"
 
 # Ensure the pattern "+++ ..." never occurs when |set -x| is set, as buildkite
 # interprets this as the start of a log group.
@@ -8,20 +11,23 @@ export PS4="++"
 #
 # Restore target/ from the previous CI build on this machine
 #
-[[ -n "$CARGO_TARGET_CACHE_NAME" ]] || (
-  d=$HOME/cargo-target-cache/"$CARGO_TARGET_CACHE_NAME"
+(
+  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=1000000000 "$d")
-    if [[ $cacheSizeInGB -gt 5 ]]; then
-      echo "$d has gotten too large, removing it"
+    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$d")
+    echo "--- ${cacheSizeInGB}GB: $d"
+    if [[ $cacheSizeInGB -gt $MAX_CACHE_SIZE ]]; then
+      echo "--- $d is too large, removing it"
       rm -rf "$d"
     fi
+  else
+    echo "--- $d not present"
   fi
 
   mkdir -p "$d"/target
-  set -x
   rsync -a --delete --link-dest="$d" "$d"/target .
 )
-

.buildkite/pipeline-upload.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+#
+# This script is used to upload the full buildkite pipeline. The steps defined
+# in the buildkite UI should simply be:
+#
+#   steps:
+#    - command: ".buildkite/pipeline-upload.sh"
+#
+
+set -e
+cd "$(dirname "$0")"/..
+
+if [[ -n $BUILDKITE_TAG ]]; then
+  buildkite-agent annotate --style info --context release-tag \
+    "https://github.com/solana-labs/solana/releases/$BUILDKITE_TAG"
+  buildkite-agent pipeline upload ci/buildkite-release.yml
+else
+  if [[ $BUILDKITE_BRANCH =~ ^pull ]]; then
+    # Add helpful link back to the corresponding Github Pull Request
+    buildkite-agent annotate --style info --context pr-backlink \
+      "Github Pull Request: https://github.com/solana-labs/solana/$BUILDKITE_BRANCH"
+  fi
+
+  if [[ $BUILDKITE_MESSAGE =~ GitBook: ]]; then
+    buildkite-agent annotate --style info --context gitbook-ci-skip \
+      "GitBook commit detected, CI skipped"
+    exit
+  fi
+
+  buildkite-agent pipeline upload ci/buildkite.yml
+fi

.codecov.yml

@@ -1,5 +1,12 @@
-ignore:
-  - "src/bin" 
 coverage:
+  range: 50..100
+  round: down
+  precision: 1
   status:
+    project: off
     patch: off
+
+comment:
+  layout: "diff"
+  behavior: default
+  require_changes: no

.gitbook.yaml

@@ -0,0 +1,5 @@
+root: ./docs/src
+
+structure:
+    readme: introduction.md
+    summary: SUMMARY.md

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,6 @@
+#### Problem
+
+
+
+#### Proposed Solution
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,5 @@
+#### Problem
+
+#### Summary of Changes
+
+Fixes #

.github/stale.yml

@@ -0,0 +1,24 @@
+only: pulls
+
+# Number of days of inactivity before a pull request becomes stale
+daysUntilStale: 7
+
+# Number of days of inactivity before a stale pull request is closed
+daysUntilClose: 7
+
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - security
+
+# Label to use when marking a pull request as stale
+staleLabel: stale
+
+# Comment to post when marking a pull request as stale. Set to `false` to disable
+markComment: >
+  This pull request has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs.
+
+# Comment to post when closing a stale pull request. Set to `false` to disable
+closeComment: >
+  This stale pull request has been automatically closed.
+  Thank you for your contributions.

.gitignore

@@ -1,16 +1,24 @@
-Cargo.lock
+/docs/html/
+/docs/src/tests.ok
+/docs/src/.gitbook/assets/*.svg
+/farf/
+/solana-release/
+/solana-release.tar.bz2
+/solana-metrics/
+/solana-metrics.tar.bz2
 /target/
 
 **/*.rs.bk
 .cargo
 
-# node configuration files
 /config/
-/config-private/
-/config-drone/
-/config-validator/
-/config-client/
-/multinode-demo/test/config-client/
 
-# test temp files, ledgers, etc.
-/farf/
+# log files
+*.log
+log-*.txt
+log-*/
+
+# intellij files
+/.idea/
+/solana.iml
+/.vscode/

.mergify.yml

@@ -0,0 +1,53 @@
+# Validate your changes with:
+#
+#   $ curl -F 'data=@.mergify.yml' https://gh.mergify.io/validate
+#
+# https://doc.mergify.io/
+pull_request_rules:
+  - name: remove outdated reviews
+    conditions:
+      - base=master
+    actions:
+      dismiss_reviews:
+        changes_requested: true
+  - name: set automerge label on mergify backport PRs
+    conditions:
+      - author=mergify[bot]
+      - head~=^mergify/bp/
+      - "#status-failure=0"
+    actions:
+      label:
+        add:
+          - automerge
+  - name: v0.23 backport
+    conditions:
+      - base=master
+      - label=v0.23
+    actions:
+      backport:
+        branches:
+          - v0.23
+  - name: v1.0 backport
+    conditions:
+      - base=master
+      - label=v1.0
+    actions:
+      backport:
+        branches:
+          - v1.0
+  - name: v1.1 backport
+    conditions:
+      - base=master
+      - label=v1.1
+    actions:
+      backport:
+        branches:
+          - v1.1
+  - name: v1.2 backport
+    conditions:
+      - base=master
+      - label=v1.2
+    actions:
+      backport:
+        branches:
+          - v1.2

.travis.yml

@@ -0,0 +1,42 @@
+os:
+  - osx
+
+language: rust
+rust:
+  - stable
+
+install:
+  - source ci/rust-version.sh
+
+script:
+  - source ci/env.sh
+  - ci/publish-tarball.sh
+
+branches:
+  only:
+    - master
+    - /^v\d+\.\d+/
+
+notifications:
+  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

CONTRIBUTING.md

@@ -1,53 +1,248 @@
-Solana Coding Guidelines
-===
+# Solana Coding Guidelines
 
-The goal of these guidelines is to improve developer productivity by allowing developers to
-jump any file in the codebase and not need to adapt to inconsistencies in how the code is
-written. The codebase should appear as if it had been authored by a single developer. If you
-don't agree with a convention, submit a PR patching this document and let's discuss! Once
-the PR is accepted, *all* code should be updated as soon as possible to reflect the new
+The goal of these guidelines is to improve developer productivity by allowing
+developers to jump into any file in the codebase and not need to adapt to
+inconsistencies in how the code is written. The codebase should appear as if it
+had been authored by a single developer. If you don't agree with a convention,
+submit a PR patching this document and let's discuss! Once the PR is accepted,
+*all* code should be updated as soon as possible to reflect the new
 conventions.
 
-Rust coding conventions
----
+## Pull Requests
 
-* All Rust code is formatted using the latest version of `rustfmt`. Once installed, it will be
-  updated automatically when you update the compiler with `rustup`.
+Small, frequent PRs are much preferred to large, infrequent ones. A large PR is
+difficult to review, can block others from making progress, and can quickly get
+its author into "rebase hell". A large PR oftentimes arises when one change
+requires another, which requires another, and then another. When you notice
+those dependencies, put the fix into a commit of its own, then checkout a new
+branch, and cherry-pick it.
 
-* All Rust code is linted with Clippy. If you'd prefer to ignore its advice, do so explicitly:
+```bash
+$ git commit -am "Fix foo, needed by bar"
+$ git checkout master
+$ git checkout -b fix-foo
+$ git cherry-pick fix-bar
+$ git push --set-upstream origin fix-foo
+```
 
-  ```rust
-  #[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
-  ```
+Open a PR to start the review process and then jump back to your original
+branch to keep making progress. Consider rebasing to make your fix the first
+commit:
+
+```bash
+$ git checkout fix-bar
+$ git rebase -i master <Move fix-foo to top>
+```
+
+Once the commit is merged, rebase the original branch to purge the
+cherry-picked commit:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+### How big is too big?
+
+If there are no functional changes, PRs can be very large and that's no
+problem. If, however, your changes are making meaningful changes or additions,
+then about 1.0.4 lines of changes is about the most you should ask a Solana
+maintainer to review.
+
+### Should I send small PRs as I develop large, new components?
+
+Add only code to the codebase that is ready to be deployed. If you are building
+a large library, consider developing it in a separate git repository. When it
+is ready to be integrated, the Solana maintainers will work with you to decide
+on a path forward. Smaller libraries may be copied in whereas very large ones
+may be pulled in with a package manager.
+
+## Getting Pull Requests Merged
+
+There is no single person assigned to watching GitHub PR queue and ushering you
+through the process. Typically, you will ask the person that wrote a component
+to review changes to it. You can find the author using `git blame` or asking on
+Discord.  When working to get your PR merged, it's most important to understand
+that changing the code is your priority and not necessarily a priority of the
+person you need an approval from. Also, while you may interact the most with
+the component author, you should aim to be inclusive of others. Providing a
+detailed problem description is the most effective means of engaging both the
+component author and other potentially interested parties.
+
+Consider opening all PRs as Draft Pull Requests first. Using a draft PR allows
+you to kickstart the CI automation, which typically takes between 10 and 30
+minutes to execute. Use that time to write a detailed problem description. Once
+the description is written and CI succeeds, click the "Ready to Review" button
+and add reviewers. Adding reviewers before CI succeeds is a fast path to losing
+reviewer engagement. Not only will they be notified and see the PR is not yet
+ready for them, they will also be bombarded them with additional notifications
+each time you push a commit to get past CI or until they "mute" the PR. Once
+muted, you'll need to reach out over some other medium, such as Discord, to
+request they have another look. When you use draft PRs, no notifications are
+sent when you push commits and edit the PR description. Use draft PRs
+liberally.  Don't bug the humans until you have gotten past the bots.
+
+### What should be in my PR description?
+
+Reviewing code is hard work and generally involves an attempt to guess the
+author's intent at various levels. Please assume reviewer time is scarce and do
+what you can to make your PR as consumable as possible. Inspired by techniques
+for writing good whitepapers, the guidance here aims to maximize reviewer
+engagement.
+
+Assume the reviewer will spend no more than a few seconds reading the PR title.
+If it doesn't describe a noteworthy change, don't expect the reviewer to click
+to see more.
+
+Next, like the abstract of a whitepaper, the reviewer will spend ~30 seconds
+reading the PR problem description. If what is described there doesn't look
+more important than competing issues, don't expect the reviewer to read on.
+
+Next, the reviewer will read the proposed changes. At this point, the reviewer
+needs to be convinced the proposed changes are a *good* solution to the problem
+described above.  If the proposed changes, not the code changes, generates
+discussion, consider closing the PR and returning with a design proposal
+instead.
+
+Finally, once the reviewer understands the problem and agrees with the approach
+to solving it, the reviewer will view the code changes. At this point, the
+reviewer is simply looking to see if the implementation actually implements
+what was proposed and if that implementation is maintainable. When a concise,
+readable test for each new code path is present, the reviewer can safely ignore
+the details of its implementation. When those tests are missing, expect to
+either lose engagement or get a pile of review comments as the reviewer
+attempts to consider every ambiguity in your implementation.
+
+### The PR Title
+
+The PR title should contain a brief summary of the change, from the perspective
+of the user. Examples of good titles:
+
+* Add rent to accounts
+* Fix out-of-memory error in validator
+* Clean up `process_message()` in runtime
+
+The conventions here are all the same as a good git commit title:
+
+* First word capitalized and in the imperative mood, not past tense ("add", not
+  "added")
+* No trailing period
+* What was done, whom it was done to, and in what context
+
+### The PR Problem Statement
+
+The git repo implements a product with various features. The problem statement
+should describe how the product is missing a feature, how a feature is
+incomplete, or how the implementation of a feature is somehow undesirable. If
+an issue being fixed already describes the problem, go ahead and copy-paste it.
+As mentioned above, reviewer time is scarce. Given a queue of PRs to review,
+the reviewer may ignore PRs that expect them to click through links to see if
+the PR warrants attention.
+
+### The Proposed Changes
+
+Typically the content under the "Proposed changes" section will be a bulleted
+list of steps taken to solve the problem. Oftentimes, the list is identical to
+the subject lines of the git commits contained in the PR. It's especially
+generous (and not expected) to rebase or reword commits such that each change
+matches the logical flow in your PR description.
+
+### When will my PR be reviewed?
+
+PRs are typically reviewed and merged in under 7 days. If your PR has been open
+for longer, it's a strong indicator that the reviewers aren't confident the
+change meets the quality standards of the codebase. You might consider closing
+it and coming back with smaller PRs and longer descriptions detailing what
+problem it solves and how it solves it. Old PRs will be marked stale and then
+closed automatically 7 days later.
+
+### How to manage review feedback?
+
+After a reviewer provides feedback, you can quickly say "acknowledged, will
+fix" using a thumb's up emoji. If you're confident your fix is exactly as
+prescribed, add a reply "Fixed in COMMIT\_HASH" and mark the comment as
+resolved. If you're not sure, reply "Is this what you had in mind?
+COMMIT\_HASH" and if so, the reviewer will reply and mark the conversation as
+resolved. Marking conversations as resolved is an excellent way to engage more
+reviewers. Leaving conversations open may imply the PR is not yet ready for
+additional review.
+
+### When will my PR be re-reviewed?
+
+Recall that once your PR is opened, a notification is sent every time you push
+a commit.  After a reviewer adds feedback, they won't be checking on the status
+of that feedback after every new commit. Instead, directly mention the reviewer
+when you feel your PR is ready for another pass.
+
+## Draft Pull Requests
+
+If you want early feedback on your PR, use GitHub's "Draft Pull Request"
+mechanism. Draft PRs are a convenient way to collaborate with the Solana
+maintainers without triggering notifications as you make changes. When you feel
+your PR is ready for a broader audience, you can transition your draft PR to a
+standard PR with the click of a button.
+
+Do not add reviewers to draft PRs.  GitHub doesn't automatically clear
+approvals when you click "Ready for Review", so a review that meant "I approve
+of the direction" suddenly has the appearance of "I approve of these changes."
+Instead, add a comment that mentions the usernames that you would like a review
+from. Ask explicitly what you would like feedback on.
+
+## Rust coding conventions
+
+* All Rust code is formatted using the latest version of `rustfmt`. Once
+  installed, it will be updated automatically when you update the compiler with
+`rustup`.
+
+* All Rust code is linted with Clippy. If you'd prefer to ignore its advice, do
+  so explicitly:
+
+  ```rust #[allow(clippy::too_many_arguments)] ```
 
   Note: Clippy defaults can be overridden in the top-level file `.clippy.toml`.
 
-* For variable names, when in doubt, spell it out. The mapping from type names to variable names
-  is to lowercase the type name, putting an underscore before each capital letter. Variable names
-  should *not* be abbreviated unless being used as closure arguments and the brevity improves
-  readability. When a function has multiple instances of the same type, qualify each with a
-  prefix and underscore (i.e. alice_keypair) or a numeric suffix (i.e. tx0).
+* For variable names, when in doubt, spell it out. The mapping from type names
+  to variable names is to lowercase the type name, putting an underscore before
+each capital letter. Variable names should *not* be abbreviated unless being
+used as closure arguments and the brevity improves readability. When a function
+has multiple instances of the same type, qualify each with a prefix and
+underscore (i.e. alice\_keypair) or a numeric suffix (i.e. tx0).
 
-* For function and method names, use `<verb>_<subject>`. For unit tests, that verb should
-  always be `test` and for benchmarks the verb should always be `bench`. Avoid namespacing
-  function names with some arbitrary word. Avoid abreviating words in function names.
+* For function and method names, use `<verb>_<subject>`. For unit tests, that
+  verb should always be `test` and for benchmarks the verb should always be
+`bench`. Avoid namespacing function names with some arbitrary word. Avoid
+abbreviating words in function names.
 
-* As they say, "When in Rome, do as the Romans do." A good patch should acknowledge the coding
-  conventions of the code that surrounds it, even in the case where that code has not yet been
-  updated to meet the conventions described here.
+* As they say, "When in Rome, do as the Romans do." A good patch should
+  acknowledge the coding conventions of the code that surrounds it, even in the
+case where that code has not yet been updated to meet the conventions described
+here.
 
 
-Terminology
----
+## Terminology
 
-Inventing new terms is allowed, but should only be done when the term is widely used and
-understood. Avoid introducing new 3-letter terms, which can be confused with 3-letter acronyms.
+Inventing new terms is allowed, but should only be done when the term is widely
+used and understood. Avoid introducing new 3-letter terms, which can be
+confused with 3-letter acronyms.
 
-Some terms we currently use regularly in the codebase:
+[Terms currently in use](docs/src/terminology.md)
 
-* fullnode: n. A fully participating network node.
-* hash: n. A SHA-256 Hash.
-* keypair: n. A Ed25519 key-pair, containing a public and private key.
-* pubkey: n. The public key of a Ed25519 key-pair.
-* sigverify: v. To verify a Ed25519 digital signature.
 
+## Design Proposals
+
+Solana's architecture is described by docs generated from markdown files in
+the `docs/src/` directory, maintained by an *editor* (currently @garious). To
+add a design proposal, you'll need to include it in the
+[Accepted Design Proposals](https://docs.solana.com/proposals)
+section of the Solana docs.  Here's the full process:
+
+1. Propose a design by creating a PR that adds a markdown document to the
+   `docs/src/proposals` directory and references it from the [table of
+   contents](docs/src/SUMMARY.md). Add any relevant *maintainers* to the PR
+   review.
+2. The PR being merged indicates your proposed change was accepted and that the
+   maintainers support your plan of attack.
+3. Submit PRs that implement the proposal. When the implementation reveals the
+   need for tweaks to the proposal, be sure to update the proposal and have that
+   change reviewed by the same people as in step 1.
+4. Once the implementation is complete, submit a PR that moves the link from
+   the Accepted Proposals to the Implemented Proposals section.

Cargo.toml

@@ -1,148 +1,64 @@
-[package]
-name = "solana"
-description = "Blockchain, Rebuilt for Scale"
-version = "0.9.0"
-documentation = "https://docs.rs/solana"
-homepage = "http://solana.com/"
-readme = "README.md"
-repository = "https://github.com/solana-labs/solana"
-authors = [
-    "Anatoly Yakovenko <anatoly@solana.com>",
-    "Greg Fitzgerald <greg@solana.com>",
-    "Stephen Akridge <stephen@solana.com>",
-    "Michael Vines <mvines@solana.com>",
-    "Rob Walker <rob@solana.com>",
-    "Pankaj Garg <pankaj@solana.com>",
-    "Tyera Eulberg <tyera@solana.com>",
-]
-license = "Apache-2.0"
-
-[[bin]]
-name = "solana-upload-perf"
-path = "src/bin/upload-perf.rs"
-
-[[bin]]
-name = "solana-bench-streamer"
-path = "src/bin/bench-streamer.rs"
-
-[[bin]]
-name = "solana-bench-tps"
-path = "src/bin/bench-tps.rs"
-
-[[bin]]
-name = "solana-drone"
-path = "src/bin/drone.rs"
-
-[[bin]]
-name = "solana-replicator"
-path = "src/bin/replicator.rs"
-
-[[bin]]
-name = "solana-fullnode"
-path = "src/bin/fullnode.rs"
-
-[[bin]]
-name = "solana-fullnode-config"
-path = "src/bin/fullnode-config.rs"
-
-[[bin]]
-name = "solana-genesis"
-path = "src/bin/genesis.rs"
-
-[[bin]]
-name = "solana-ledger-tool"
-path = "src/bin/ledger-tool.rs"
-
-[[bin]]
-name = "solana-keygen"
-path = "src/bin/keygen.rs"
-
-[[bin]]
-name = "solana-wallet"
-path = "src/bin/wallet.rs"
-
-[badges]
-codecov = { repository = "solana-labs/solana", branch = "master", service = "github" }
-
-[features]
-unstable = []
-ipv6 = []
-cuda = []
-erasure = []
-test = []
-
-[dependencies]
-atty = "0.2"
-bincode = "1.0.0"
-bs58 = "0.2.0"
-byteorder = "1.2.1"
-bytes = "0.4"
-chrono = { version = "0.4.0", features = ["serde"] }
-clap = "2.31"
-dirs = "1.0.2"
-env_logger = "0.5.12"
-generic-array = { version = "0.12.0", default-features = false, features = ["serde"] }
-getopts = "0.2"
-influx_db_client = "0.3.4"
-solana-jsonrpc-core = "0.1"
-solana-jsonrpc-http-server = "0.1"
-solana-jsonrpc-macros = "0.1"
-ipnetwork = "0.12.7"
-itertools = "0.7.8"
-libc = "0.2.43"
-libloading = "0.5.0"
-log = "0.4.2"
-matches = "0.1.6"
-nix = "0.11.0"
-pnet_datalink = "0.21.0"
-rand = "0.5.1"
-rayon = "1.0.0"
-reqwest = "0.9.0"
-ring = "0.13.2"
-sha2 = "0.7.0"
-serde = "1.0.27"
-serde_cbor = "0.9.0"
-serde_derive = "1.0.27"
-serde_json = "1.0.10"
-socket2 = "0.3.8"
-solana_program_interface = { path = "common" }
-sys-info = "0.5.6"
-tokio = "0.1"
-tokio-codec = "0.1"
-untrusted = "0.6.2"
-
-[dev-dependencies]
-noop = { path = "programs/noop" }
-print = { path = "programs/print" }
-move_funds = { path = "programs/move_funds" }
-
-[[bench]]
-name = "bank"
-
-[[bench]]
-name = "banking_stage"
-
-[[bench]]
-name = "ledger"
-
-[[bench]]
-name = "signature"
-
-[[bench]]
-name = "sigverify"
-
 [workspace]
 members = [
-    ".",
-    "common",
+    "bench-exchange",
+    "bench-streamer",
+    "bench-tps",
+    "banking-bench",
+    "chacha",
+    "chacha-cuda",
+    "chacha-sys",
+    "cli-config",
+    "client",
+    "core",
+    "faucet",
+    "perf",
+    "validator",
+    "genesis",
+    "genesis-programs",
+    "gossip",
+    "install",
+    "keygen",
+    "ledger",
+    "ledger-tool",
+    "local-cluster",
+    "logger",
+    "log-analyzer",
+    "merkle-tree",
+    "measure",
+    "metrics",
+    "net-shaper",
+    "programs/bpf_loader",
+    "programs/budget",
+    "programs/btc_spv",
+    "programs/btc_spv_bin",
+    "programs/config",
+    "programs/exchange",
+    "programs/failure",
     "programs/noop",
-    "programs/print",
-    "programs/move_funds",
+    "programs/ownable",
+    "programs/stake",
+    "programs/storage",
+    "programs/vest",
+    "programs/vote",
+    "archiver",
+    "archiver-lib",
+    "archiver-utils",
+    "remote-wallet",
+    "runtime",
+    "sdk",
+    "sdk-c",
+    "scripts",
+    "sys-tuner",
+    "upload-perf",
+    "net-utils",
+    "vote-signer",
+    "cli",
+    "rayon-threadlimit",
+    "watchtower",
 ]
-default-members = [
-    ".",
-    "common",
-    "programs/noop",
-    "programs/print",
-    "programs/move_funds",
+
+exclude = [
+    "programs/bpf",
+    "programs/move_loader",
+    "programs/librapay",
 ]

README.md

@@ -1,9 +1,9 @@
-[![Solana crate](https://img.shields.io/crates/v/solana.svg)](https://crates.io/crates/solana)
-[![Solana documentation](https://docs.rs/solana/badge.svg)](https://docs.rs/solana)
-[![Build status](https://badge.buildkite.com/d4c4d7da9154e3a8fb7199325f430ccdb05be5fc1e92777e51.svg?branch=master)](https://solana-ci-gate.herokuapp.com/buildkite_public_log?https://buildkite.com/solana-labs/solana/builds/latest/master)
+[![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
+Blockchain Rebuilt for Scale
 ===
 
 Solana™ is a new blockchain architecture built from the ground up for scale. The architecture supports
@@ -21,246 +21,48 @@ It's possible for a centralized database to process 710,000 transactions per sec
 
 > Perhaps the most striking difference between algorithms obtained by our method and ones based upon timeout is that using timeout produces a traditional distributed algorithm in which the processes operate asynchronously, while our method produces a globally synchronous one in which every process does the same thing at (approximately) the same time. Our method seems to contradict the whole purpose of distributed processing, which is to permit different processes to operate independently and perform different functions. However, if a distributed system is really a single system, then the processes must be synchronized in some way. Conceptually, the easiest way to synchronize processes is to get them all to do the same thing at the same time. Therefore, our method is used to implement a kernel that performs the necessary synchronization--for example, making sure that two different processes do not try to modify a file at the same time. Processes might spend only a small fraction of their time executing the synchronizing kernel; the rest of the time, they can operate independently--e.g., accessing different files. This is an approach we have advocated even when fault-tolerance is not required. The method's basic simplicity makes it easier to understand the precise properties of a system, which is crucial if one is to know just how fault-tolerant the system is. [\[L.Lamport (1984)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.71.1078)
 
-Furthermore, and much to our surprise, it can be implemented using a mechanism that has existed in Bitcoin since day one. The Bitcoin feature is called nLocktime and it can be used to postdate transactions using block height instead of a timestamp. As a Bitcoin client, you'd use block height instead of a timestamp if you don't trust the network. Block height turns out to be an instance of what's being called a Verifiable Delay Function in cryptography circles. It's a cryptographically secure way to say time has passed. In Solana, we use a far more granular verifiable delay function, a SHA 256 hash chain, to checkpoint the ledger and coordinate consensus. With it, we implement Optimistic Concurrency Control and are now well in route towards that theoretical limit of 710,000 transactions per second.
+Furthermore, and much to our surprise, it can be implemented using a mechanism that has existed in Bitcoin since day one. The Bitcoin feature is called nLocktime and it can be used to postdate transactions using block height instead of a timestamp. As a Bitcoin client, you'd use block height instead of a timestamp if you don't trust the network. Block height turns out to be an instance of what's being called a Verifiable Delay Function in cryptography circles. It's a cryptographically secure way to say time has passed. In Solana, we use a far more granular verifiable delay function, a SHA 256 hash chain, to checkpoint the ledger and coordinate consensus. With it, we implement Optimistic Concurrency Control and are now well en route towards that theoretical limit of 710,000 transactions per second.
 
-
-Testnet Demos
+Documentation
 ===
 
-The Solana repo contains all the scripts you might need to spin up your own
-local testnet. Depending on what you're looking to achieve, you may want to
-run a different variation, as the full-fledged, performance-enhanced
-multinode testnet is considerably more complex to set up than a Rust-only,
-singlenode testnode.  If you are looking to develop high-level features, such
-as experimenting with smart contracts, save yourself some setup headaches and
-stick to the Rust-only singlenode demo.  If you're doing performance optimization
-of the transaction pipeline, consider the enhanced singlenode demo. If you're
-doing consensus work, you'll need at least a Rust-only multinode demo. If you want
-to reproduce our TPS metrics, run the enhanced multinode demo.
+Before you jump into the code, review the documentation [Solana: Blockchain Rebuilt for Scale](https://docs.solana.com).
 
-For all four variations, you'd need the latest Rust toolchain and the Solana
-source code:
+(The _latest_ development version of the docs is [available here](https://docs.solana.com/v/master).)
 
-First, install Rust's package manager Cargo.
+Release Binaries
+===
+Official release binaries are available at [Github Releases](https://github.com/solana-labs/solana/releases).
 
-```bash
-$ curl https://sh.rustup.rs -sSf | sh
-$ source $HOME/.cargo/env
-```
+Additionally we provide pre-release binaries for the latest code on the edge and
+beta channels.  Note that these pre-release binaries may be less stable than an
+official release.
 
-Now checkout the code from github:
+### Edge channel
+#### Linux (x86_64-unknown-linux-gnu)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-unknown-linux-gnu.tar.bz2)
+* [solana-install-init](http://release.solana.com/edge/solana-install-init-x86_64-unknown-linux-gnu) as a stand-alone executable
+#### mac OS (x86_64-apple-darwin)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-apple-darwin.tar.bz2)
+* [solana-install-init](http://release.solana.com/edge/solana-install-init-x86_64-apple-darwin) as a stand-alone executable
+#### Windows (x86_64-pc-windows-msvc)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-pc-windows-msvc.tar.bz2)
+* [solana-install-init.exe](http://release.solana.com/edge/solana-install-init-x86_64-pc-windows-msvc.exe) as a stand-alone executable
+#### All platforms
+* [solana-metrics.tar.bz2](http://release.solana.com.s3.amazonaws.com/edge/solana-metrics.tar.bz2)
 
-```bash
-$ git clone https://github.com/solana-labs/solana.git
-$ cd solana
-```
-
-The demo code is sometimes broken between releases as we add new low-level
-features, so if this is your first time running the demo, you'll improve
-your odds of success if you check out the
-[latest release](https://github.com/solana-labs/solana/releases)
-before proceeding:
-
-```bash
-$ git checkout v0.8.0
-```
-
-Configuration Setup
----
-
-The network is initialized with a genesis ledger and leader/validator configuration files.
-These files can be generated by running the following script.
-
-```bash
-$ ./multinode-demo/setup.sh
-```
-
-Drone
----
-
-In order for the leader, client and validators to work, we'll need to
-spin up a drone to give out some test tokens.  The drone delivers Milton
-Friedman-style "air drops" (free tokens to requesting clients) to be used in
-test transactions.
-
-Start the drone on the leader node with:
-
-```bash
-$ ./multinode-demo/drone.sh
-```
-
-Singlenode Testnet
----
-
-Before you start a fullnode, make sure you know the IP address of the machine you
-want to be the leader for the demo, and make sure that udp ports 8000-10000 are
-open on all the machines you want to test with.
-
-Now start the server in a separate shell:
-
-```bash
-$ ./multinode-demo/leader.sh
-```
-
-Wait a few seconds for the server to initialize. It will print "leader ready..." when it's ready to
-receive transactions. The leader will request some tokens from the drone if it doesn't have any.
-The drone does not need to be running for subsequent leader starts.
-
-Multinode Testnet
----
-
-To run a multinode testnet, after starting a leader node, spin up some validator nodes in
-separate shells:
-
-```bash
-$ ./multinode-demo/validator.sh
-```
-
-To run a performance-enhanced leader or validator (on Linux),
-[CUDA 9.2](https://developer.nvidia.com/cuda-downloads) must be installed on
-your system:
-
-```bash
-$ ./fetch-perf-libs.sh
-$ SOLANA_CUDA=1 ./multinode-demo/leader.sh
-$ SOLANA_CUDA=1 ./multinode-demo/validator.sh
-```
-
-
-Testnet Client Demo
----
-
-Now that your singlenode or multinode testnet is up and running let's send it
-some transactions!
-
-In a separate shell start the client:
-
-```bash
-$ ./multinode-demo/client.sh # runs against localhost by default
-```
-
-What just happened? The client demo spins up several threads to send 500,000 transactions
-to the testnet as quickly as it can. The client then pings the testnet periodically to see
-how many transactions it processed in that time. Take note that the demo intentionally
-floods the network with UDP packets, such that the network will almost certainly drop a
-bunch of them. This ensures the testnet has an opportunity to reach 710k TPS. The client
-demo completes after it has convinced itself the testnet won't process any additional
-transactions. You should see several TPS measurements printed to the screen. In the
-multinode variation, you'll see TPS measurements for each validator node as well.
-
-Public Testnet
---------------
-In this example the client connects to our public testnet. To run validators on the testnet you would need to open udp ports `8000-10000`.
-
-```bash
-$ ./multinode-demo/client.sh --network $(dig +short testnet.solana.com):8001 --identity config-private/client-id.json --duration 60
-```
-
-You can observe the effects of your client's transactions on our [dashboard](https://metrics.solana.com:3000/d/testnet/testnet-hud?orgId=2&from=now-30m&to=now&refresh=5s&var-testnet=testnet)
-
-
-Linux Snap
----
-A Linux [Snap](https://snapcraft.io/) is available, which can be used to
-easily get Solana running on supported Linux systems without building anything
-from source.  The `edge` Snap channel is updated daily with the latest
-development from the `master` branch.  To install:
-
-```bash
-$ sudo snap install solana --edge --devmode
-```
-
-(`--devmode` flag is required only for `solana.fullnode-cuda`)
-
-Once installed the usual Solana programs will be available as `solona.*` instead
-of `solana-*`.  For example, `solana.fullnode` instead of `solana-fullnode`.
-
-Update to the latest version at any time with:
-
-```bash
-$ snap info solana
-$ sudo snap refresh solana --devmode
-```
-
-### Daemon support
-The snap supports running a leader, validator or leader+drone node as a system
-daemon.
-
-Run `sudo snap get solana` to view the current daemon configuration.  To view
-daemon logs:
-1. Run `sudo snap logs -n=all solana` to view the daemon initialization log
-2. Runtime logging can be found under `/var/snap/solana/current/leader/`,
-`/var/snap/solana/current/validator/`, or `/var/snap/solana/current/drone/` depending
-on which `mode=` was selected.  Within each log directory the file `current`
-contains the latest log, and the files `*.s` (if present) contain older rotated
-logs.
-
-Disable the daemon at any time by running:
-
-```bash
-$ sudo snap set solana mode=
-```
-
-Runtime configuration files for the daemon can be found in
-`/var/snap/solana/current/config`.
-
-#### Leader daemon
-
-```bash
-$ sudo snap set solana mode=leader
-```
-
-If CUDA is available:
-
-```bash
-$ sudo snap set solana mode=leader enable-cuda=1
-```
-
-`rsync` must be configured and running on the leader.
-
-1. Ensure rsync is installed with `sudo apt-get -y install rsync`
-2. Edit `/etc/rsyncd.conf` to include the following
-```
-[config]
-path = /var/snap/solana/current/config
-hosts allow = *
-read only = true
-```
-3. Run `sudo systemctl enable rsync; sudo systemctl start rsync`
-4. Test by running `rsync -Pzravv rsync://<ip-address-of-leader>/config
-solana-config` from another machine.  **If the leader is running on a cloud
-provider it may be necessary to configure the Firewall rules to permit ingress
-to port tcp:873, tcp:9900 and the port range udp:8000-udp:10000**
-
-
-To run both the Leader and Drone:
-
-```bash
-$ sudo snap set solana mode=leader+drone
-
-```
-
-#### Validator daemon
-
-```bash
-$ sudo snap set solana mode=validator
-
-```
-If CUDA is available:
-
-```bash
-$ sudo snap set solana mode=validator enable-cuda=1
-```
-
-By default the validator will connect to **testnet.solana.com**, override
-the leader IP address by running:
-
-```bash
-$ sudo snap set solana mode=validator leader-address=127.0.0.1 #<-- change IP address
-```
-
-It's assumed that the leader will be running `rsync` configured as described in
-the previous **Leader daemon** section.
+### Beta channel
+#### Linux (x86_64-unknown-linux-gnu)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-unknown-linux-gnu.tar.bz2)
+* [solana-install-init](http://release.solana.com/beta/solana-install-init-x86_64-unknown-linux-gnu) as a stand-alone executable
+#### mac OS (x86_64-apple-darwin)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-apple-darwin.tar.bz2)
+* [solana-install-init](http://release.solana.com/beta/solana-install-init-x86_64-apple-darwin) as a stand-alone executable
+#### Windows (x86_64-pc-windows-msvc)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-pc-windows-msvc.tar.bz2)
+* [solana-install-init.exe](http://release.solana.com/beta/solana-install-init-x86_64-pc-windows-msvc.exe) as a stand-alone executable
+#### All platforms
+* [solana-metrics.tar.bz2](http://release.solana.com.s3.amazonaws.com/beta/solana-metrics.tar.bz2)
 
 Developing
 ===
@@ -273,10 +75,10 @@ Install rustc, cargo and rustfmt:
 ```bash
 $ curl https://sh.rustup.rs -sSf | sh
 $ source $HOME/.cargo/env
-$ rustup component add rustfmt-preview
+$ rustup component add rustfmt
 ```
 
-If your rustc version is lower than 1.26.1, please update it:
+If your rustc version is lower than 1.39.0, please update it:
 
 ```bash
 $ rustup update
@@ -285,7 +87,8 @@ $ rustup update
 On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, etc.  On Ubuntu:
 
 ```bash
-$ sudo apt-get install libssl-dev pkg-config zlib1g-dev
+$ sudo apt-get update
+$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```
 
 Download the source code:
@@ -295,6 +98,17 @@ $ git clone https://github.com/solana-labs/solana.git
 $ cd solana
 ```
 
+Build
+
+```bash
+$ cargo build
+```
+
+Then to run a minimal local cluster
+```bash
+$ ./run.sh
+```
+
 Testing
 ---
 
@@ -304,43 +118,88 @@ Run the test suite:
 $ cargo test
 ```
 
-To emulate all the tests that will run on a Pull Request, run:
-
-```bash
-$ ./ci/run-local.sh
-```
-
-Debugging
+Local Testnet
 ---
 
-There are some useful debug messages in the code, you can enable them on a per-module and per-level
-basis.  Before running a leader or validator set the normal RUST\_LOG environment variable.
+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).
 
-For example, to enable info everywhere and debug only in the solana::banking_stage module:
+Remote Testnets
+---
 
-```bash
-$ export RUST_LOG=info,solana::banking_stage=debug
-```
+* `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7
 
-Generally we are using debug for infrequent debug messages, trace for potentially frequent
-messages and info for performance-related logging.
 
-You can also attach to a running process with GDB.  The leader's process is named
-_solana-fullnode_:
+## Deploy process
 
-```bash
-$ sudo gdb
-attach <PID>
-set logging on
-thread apply all bt
-```
+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
 
-This will dump all the threads stack traces into gdb.txt
 
 Benchmarking
 ---
 
-First install the nightly build of rustc. `cargo bench` requires unstable features:
+First install the nightly build of rustc. `cargo bench` requires use of the
+unstable features only available in the nightly build.
 
 ```bash
 $ rustup install nightly
@@ -349,33 +208,24 @@ $ rustup install nightly
 Run the benchmarks:
 
 ```bash
-$ cargo +nightly bench --features="unstable"
+$ cargo +nightly bench
 ```
 
 Release Process
 ---
-The release process for this project is described [here](rfcs/rfc-005-branches-tags-and-channels.md).
+The release process for this project is described [here](RELEASE.md).
 
 
 Code coverage
 ---
 
-To generate code coverage statistics, install cargo-cov. Note: the tool currently only works
-in Rust nightly.
+To generate code coverage statistics:
 
 ```bash
-$ cargo +nightly install cargo-cov
+$ scripts/coverage.sh
+$ open target/cov/lcov-local/index.html
 ```
 
-Run cargo-cov and generate a report:
-
-```bash
-$ cargo +nightly cov test
-$ cargo +nightly cov report --open
-```
-
-The coverage report will be written to `./target/cov/report/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

RELEASE.md

@@ -1,32 +1,185 @@
 # Solana Release process
 
-## Introduction
+## Branches and Tags
 
-Solana uses a channel-oriented, date-based branching process described [here](https://github.com/solana-labs/solana/blob/master/rfcs/rfc-005-branches-tags-and-channels.md).
+```
+========================= master branch (edge channel) =======================>
+         \                      \                     \
+          \___v0.7.0 tag         \                     \
+           \                      \         v0.9.0 tag__\
+            \          v0.8.0 tag__\                     \
+ v0.7.1 tag__\                      \                 v0.9 branch (beta channel)
+              \___v0.7.2 tag         \___v0.8.1 tag
+               \                      \
+                \                      \
+           v0.7 branch         v0.8 branch (stable channel)
 
-## Release Steps
+```
 
-### Changing channels
+### master branch
+All new development occurs on the `master` branch.
 
-When cutting a new channel branch these pre-steps are required:
+Bug fixes that affect a `vX.Y` branch are first made on `master`.  This is to
+allow a fix some soak time on `master` before it is applied to one or more
+stabilization branches.
 
-1. Pick your branch point for release on master.
-2. Create the branch.  The name should be "v" + the first 2 "version" fields from Cargo.toml.  For example, a Cargo.toml with version = "0.9.0" implies the next branch name is "v0.9".
-3. Update Cargo.toml to the next semantic version (e.g. 0.9.0 -> 0.10.0).
-4. Push your new branch to solana.git
-5. Land your Carto.toml change as a master PR.
+Merging to `master` first also helps ensure that fixes applied to one release
+are present for future releases.  (Sometimes the joy of landing a critical
+release blocker in a branch causes you to forget to propagate back to
+`master`!)"
 
-At this point, ci/channel-info.sh should show your freshly cut release branch as "BETA_CHANNEL" and the previous release branch as "STABLE_CHANNEL".
+Once the bug fix lands on `master` it is cherry-picked into the `vX.Y` branch
+and potentially the `vX.Y-1` branch.  The exception to this rule is when a bug
+fix for `vX.Y` doesn't apply to `master` or `vX.Y-1`.
 
-### Updating channels (i.e. "making a release")
+Immediately after a new stabilization branch is forged, the `Cargo.toml` minor
+version (*Y*) in the `master` branch is incremented by the release engineer.
+Incrementing the major version of the `master` branch is outside the scope of
+this document.
 
-We use [github's Releases UI](https://github.com/solana-labs/solana/releases) for tagging a release.
+### v*X.Y* stabilization branches
+These are stabilization branches for a given milestone.  They are created off
+the `master` branch as late as possible prior to the milestone release.
 
-1. Go [there ;)](https://github.com/solana-labs/solana/releases).
-2. Click "Draft new release".
-3. If the first major release on the branch (e.g. v0.8.0), paste in [this template](https://raw.githubusercontent.com/solana-labs/solana/master/.github/RELEASE_TEMPLATE.md) and fill it in.
-4. Test the release by generating a tag using semver's rules.  First try at a release should be <branchname>.X-rc.0.
-5. Verify release automation:
-   1. [Crates.io](https://crates.io/crates/solana) should have an updated Solana version.
-   2. ...
-6. After testnet deployment, verify that testnets are running correct software.  http://metrics.solana.com should show testnet running on a hash from your newly created branch.
+### v*X.Y.Z* release tag
+The release tags are created as desired by the owner of the given stabilization
+branch, and cause that *X.Y.Z* release to be shipped to https://crates.io
+
+Immediately after a new v*X.Y.Z* branch tag has been created, the `Cargo.toml`
+patch version number (*Z*) of the stabilization branch is incremented by the
+release engineer.
+
+## Channels
+Channels are used by end-users (humans and bots) to consume the branches
+described in the previous section, so they may automatically update to the most
+recent version matching their desired stability.
+
+There are three release channels that map to branches as follows:
+* edge - tracks the `master` branch, least stable.
+* beta - tracks the largest (and latest) `vX.Y` stabilization branch, more stable.
+* stable - tracks the second largest `vX.Y` stabilization branch, most stable.
+
+## Steps to Create a Branch
+
+### Create the new branch
+1. Check out the latest commit on `master` branch:
+    ```
+    git fetch --all
+    git checkout upstream/master
+    ```
+1. Determine the new branch name.  The name should be "v" + the first 2 version fields
+   from Cargo.toml.  For example, a Cargo.toml with version = "0.9.0" implies
+   the next branch name is "v0.9".
+1. Create the new branch and push this branch to the `solana` repository:
+    ```
+    git checkout -b <branchname>
+    git push -u origin <branchname>
+    ```
+
+### Update master branch with the next version
+
+1. After the new branch has been created and pushed, update the Cargo.toml files on **master** to the next semantic version (e.g. 0.9.0 -> 0.10.0) with:
+     ```
+     scripts/increment-cargo-version.sh minor
+     ```
+1. Rebuild to get an updated version of `Cargo.lock`:
+    ```
+    cargo build
+    ```
+1. Push all the changed Cargo.toml and Cargo.lock files to the `master` branch with something like:
+    ```
+    git co -b version_update
+    git ls-files -m | xargs git add
+    git commit -m 'Update Cargo.toml versions from X.Y to X.Y+1'
+    git push -u origin version_update
+    ```
+1. Confirm that your freshly cut release branch is shown as `BETA_CHANNEL` and the previous release branch as `STABLE_CHANNEL`:
+    ```
+    ci/channel_info.sh
+    ```
+
+## Steps to Create a Release
+
+### Create the Release Tag on GitHub
+
+1. Go to [GitHub's Releases UI](https://github.com/solana-labs/solana/releases) for tagging a release.
+1. Click "Draft new release".  The release tag must exactly match the `version`
+   field in `/Cargo.toml` prefixed by `v`.
+   1.  If the Cargo.toml verion field is **0.12.3**, then the release tag must be **v0.12.3**
+1. Make sure the Target Branch field matches the branch you want to make a release on.
+   1.  If you want to release v0.12.0, the target branch must be v0.12
+1. If this is the first release on the branch (e.g. v0.13.**0**), paste in [this
+   template](https://raw.githubusercontent.com/solana-labs/solana/master/.github/RELEASE_TEMPLATE.md).  Engineering Lead can provide summary contents for release notes if needed.
+1. Click "Save Draft", then confirm the release notes look good and the tag name and branch are correct.  Go back into edit the release and click "Publish release" when ready.
+
+### Update release branch with the next patch version
+
+1. After the new release has been tagged, update the Cargo.toml files on **release branch** to the next semantic version (e.g. 0.9.0 -> 0.9.1) with:
+     ```
+     scripts/increment-cargo-version.sh patch
+     ```
+1. Rebuild to get an updated version of `Cargo.lock`:
+    ```
+    cargo build
+    ```
+1. Push all the changed Cargo.toml and Cargo.lock files to the **release branch** with something like:
+    ```
+    git co -b version_update
+    git ls-files -m | xargs git add
+    git commit -m 'Update Cargo.toml versions from X.Y.Z to X.Y.Z+1'
+    git push -u origin version_update
+    ```
+
+### Verify release automation success
+1. Go to [Solana Releases](https://github.com/solana-labs/solana/releases) and click on the latest release that you just published.  Verify that all of the build artifacts are present.  This can take up to 90 minutes after creating the tag.
+1. The `solana-secondary` Buildkite pipeline handles creating the binary tarballs and updated crates.  Look for a job under the tag name of the release: https://buildkite.com/solana-labs/solana-secondary
+1. [Crates.io](https://crates.io/crates/solana) should have an updated Solana version.
+
+### Update documentation
+TODO: Documentation update procedure is WIP as we move to gitbook
+
+Document the new recommended version by updating `docs/src/running-archiver.md` and `docs/src/validator-testnet.md` on the release (beta) branch to point at the `solana-install` for the upcoming release version.
+
+### Update software on devnet.solana.com
+
+The testnet running on devnet.solana.com is set to use a fixed release tag
+which is set in the Buildkite testnet-management pipeline.
+This tag needs to be updated and the testnet restarted after a new release
+tag is created.
+
+#### Update testnet schedules
+
+Go to https://buildkite.com/solana-labs and click through: Pipelines ->
+testnet-management -> Pipeline Settings -> Schedules
+Or just click here:
+https://buildkite.com/solana-labs/testnet-management/settings/schedules
+
+There are two scheduled jobs for testnet: a daily restart and an hourly sanity-or-restart. \
+https://buildkite.com/solana-labs/testnet-management/settings/schedules/0efd7856-7143-4713-8817-47e6bdb05387
+https://buildkite.com/solana-labs/testnet-management/settings/schedules/2a926646-d972-42b5-aeb9-bb6759592a53
+
+On each schedule:
+1.  Set TESTNET_TAG environment variable to the desired release tag.
+    1. Example, TESTNET_TAG=v0.13.2
+1.  Set the Build Branch to the branch that TESTNET_TAG is from.
+    1. Example: v0.13
+
+#### Restart the testnet
+
+Trigger a TESTNET_OP=create-and-start to refresh the cluster with the new version
+
+1.  Go to https://buildkite.com/solana-labs/testnet-management
+2.  Click "New Build" and use the following settings, then click "Create Build"
+    1.  Commit: HEAD
+    1.  Branch: [channel branch as set in the schedules]
+    1.  Environment Variables:
+```
+TESTNET=testnet
+TESTNET_TAG=[same value as used in TESTNET_TAG in the schedules]
+TESTNET_OP=create-and-start
+```
+
+### Alert the community
+
+Notify Discord users on #validator-support that a new release for
+devnet.solana.com is available

archiver-lib/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "solana-archiver-lib"
+version = "1.0.4"
+description = "Solana Archiver Library"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+bincode = "1.2.1"
+crossbeam-channel = "0.3"
+ed25519-dalek = "=1.0.0-pre.1"
+log = "0.4.8"
+rand = "0.6.5"
+rand_chacha = "0.1.1"
+solana-client = { path = "../client", version = "1.0.4" }
+solana-storage-program = { path = "../programs/storage", version = "1.0.4" }
+thiserror = "1.0"
+serde = "1.0.104"
+serde_json = "1.0.46"
+serde_derive = "1.0.103"
+solana-net-utils = { path = "../net-utils", version = "1.0.4" }
+solana-chacha = { path = "../chacha", version = "1.0.4" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.0.4" }
+solana-ledger = { path = "../ledger", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-perf = { path = "../perf", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+solana-core = { path = "../core", version = "1.0.4" }
+solana-archiver-utils = { path = "../archiver-utils", version = "1.0.4" }
+solana-metrics = { path = "../metrics", version = "1.0.4" }
+
+[dev-dependencies]
+hex = "0.4.0"
+
+[lib]
+name = "solana_archiver_lib"

archiver-lib/src/archiver.rs

@@ -0,0 +1,936 @@
+use crate::result::ArchiverError;
+use crossbeam_channel::unbounded;
+use rand::{thread_rng, Rng, SeedableRng};
+use rand_chacha::ChaChaRng;
+use solana_archiver_utils::sample_file;
+use solana_chacha::chacha::{chacha_cbc_encrypt_ledger, CHACHA_BLOCK_SIZE};
+use solana_client::{
+    rpc_client::RpcClient, rpc_request::RpcRequest, rpc_response::RpcStorageTurn,
+    thin_client::ThinClient,
+};
+use solana_core::{
+    cluster_info::{ClusterInfo, Node, VALIDATOR_PORT_RANGE},
+    contact_info::ContactInfo,
+    gossip_service::GossipService,
+    packet::{limited_deserialize, PACKET_DATA_SIZE},
+    repair_service,
+    repair_service::{RepairService, RepairSlotRange, RepairStrategy},
+    serve_repair::ServeRepair,
+    shred_fetch_stage::ShredFetchStage,
+    sigverify_stage::{DisabledSigVerifier, SigVerifyStage},
+    storage_stage::NUM_STORAGE_SAMPLES,
+    streamer::{receiver, responder, PacketReceiver},
+    window_service::WindowService,
+};
+use solana_ledger::{
+    blockstore::Blockstore, leader_schedule_cache::LeaderScheduleCache, shred::Shred,
+};
+use solana_net_utils::bind_in_range;
+use solana_perf::packet::Packets;
+use solana_perf::recycler::Recycler;
+use solana_sdk::packet::Packet;
+use solana_sdk::{
+    account_utils::StateMut,
+    client::{AsyncClient, SyncClient},
+    clock::{get_complete_segment_from_slot, get_segment_from_slot, Slot},
+    commitment_config::CommitmentConfig,
+    hash::Hash,
+    message::Message,
+    signature::{Keypair, Signature, Signer},
+    timing::timestamp,
+    transaction::Transaction,
+    transport::TransportError,
+};
+use solana_storage_program::{
+    storage_contract::StorageContract,
+    storage_instruction::{self, StorageAccountType},
+};
+use std::{
+    io::{self, ErrorKind},
+    net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
+    path::{Path, PathBuf},
+    result,
+    sync::atomic::{AtomicBool, Ordering},
+    sync::mpsc::{channel, Receiver, Sender},
+    sync::{Arc, RwLock},
+    thread::{sleep, spawn, JoinHandle},
+    time::Duration,
+};
+
+type Result<T> = std::result::Result<T, ArchiverError>;
+
+static ENCRYPTED_FILENAME: &str = "ledger.enc";
+
+#[derive(Serialize, Deserialize)]
+pub enum ArchiverRequest {
+    GetSlotHeight(SocketAddr),
+}
+
+pub struct Archiver {
+    thread_handles: Vec<JoinHandle<()>>,
+    exit: Arc<AtomicBool>,
+}
+
+// Shared Archiver Meta struct used internally
+#[derive(Default)]
+struct ArchiverMeta {
+    slot: Slot,
+    slots_per_segment: u64,
+    ledger_path: PathBuf,
+    signature: Signature,
+    ledger_data_file_encrypted: PathBuf,
+    sampling_offsets: Vec<u64>,
+    blockhash: Hash,
+    sha_state: Hash,
+    num_chacha_blocks: usize,
+    client_commitment: CommitmentConfig,
+}
+
+fn get_slot_from_signature(
+    signature: &Signature,
+    storage_turn: u64,
+    slots_per_segment: u64,
+) -> u64 {
+    let signature_vec = signature.as_ref();
+    let mut segment_index = u64::from(signature_vec[0])
+        | (u64::from(signature_vec[1]) << 8)
+        | (u64::from(signature_vec[1]) << 16)
+        | (u64::from(signature_vec[2]) << 24);
+    let max_segment_index =
+        get_complete_segment_from_slot(storage_turn, slots_per_segment).unwrap();
+    segment_index %= max_segment_index as u64;
+    segment_index * slots_per_segment
+}
+
+fn create_request_processor(
+    socket: UdpSocket,
+    exit: &Arc<AtomicBool>,
+    slot_receiver: Receiver<u64>,
+) -> Vec<JoinHandle<()>> {
+    let mut thread_handles = vec![];
+    let (s_reader, r_reader) = channel();
+    let (s_responder, r_responder) = channel();
+    let storage_socket = Arc::new(socket);
+    let recycler = Recycler::default();
+    let t_receiver = receiver(storage_socket.clone(), exit, s_reader, recycler, "archiver");
+    thread_handles.push(t_receiver);
+
+    let t_responder = responder("archiver-responder", storage_socket, r_responder);
+    thread_handles.push(t_responder);
+
+    let exit = exit.clone();
+    let t_processor = spawn(move || {
+        let slot = poll_for_slot(slot_receiver, &exit);
+
+        loop {
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+
+            let packets = r_reader.recv_timeout(Duration::from_secs(1));
+
+            if let Ok(packets) = packets {
+                for packet in &packets.packets {
+                    let req: result::Result<ArchiverRequest, Box<bincode::ErrorKind>> =
+                        limited_deserialize(&packet.data[..packet.meta.size]);
+                    match req {
+                        Ok(ArchiverRequest::GetSlotHeight(from)) => {
+                            let packet = Packet::from_data(&from, slot);
+                            let _ = s_responder.send(Packets::new(vec![packet]));
+                        }
+                        Err(e) => {
+                            info!("invalid request: {:?}", e);
+                        }
+                    }
+                }
+            }
+        }
+    });
+    thread_handles.push(t_processor);
+    thread_handles
+}
+
+fn poll_for_slot(receiver: Receiver<u64>, exit: &Arc<AtomicBool>) -> u64 {
+    loop {
+        let slot = receiver.recv_timeout(Duration::from_secs(1));
+        if let Ok(slot) = slot {
+            return slot;
+        }
+        if exit.load(Ordering::Relaxed) {
+            return 0;
+        }
+    }
+}
+
+impl Archiver {
+    /// Returns a Result that contains an archiver on success
+    ///
+    /// # Arguments
+    /// * `ledger_path` - path to where the ledger will be stored.
+    /// Causes panic if none
+    /// * `node` - The archiver node
+    /// * `cluster_entrypoint` - ContactInfo representing an entry into the network
+    /// * `keypair` - Keypair for this archiver
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new(
+        ledger_path: &Path,
+        node: Node,
+        cluster_entrypoint: ContactInfo,
+        keypair: Arc<Keypair>,
+        storage_keypair: Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) -> Result<Self> {
+        let exit = Arc::new(AtomicBool::new(false));
+
+        info!("Archiver: id: {}", keypair.pubkey());
+        info!("Creating cluster info....");
+        let mut cluster_info = ClusterInfo::new(node.info.clone(), keypair.clone());
+        cluster_info.set_entrypoint(cluster_entrypoint.clone());
+        let cluster_info = Arc::new(RwLock::new(cluster_info));
+
+        // Note for now, this ledger will not contain any of the existing entries
+        // in the ledger located at ledger_path, and will only append on newly received
+        // entries after being passed to window_service
+        let blockstore = Arc::new(
+            Blockstore::open(ledger_path).expect("Expected to be able to open database ledger"),
+        );
+
+        let gossip_service = GossipService::new(&cluster_info, None, node.sockets.gossip, &exit);
+
+        info!("Connecting to the cluster via {:?}", cluster_entrypoint);
+        let (nodes, _) =
+            match solana_core::gossip_service::discover_cluster(&cluster_entrypoint.gossip, 1) {
+                Ok(nodes_and_archivers) => nodes_and_archivers,
+                Err(e) => {
+                    //shutdown services before exiting
+                    exit.store(true, Ordering::Relaxed);
+                    gossip_service.join()?;
+                    return Err(e.into());
+                }
+            };
+        let client = solana_core::gossip_service::get_client(&nodes);
+
+        info!("Setting up mining account...");
+        if let Err(e) =
+            Self::setup_mining_account(&client, &keypair, &storage_keypair, client_commitment)
+        {
+            //shutdown services before exiting
+            exit.store(true, Ordering::Relaxed);
+            gossip_service.join()?;
+            return Err(e);
+        };
+
+        let repair_socket = Arc::new(node.sockets.repair);
+        let shred_sockets: Vec<Arc<UdpSocket>> =
+            node.sockets.tvu.into_iter().map(Arc::new).collect();
+        let shred_forward_sockets: Vec<Arc<UdpSocket>> = node
+            .sockets
+            .tvu_forwards
+            .into_iter()
+            .map(Arc::new)
+            .collect();
+        let (shred_fetch_sender, shred_fetch_receiver) = channel();
+        let fetch_stage = ShredFetchStage::new(
+            shred_sockets,
+            shred_forward_sockets,
+            repair_socket.clone(),
+            &shred_fetch_sender,
+            &exit,
+        );
+        let (slot_sender, slot_receiver) = channel();
+        let request_processor =
+            create_request_processor(node.sockets.storage.unwrap(), &exit, slot_receiver);
+
+        let t_archiver = {
+            let exit = exit.clone();
+            let node_info = node.info.clone();
+            let mut meta = ArchiverMeta {
+                ledger_path: ledger_path.to_path_buf(),
+                client_commitment,
+                ..ArchiverMeta::default()
+            };
+            spawn(move || {
+                // setup archiver
+                let window_service = match Self::setup(
+                    &mut meta,
+                    cluster_info.clone(),
+                    &blockstore,
+                    &exit,
+                    &node_info,
+                    &storage_keypair,
+                    repair_socket,
+                    shred_fetch_receiver,
+                    slot_sender,
+                ) {
+                    Ok(window_service) => window_service,
+                    Err(e) => {
+                        //shutdown services before exiting
+                        error!("setup failed {:?}; archiver thread exiting...", e);
+                        exit.store(true, Ordering::Relaxed);
+                        request_processor
+                            .into_iter()
+                            .for_each(|t| t.join().unwrap());
+                        fetch_stage.join().unwrap();
+                        gossip_service.join().unwrap();
+                        return;
+                    }
+                };
+
+                info!("setup complete");
+                // run archiver
+                Self::run(
+                    &mut meta,
+                    &blockstore,
+                    cluster_info,
+                    &keypair,
+                    &storage_keypair,
+                    &exit,
+                );
+                // wait until exit
+                request_processor
+                    .into_iter()
+                    .for_each(|t| t.join().unwrap());
+                fetch_stage.join().unwrap();
+                gossip_service.join().unwrap();
+                window_service.join().unwrap()
+            })
+        };
+
+        Ok(Self {
+            thread_handles: vec![t_archiver],
+            exit,
+        })
+    }
+
+    fn run(
+        meta: &mut ArchiverMeta,
+        blockstore: &Arc<Blockstore>,
+        cluster_info: Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        exit: &Arc<AtomicBool>,
+    ) {
+        // encrypt segment
+        Self::encrypt_ledger(meta, blockstore).expect("ledger encrypt not successful");
+        let enc_file_path = meta.ledger_data_file_encrypted.clone();
+        // do replicate
+        loop {
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+
+            // TODO check if more segments are available - based on space constraints
+            Self::create_sampling_offsets(meta);
+            let sampling_offsets = &meta.sampling_offsets;
+            meta.sha_state =
+                match Self::sample_file_to_create_mining_hash(&enc_file_path, sampling_offsets) {
+                    Ok(hash) => hash,
+                    Err(err) => {
+                        warn!("Error sampling file, exiting: {:?}", err);
+                        break;
+                    }
+                };
+
+            Self::submit_mining_proof(meta, &cluster_info, archiver_keypair, storage_keypair);
+
+            // TODO make this a lot more frequent by picking a "new" blockhash instead of picking a storage blockhash
+            // prep the next proof
+            let (storage_blockhash, _) = match Self::poll_for_blockhash_and_slot(
+                &cluster_info,
+                meta.slots_per_segment,
+                &meta.blockhash,
+                exit,
+            ) {
+                Ok(blockhash_and_slot) => blockhash_and_slot,
+                Err(e) => {
+                    warn!(
+                        "Error couldn't get a newer blockhash than {:?}. {:?}",
+                        meta.blockhash, e
+                    );
+                    break;
+                }
+            };
+            meta.blockhash = storage_blockhash;
+            Self::redeem_rewards(
+                &cluster_info,
+                archiver_keypair,
+                storage_keypair,
+                meta.client_commitment,
+            );
+        }
+        exit.store(true, Ordering::Relaxed);
+    }
+
+    fn redeem_rewards(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+        client_commitment: CommitmentConfig,
+    ) {
+        let nodes = cluster_info.read().unwrap().tvu_peers();
+        let client = solana_core::gossip_service::get_client(&nodes);
+
+        if let Ok(Some(account)) =
+            client.get_account_with_commitment(&storage_keypair.pubkey(), client_commitment)
+        {
+            if let Ok(StorageContract::ArchiverStorage { validations, .. }) = account.state() {
+                if !validations.is_empty() {
+                    let ix = storage_instruction::claim_reward(
+                        &archiver_keypair.pubkey(),
+                        &storage_keypair.pubkey(),
+                    );
+                    let message =
+                        Message::new_with_payer(vec![ix], Some(&archiver_keypair.pubkey()));
+                    if let Err(e) = client.send_message(&[archiver_keypair.as_ref()], message) {
+                        error!("unable to redeem reward, tx failed: {:?}", e);
+                    } else {
+                        info!(
+                            "collected mining rewards: Account balance {:?}",
+                            client.get_balance_with_commitment(
+                                &archiver_keypair.pubkey(),
+                                client_commitment
+                            )
+                        );
+                    }
+                }
+            }
+        } else {
+            info!("Redeem mining reward: No account data found");
+        }
+    }
+
+    // Find a segment to replicate and download it.
+    fn setup(
+        meta: &mut ArchiverMeta,
+        cluster_info: Arc<RwLock<ClusterInfo>>,
+        blockstore: &Arc<Blockstore>,
+        exit: &Arc<AtomicBool>,
+        node_info: &ContactInfo,
+        storage_keypair: &Arc<Keypair>,
+        repair_socket: Arc<UdpSocket>,
+        shred_fetch_receiver: PacketReceiver,
+        slot_sender: Sender<u64>,
+    ) -> Result<WindowService> {
+        let slots_per_segment =
+            match Self::get_segment_config(&cluster_info, meta.client_commitment) {
+                Ok(slots_per_segment) => slots_per_segment,
+                Err(e) => {
+                    error!("unable to get segment size configuration, exiting...");
+                    //shutdown services before exiting
+                    exit.store(true, Ordering::Relaxed);
+                    return Err(e);
+                }
+            };
+        let (segment_blockhash, segment_slot) = match Self::poll_for_segment(
+            &cluster_info,
+            slots_per_segment,
+            &Hash::default(),
+            exit,
+        ) {
+            Ok(blockhash_and_slot) => blockhash_and_slot,
+            Err(e) => {
+                //shutdown services before exiting
+                exit.store(true, Ordering::Relaxed);
+                return Err(e);
+            }
+        };
+        let signature = storage_keypair.sign_message(segment_blockhash.as_ref());
+        let slot = get_slot_from_signature(&signature, segment_slot, slots_per_segment);
+        info!("replicating slot: {}", slot);
+        slot_sender.send(slot)?;
+        meta.slot = slot;
+        meta.slots_per_segment = slots_per_segment;
+        meta.signature = signature;
+        meta.blockhash = segment_blockhash;
+
+        let mut repair_slot_range = RepairSlotRange::default();
+        repair_slot_range.end = slot + slots_per_segment;
+        repair_slot_range.start = slot;
+
+        let (retransmit_sender, _) = channel();
+
+        let (verified_sender, verified_receiver) = unbounded();
+
+        let _sigverify_stage = SigVerifyStage::new(
+            shred_fetch_receiver,
+            verified_sender,
+            DisabledSigVerifier::default(),
+        );
+
+        let window_service = WindowService::new(
+            blockstore.clone(),
+            cluster_info.clone(),
+            verified_receiver,
+            retransmit_sender,
+            repair_socket,
+            &exit,
+            RepairStrategy::RepairRange(repair_slot_range),
+            &Arc::new(LeaderScheduleCache::default()),
+            |_, _, _, _| true,
+        );
+        info!("waiting for ledger download");
+        Self::wait_for_segment_download(
+            slot,
+            slots_per_segment,
+            &blockstore,
+            &exit,
+            &node_info,
+            cluster_info,
+        );
+        Ok(window_service)
+    }
+
+    fn wait_for_segment_download(
+        start_slot: Slot,
+        slots_per_segment: u64,
+        blockstore: &Arc<Blockstore>,
+        exit: &Arc<AtomicBool>,
+        node_info: &ContactInfo,
+        cluster_info: Arc<RwLock<ClusterInfo>>,
+    ) {
+        info!(
+            "window created, waiting for ledger download starting at slot {:?}",
+            start_slot
+        );
+        let mut current_slot = start_slot;
+        'outer: loop {
+            while blockstore.is_full(current_slot) {
+                current_slot += 1;
+                info!("current slot: {}", current_slot);
+                if current_slot >= start_slot + slots_per_segment {
+                    break 'outer;
+                }
+            }
+            if exit.load(Ordering::Relaxed) {
+                break;
+            }
+            sleep(Duration::from_secs(1));
+        }
+
+        info!("Done receiving entries from window_service");
+
+        // Remove archiver from the data plane
+        let mut contact_info = node_info.clone();
+        contact_info.tvu = "0.0.0.0:0".parse().unwrap();
+        contact_info.wallclock = timestamp();
+        // copy over the adopted shred_version from the entrypoint
+        contact_info.shred_version = cluster_info.read().unwrap().my_data().shred_version;
+        {
+            let mut cluster_info_w = cluster_info.write().unwrap();
+            cluster_info_w.insert_self(contact_info);
+        }
+    }
+
+    fn encrypt_ledger(meta: &mut ArchiverMeta, blockstore: &Arc<Blockstore>) -> Result<()> {
+        meta.ledger_data_file_encrypted = meta.ledger_path.join(ENCRYPTED_FILENAME);
+
+        {
+            let mut ivec = [0u8; 64];
+            ivec.copy_from_slice(&meta.signature.as_ref());
+
+            let num_encrypted_bytes = chacha_cbc_encrypt_ledger(
+                blockstore,
+                meta.slot,
+                meta.slots_per_segment,
+                &meta.ledger_data_file_encrypted,
+                &mut ivec,
+            )?;
+
+            meta.num_chacha_blocks = num_encrypted_bytes / CHACHA_BLOCK_SIZE;
+        }
+
+        info!(
+            "Done encrypting the ledger: {:?}",
+            meta.ledger_data_file_encrypted
+        );
+        Ok(())
+    }
+
+    fn create_sampling_offsets(meta: &mut ArchiverMeta) {
+        meta.sampling_offsets.clear();
+        let mut rng_seed = [0u8; 32];
+        rng_seed.copy_from_slice(&meta.blockhash.as_ref());
+        let mut rng = ChaChaRng::from_seed(rng_seed);
+        for _ in 0..NUM_STORAGE_SAMPLES {
+            meta.sampling_offsets
+                .push(rng.gen_range(0, meta.num_chacha_blocks) as u64);
+        }
+    }
+
+    fn sample_file_to_create_mining_hash(
+        enc_file_path: &Path,
+        sampling_offsets: &[u64],
+    ) -> Result<Hash> {
+        let sha_state = sample_file(enc_file_path, sampling_offsets)?;
+        info!("sampled sha_state: {}", sha_state);
+        Ok(sha_state)
+    }
+
+    fn setup_mining_account(
+        client: &ThinClient,
+        keypair: &Keypair,
+        storage_keypair: &Keypair,
+        client_commitment: CommitmentConfig,
+    ) -> Result<()> {
+        // make sure archiver has some balance
+        info!("checking archiver keypair...");
+        if client.poll_balance_with_timeout_and_commitment(
+            &keypair.pubkey(),
+            &Duration::from_millis(100),
+            &Duration::from_secs(5),
+            client_commitment,
+        )? == 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",
+                    ),
+                })?;
+        }
+        Ok(())
+    }
+
+    fn submit_mining_proof(
+        meta: &ArchiverMeta,
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        archiver_keypair: &Arc<Keypair>,
+        storage_keypair: &Arc<Keypair>,
+    ) {
+        // No point if we've got no storage account...
+        let nodes = cluster_info.read().unwrap().tvu_peers();
+        let client = solana_core::gossip_service::get_client(&nodes);
+        let storage_balance = client
+            .poll_get_balance_with_commitment(&storage_keypair.pubkey(), meta.client_commitment);
+        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(vec![instruction], Some(&archiver_keypair.pubkey()));
+        let mut transaction = Transaction::new(
+            &[archiver_keypair.as_ref(), storage_keypair.as_ref()],
+            message,
+            blockhash,
+        );
+        if let Err(err) = client.send_and_confirm_transaction(
+            &[archiver_keypair.as_ref(), storage_keypair.as_ref()],
+            &mut transaction,
+            10,
+            0,
+        ) {
+            error!("Error: {:?}; while sending mining proof", err);
+        }
+    }
+
+    pub fn close(self) {
+        self.exit.store(true, Ordering::Relaxed);
+        self.join()
+    }
+
+    pub fn join(self) {
+        for handle in self.thread_handles {
+            handle.join().unwrap();
+        }
+    }
+
+    fn get_segment_config(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        client_commitment: CommitmentConfig,
+    ) -> Result<u64> {
+        let rpc_peers = {
+            let cluster_info = cluster_info.read().unwrap();
+            cluster_info.all_rpc_peers()
+        };
+        debug!("rpc peers: {:?}", rpc_peers);
+        if !rpc_peers.is_empty() {
+            let rpc_client = {
+                let node_index = thread_rng().gen_range(0, rpc_peers.len());
+                RpcClient::new_socket(rpc_peers[node_index].rpc)
+            };
+            Ok(rpc_client
+                .send(
+                    &RpcRequest::GetSlotsPerSegment,
+                    serde_json::json!([client_commitment]),
+                    0,
+                )
+                .map_err(|err| {
+                    warn!("Error while making rpc request {:?}", err);
+                    ArchiverError::ClientError(err)
+                })?
+                .as_u64()
+                .unwrap())
+        } else {
+            Err(ArchiverError::NoRpcPeers)
+        }
+    }
+
+    /// Waits until the first segment is ready, and returns the current segment
+    fn poll_for_segment(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        loop {
+            let (blockhash, turn_slot) = Self::poll_for_blockhash_and_slot(
+                cluster_info,
+                slots_per_segment,
+                previous_blockhash,
+                exit,
+            )?;
+            if get_complete_segment_from_slot(turn_slot, slots_per_segment).is_some() {
+                return Ok((blockhash, turn_slot));
+            }
+        }
+    }
+
+    /// Poll for a different blockhash and associated max_slot than `previous_blockhash`
+    fn poll_for_blockhash_and_slot(
+        cluster_info: &Arc<RwLock<ClusterInfo>>,
+        slots_per_segment: u64,
+        previous_blockhash: &Hash,
+        exit: &Arc<AtomicBool>,
+    ) -> Result<(Hash, u64)> {
+        info!("waiting for the next turn...");
+        loop {
+            let rpc_peers = {
+                let cluster_info = cluster_info.read().unwrap();
+                cluster_info.all_rpc_peers()
+            };
+            debug!("rpc peers: {:?}", rpc_peers);
+            if !rpc_peers.is_empty() {
+                let rpc_client = {
+                    let node_index = thread_rng().gen_range(0, rpc_peers.len());
+                    RpcClient::new_socket(rpc_peers[node_index].rpc)
+                };
+                let response = rpc_client
+                    .send(
+                        &RpcRequest::GetStorageTurn,
+                        serde_json::value::Value::Null,
+                        0,
+                    )
+                    .map_err(|err| {
+                        warn!("Error while making rpc request {:?}", err);
+                        ArchiverError::ClientError(err)
+                    })?;
+                let RpcStorageTurn {
+                    blockhash: storage_blockhash,
+                    slot: turn_slot,
+                } = serde_json::from_value::<RpcStorageTurn>(response)
+                    .map_err(ArchiverError::JsonError)?;
+                let turn_blockhash = storage_blockhash.parse().map_err(|err| {
+                    io::Error::new(
+                        io::ErrorKind::Other,
+                        format!(
+                            "Blockhash parse failure: {:?} on {:?}",
+                            err, storage_blockhash
+                        ),
+                    )
+                })?;
+                if turn_blockhash != *previous_blockhash {
+                    info!("turn slot: {}", turn_slot);
+                    if get_segment_from_slot(turn_slot, slots_per_segment) != 0 {
+                        return Ok((turn_blockhash, turn_slot));
+                    }
+                }
+            }
+            if exit.load(Ordering::Relaxed) {
+                return Err(ArchiverError::IO(io::Error::new(
+                    ErrorKind::Other,
+                    "exit signalled...",
+                )));
+            }
+            sleep(Duration::from_secs(5));
+        }
+    }
+
+    /// Ask an archiver to populate a given blockstore with its segment.
+    /// Return the slot at the start of the archiver's segment
+    ///
+    /// It is recommended to use a temporary blockstore for this since the download will not verify
+    /// shreds received and might impact the chaining of shreds across slots
+    pub fn download_from_archiver(
+        serve_repair: &ServeRepair,
+        archiver_info: &ContactInfo,
+        blockstore: &Arc<Blockstore>,
+        slots_per_segment: u64,
+    ) -> Result<u64> {
+        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,
+            );
+            //iter over the repairs and send them
+            if let Ok(repairs) = repairs {
+                let reqs: Vec<_> = repairs
+                    .into_iter()
+                    .filter_map(|repair_request| {
+                        serve_repair
+                            .map_repair_request(&repair_request)
+                            .map(|result| ((archiver_info.gossip, result), repair_request))
+                            .ok()
+                    })
+                    .collect();
+
+                for ((to, req), repair_request) in reqs {
+                    if let Ok(local_addr) = repair_socket.local_addr() {
+                        datapoint_info!(
+                            "archiver_download",
+                            ("repair_request", format!("{:?}", repair_request), String),
+                            ("to", to.to_string(), String),
+                            ("from", local_addr.to_string(), String),
+                            ("id", id.to_string(), String)
+                        );
+                    }
+                    repair_socket
+                        .send_to(&req, archiver_info.gossip)
+                        .unwrap_or_else(|e| {
+                            error!("{} repair req send_to({}) error {:?}", id, to, e);
+                            0
+                        });
+                }
+            }
+            let res = r_reader.recv_timeout(Duration::new(1, 0));
+            if let Ok(mut packets) = res {
+                while let Ok(mut more) = r_reader.try_recv() {
+                    packets.packets.append_pinned(&mut more.packets);
+                }
+                let shreds: Vec<Shred> = packets
+                    .packets
+                    .into_iter()
+                    .filter_map(|p| Shred::new_from_serialized_shred(p.data.to_vec()).ok())
+                    .collect();
+                blockstore.insert_shreds(shreds, None, false)?;
+            }
+            // check if all the slots in the segment are complete
+            if Self::segment_complete(start_slot, slots_per_segment, blockstore) {
+                break;
+            }
+            sleep(Duration::from_millis(500));
+        }
+        exit.store(true, Ordering::Relaxed);
+        t_receiver.join().unwrap();
+
+        // check if all the slots in the segment are complete
+        if !Self::segment_complete(start_slot, slots_per_segment, blockstore) {
+            return Err(ArchiverError::SegmentDownloadError);
+        }
+        Ok(start_slot)
+    }
+
+    fn segment_complete(
+        start_slot: Slot,
+        slots_per_segment: u64,
+        blockstore: &Arc<Blockstore>,
+    ) -> bool {
+        for slot in start_slot..(start_slot + slots_per_segment) {
+            if !blockstore.is_full(slot) {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn get_archiver_segment_slot(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

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

@@ -0,0 +1,48 @@
+use serde_json;
+use solana_client::client_error;
+use solana_ledger::blockstore;
+use solana_sdk::transport;
+use std::any::Any;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ArchiverError {
+    #[error("IO error")]
+    IO(#[from] std::io::Error),
+
+    #[error("blockstore error")]
+    BlockstoreError(#[from] blockstore::BlockstoreError),
+
+    #[error("crossbeam error")]
+    CrossbeamSendError(#[from] crossbeam_channel::SendError<u64>),
+
+    #[error("send error")]
+    SendError(#[from] std::sync::mpsc::SendError<u64>),
+
+    #[error("join error")]
+    JoinError(Box<dyn Any + Send + 'static>),
+
+    #[error("transport error")]
+    TransportError(#[from] transport::TransportError),
+
+    #[error("client error")]
+    ClientError(#[from] client_error::ClientError),
+
+    #[error("Json parsing error")]
+    JsonError(#[from] serde_json::error::Error),
+
+    #[error("Storage account has no balance")]
+    EmptyStorageAccountBalance,
+
+    #[error("No RPC peers..")]
+    NoRpcPeers,
+
+    #[error("Couldn't download full segment")]
+    SegmentDownloadError,
+}
+
+impl std::convert::From<Box<dyn Any + Send + 'static>> for ArchiverError {
+    fn from(e: Box<dyn Any + Send + 'static>) -> ArchiverError {
+        ArchiverError::JoinError(e)
+    }
+}

archiver-utils/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "solana-archiver-utils"
+version = "1.0.4"
+description = "Solana Archiver Utils"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+rand = "0.6.5"
+solana-chacha = { path = "../chacha", version = "1.0.4" }
+solana-chacha-sys = { path = "../chacha-sys", version = "1.0.4" }
+solana-ledger = { path = "../ledger", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-perf = { path = "../perf", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+
+[dev-dependencies]
+hex = "0.4.0"
+
+[lib]
+name = "solana_archiver_utils"

archiver-utils/src/lib.rs

@@ -0,0 +1,120 @@
+#[macro_use]
+extern crate log;
+
+use solana_sdk::hash::{Hash, Hasher};
+use std::fs::File;
+use std::io::{self, BufReader, ErrorKind, Read, Seek, SeekFrom};
+use std::mem::size_of;
+use std::path::Path;
+
+pub fn sample_file(in_path: &Path, sample_offsets: &[u64]) -> io::Result<Hash> {
+    let in_file = File::open(in_path)?;
+    let metadata = in_file.metadata()?;
+    let mut buffer_file = BufReader::new(in_file);
+
+    let mut hasher = Hasher::default();
+    let sample_size = size_of::<Hash>();
+    let sample_size64 = sample_size as u64;
+    let mut buf = vec![0; sample_size];
+
+    let file_len = metadata.len();
+    if file_len < sample_size64 {
+        return Err(io::Error::new(ErrorKind::Other, "file too short!"));
+    }
+    for offset in sample_offsets {
+        if *offset > (file_len - sample_size64) / sample_size64 {
+            return Err(io::Error::new(ErrorKind::Other, "offset too large"));
+        }
+        buffer_file.seek(SeekFrom::Start(*offset * sample_size64))?;
+        trace!("sampling @ {} ", *offset);
+        match buffer_file.read(&mut buf) {
+            Ok(size) => {
+                assert_eq!(size, buf.len());
+                hasher.hash(&buf);
+            }
+            Err(e) => {
+                warn!("Error sampling file");
+                return Err(e);
+            }
+        }
+    }
+
+    Ok(hasher.result())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::{thread_rng, Rng};
+    use std::fs::{create_dir_all, remove_file};
+    use std::io::Write;
+    use std::path::PathBuf;
+
+    extern crate hex;
+
+    fn tmp_file_path(name: &str) -> PathBuf {
+        use std::env;
+        let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let mut rand_bits = [0u8; 32];
+        thread_rng().fill(&mut rand_bits[..]);
+
+        let mut path = PathBuf::new();
+        path.push(out_dir);
+        path.push("tmp");
+        create_dir_all(&path).unwrap();
+
+        path.push(format!("{}-{:?}", name, hex::encode(rand_bits)));
+        println!("path: {:?}", path);
+        path
+    }
+
+    #[test]
+    fn test_sample_file() {
+        solana_logger::setup();
+        let in_path = tmp_file_path("test_sample_file_input.txt");
+        let num_strings = 4096;
+        let string = "12foobar";
+        {
+            let mut in_file = File::create(&in_path).unwrap();
+            for _ in 0..num_strings {
+                in_file.write(string.as_bytes()).unwrap();
+            }
+        }
+        let num_samples = (string.len() * num_strings / size_of::<Hash>()) as u64;
+        let samples: Vec<_> = (0..num_samples).collect();
+        let res = sample_file(&in_path, samples.as_slice());
+        let ref_hash: Hash = Hash::new(&[
+            173, 251, 182, 165, 10, 54, 33, 150, 133, 226, 106, 150, 99, 192, 179, 1, 230, 144,
+            151, 126, 18, 191, 54, 67, 249, 140, 230, 160, 56, 30, 170, 52,
+        ]);
+        let res = res.unwrap();
+        assert_eq!(res, ref_hash);
+
+        // Sample just past the end
+        assert!(sample_file(&in_path, &[num_samples]).is_err());
+        remove_file(&in_path).unwrap();
+    }
+
+    #[test]
+    fn test_sample_file_invalid_offset() {
+        let in_path = tmp_file_path("test_sample_file_invalid_offset_input.txt");
+        {
+            let mut in_file = File::create(&in_path).unwrap();
+            for _ in 0..4096 {
+                in_file.write("123456foobar".as_bytes()).unwrap();
+            }
+        }
+        let samples = [0, 200000];
+        let res = sample_file(&in_path, &samples);
+        assert!(res.is_err());
+        remove_file(in_path).unwrap();
+    }
+
+    #[test]
+    fn test_sample_file_missing_file() {
+        let in_path = tmp_file_path("test_sample_file_that_doesnt_exist.txt");
+        let samples = [0, 5];
+        let res = sample_file(&in_path, &samples);
+        assert!(res.is_err());
+    }
+}

archiver/.gitignore

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

archiver/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-archiver"
+version = "1.0.4"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+
+[dependencies]
+clap = "2.33.0"
+console = "0.9.2"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.4" }
+solana-core = { path = "../core", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-metrics = { path = "../metrics", version = "1.0.4" }
+solana-archiver-lib = { path = "../archiver-lib", version = "1.0.4" }
+solana-net-utils = { path = "../net-utils", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+

archiver/src/main.rs

@@ -0,0 +1,153 @@
+use clap::{crate_description, crate_name, App, Arg};
+use console::style;
+use solana_archiver_lib::archiver::Archiver;
+use solana_clap_utils::{
+    input_validators::is_keypair,
+    keypair::{
+        self, keypair_input, KeypairWithSource, ASK_SEED_PHRASE_ARG,
+        SKIP_SEED_PHRASE_VALIDATION_ARG,
+    },
+};
+use solana_core::{
+    cluster_info::{Node, VALIDATOR_PORT_RANGE},
+    contact_info::ContactInfo,
+};
+use solana_sdk::{commitment_config::CommitmentConfig, signature::Signer};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    path::PathBuf,
+    process::exit,
+    sync::Arc,
+};
+
+fn main() {
+    solana_logger::setup();
+
+    let matches = App::new(crate_name!())
+        .about(crate_description!())
+        .version(solana_clap_utils::version!())
+        .arg(
+            Arg::with_name("identity_keypair")
+                .short("i")
+                .long("identity-keypair")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair)
+                .help("File containing an identity (keypair)"),
+        )
+        .arg(
+            Arg::with_name("entrypoint")
+                .short("n")
+                .long("entrypoint")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .required(true)
+                .validator(solana_net_utils::is_host_port)
+                .help("Rendezvous with the cluster at this entry point"),
+        )
+        .arg(
+            Arg::with_name("ledger")
+                .short("l")
+                .long("ledger")
+                .value_name("DIR")
+                .takes_value(true)
+                .required(true)
+                .help("use DIR as persistent ledger location"),
+        )
+        .arg(
+            Arg::with_name("storage_keypair")
+                .short("s")
+                .long("storage-keypair")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair)
+                .help("File containing the storage account keypair"),
+        )
+        .arg(
+            Arg::with_name(ASK_SEED_PHRASE_ARG.name)
+                .long(ASK_SEED_PHRASE_ARG.long)
+                .value_name("KEYPAIR NAME")
+                .multiple(true)
+                .takes_value(true)
+                .possible_values(&["identity-keypair", "storage-keypair"])
+                .help(ASK_SEED_PHRASE_ARG.help),
+        )
+        .arg(
+            Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
+                .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
+                .requires(ASK_SEED_PHRASE_ARG.name)
+                .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
+        )
+        .get_matches();
+
+    let ledger_path = PathBuf::from(matches.value_of("ledger").unwrap());
+
+    let identity_keypair = keypair_input(&matches, "identity_keypair")
+        .unwrap_or_else(|err| {
+            eprintln!("Identity keypair input failed: {}", err);
+            exit(1);
+        })
+        .keypair;
+    let KeypairWithSource {
+        keypair: storage_keypair,
+        source: storage_keypair_source,
+    } = keypair_input(&matches, "storage_keypair").unwrap_or_else(|err| {
+        eprintln!("Storage keypair input failed: {}", err);
+        exit(1);
+    });
+    if storage_keypair_source == keypair::Source::Generated {
+        clap::Error::with_description(
+            "The `storage-keypair` argument was not found",
+            clap::ErrorKind::ArgumentNotFound,
+        )
+        .exit();
+    }
+
+    let entrypoint_addr = matches
+        .value_of("entrypoint")
+        .map(|entrypoint| {
+            solana_net_utils::parse_host_port(entrypoint)
+                .expect("failed to parse entrypoint address")
+        })
+        .unwrap();
+
+    let gossip_addr = {
+        let ip = solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap();
+        let mut addr = SocketAddr::new(ip, 0);
+        addr.set_ip(solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap());
+        addr
+    };
+    let node = Node::new_archiver_with_external_ip(
+        &identity_keypair.pubkey(),
+        &gossip_addr,
+        VALIDATOR_PORT_RANGE,
+        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/.gitignore

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

banking-bench/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-banking-bench"
+version = "1.0.4"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+
+[dependencies]
+log = "0.4.6"
+rayon = "1.2.0"
+solana-core = { path = "../core", version = "1.0.4" }
+solana-ledger = { path = "../ledger", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-runtime = { path = "../runtime", version = "1.0.4" }
+solana-measure = { path = "../measure", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+rand = "0.6.5"
+crossbeam-channel = "0.3"

banking-bench/src/main.rs

@@ -0,0 +1,306 @@
+use crossbeam_channel::unbounded;
+use log::*;
+use rand::{thread_rng, Rng};
+use rayon::prelude::*;
+use solana_core::banking_stage::{create_test_recorder, BankingStage};
+use solana_core::cluster_info::ClusterInfo;
+use solana_core::cluster_info::Node;
+use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
+use solana_core::packet::to_packets_chunked;
+use solana_core::poh_recorder::PohRecorder;
+use solana_core::poh_recorder::WorkingBankEntry;
+use solana_ledger::bank_forks::BankForks;
+use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
+use solana_measure::measure::Measure;
+use solana_runtime::bank::Bank;
+use solana_sdk::hash::Hash;
+use solana_sdk::pubkey::Pubkey;
+use solana_sdk::signature::Keypair;
+use solana_sdk::signature::Signature;
+use solana_sdk::system_transaction;
+use solana_sdk::timing::{duration_as_us, timestamp};
+use solana_sdk::transaction::Transaction;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc::Receiver;
+use std::sync::{Arc, Mutex, RwLock};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+fn check_txs(
+    receiver: &Arc<Receiver<WorkingBankEntry>>,
+    ref_tx_count: usize,
+    poh_recorder: &Arc<Mutex<PohRecorder>>,
+) -> bool {
+    let mut total = 0;
+    let now = Instant::now();
+    let mut no_bank = false;
+    loop {
+        if let Ok((_bank, (entry, _tick_height))) = receiver.recv_timeout(Duration::from_millis(10))
+        {
+            total += entry.transactions.len();
+        }
+        if total >= ref_tx_count {
+            break;
+        }
+        if now.elapsed().as_secs() > 60 {
+            break;
+        }
+        if poh_recorder.lock().unwrap().bank().is_none() {
+            trace!("no bank");
+            no_bank = true;
+            break;
+        }
+    }
+    if !no_bank {
+        assert!(total >= ref_tx_count);
+    }
+    no_bank
+}
+
+fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> {
+    let to_pubkey = Pubkey::new_rand();
+    let dummy = system_transaction::transfer(mint_keypair, &to_pubkey, 1, hash);
+    (0..txes)
+        .into_par_iter()
+        .map(|_| {
+            let mut new = dummy.clone();
+            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
+            new.message.account_keys[0] = Pubkey::new_rand();
+            new.message.account_keys[1] = Pubkey::new_rand();
+            new.signatures = vec![Signature::new(&sig[0..64])];
+            new
+        })
+        .collect()
+}
+
+struct Config {
+    packets_per_batch: usize,
+    chunk_len: usize,
+    num_threads: usize,
+}
+
+impl Config {
+    fn get_transactions_index(&self, chunk_index: usize) -> usize {
+        chunk_index * (self.chunk_len / self.num_threads) * self.packets_per_batch
+    }
+}
+
+fn bytes_as_usize(bytes: &[u8]) -> usize {
+    bytes[0] as usize | (bytes[1] as usize) << 8
+}
+
+fn main() {
+    solana_logger::setup();
+    let num_threads = BankingStage::num_threads() as usize;
+    //   a multiple of packet chunk duplicates to avoid races
+    const CHUNKS: usize = 8 * 2;
+    const PACKETS_PER_BATCH: usize = 192;
+    let txes = PACKETS_PER_BATCH * num_threads * CHUNKS;
+    let mint_total = 1_000_000_000_000;
+    let GenesisConfigInfo {
+        genesis_config,
+        mint_keypair,
+        ..
+    } = create_genesis_config(mint_total);
+
+    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 = bank_forks.working_bank();
+
+    info!("threads: {} txs: {}", num_threads, txes);
+
+    let mut transactions = make_accounts_txs(txes, &mint_keypair, genesis_config.hash());
+
+    // fund all the accounts
+    transactions.iter().for_each(|tx| {
+        let fund = system_transaction::transfer(
+            &mint_keypair,
+            &tx.message.account_keys[0],
+            mint_total / txes as u64,
+            genesis_config.hash(),
+        );
+        let x = bank.process_transaction(&fund);
+        x.unwrap();
+    });
+    //sanity check, make sure all the transactions can execute sequentially
+    transactions.iter().for_each(|tx| {
+        let res = bank.process_transaction(&tx);
+        assert!(res.is_ok(), "sanity test transactions");
+    });
+    bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute in parallel
+    let res = bank.process_transactions(&transactions);
+    for r in res {
+        assert!(r.is_ok(), "sanity parallel execution");
+    }
+    bank.clear_signatures();
+    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
+    let ledger_path = get_tmp_ledger_path!();
+    {
+        let blockstore = Arc::new(
+            Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
+        );
+        let (exit, poh_recorder, poh_service, signal_receiver) =
+            create_test_recorder(&bank, &blockstore, None);
+        let cluster_info = ClusterInfo::new_with_invalid_keypair(Node::new_localhost().info);
+        let cluster_info = Arc::new(RwLock::new(cluster_info));
+        let banking_stage = BankingStage::new(
+            &cluster_info,
+            &poh_recorder,
+            verified_receiver,
+            vote_receiver,
+            None,
+        );
+        poh_recorder.lock().unwrap().set_bank(&bank);
+
+        let chunk_len = verified.len() / CHUNKS;
+        let mut start = 0;
+
+        // This is so that the signal_receiver does not go out of scope after the closure.
+        // If it is dropped before poh_service, then poh_service will error when
+        // calling send() on the channel.
+        let signal_receiver = Arc::new(signal_receiver);
+        let mut total_us = 0;
+        let mut tx_total_us = 0;
+        let mut txs_processed = 0;
+        let mut root = 1;
+        let collector = Pubkey::new_rand();
+        const ITERS: usize = 1_000;
+        let config = Config {
+            packets_per_batch: PACKETS_PER_BATCH,
+            chunk_len,
+            num_threads,
+        };
+        let mut total_sent = 0;
+        for _ in 0..ITERS {
+            let now = Instant::now();
+            let mut sent = 0;
+
+            for (i, v) in verified[start..start + chunk_len]
+                .chunks(chunk_len / num_threads)
+                .enumerate()
+            {
+                let mut byte = 0;
+                let index = config.get_transactions_index(start + i);
+                if index < transactions.len() {
+                    byte = bytes_as_usize(transactions[index].signatures[0].as_ref());
+                }
+                trace!(
+                    "sending... {}..{} {} v.len: {} sig: {} transactions.len: {} index: {}",
+                    start + i,
+                    start + chunk_len,
+                    timestamp(),
+                    v.len(),
+                    byte,
+                    transactions.len(),
+                    index,
+                );
+                for xv in v {
+                    sent += xv.packets.len();
+                }
+                verified_sender.send(v.to_vec()).unwrap();
+            }
+            let start_tx_index = config.get_transactions_index(start);
+            let end_tx_index = config.get_transactions_index(start + chunk_len);
+            for tx in &transactions[start_tx_index..end_tx_index] {
+                loop {
+                    if bank.get_signature_status(&tx.signatures[0]).is_some() {
+                        break;
+                    }
+                    if poh_recorder.lock().unwrap().bank().is_none() {
+                        break;
+                    }
+                    sleep(Duration::from_millis(5));
+                }
+            }
+            if check_txs(&signal_receiver, txes / CHUNKS, &poh_recorder) {
+                debug!(
+                    "resetting bank {} tx count: {} txs_proc: {}",
+                    bank.slot(),
+                    bank.transaction_count(),
+                    txs_processed
+                );
+                assert!(txs_processed < bank.transaction_count());
+                txs_processed = bank.transaction_count();
+                tx_total_us += duration_as_us(&now.elapsed());
+
+                let mut poh_time = Measure::start("poh_time");
+                poh_recorder.lock().unwrap().reset(
+                    bank.last_blockhash(),
+                    bank.slot(),
+                    Some((bank.slot(), bank.slot() + 1)),
+                );
+                poh_time.stop();
+
+                let mut new_bank_time = Measure::start("new_bank");
+                let new_bank = Bank::new_from_parent(&bank, &collector, bank.slot() + 1);
+                new_bank_time.stop();
+
+                let mut insert_time = Measure::start("insert_time");
+                bank_forks.insert(new_bank);
+                bank = bank_forks.working_bank();
+                insert_time.stop();
+
+                poh_recorder.lock().unwrap().set_bank(&bank);
+                assert!(poh_recorder.lock().unwrap().bank().is_some());
+                if bank.slot() > 32 {
+                    bank_forks.set_root(root, &None);
+                    root += 1;
+                }
+                debug!(
+                    "new_bank_time: {}us insert_time: {}us poh_time: {}us",
+                    new_bank_time.as_us(),
+                    insert_time.as_us(),
+                    poh_time.as_us(),
+                );
+            } else {
+                tx_total_us += duration_as_us(&now.elapsed());
+            }
+
+            // This signature clear may not actually clear the signatures
+            // in this chunk, but since we rotate between CHUNKS then
+            // we should clear them by the time we come around again to re-use that chunk.
+            bank.clear_signatures();
+            total_us += duration_as_us(&now.elapsed());
+            debug!(
+                "time: {} us checked: {} sent: {}",
+                duration_as_us(&now.elapsed()),
+                txes / CHUNKS,
+                sent,
+            );
+            total_sent += sent;
+
+            if bank.slot() > 0 && bank.slot() % 16 == 0 {
+                for tx in transactions.iter_mut() {
+                    tx.message.recent_blockhash = bank.last_blockhash();
+                    let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
+                    tx.signatures[0] = Signature::new(&sig[0..64]);
+                }
+                verified = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
+            }
+
+            start += chunk_len;
+            start %= verified.len();
+        }
+        eprintln!(
+            "{{'name': 'banking_bench_total', 'median': '{}'}}",
+            (1000.0 * 1000.0 * total_sent as f64) / (total_us as f64),
+        );
+        eprintln!(
+            "{{'name': 'banking_bench_tx_total', 'median': '{}'}}",
+            (1000.0 * 1000.0 * total_sent as f64) / (tx_total_us as f64),
+        );
+
+        drop(verified_sender);
+        drop(vote_sender);
+        exit.store(true, Ordering::Relaxed);
+        banking_stage.join().unwrap();
+        debug!("waited for banking_stage");
+        poh_service.join().unwrap();
+        sleep(Duration::from_secs(1));
+        debug!("waited for poh_service");
+    }
+    let _unused = Blockstore::destroy(&ledger_path);
+}

bench-exchange/.gitignore

@@ -0,0 +1,4 @@
+/target/
+/config/
+/config-local/
+/farf/

bench-exchange/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-bench-exchange"
+version = "1.0.4"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+publish = false
+
+[dependencies]
+clap = "2.32.0"
+itertools = "0.8.2"
+log = "0.4.8"
+num-derive = "0.3"
+num-traits = "0.2"
+rand = "0.6.5"
+rayon = "1.2.0"
+serde_json = "1.0.46"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.4" }
+solana-core = { path = "../core", version = "1.0.4" }
+solana-genesis = { path = "../genesis", version = "1.0.4" }
+solana-client = { path = "../client", version = "1.0.4" }
+solana-faucet = { path = "../faucet", version = "1.0.4" }
+solana-exchange-program = { path = "../programs/exchange", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-metrics = { path = "../metrics", version = "1.0.4" }
+solana-net-utils = { path = "../net-utils", version = "1.0.4" }
+solana-runtime = { path = "../runtime", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+
+[dev-dependencies]
+solana-local-cluster = { path = "../local-cluster", version = "1.0.4" }

bench-exchange/README.md

@@ -0,0 +1,479 @@
+# token-exchange
+Solana Token Exchange Bench
+
+If you can't wait; jump to [Running the exchange](#Running-the-exchange) to
+learn how to start and interact with the exchange.
+
+### Table of Contents
+[Overview](#Overview)<br>
+[Premise](#Premise)<br>
+[Exchange startup](#Exchange-startup)<br>
+[Order Requests](#Trade-requests)<br>
+[Order Cancellations](#Trade-cancellations)<br>
+[Trade swap](#Trade-swap)<br>
+[Exchange program operations](#Exchange-program-operations)<br>
+[Quotes and OHLCV](#Quotes-and-OHLCV)<br>
+[Investor strategies](#Investor-strategies)<br>
+[Running the exchange](#Running-the-exchange)<br>
+
+## Overview
+
+An exchange is a marketplace where one asset can be traded for another.  This
+demo demonstrates one way to host an exchange on the Solana blockchain by
+emulating a currency exchange.
+
+The assets are virtual tokens held by investors who may post order requests to
+the exchange.  A Matcher monitors the exchange and posts swap requests for
+matching orders.  All the transactions can execute concurrently.
+
+## Premise
+
+- Exchange
+  -  An exchange is a marketplace where one asset can be traded for another.
+     The exchange in this demo is the on-chain program that implements the
+     tokens and the policies for trading those tokens.
+- Token
+  - A virtual asset that can be owned, traded, and holds virtual intrinsic value
+    compared to other assets.  There are four types of tokens in this demo, A,
+    B, C, D.  Each one may be traded for another.
+- Token account
+  - An account owned by the exchange that holds a quantity of one type of token.
+- Account request
+  - A request to create a token account
+- Token request
+  - A request to deposit tokens of a particular type into a token account.
+- Asset pair
+  - A struct with fields Base and Quote, representing the two assets which make up a 
+    trading pair,  which themselves are Tokens. The Base or 'primary' asset is the
+    numerator and the Quote is the denominator for pricing purposes.
+- Order side
+  - Describes which side of the market an investor wants to place a trade on. Options
+    are "Bid" or "Ask", where a bid represents an offer to purchase the Base asset of
+    the AssetPair for a sum of the Quote Asset and an Ask is an offer to sell Base asset
+    for the Quote asset.
+- Price ratio
+  -  An expression of the relative prices of two tokens. Calculated with the Base
+     Asset as the numerator and the Quote Asset as the denominator. Ratios are 
+     represented as fixed point numbers.  The fixed point scaler is defined in
+     [exchange_state.rs](https://github.com/solana-labs/solana/blob/c2fdd1362a029dcf89c8907c562d2079d977df11/programs/exchange_api/src/exchange_state.rs#L7)
+- Order request
+  - A Solana transaction sent by a trader to the exchange to submit an order. 
+    Order requests are made up of the token pair, the order side (bid or ask),
+    quantity of the primary token, the price ratio, and the two token accounts
+    to be credited/deducted.  An example trade request looks like "T AB 5 2" 
+    which reads "Exchange 5 A tokens to B tokens at a price ratio of 1:2"  A fulfilled trade would result in 5 A tokens
+    deducted and 10 B tokens credited to the trade initiator's token accounts.
+    Successful order requests result in an order.
+- Order
+  - The result of a successful order request.  orders are stored in
+    accounts owned by the submitter of the order request.  They can only be
+    canceled by their owner but can be used by anyone in a trade swap.  They
+    contain the same information as the order request.
+- Price spread
+  - The difference between the two matching orders. The spread is the
+    profit of the Matcher initiating the swap request.
+- Match requirements
+  - Policies that result in a successful trade swap.
+- Match request
+  - A request to fill two complementary orders (bid/ask), resulting if successful,
+    in a trade being created.
+- Trade
+  - A successful trade is created from two matching orders that meet
+    swap requirements which are submitted in a Match Request by a Matcher and
+    executed by the exchange. A trade may not wholly satisfy one or both of the
+    orders in which case the orders are adjusted appropriately. Upon execution,
+    tokens are distributed to the traders' accounts and any overlap or 
+    "negative spread" between orders is deposited into the Matcher's profit
+    account.  All successful trades are recorded in the data of a new solana 
+    account for posterity.
+- Investor
+  - Individual investors who hold a number of tokens and wish to trade them on
+    the exchange.  Investors operate as Solana thin clients who own a set of
+    accounts containing tokens and/or order requests.  Investors post
+    transactions to the exchange in order to request tokens and post or cancel
+    order requests.
+- Matcher
+  - An agent who facilitates trading between investors.  Matchers operate as
+    Solana thin clients who monitor all the orders looking for a trade
+    match.  Once found, the Matcher issues a swap request to the exchange.
+    Matchers are the engine of the exchange and are rewarded for their efforts by
+    accumulating the price spreads of the swaps they initiate.  Matchers also
+    provide current bid/ask price and OHLCV (Open, High, Low, Close, Volume)
+    information on demand via a public network port.
+- Transaction fees
+  - Solana transaction fees are paid for by the transaction submitters who are
+    the Investors and Matchers.
+
+## Exchange startup
+
+The exchange is up and running when it reaches a state where it can take
+investors' trades and Matchers' match requests.  To achieve this state the
+following must occur in order:
+
+- Start the Solana blockchain
+- Start the  thin-client
+- The Matcher subscribes to change notifications for all the accounts owned by
+  the exchange program id.  The subscription is managed via Solana's JSON RPC
+  interface.
+- The Matcher starts responding to queries for bid/ask price and OHLCV
+
+The Matcher responding successfully to price and OHLCV requests is the signal to
+the investors that trades submitted after that point will be analyzed.  <!--This
+is not ideal, and instead investors should be able to submit trades at any time,
+and the Matcher could come and go without missing a trade.  One way to achieve
+this is for the Matcher to read the current state of all accounts looking for all
+open orders.-->
+
+Investors will initially query the exchange to discover their current balance
+for each type of token.  If the investor does not already have an account for
+each type of token, they will submit account requests.  Matcher as well will
+request accounts to hold the tokens they earn by initiating trade swaps.
+
+```rust
+/// Supported token types
+pub enum Token {
+    A,
+    B,
+    C,
+    D,
+}
+
+/// Supported token pairs
+pub enum TokenPair {
+    AB,
+    AC,
+    AD,
+    BC,
+    BD,
+    CD,
+}
+
+pub enum ExchangeInstruction {
+    /// New token account
+    /// key 0 - Signer
+    /// key 1 - New token account
+    AccountRequest,
+}
+
+/// Token accounts are populated with this structure
+pub struct TokenAccountInfo {
+    /// Investor who owns this account
+    pub owner: Pubkey,
+    /// Current number of tokens this account holds
+    pub tokens: Tokens,
+}
+```
+
+For this demo investors or Matcher can request more tokens from the exchange at
+any time by submitting token requests. In non-demos, an exchange of this type
+would provide another way to exchange a 3rd party asset into tokens.
+
+To request tokens, investors submit transfer requests:
+
+```rust
+pub enum ExchangeInstruction {
+    /// Transfer tokens between two accounts
+    /// key 0 - Account to transfer tokens to
+    /// key 1 - Account to transfer tokens from.  This can be the exchange program itself,
+    ///         the exchange has a limitless number of tokens it can transfer.
+    TransferRequest(Token, u64),
+}
+```
+
+## Order Requests
+
+When an investor decides to exchange a token of one type for another, they
+submit a transaction to the Solana Blockchain containing an order request, which,
+if successful, is turned into an order.  orders do not expire but are
+cancellable. <!-- orders should have a timestamp to enable trade
+expiration -->  When an order is created, tokens are deducted from a token
+account and the order acts as an escrow.  The tokens are held until the
+order is fulfilled or canceled. If the direction is `To`, then the number
+of `tokens` are deducted from the primary account, if `From` then `tokens`
+multiplied by `price` are deducted from the secondary account.  orders are
+no longer valid when the number of `tokens` goes to zero, at which point they
+can no longer be used. <!-- Could support refilling orders, so order
+accounts are refilled rather than accumulating -->
+
+```rust
+/// Direction of the exchange between two tokens in a pair
+pub enum Direction {
+    /// Trade first token type (primary) in the pair 'To' the second
+    To,
+    /// Trade first token type in the pair 'From' the second (secondary)
+    From,
+}
+
+pub struct OrderRequestInfo {
+    /// Direction of trade
+    pub direction: Direction,
+
+    /// Token pair to trade
+    pub pair: TokenPair,
+
+    /// Number of tokens to exchange; refers to the primary or the secondary depending on the direction
+    pub tokens: u64,
+
+    /// The price ratio the primary price over the secondary price.  The primary price is fixed
+    /// and equal to the variable `SCALER`.
+    pub price: u64,
+
+    /// Token account to deposit tokens on successful swap
+    pub dst_account: Pubkey,
+}
+
+pub enum ExchangeInstruction {
+    /// order request
+    /// key 0 - Signer
+    /// key 1 - Account in which to record the swap
+    /// key 2 - Token account associated with this trade
+    TradeRequest(TradeRequestInfo),
+}
+
+/// Trade accounts are populated with this structure
+pub struct TradeOrderInfo {
+    /// Owner of the order
+    pub owner: Pubkey,
+    /// Direction of the exchange
+    pub direction: Direction,
+    /// Token pair indicating two tokens to exchange, first is primary
+    pub pair: TokenPair,
+    /// Number of tokens to exchange; primary or secondary depending on direction
+    pub tokens: u64,
+    /// Scaled price of the secondary token given the primary is equal to the scale value
+    /// If scale is 1 and price is 2 then ratio is 1:2 or 1 primary token for 2 secondary tokens
+    pub price: u64,
+    /// account which the tokens were source from.  The trade account holds the tokens in escrow
+    /// until either one or more part of a swap or the trade is canceled.
+    pub src_account: Pubkey,
+    /// account which the tokens the tokens will be deposited into on a successful trade
+    pub dst_account: Pubkey,
+}
+```
+
+## Order cancellations
+
+An investor may cancel a trade at anytime, but only trades they own.  If the
+cancellation is successful, any tokens held in escrow are returned to the
+account from which they came.
+
+```rust
+pub enum ExchangeInstruction {
+    /// order cancellation
+    /// key 0 - Signer
+    /// key 1 -order to cancel
+    TradeCancellation,
+}
+```
+
+## Trade swaps
+
+The Matcher is monitoring the accounts assigned to the exchange program and
+building a trade-order table.  The order table is used to identify
+matching orders which could be fulfilled.  When a match is found the
+Matcher should issue a swap request.  Swap requests may not satisfy the entirety
+of either order, but the exchange will greedily fulfill it.  Any leftover tokens
+in either account will keep the order valid for further swap requests in
+the future.
+
+Matching orders are defined by the following swap requirements:
+
+- Opposite polarity (one `To` and one `From`)
+- Operate on the same token pair
+- The price ratio of the `From` order is greater than or equal to the `To` order
+- There are sufficient tokens to perform the trade
+
+Orders can be written in the following format:
+
+`investor direction pair quantity price-ratio`
+
+For example:
+
+- `1 T AB 2 1`
+  - Investor 1 wishes to exchange 2 A tokens to B tokens at a ratio of 1 A to 1
+    B
+- `2 F AC 6 1.2`
+  - Investor 2 wishes to exchange A tokens from 6 B tokens at a ratio of 1 A
+    from 1.2 B
+
+An order table could look something like the following. Notice how the columns
+are sorted low to high and high to low, respectively.  Prices are dramatic and
+whole for clarity.
+
+|Row| To          | From       |
+|---|-------------|------------|
+| 1 | 1 T AB 2 4  | 2 F AB 2 8 |
+| 2 | 1 T AB 1 4  | 2 F AB 2 8 |
+| 3 | 1 T AB 6 6  | 2 F AB 2 7 |
+| 4 | 1 T AB 2 8  | 2 F AB 3 6 |
+| 5 | 1 T AB 2 10 | 2 F AB 1 5 |
+
+As part of a successful swap request, the exchange will credit tokens to the
+Matcher's account equal to the difference in the price ratios or the two orders.
+These tokens are considered the Matcher's profit for initiating the trade.
+
+The Matcher would initiate the following swap on the order table above:
+
+  - Row 1, To:   Investor 1 trades 2 A tokens to 8 B tokens
+  - Row 1, From: Investor 2 trades 2 A tokens from 8 B tokens
+  - Matcher takes 8 B tokens as profit
+
+Both row 1 trades are fully realized, table becomes:
+
+|Row| To          | From       |
+|---|-------------|------------|
+| 1 | 1 T AB 1 4  | 2 F AB 2 8 |
+| 2 | 1 T AB 6 6  | 2 F AB 2 7 |
+| 3 | 1 T AB 2 8  | 2 F AB 3 6 |
+| 4 | 1 T AB 2 10 | 2 F AB 1 5 |
+
+The Matcher would initiate the following swap:
+
+  - Row 1, To:   Investor 1 trades 1 A token to 4 B tokens
+  - Row 1, From: Investor 2 trades 1 A token from 4 B tokens
+  - Matcher takes 4 B tokens as profit
+
+Row 1 From is not fully realized, table becomes:
+
+|Row| To          | From       |
+|---|-------------|------------|
+| 1 | 1 T AB 6 6  | 2 F AB 1 8 |
+| 2 | 1 T AB 2 8  | 2 F AB 2 7 |
+| 3 | 1 T AB 2 10 | 2 F AB 3 6 |
+| 4 |             | 2 F AB 1 5 |
+
+The Matcher would initiate the following swap:
+
+  - Row 1, To:   Investor 1 trades 1 A token to 6 B tokens
+  - Row 1, From: Investor 2 trades 1 A token from 6 B tokens
+  - Matcher takes 2 B tokens as profit
+
+Row 1 To is now fully realized, table becomes:
+
+|Row| To          | From       |
+|---|-------------|------------|
+| 1 | 1 T AB 5 6  | 2 F AB 2 7 |
+| 2 | 1 T AB 2 8  | 2 F AB 3 5 |
+| 3 | 1 T AB 2 10 | 2 F AB 1 5 |
+
+The Matcher would initiate the following last swap:
+
+  - Row 1, To:   Investor 1 trades 2 A token to 12 B tokens
+  - Row 1, From: Investor 2 trades 2 A token from 12 B tokens
+  - Matcher takes 2 B tokens as profit
+
+Table becomes:
+
+|Row| To          | From       |
+|---|-------------|------------|
+| 1 | 1 T AB 3 6  | 2 F AB 3 5 |
+| 2 | 1 T AB 2 8  | 2 F AB 1 5 |
+| 3 | 1 T AB 2 10 |            |
+
+At this point the lowest To's price is larger than the largest From's price so
+no more swaps would be initiated until new orders came in.
+
+```rust
+pub enum ExchangeInstruction {
+    /// Trade swap request
+    /// key 0 - Signer
+    /// key 1 - Account in which to record the swap
+    /// key 2 - 'To' order
+    /// key 3 - `From` order
+    /// key 4 - Token account associated with the To Trade
+    /// key 5 - Token account associated with From trade
+    /// key 6 - Token account in which to deposit the Matcher profit from the swap.
+    SwapRequest,
+}
+
+/// Swap accounts are populated with this structure
+pub struct TradeSwapInfo {
+    /// Pair swapped
+    pub pair: TokenPair,
+    /// `To` order
+    pub to_trade_order: Pubkey,
+    /// `From` order
+    pub from_trade_order: Pubkey,
+    /// Number of primary tokens exchanged
+    pub primary_tokens: u64,
+    /// Price the primary tokens were exchanged for
+    pub primary_price: u64,
+    /// Number of secondary tokens exchanged
+    pub secondary_tokens: u64,
+    /// Price the secondary tokens were exchanged for
+    pub secondary_price: u64,
+}
+```
+
+## Exchange program operations
+
+Putting all the commands together from above, the following operations will be
+supported by the on-chain exchange program:
+
+```rust
+pub enum ExchangeInstruction {
+    /// New token account
+    /// key 0 - Signer
+    /// key 1 - New token account
+    AccountRequest,
+
+    /// Transfer tokens between two accounts
+    /// key 0 - Account to transfer tokens to
+    /// key 1 - Account to transfer tokens from.  This can be the exchange program itself,
+    ///         the exchange has a limitless number of tokens it can transfer.
+    TransferRequest(Token, u64),
+
+    /// order request
+    /// key 0 - Signer
+    /// key 1 - Account in which to record the swap
+    /// key 2 - Token account associated with this trade
+    TradeRequest(TradeRequestInfo),
+
+    /// order cancellation
+    /// key 0 - Signer
+    /// key 1 -order to cancel
+    TradeCancellation,
+
+    /// Trade swap request
+    /// key 0 - Signer
+    /// key 1 - Account in which to record the swap
+    /// key 2 - 'To' order
+    /// key 3 - `From` order
+    /// key 4 - Token account associated with the To Trade
+    /// key 5 - Token account associated with From trade
+    /// key 6 - Token account in which to deposit the Matcher profit from the swap.
+    SwapRequest,
+}
+```
+
+## Quotes and OHLCV
+
+The Matcher will provide current bid/ask price quotes based on trade actively and
+also provide OHLCV based on some time window.  The details of how the bid/ask
+price quotes are calculated are yet to be decided.
+
+## Investor strategies
+
+To make a compelling demo, the investors needs to provide interesting trade
+behavior.  Something as simple as a randomly twiddled baseline would be a
+minimum starting point.
+
+## Running the exchange
+
+The exchange bench posts trades and swaps matches as fast as it can.  
+
+You might want to bump the duration up
+to 60 seconds and the batch size to 1000 for better numbers.  You can modify those
+in client_demo/src/demo.rs::test_exchange_local_cluster.
+
+The following command runs the bench:
+
+```bash
+$ RUST_LOG=solana_bench_exchange=info cargo test --release -- --nocapture test_exchange_local_cluster
+```
+
+To also see the cluster messages:
+
+```bash
+$ RUST_LOG=solana_bench_exchange=info,solana=info cargo test --release -- --nocapture test_exchange_local_cluster
+```

bench-exchange/src/cli.rs

@@ -0,0 +1,220 @@
+use clap::{crate_description, crate_name, value_t, App, Arg, ArgMatches};
+use solana_core::gen_keys::GenKeys;
+use solana_faucet::faucet::FAUCET_PORT;
+use solana_sdk::signature::{read_keypair_file, Keypair};
+use std::net::SocketAddr;
+use std::process::exit;
+use std::time::Duration;
+
+pub struct Config {
+    pub entrypoint_addr: SocketAddr,
+    pub faucet_addr: SocketAddr,
+    pub identity: Keypair,
+    pub threads: usize,
+    pub num_nodes: usize,
+    pub duration: Duration,
+    pub transfer_delay: u64,
+    pub fund_amount: u64,
+    pub batch_size: usize,
+    pub chunk_size: usize,
+    pub account_groups: usize,
+    pub client_ids_and_stake_file: String,
+    pub write_to_client_file: bool,
+    pub read_from_client_file: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            entrypoint_addr: SocketAddr::from(([127, 0, 0, 1], 8001)),
+            faucet_addr: SocketAddr::from(([127, 0, 0, 1], FAUCET_PORT)),
+            identity: Keypair::new(),
+            num_nodes: 1,
+            threads: 4,
+            duration: Duration::new(u64::max_value(), 0),
+            transfer_delay: 0,
+            fund_amount: 100_000,
+            batch_size: 100,
+            chunk_size: 100,
+            account_groups: 100,
+            client_ids_and_stake_file: String::new(),
+            write_to_client_file: false,
+            read_from_client_file: false,
+        }
+    }
+}
+
+pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
+    App::new(crate_name!())
+        .about(crate_description!())
+        .version(version)
+        .arg(
+            Arg::with_name("entrypoint")
+                .short("n")
+                .long("entrypoint")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .required(false)
+                .default_value("127.0.0.1:8001")
+                .help("Cluster entry point; defaults to 127.0.0.1:8001"),
+        )
+        .arg(
+            Arg::with_name("faucet")
+                .short("d")
+                .long("faucet")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .required(false)
+                .default_value("127.0.0.1:9900")
+                .help("Location of the faucet; defaults to 127.0.0.1:9900"),
+        )
+        .arg(
+            Arg::with_name("identity")
+                .short("i")
+                .long("identity")
+                .value_name("PATH")
+                .takes_value(true)
+                .help("File containing a client identity (keypair)"),
+        )
+        .arg(
+            Arg::with_name("threads")
+                .long("threads")
+                .value_name("<threads>")
+                .takes_value(true)
+                .required(false)
+                .default_value("1")
+                .help("Number of threads submitting transactions"),
+        )
+        .arg(
+            Arg::with_name("num-nodes")
+                .long("num-nodes")
+                .value_name("NUM")
+                .takes_value(true)
+                .required(false)
+                .default_value("1")
+                .help("Wait for NUM nodes to converge"),
+        )
+        .arg(
+            Arg::with_name("duration")
+                .long("duration")
+                .value_name("SECS")
+                .takes_value(true)
+                .default_value("60")
+                .help("Seconds to run benchmark, then exit; default is forever"),
+        )
+        .arg(
+            Arg::with_name("transfer-delay")
+                .long("transfer-delay")
+                .value_name("<delay>")
+                .takes_value(true)
+                .required(false)
+                .default_value("0")
+                .help("Delay between each chunk"),
+        )
+        .arg(
+            Arg::with_name("fund-amount")
+                .long("fund-amount")
+                .value_name("<fund>")
+                .takes_value(true)
+                .required(false)
+                .default_value("100000")
+                .help("Number of lamports to fund to each signer"),
+        )
+        .arg(
+            Arg::with_name("batch-size")
+                .long("batch-size")
+                .value_name("<batch>")
+                .takes_value(true)
+                .required(false)
+                .default_value("1000")
+                .help("Number of transactions before the signer rolls over"),
+        )
+        .arg(
+            Arg::with_name("chunk-size")
+                .long("chunk-size")
+                .value_name("<cunk>")
+                .takes_value(true)
+                .required(false)
+                .default_value("500")
+                .help("Number of transactions to generate and send at a time"),
+        )
+        .arg(
+            Arg::with_name("account-groups")
+                .long("account-groups")
+                .value_name("<groups>")
+                .takes_value(true)
+                .required(false)
+                .default_value("10")
+                .help("Number of account groups to cycle for each batch"),
+        )
+        .arg(
+            Arg::with_name("write-client-keys")
+                .long("write-client-keys")
+                .value_name("FILENAME")
+                .takes_value(true)
+                .help("Generate client keys and stakes and write the list to YAML file"),
+        )
+        .arg(
+            Arg::with_name("read-client-keys")
+                .long("read-client-keys")
+                .value_name("FILENAME")
+                .takes_value(true)
+                .help("Read client keys and stakes from the YAML file"),
+        )
+}
+
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
+    let mut args = Config::default();
+
+    args.entrypoint_addr = solana_net_utils::parse_host_port(
+        matches.value_of("entrypoint").unwrap(),
+    )
+    .unwrap_or_else(|e| {
+        eprintln!("failed to parse entrypoint address: {}", e);
+        exit(1)
+    });
+
+    args.faucet_addr = solana_net_utils::parse_host_port(matches.value_of("faucet").unwrap())
+        .unwrap_or_else(|e| {
+            eprintln!("failed to parse faucet address: {}", e);
+            exit(1)
+        });
+
+    if matches.is_present("identity") {
+        args.identity = read_keypair_file(matches.value_of("identity").unwrap())
+            .expect("can't read client identity");
+    } else {
+        args.identity = {
+            let seed = [42_u8; 32];
+            let mut rnd = GenKeys::new(seed);
+            rnd.gen_keypair()
+        };
+    }
+    args.threads = value_t!(matches.value_of("threads"), usize).expect("Failed to parse threads");
+    args.num_nodes =
+        value_t!(matches.value_of("num-nodes"), usize).expect("Failed to parse num-nodes");
+    let duration = value_t!(matches.value_of("duration"), u64).expect("Failed to parse duration");
+    args.duration = Duration::from_secs(duration);
+    args.transfer_delay =
+        value_t!(matches.value_of("transfer-delay"), u64).expect("Failed to parse transfer-delay");
+    args.fund_amount =
+        value_t!(matches.value_of("fund-amount"), u64).expect("Failed to parse fund-amount");
+    args.batch_size =
+        value_t!(matches.value_of("batch-size"), usize).expect("Failed to parse batch-size");
+    args.chunk_size =
+        value_t!(matches.value_of("chunk-size"), usize).expect("Failed to parse chunk-size");
+    args.account_groups = value_t!(matches.value_of("account-groups"), usize)
+        .expect("Failed to parse account-groups");
+
+    if let Some(s) = matches.value_of("write-client-keys") {
+        args.write_to_client_file = true;
+        args.client_ids_and_stake_file = s.to_string();
+    }
+
+    if let Some(s) = matches.value_of("read-client-keys") {
+        assert!(!args.write_to_client_file);
+        args.read_from_client_file = true;
+        args.client_ids_and_stake_file = s.to_string();
+    }
+    args
+}

bench-exchange/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod bench;
+pub mod cli;
+mod order_book;

bench-exchange/src/main.rs

@@ -0,0 +1,83 @@
+pub mod bench;
+mod cli;
+pub mod order_book;
+
+use crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config};
+use log::*;
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
+use solana_sdk::signature::Signer;
+
+fn main() {
+    solana_logger::setup();
+    solana_metrics::set_panic_hook("bench-exchange");
+
+    let matches = cli::build_args(solana_clap_utils::version!()).get_matches();
+    let cli_config = cli::extract_args(&matches);
+
+    let cli::Config {
+        entrypoint_addr,
+        faucet_addr,
+        identity,
+        threads,
+        num_nodes,
+        duration,
+        transfer_delay,
+        fund_amount,
+        batch_size,
+        chunk_size,
+        account_groups,
+        client_ids_and_stake_file,
+        write_to_client_file,
+        read_from_client_file,
+        ..
+    } = cli_config;
+
+    let config = Config {
+        identity,
+        threads,
+        duration,
+        transfer_delay,
+        fund_amount,
+        batch_size,
+        chunk_size,
+        account_groups,
+        client_ids_and_stake_file,
+        read_from_client_file,
+    };
+
+    if write_to_client_file {
+        create_client_accounts_file(
+            &config.client_ids_and_stake_file,
+            config.batch_size,
+            config.account_groups,
+            config.fund_amount,
+        );
+    } else {
+        info!("Connecting to the cluster");
+        let (nodes, _archivers) =
+            discover_cluster(&entrypoint_addr, num_nodes).unwrap_or_else(|_| {
+                panic!("Failed to discover nodes");
+            });
+
+        let (client, num_clients) = get_multi_client(&nodes);
+
+        info!("{} nodes found", num_clients);
+        if num_clients < num_nodes {
+            panic!("Error: Insufficient nodes discovered");
+        }
+
+        if !read_from_client_file {
+            info!("Funding keypair: {}", config.identity.pubkey());
+
+            let accounts_in_groups = batch_size * account_groups;
+            const NUM_SIGNERS: u64 = 2;
+            airdrop_lamports(
+                &client,
+                &faucet_addr,
+                &config.identity,
+                fund_amount * (accounts_in_groups + 1) as u64 * NUM_SIGNERS,
+            );
+        }
+        do_bench_exchange(vec![client], config);
+    }
+}

bench-exchange/src/order_book.rs

@@ -0,0 +1,134 @@
+use itertools::EitherOrBoth::{Both, Left, Right};
+use itertools::Itertools;
+use log::*;
+use solana_exchange_program::exchange_state::*;
+use solana_sdk::pubkey::Pubkey;
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+use std::{error, fmt};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ToOrder {
+    pub pubkey: Pubkey,
+    pub info: OrderInfo,
+}
+
+impl Ord for ToOrder {
+    fn cmp(&self, other: &Self) -> Ordering {
+        other.info.price.cmp(&self.info.price)
+    }
+}
+impl PartialOrd for ToOrder {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FromOrder {
+    pub pubkey: Pubkey,
+    pub info: OrderInfo,
+}
+
+impl Ord for FromOrder {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.info.price.cmp(&other.info.price)
+    }
+}
+impl PartialOrd for FromOrder {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[derive(Default)]
+pub struct OrderBook {
+    // TODO scale to x token types
+    to_ab: BinaryHeap<ToOrder>,
+    from_ab: BinaryHeap<FromOrder>,
+}
+impl fmt::Display for OrderBook {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(
+            f,
+            "+-Order Book--------------------------+-------------------------------------+"
+        )?;
+        for (i, it) in self
+            .to_ab
+            .iter()
+            .zip_longest(self.from_ab.iter())
+            .enumerate()
+        {
+            match it {
+                Both(to, from) => writeln!(
+                    f,
+                    "| T AB {:8} for {:8}/{:8} | F AB {:8} for {:8}/{:8} |{}",
+                    to.info.tokens,
+                    SCALER,
+                    to.info.price,
+                    from.info.tokens,
+                    SCALER,
+                    from.info.price,
+                    i
+                )?,
+                Left(to) => writeln!(
+                    f,
+                    "| T AB {:8} for {:8}/{:8} |                                     |{}",
+                    to.info.tokens, SCALER, to.info.price, i
+                )?,
+                Right(from) => writeln!(
+                    f,
+                    "|                                     | F AB {:8} for {:8}/{:8} |{}",
+                    from.info.tokens, SCALER, from.info.price, i
+                )?,
+            }
+        }
+        write!(
+            f,
+            "+-------------------------------------+-------------------------------------+"
+        )?;
+        Ok(())
+    }
+}
+
+impl OrderBook {
+    // TODO
+    // pub fn cancel(&mut self, pubkey: Pubkey) -> Result<(), Box<dyn error::Error>> {
+    //     Ok(())
+    // }
+    pub fn push(&mut self, pubkey: Pubkey, info: OrderInfo) -> Result<(), Box<dyn error::Error>> {
+        check_trade(info.side, info.tokens, info.price)?;
+        match info.side {
+            OrderSide::Ask => {
+                self.to_ab.push(ToOrder { pubkey, info });
+            }
+            OrderSide::Bid => {
+                self.from_ab.push(FromOrder { pubkey, info });
+            }
+        }
+        Ok(())
+    }
+    pub fn pop(&mut self) -> Option<(ToOrder, FromOrder)> {
+        if let Some(pair) = Self::pop_pair(&mut self.to_ab, &mut self.from_ab) {
+            return Some(pair);
+        }
+        None
+    }
+    pub fn get_num_outstanding(&self) -> (usize, usize) {
+        (self.to_ab.len(), self.from_ab.len())
+    }
+
+    fn pop_pair(
+        to_ab: &mut BinaryHeap<ToOrder>,
+        from_ab: &mut BinaryHeap<FromOrder>,
+    ) -> Option<(ToOrder, FromOrder)> {
+        let to = to_ab.peek()?;
+        let from = from_ab.peek()?;
+        if from.info.price < to.info.price {
+            debug!("Trade not viable");
+            return None;
+        }
+        let to = to_ab.pop()?;
+        let from = from_ab.pop()?;
+        Some((to, from))
+    }
+}

bench-exchange/tests/bench_exchange.rs

@@ -0,0 +1,103 @@
+use log::*;
+use solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
+use solana_core::validator::ValidatorConfig;
+use solana_exchange_program::exchange_processor::process_instruction;
+use solana_exchange_program::id;
+use solana_exchange_program::solana_exchange_program;
+use solana_faucet::faucet::run_local_faucet;
+use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
+use solana_runtime::bank::Bank;
+use solana_runtime::bank_client::BankClient;
+use solana_sdk::genesis_config::create_genesis_config;
+use solana_sdk::signature::{Keypair, Signer};
+use std::process::exit;
+use std::sync::mpsc::channel;
+use std::time::Duration;
+
+#[test]
+#[ignore]
+fn test_exchange_local_cluster() {
+    solana_logger::setup();
+
+    const NUM_NODES: usize = 1;
+
+    let mut config = Config::default();
+    config.identity = Keypair::new();
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 15
+    config.batch_size = 100; // 1000;
+    config.chunk_size = 10; // 200;
+    config.account_groups = 1; // 10;
+    let Config {
+        fund_amount,
+        batch_size,
+        account_groups,
+        ..
+    } = config;
+    let accounts_in_groups = batch_size * account_groups;
+
+    let cluster = LocalCluster::new(&ClusterConfig {
+        node_stakes: vec![100_000; NUM_NODES],
+        cluster_lamports: 100_000_000_000_000,
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
+        native_instruction_processors: [solana_exchange_program!()].to_vec(),
+        ..ClusterConfig::default()
+    });
+
+    let faucet_keypair = Keypair::new();
+    cluster.transfer(
+        &cluster.funding_keypair,
+        &faucet_keypair.pubkey(),
+        2_000_000_000_000,
+    );
+
+    let (addr_sender, addr_receiver) = channel();
+    run_local_faucet(faucet_keypair, addr_sender, Some(1_000_000_000_000));
+    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();
+
+    info!("Connecting to the cluster");
+    let (nodes, _) =
+        discover_cluster(&cluster.entry_point_info.gossip, NUM_NODES).unwrap_or_else(|err| {
+            error!("Failed to discover {} nodes: {:?}", NUM_NODES, err);
+            exit(1);
+        });
+
+    let (client, num_clients) = get_multi_client(&nodes);
+
+    info!("clients: {}", num_clients);
+    assert!(num_clients >= NUM_NODES);
+
+    const NUM_SIGNERS: u64 = 2;
+    airdrop_lamports(
+        &client,
+        &faucet_addr,
+        &config.identity,
+        fund_amount * (accounts_in_groups + 1) as u64 * NUM_SIGNERS,
+    );
+
+    do_bench_exchange(vec![client], config);
+}
+
+#[test]
+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_instruction_processor(id(), process_instruction);
+    let clients = vec![BankClient::new(bank)];
+
+    let mut config = Config::default();
+    config.identity = identity;
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 0;
+    config.batch_size = 100; // 1500;
+    config.chunk_size = 10; // 1500;
+    config.account_groups = 1; // 50;
+
+    do_bench_exchange(clients, config);
+}

bench-streamer/.gitignore

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

bench-streamer/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-bench-streamer"
+version = "1.0.4"
+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.0.4" }
+solana-core = { path = "../core", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-net-utils = { path = "../net-utils", version = "1.0.4" }

bench-streamer/src/main.rs

@@ -1,38 +1,33 @@
-extern crate clap;
-extern crate solana;
-
-use clap::{App, Arg};
-use solana::netutil::bind_to;
-use solana::packet::{Packet, SharedPackets, BLOB_SIZE, PACKET_DATA_SIZE};
-use solana::result::Result;
-use solana::streamer::{receiver, PacketReceiver};
+use clap::{crate_description, crate_name, App, Arg};
+use solana_core::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE};
+use solana_core::streamer::{receiver, PacketReceiver};
 use std::cmp::max;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::mpsc::channel;
 use std::sync::Arc;
 use std::thread::sleep;
-use std::thread::{spawn, JoinHandle};
+use std::thread::{spawn, JoinHandle, Result};
 use std::time::Duration;
 use std::time::SystemTime;
 
 fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
     let send = UdpSocket::bind("0.0.0.0:0").unwrap();
-    let msgs = SharedPackets::default();
-    let msgs_ = msgs.clone();
-    msgs.write().unwrap().packets.resize(10, Packet::default());
-    for w in &mut msgs.write().unwrap().packets {
+    let mut msgs = Packets::default();
+    msgs.packets.resize(10, Packet::default());
+    for w in msgs.packets.iter_mut() {
         w.meta.size = PACKET_DATA_SIZE;
         w.meta.set_addr(&addr);
     }
+    let msgs = Arc::new(msgs);
     spawn(move || loop {
         if exit.load(Ordering::Relaxed) {
             return;
         }
         let mut num = 0;
-        for p in &msgs_.read().unwrap().packets {
+        for p in &msgs.packets {
             let a = p.meta.addr();
-            assert!(p.meta.size < BLOB_SIZE);
+            assert!(p.meta.size < PACKET_DATA_SIZE);
             send.send_to(&p.data[..p.meta.size], &a).unwrap();
             num += 1;
         }
@@ -47,7 +42,7 @@ fn sink(exit: Arc<AtomicBool>, rvs: Arc<AtomicUsize>, r: PacketReceiver) -> Join
         }
         let timer = Duration::new(1, 0);
         if let Ok(msgs) = r.recv_timeout(timer) {
-            rvs.fetch_add(msgs.read().unwrap().packets.len(), Ordering::Relaxed);
+            rvs.fetch_add(msgs.packets.len(), Ordering::Relaxed);
         }
     })
 }
@@ -55,28 +50,33 @@ fn sink(exit: Arc<AtomicBool>, rvs: Arc<AtomicUsize>, r: PacketReceiver) -> Join
 fn main() -> Result<()> {
     let mut num_sockets = 1usize;
 
-    let matches = App::new("solana-bench-streamer")
+    let matches = App::new(crate_name!())
+        .about(crate_description!())
+        .version(solana_clap_utils::version!())
         .arg(
             Arg::with_name("num-recv-sockets")
                 .long("num-recv-sockets")
                 .value_name("NUM")
                 .takes_value(true)
                 .help("Use NUM receive sockets"),
-        ).get_matches();
+        )
+        .get_matches();
 
     if let Some(n) = matches.value_of("num-recv-sockets") {
         num_sockets = max(num_sockets, n.to_string().parse().expect("integer"));
     }
 
     let mut port = 0;
-    let mut addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
+    let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
+    let mut addr = SocketAddr::new(ip_addr, 0);
 
     let exit = Arc::new(AtomicBool::new(false));
 
     let mut read_channels = Vec::new();
     let mut read_threads = Vec::new();
+    let recycler = PacketsRecycler::default();
     for _ in 0..num_sockets {
-        let read = bind_to(port, false).unwrap();
+        let read = solana_net_utils::bind_to(ip_addr, port, false).unwrap();
         read.set_read_timeout(Some(Duration::new(1, 0))).unwrap();
 
         addr = read.local_addr().unwrap();
@@ -86,9 +86,10 @@ fn main() -> Result<()> {
         read_channels.push(r_reader);
         read_threads.push(receiver(
             Arc::new(read),
-            exit.clone(),
+            &exit,
             s_reader,
-            "bench-streamer",
+            recycler.clone(),
+            "bench-streamer-test",
         ));
     }
 

bench-tps/.gitignore

@@ -0,0 +1,4 @@
+/target/
+/config/
+/config-local/
+/farf/

bench-tps/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+edition = "2018"
+name = "solana-bench-tps"
+version = "1.0.4"
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+
+[dependencies]
+bincode = "1.2.1"
+clap = "2.33.0"
+log = "0.4.8"
+rayon = "1.2.0"
+serde_json = "1.0.46"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.4" }
+solana-core = { path = "../core", version = "1.0.4" }
+solana-genesis = { path = "../genesis", version = "1.0.4" }
+solana-client = { path = "../client", version = "1.0.4" }
+solana-faucet = { path = "../faucet", version = "1.0.4" }
+solana-librapay = { path = "../programs/librapay", version = "1.0.4", optional = true }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-metrics = { path = "../metrics", version = "1.0.4" }
+solana-measure = { path = "../measure", version = "1.0.4" }
+solana-net-utils = { path = "../net-utils", version = "1.0.4" }
+solana-runtime = { path = "../runtime", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+solana-move-loader-program = { path = "../programs/move_loader", version = "1.0.4", optional = true }
+
+[dev-dependencies]
+serial_test = "0.3.2"
+serial_test_derive = "0.4.0"
+solana-local-cluster = { path = "../local-cluster", version = "1.0.4" }
+
+[features]
+move = ["solana-librapay", "solana-move-loader-program"]

bench-tps/src/cli.rs

@@ -0,0 +1,263 @@
+use clap::{crate_description, crate_name, App, Arg, ArgMatches};
+use solana_faucet::faucet::FAUCET_PORT;
+use solana_sdk::fee_calculator::FeeRateGovernor;
+use solana_sdk::signature::{read_keypair_file, Keypair};
+use std::{net::SocketAddr, process::exit, time::Duration};
+
+const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;
+
+/// Holds the configuration for a single run of the benchmark
+pub struct Config {
+    pub entrypoint_addr: SocketAddr,
+    pub faucet_addr: SocketAddr,
+    pub id: Keypair,
+    pub threads: usize,
+    pub num_nodes: usize,
+    pub duration: Duration,
+    pub tx_count: usize,
+    pub keypair_multiplier: usize,
+    pub thread_batch_sleep_ms: usize,
+    pub sustained: bool,
+    pub client_ids_and_stake_file: String,
+    pub write_to_client_file: bool,
+    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,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            entrypoint_addr: SocketAddr::from(([127, 0, 0, 1], 8001)),
+            faucet_addr: SocketAddr::from(([127, 0, 0, 1], FAUCET_PORT)),
+            id: Keypair::new(),
+            threads: 4,
+            num_nodes: 1,
+            duration: Duration::new(std::u64::MAX, 0),
+            tx_count: 50_000,
+            keypair_multiplier: 8,
+            thread_batch_sleep_ms: 1000,
+            sustained: false,
+            client_ids_and_stake_file: String::new(),
+            write_to_client_file: false,
+            read_from_client_file: false,
+            target_lamports_per_signature: FeeRateGovernor::default().target_lamports_per_signature,
+            multi_client: true,
+            use_move: false,
+            num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
+        }
+    }
+}
+
+/// Defines and builds the CLI args for a run of the benchmark
+pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
+    App::new(crate_name!()).about(crate_description!())
+        .version(version)
+        .arg(
+            Arg::with_name("entrypoint")
+                .short("n")
+                .long("entrypoint")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .help("Rendezvous with the cluster at this entry point; defaults to 127.0.0.1:8001"),
+        )
+        .arg(
+            Arg::with_name("faucet")
+                .short("d")
+                .long("faucet")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .help("Location of the faucet; defaults to entrypoint:FAUCET_PORT"),
+        )
+        .arg(
+            Arg::with_name("identity")
+                .short("i")
+                .long("identity")
+                .value_name("PATH")
+                .takes_value(true)
+                .help("File containing a client identity (keypair)"),
+        )
+        .arg(
+            Arg::with_name("num-nodes")
+                .short("N")
+                .long("num-nodes")
+                .value_name("NUM")
+                .takes_value(true)
+                .help("Wait for NUM nodes to converge"),
+        )
+        .arg(
+            Arg::with_name("threads")
+                .short("t")
+                .long("threads")
+                .value_name("NUM")
+                .takes_value(true)
+                .help("Number of threads"),
+        )
+        .arg(
+            Arg::with_name("duration")
+                .long("duration")
+                .value_name("SECS")
+                .takes_value(true)
+                .help("Seconds to run benchmark, then exit; default is forever"),
+        )
+        .arg(
+            Arg::with_name("sustained")
+                .long("sustained")
+                .help("Use sustained performance mode vs. peak mode. This overlaps the tx generation with transfers."),
+        )
+        .arg(
+            Arg::with_name("use-move")
+                .long("use-move")
+                .help("Use Move language transactions to perform transfers."),
+        )
+        .arg(
+            Arg::with_name("no-multi-client")
+                .long("no-multi-client")
+                .help("Disable multi-client support, only transact with the entrypoint."),
+        )
+        .arg(
+            Arg::with_name("tx_count")
+                .long("tx_count")
+                .value_name("NUM")
+                .takes_value(true)
+                .help("Number of transactions to send per batch")
+        )
+        .arg(
+            Arg::with_name("keypair_multiplier")
+                .long("keypair-multiplier")
+                .value_name("NUM")
+                .takes_value(true)
+                .help("Multiply by transaction count to determine number of keypairs to create")
+        )
+        .arg(
+            Arg::with_name("thread-batch-sleep-ms")
+                .short("z")
+                .long("thread-batch-sleep-ms")
+                .value_name("NUM")
+                .takes_value(true)
+                .help("Per-thread-per-iteration sleep in ms"),
+        )
+        .arg(
+            Arg::with_name("write-client-keys")
+                .long("write-client-keys")
+                .value_name("FILENAME")
+                .takes_value(true)
+                .help("Generate client keys and stakes and write the list to YAML file"),
+        )
+        .arg(
+            Arg::with_name("read-client-keys")
+                .long("read-client-keys")
+                .value_name("FILENAME")
+                .takes_value(true)
+                .help("Read client keys and stakes from the YAML file"),
+        )
+        .arg(
+            Arg::with_name("target_lamports_per_signature")
+                .long("target-lamports-per-signature")
+                .value_name("LAMPORTS")
+                .takes_value(true)
+                .help(
+                    "The cost in lamports that the cluster will charge for signature \
+                     verification when the cluster is operating at target-signatures-per-slot",
+                ),
+        )
+        .arg(
+            Arg::with_name("num_lamports_per_account")
+                .long("num-lamports-per-account")
+                .value_name("LAMPORTS")
+                .takes_value(true)
+                .help(
+                    "Number of lamports per account.",
+                ),
+        )
+}
+
+/// Parses a clap `ArgMatches` structure into a `Config`
+/// # Arguments
+/// * `matches` - command line arguments parsed by clap
+/// # Panics
+/// Panics if there is trouble parsing any of the arguments
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
+    let mut args = Config::default();
+
+    if let Some(addr) = matches.value_of("entrypoint") {
+        args.entrypoint_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
+            eprintln!("failed to parse entrypoint address: {}", e);
+            exit(1)
+        });
+    }
+
+    if let Some(addr) = matches.value_of("faucet") {
+        args.faucet_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
+            eprintln!("failed to parse faucet address: {}", e);
+            exit(1)
+        });
+    }
+
+    if matches.is_present("identity") {
+        args.id = read_keypair_file(matches.value_of("identity").unwrap())
+            .expect("can't read client identity");
+    }
+
+    if let Some(t) = matches.value_of("threads") {
+        args.threads = t.to_string().parse().expect("can't parse threads");
+    }
+
+    if let Some(n) = matches.value_of("num-nodes") {
+        args.num_nodes = n.to_string().parse().expect("can't parse num-nodes");
+    }
+
+    if let Some(duration) = matches.value_of("duration") {
+        args.duration = Duration::new(
+            duration.to_string().parse().expect("can't parse duration"),
+            0,
+        );
+    }
+
+    if let Some(s) = matches.value_of("tx_count") {
+        args.tx_count = s.to_string().parse().expect("can't parse tx_count");
+    }
+
+    if let Some(s) = matches.value_of("keypair_multiplier") {
+        args.keypair_multiplier = s
+            .to_string()
+            .parse()
+            .expect("can't parse keypair-multiplier");
+        assert!(args.keypair_multiplier >= 2);
+    }
+
+    if let Some(t) = matches.value_of("thread-batch-sleep-ms") {
+        args.thread_batch_sleep_ms = t
+            .to_string()
+            .parse()
+            .expect("can't parse thread-batch-sleep-ms");
+    }
+
+    args.sustained = matches.is_present("sustained");
+
+    if let Some(s) = matches.value_of("write-client-keys") {
+        args.write_to_client_file = true;
+        args.client_ids_and_stake_file = s.to_string();
+    }
+
+    if let Some(s) = matches.value_of("read-client-keys") {
+        assert!(!args.write_to_client_file);
+        args.read_from_client_file = true;
+        args.client_ids_and_stake_file = s.to_string();
+    }
+
+    if let Some(v) = matches.value_of("target_lamports_per_signature") {
+        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");
+    }
+
+    args
+}

bench-tps/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod bench;
+pub mod cli;

bench-tps/src/main.rs

@@ -0,0 +1,137 @@
+use log::*;
+use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs};
+use solana_bench_tps::cli;
+use solana_core::gossip_service::{discover_cluster, get_client, get_multi_client};
+use solana_genesis::Base64Account;
+use solana_sdk::fee_calculator::FeeRateGovernor;
+use solana_sdk::signature::{Keypair, Signer};
+use solana_sdk::system_program;
+use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc};
+
+/// Number of signatures for all transactions in ~1 week at ~100K TPS
+pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 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 cli_config = cli::extract_args(&matches);
+
+    let cli::Config {
+        entrypoint_addr,
+        faucet_addr,
+        id,
+        num_nodes,
+        tx_count,
+        keypair_multiplier,
+        client_ids_and_stake_file,
+        write_to_client_file,
+        read_from_client_file,
+        target_lamports_per_signature,
+        use_move,
+        multi_client,
+        num_lamports_per_account,
+        ..
+    } = &cli_config;
+
+    let keypair_count = *tx_count * keypair_multiplier;
+    if *write_to_client_file {
+        info!("Generating {} keypairs", keypair_count);
+        let (keypairs, _) = generate_keypairs(&id, keypair_count as u64);
+        let num_accounts = keypairs.len() as u64;
+        let max_fee =
+            FeeRateGovernor::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
+        let num_lamports_per_account = (num_accounts - 1 + NUM_SIGNATURES_FOR_TXS * max_fee)
+            / num_accounts
+            + num_lamports_per_account;
+        let mut accounts = HashMap::new();
+        keypairs.iter().for_each(|keypair| {
+            accounts.insert(
+                serde_json::to_string(&keypair.to_bytes().to_vec()).unwrap(),
+                Base64Account {
+                    balance: num_lamports_per_account,
+                    executable: false,
+                    owner: system_program::id().to_string(),
+                    data: String::new(),
+                },
+            );
+        });
+
+        info!("Writing {}", client_ids_and_stake_file);
+        let serialized = serde_yaml::to_string(&accounts).unwrap();
+        let path = Path::new(&client_ids_and_stake_file);
+        let mut file = File::create(path).unwrap();
+        file.write_all(&serialized.into_bytes()).unwrap();
+        return;
+    }
+
+    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 client = if *multi_client {
+        let (client, num_clients) = get_multi_client(&nodes);
+        if nodes.len() < num_clients {
+            eprintln!(
+                "Error: Insufficient nodes discovered.  Expecting {} or more",
+                num_nodes
+            );
+            exit(1);
+        }
+        Arc::new(client)
+    } else {
+        Arc::new(get_client(&nodes))
+    };
+
+    let (keypairs, move_keypairs) = if *read_from_client_file && !use_move {
+        let path = Path::new(&client_ids_and_stake_file);
+        let file = File::open(path).unwrap();
+
+        info!("Reading {}", client_ids_and_stake_file);
+        let accounts: HashMap<String, Base64Account> = serde_yaml::from_reader(file).unwrap();
+        let mut keypairs = vec![];
+        let mut last_balance = 0;
+
+        accounts
+            .into_iter()
+            .for_each(|(keypair, primordial_account)| {
+                let bytes: Vec<u8> = serde_json::from_str(keypair.as_str()).unwrap();
+                keypairs.push(Keypair::from_bytes(&bytes).unwrap());
+                last_balance = primordial_account.balance;
+            });
+
+        if keypairs.len() < keypair_count {
+            eprintln!(
+                "Expected {} accounts in {}, only received {} (--tx_count mismatch?)",
+                keypair_count,
+                client_ids_and_stake_file,
+                keypairs.len(),
+            );
+            exit(1);
+        }
+        // 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)
+    } else {
+        generate_and_fund_keypairs(
+            client.clone(),
+            Some(*faucet_addr),
+            &id,
+            keypair_count,
+            *num_lamports_per_account,
+            *use_move,
+        )
+        .unwrap_or_else(|e| {
+            eprintln!("Error could not fund keys: {:?}", e);
+            exit(1);
+        })
+    };
+
+    do_bench_tps(client, cli_config, keypairs, move_keypairs);
+}

bench-tps/tests/bench_tps.rs

@@ -0,0 +1,86 @@
+use serial_test_derive::serial;
+use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs};
+use solana_bench_tps::cli::Config;
+use solana_client::thin_client::create_client;
+use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
+use solana_core::validator::ValidatorConfig;
+use solana_faucet::faucet::run_local_faucet;
+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();
+    const NUM_NODES: usize = 1;
+    let cluster = LocalCluster::new(&ClusterConfig {
+        node_stakes: vec![999_990; NUM_NODES],
+        cluster_lamports: 200_000_000,
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
+        native_instruction_processors,
+        ..ClusterConfig::default()
+    });
+
+    let faucet_keypair = Keypair::new();
+    cluster.transfer(
+        &cluster.funding_keypair,
+        &faucet_keypair.pubkey(),
+        100_000_000,
+    );
+
+    let client = Arc::new(create_client(
+        (cluster.entry_point_info.rpc, cluster.entry_point_info.tpu),
+        VALIDATOR_PORT_RANGE,
+    ));
+
+    let (addr_sender, addr_receiver) = channel();
+    run_local_faucet(faucet_keypair, addr_sender, None);
+    let faucet_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();
+
+    let lamports_per_account = 100;
+
+    let keypair_count = config.tx_count * config.keypair_multiplier;
+    let (keypairs, move_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);
+
+    #[cfg(not(debug_assertions))]
+    assert!(_total > 100);
+}
+
+#[test]
+#[serial]
+fn test_bench_tps_local_cluster_solana() {
+    let mut config = Config::default();
+    config.tx_count = 100;
+    config.duration = Duration::from_secs(10);
+
+    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);
+}

benches/bank.rs

@@ -1,55 +0,0 @@
-#![feature(test)]
-extern crate bincode;
-extern crate rayon;
-extern crate solana;
-extern crate test;
-
-use bincode::serialize;
-use rayon::prelude::*;
-use solana::bank::*;
-use solana::hash::hash;
-use solana::mint::Mint;
-use solana::signature::{Keypair, KeypairUtil};
-use solana::system_transaction::SystemTransaction;
-use solana::transaction::Transaction;
-use test::Bencher;
-
-#[bench]
-fn bench_process_transaction(bencher: &mut Bencher) {
-    let mint = Mint::new(100_000_000);
-    let bank = Bank::new(&mint);
-
-    // Create transactions between unrelated parties.
-    let transactions: Vec<_> = (0..4096)
-        .into_par_iter()
-        .map(|i| {
-            // Seed the 'from' account.
-            let rando0 = Keypair::new();
-            let tx = Transaction::system_move(
-                &mint.keypair(),
-                rando0.pubkey(),
-                10_000,
-                mint.last_id(),
-                0,
-            );
-            assert!(bank.process_transaction(&tx).is_ok());
-
-            // Seed the 'to' account and a cell for its signature.
-            let last_id = hash(&serialize(&i).unwrap()); // Unique hash
-            bank.register_entry_id(&last_id);
-
-            let rando1 = Keypair::new();
-            let tx = Transaction::system_move(&rando0, rando1.pubkey(), 1, last_id, 0);
-            assert!(bank.process_transaction(&tx).is_ok());
-
-            // Finally, return the transaction to the benchmark.
-            tx
-        }).collect();
-
-    bencher.iter(|| {
-        // Since benchmarker runs this multiple times, we need to clear the signatures.
-        bank.clear_signatures();
-        let results = bank.process_transactions(&transactions);
-        assert!(results.iter().all(Result::is_ok));
-    })
-}

benches/banking_stage.rs

@@ -1,110 +0,0 @@
-#![feature(test)]
-extern crate bincode;
-extern crate rand;
-extern crate rayon;
-extern crate solana;
-extern crate solana_program_interface;
-extern crate test;
-
-use rand::{thread_rng, Rng};
-use rayon::prelude::*;
-use solana::bank::Bank;
-use solana::banking_stage::{BankingStage, NUM_THREADS};
-use solana::entry::Entry;
-use solana::mint::Mint;
-use solana::packet::to_packets_chunked;
-use solana::signature::{KeypairUtil, Signature};
-use solana::system_transaction::SystemTransaction;
-use solana::transaction::Transaction;
-use solana_program_interface::pubkey::Pubkey;
-use std::iter;
-use std::sync::mpsc::{channel, Receiver};
-use std::sync::Arc;
-use std::time::Duration;
-use test::Bencher;
-
-fn check_txs(receiver: &Receiver<Vec<Entry>>, ref_tx_count: usize) {
-    let mut total = 0;
-    loop {
-        let entries = receiver.recv_timeout(Duration::new(1, 0));
-        if let Ok(entries) = entries {
-            for entry in &entries {
-                total += entry.transactions.len();
-            }
-        } else {
-            break;
-        }
-        if total >= ref_tx_count {
-            break;
-        }
-    }
-    assert_eq!(total, ref_tx_count);
-}
-
-#[bench]
-fn bench_banking_stage_multi_accounts(bencher: &mut Bencher) {
-    let txes = 1000 * NUM_THREADS;
-    let mint_total = 1_000_000_000_000;
-    let mint = Mint::new(mint_total);
-
-    let (verified_sender, verified_receiver) = channel();
-    let bank = Arc::new(Bank::new(&mint));
-    let dummy = Transaction::system_move(
-        &mint.keypair(),
-        mint.keypair().pubkey(),
-        1,
-        mint.last_id(),
-        0,
-    );
-    let transactions: Vec<_> = (0..txes)
-        .into_par_iter()
-        .map(|_| {
-            let mut new = dummy.clone();
-            let from: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            let to: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            new.keys[0] = Pubkey::new(&from[0..32]);
-            new.keys[1] = Pubkey::new(&to[0..32]);
-            new.signature = Signature::new(&sig[0..64]);
-            new
-        }).collect();
-    // fund all the accounts
-    transactions.iter().for_each(|tx| {
-        let fund = Transaction::system_move(
-            &mint.keypair(),
-            tx.keys[0],
-            mint_total / txes as i64,
-            mint.last_id(),
-            0,
-        );
-        assert!(bank.process_transaction(&fund).is_ok());
-    });
-    //sanity check, make sure all the transactions can execute sequentially
-    transactions.iter().for_each(|tx| {
-        let res = bank.process_transaction(&tx);
-        assert!(res.is_ok(), "sanity test transactions");
-    });
-    bank.clear_signatures();
-    //sanity check, make sure all the transactions can execute in parallel
-    let res = bank.process_transactions(&transactions);
-    for r in res {
-        assert!(r.is_ok(), "sanity parallel execution");
-    }
-    bank.clear_signatures();
-    let verified: Vec<_> = to_packets_chunked(&transactions.clone(), 192)
-        .into_iter()
-        .map(|x| {
-            let len = x.read().unwrap().packets.len();
-            (x, iter::repeat(1).take(len).collect())
-        }).collect();
-    let (_stage, signal_receiver) = BankingStage::new(&bank, verified_receiver, Default::default());
-    bencher.iter(move || {
-        for v in verified.chunks(verified.len() / NUM_THREADS) {
-            verified_sender.send(v.to_vec()).unwrap();
-        }
-        check_txs(&signal_receiver, txes);
-        bank.clear_signatures();
-        // make sure the tx last id is still registered
-        bank.register_entry_id(&mint.last_id());
-    });
-}

benches/ledger.rs

@@ -1,25 +0,0 @@
-#![feature(test)]
-extern crate solana;
-extern crate test;
-
-use solana::hash::{hash, Hash};
-use solana::ledger::{next_entries, reconstruct_entries_from_blobs, Block};
-use solana::signature::{Keypair, KeypairUtil};
-use solana::system_transaction::SystemTransaction;
-use solana::transaction::Transaction;
-use test::Bencher;
-
-#[bench]
-fn bench_block_to_blobs_to_block(bencher: &mut Bencher) {
-    let zero = Hash::default();
-    let one = hash(&zero.as_ref());
-    let keypair = Keypair::new();
-    let tx0 = Transaction::system_move(&keypair, keypair.pubkey(), 1, one, 0);
-    let transactions = vec![tx0; 10];
-    let entries = next_entries(&zero, 1, transactions);
-
-    bencher.iter(|| {
-        let blobs = entries.to_blobs();
-        assert_eq!(reconstruct_entries_from_blobs(blobs).unwrap(), entries);
-    });
-}

benches/sigverify.rs

@@ -1,23 +0,0 @@
-#![feature(test)]
-extern crate bincode;
-extern crate rayon;
-extern crate solana;
-extern crate test;
-
-use solana::packet::to_packets;
-use solana::sigverify;
-use solana::system_transaction::test_tx;
-use test::Bencher;
-
-#[bench]
-fn bench_sigverify(bencher: &mut Bencher) {
-    let tx = test_tx();
-
-    // generate packet vector
-    let batches = to_packets(&vec![tx; 128]);
-
-    // verify packets
-    bencher.iter(|| {
-        let _ans = sigverify::ed25519_verify(&batches);
-    })
-}

build.rs

@@ -1,34 +0,0 @@
-use std::env;
-use std::fs;
-
-fn main() {
-    println!("cargo:rerun-if-changed=target/perf-libs");
-    println!("cargo:rerun-if-changed=build.rs");
-
-    // Ensure target/perf-libs/ exists.  It's been observed that
-    // a cargo:rerun-if-changed= directive with a non-existent
-    // directory triggers a rebuild on every |cargo build| invocation
-    fs::create_dir("target/perf-libs").unwrap_or_else(|err| {
-        if err.kind() != std::io::ErrorKind::AlreadyExists {
-            panic!("Unable to create target/perf-libs: {:?}", err);
-        }
-    });
-
-    let cuda = !env::var("CARGO_FEATURE_CUDA").is_err();
-    let erasure = !env::var("CARGO_FEATURE_ERASURE").is_err();
-
-    if cuda || erasure {
-        println!("cargo:rustc-link-search=native=target/perf-libs");
-    }
-    if cuda {
-        println!("cargo:rustc-link-lib=static=cuda_verify_ed25519");
-        println!("cargo:rustc-link-search=native=/usr/local/cuda/lib64");
-        println!("cargo:rustc-link-lib=dylib=cudart");
-        println!("cargo:rustc-link-lib=dylib=cuda");
-        println!("cargo:rustc-link-lib=dylib=cudadevrt");
-    }
-    if erasure {
-        println!("cargo:rustc-link-lib=dylib=Jerasure");
-        println!("cargo:rustc-link-lib=dylib=gf_complete");
-    }
-}

chacha-cuda/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "solana-chacha-cuda"
+version = "1.0.4"
+description = "Solana Chacha Cuda APIs"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+solana-archiver-utils = { path = "../archiver-utils", version = "1.0.4" }
+solana-chacha = { path = "../chacha", version = "1.0.4" }
+solana-ledger = { path = "../ledger", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-perf = { path = "../perf", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha_cuda"

chacha-cuda/src/chacha_cuda.rs

@@ -0,0 +1,280 @@
+// Module used by validators to approve storage mining proofs in parallel using the GPU
+
+use solana_chacha::chacha::{CHACHA_BLOCK_SIZE, CHACHA_KEY_SIZE};
+use solana_ledger::blockstore::Blockstore;
+use solana_perf::perf_libs;
+use solana_sdk::hash::Hash;
+use std::io;
+use std::mem::size_of;
+use std::sync::Arc;
+
+// Encrypt a file with multiple starting IV states, determined by ivecs.len()
+//
+// Then sample each block at the offsets provided by samples argument with sha256
+// and return the vec of sha states
+pub fn chacha_cbc_encrypt_file_many_keys(
+    blockstore: &Arc<Blockstore>,
+    segment: u64,
+    slots_per_segment: u64,
+    ivecs: &mut [u8],
+    samples: &[u64],
+) -> io::Result<Vec<Hash>> {
+    let api = perf_libs::api().expect("no perf libs");
+    if ivecs.len() % CHACHA_BLOCK_SIZE != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!(
+                "bad IV length({}) not divisible by {} ",
+                ivecs.len(),
+                CHACHA_BLOCK_SIZE,
+            ),
+        ));
+    }
+
+    const BUFFER_SIZE: usize = 8 * 1024;
+    let mut buffer = [0; BUFFER_SIZE];
+    let num_keys = ivecs.len() / CHACHA_BLOCK_SIZE;
+    let mut sha_states = vec![0; num_keys * size_of::<Hash>()];
+    let mut int_sha_states = vec![0; num_keys * 112];
+    let keys: Vec<u8> = vec![0; num_keys * CHACHA_KEY_SIZE]; // keys not used ATM, uniqueness comes from IV
+    let mut current_slot = segment * slots_per_segment;
+    let mut start_index = 0;
+    let start_slot = current_slot;
+    let mut total_size = 0;
+    let mut time: f32 = 0.0;
+    unsafe {
+        (api.chacha_init_sha_state)(int_sha_states.as_mut_ptr(), num_keys as u32);
+    }
+    loop {
+        match blockstore.get_data_shreds(current_slot, start_index, std::u64::MAX, &mut buffer) {
+            Ok((last_index, mut size)) => {
+                debug!(
+                    "chacha_cuda: encrypting segment: {} num_shreds: {} data_len: {}",
+                    segment,
+                    last_index.saturating_sub(start_index),
+                    size
+                );
+
+                if size == 0 {
+                    if current_slot.saturating_sub(start_slot) < slots_per_segment {
+                        current_slot += 1;
+                        start_index = 0;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                if size < BUFFER_SIZE {
+                    // round to the nearest key_size boundary
+                    size = (size + CHACHA_KEY_SIZE - 1) & !(CHACHA_KEY_SIZE - 1);
+                }
+
+                unsafe {
+                    (api.chacha_cbc_encrypt_many_sample)(
+                        buffer[..size].as_ptr(),
+                        int_sha_states.as_mut_ptr(),
+                        size,
+                        keys.as_ptr(),
+                        ivecs.as_mut_ptr(),
+                        num_keys as u32,
+                        samples.as_ptr(),
+                        samples.len() as u32,
+                        total_size,
+                        &mut time,
+                    );
+                }
+
+                total_size += size as u64;
+                start_index = last_index + 1;
+            }
+            Err(e) => {
+                info!("Error encrypting file: {:?}", e);
+                break;
+            }
+        }
+    }
+    unsafe {
+        (api.chacha_end_sha_state)(
+            int_sha_states.as_ptr(),
+            sha_states.as_mut_ptr(),
+            num_keys as u32,
+        );
+    }
+    let mut res = Vec::new();
+    for x in 0..num_keys {
+        let start = x * size_of::<Hash>();
+        let end = start + size_of::<Hash>();
+        res.push(Hash::new(&sha_states[start..end]));
+    }
+    Ok(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_archiver_utils::sample_file;
+    use solana_chacha::chacha::chacha_cbc_encrypt_ledger;
+    use solana_ledger::entry::create_ticks;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_sdk::clock::DEFAULT_SLOTS_PER_SEGMENT;
+    use solana_sdk::signature::Keypair;
+    use std::fs::{remove_dir_all, remove_file};
+    use std::path::Path;
+
+    #[test]
+    fn test_encrypt_file_many_keys_single() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let slots_per_segment = 32;
+        let entries = create_ticks(slots_per_segment, 0, Hash::default());
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 16;
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                Some(0),
+                true,
+                &Arc::new(Keypair::new()),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let out_path = Path::new("test_chacha_encrypt_file_many_keys_single_output.txt.enc");
+
+        let samples = [0];
+        let mut ivecs = hex!(
+            "abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234
+                              abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234"
+        );
+
+        let mut cpu_iv = ivecs.clone();
+        chacha_cbc_encrypt_ledger(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            out_path,
+            &mut cpu_iv,
+        )
+        .unwrap();
+
+        let ref_hash = sample_file(&out_path, &samples).unwrap();
+
+        let hashes = chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            &mut ivecs,
+            &samples,
+        )
+        .unwrap();
+
+        assert_eq!(hashes[0], ref_hash);
+
+        let _ignored = remove_dir_all(&ledger_path);
+        let _ignored = remove_file(out_path);
+    }
+
+    #[test]
+    fn test_encrypt_file_many_keys_multiple_keys() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 90;
+        let entries = create_ticks(2 * ticks_per_slot, 0, Hash::default());
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                Some(0),
+                true,
+                &Arc::new(Keypair::new()),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let out_path = Path::new("test_chacha_encrypt_file_many_keys_multiple_output.txt.enc");
+
+        let samples = [0, 1, 3, 4, 5, 150];
+        let mut ivecs = Vec::new();
+        let mut ref_hashes: Vec<Hash> = vec![];
+        for i in 0..2 {
+            let mut ivec = hex!(
+                "abc123abc123abc123abc123abc123abc123abababababababababababababab
+                                 abc123abc123abc123abc123abc123abc123abababababababababababababab"
+            );
+            ivec[0] = i;
+            ivecs.extend(ivec.clone().iter());
+            chacha_cbc_encrypt_ledger(
+                &blockstore.clone(),
+                0,
+                DEFAULT_SLOTS_PER_SEGMENT,
+                out_path,
+                &mut ivec,
+            )
+            .unwrap();
+
+            ref_hashes.push(sample_file(&out_path, &samples).unwrap());
+            info!(
+                "ivec: {:?} hash: {:?} ivecs: {:?}",
+                ivec.to_vec(),
+                ref_hashes.last(),
+                ivecs
+            );
+        }
+
+        let hashes = chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            DEFAULT_SLOTS_PER_SEGMENT,
+            &mut ivecs,
+            &samples,
+        )
+        .unwrap();
+
+        assert_eq!(hashes, ref_hashes);
+
+        let _ignored = remove_dir_all(&ledger_path);
+        let _ignored = remove_file(out_path);
+    }
+
+    #[test]
+    fn test_encrypt_file_many_keys_bad_key_length() {
+        solana_logger::setup();
+        if perf_libs::api().is_none() {
+            info!("perf-libs unavailable, skipped");
+            return;
+        }
+
+        let mut keys = hex!("abc123");
+        let ledger_path = get_tmp_ledger_path!();
+        let samples = [0];
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        assert!(chacha_cbc_encrypt_file_many_keys(
+            &blockstore,
+            0,
+            DEFAULT_SLOTS_PER_SEGMENT,
+            &mut keys,
+            &samples,
+        )
+        .is_err());
+    }
+}

chacha-cuda/src/lib.rs

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

chacha-sys/.gitignore

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

chacha-sys/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "solana-chacha-sys"
+version = "1.0.4"
+description = "Solana chacha-sys"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+homepage = "https://solana.com/"
+license = "Apache-2.0"
+edition = "2018"
+
+[build-dependencies]
+cc = "1.0.49"

chacha-sys/build.rs

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

chacha-sys/cpu-crypt/.gitignore

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

chacha-sys/cpu-crypt/Makefile

@@ -0,0 +1,25 @@
+V:=debug
+
+LIB:=cpu-crypt
+
+CFLAGS_common:=-Wall -Werror -pedantic -fPIC
+CFLAGS_release:=-march=native -O3 $(CFLAGS_common)
+CFLAGS_debug:=-g $(CFLAGS_common)
+CFLAGS:=$(CFLAGS_$V)
+
+all: $V/lib$(LIB).a
+
+$V/chacha20_core.o: chacha20_core.c chacha.h
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$V/chacha_cbc.o: chacha_cbc.c chacha.h
+	@mkdir -p $(@D)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$V/lib$(LIB).a: $V/chacha20_core.o $V/chacha_cbc.o
+	$(AR) rcs $@ $^
+
+.PHONY:clean
+clean:
+	rm -rf $V

chacha-sys/cpu-crypt/chacha.h

@@ -0,0 +1,35 @@
+#ifndef HEADER_CHACHA_H
+# define HEADER_CHACHA_H
+
+#include <string.h>
+#include <inttypes.h>
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef unsigned int u32;
+
+#define CHACHA_KEY_SIZE 32
+#define CHACHA_NONCE_SIZE 12
+#define CHACHA_BLOCK_SIZE 64
+#define CHACHA_ROUNDS 500
+
+void chacha20_encrypt(const u32 input[16],
+                      unsigned char output[64],
+                      int num_rounds);
+
+void chacha20_encrypt_ctr(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE], const uint8_t nonce[CHACHA_NONCE_SIZE],
+                          uint32_t counter);
+
+void chacha20_cbc128_encrypt(const unsigned char* in, unsigned char* out,
+                             uint32_t len, const uint8_t* key,
+                             unsigned char* ivec);
+
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif

chacha-sys/cpu-crypt/chacha20_core.c

@@ -0,0 +1,102 @@
+#include "chacha.h"
+
+#define ROTL32(v, n) (((v) << (n)) | ((v) >> (32 - (n))))
+
+#define ROTATE(v, c) ROTL32((v), (c))
+
+#define XOR(v, w) ((v) ^ (w))
+
+#define PLUS(x, y) ((x) + (y))
+
+#define U32TO8_LITTLE(p, v) \
+{ (p)[0] = ((v)      ) & 0xff; (p)[1] = ((v) >>  8) & 0xff; \
+  (p)[2] = ((v) >> 16) & 0xff; (p)[3] = ((v) >> 24) & 0xff; }
+
+#define U8TO32_LITTLE(p)   \
+     (((u32)((p)[0])      ) | ((u32)((p)[1]) <<  8) | \
+      ((u32)((p)[2]) << 16) | ((u32)((p)[3]) << 24)   )
+
+#define QUARTERROUND(a,b,c,d) \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]),16); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]),12); \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]), 8); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]), 7);
+
+// sigma contains the ChaCha constants, which happen to be an ASCII string.
+static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3',
+                                   '2', '-', 'b', 'y', 't', 'e', ' ', 'k' };
+
+void chacha20_encrypt(const u32 input[16],
+                      unsigned char output[64],
+                      int num_rounds)
+{
+    u32 x[16];
+    int i;
+    memcpy(x, input, sizeof(u32) * 16);
+    for (i = num_rounds; i > 0; i -= 2) {
+        QUARTERROUND( 0, 4, 8,12)
+        QUARTERROUND( 1, 5, 9,13)
+        QUARTERROUND( 2, 6,10,14)
+        QUARTERROUND( 3, 7,11,15)
+        QUARTERROUND( 0, 5,10,15)
+        QUARTERROUND( 1, 6,11,12)
+        QUARTERROUND( 2, 7, 8,13)
+        QUARTERROUND( 3, 4, 9,14)
+    }
+    for (i = 0; i < 16; ++i) {
+        x[i] = PLUS(x[i], input[i]);
+    }
+    for (i = 0; i < 16; ++i) {
+        U32TO8_LITTLE(output + 4 * i, x[i]);
+    }
+}
+
+void chacha20_encrypt_ctr(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE],
+                          const uint8_t nonce[CHACHA_NONCE_SIZE],
+                          uint32_t counter)
+{
+  uint32_t input[16];
+  uint8_t buf[64];
+  size_t todo, i;
+
+  input[0] = U8TO32_LITTLE(sigma + 0);
+  input[1] = U8TO32_LITTLE(sigma + 4);
+  input[2] = U8TO32_LITTLE(sigma + 8);
+  input[3] = U8TO32_LITTLE(sigma + 12);
+
+  input[4] = U8TO32_LITTLE(key + 0);
+  input[5] = U8TO32_LITTLE(key + 4);
+  input[6] = U8TO32_LITTLE(key + 8);
+  input[7] = U8TO32_LITTLE(key + 12);
+
+  input[8] = U8TO32_LITTLE(key + 16);
+  input[9] = U8TO32_LITTLE(key + 20);
+  input[10] = U8TO32_LITTLE(key + 24);
+  input[11] = U8TO32_LITTLE(key + 28);
+
+  input[12] = counter;
+  input[13] = U8TO32_LITTLE(nonce + 0);
+  input[14] = U8TO32_LITTLE(nonce + 4);
+  input[15] = U8TO32_LITTLE(nonce + 8);
+
+  while (in_len > 0) {
+    todo = sizeof(buf);
+    if (in_len < todo) {
+      todo = in_len;
+    }
+
+    chacha20_encrypt(input, buf, 20);
+    for (i = 0; i < todo; i++) {
+      out[i] = in[i] ^ buf[i];
+    }
+
+    out += todo;
+    in += todo;
+    in_len -= todo;
+
+    input[12]++;
+  }
+}
+
+

chacha-sys/cpu-crypt/chacha_cbc.c

@@ -0,0 +1,72 @@
+#include "chacha.h"
+
+#if !defined(STRICT_ALIGNMENT) && !defined(PEDANTIC)
+# define STRICT_ALIGNMENT 0
+#endif
+
+void chacha20_cbc128_encrypt(const unsigned char* in, unsigned char* out,
+                             uint32_t len, const uint8_t* key,
+                             unsigned char* ivec)
+{
+    size_t n;
+    unsigned char *iv = ivec;
+    (void)key;
+
+    if (len == 0) {
+        return;
+    }
+
+#if !defined(OPENSSL_SMALL_FOOTPRINT)
+    if (STRICT_ALIGNMENT &&
+        ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) != 0) {
+        while (len >= CHACHA_BLOCK_SIZE) {
+            for (n = 0; n < CHACHA_BLOCK_SIZE; ++n) {
+                out[n] = in[n] ^ iv[n];
+                //printf("%x ", out[n]);
+            }
+            chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+            iv = out;
+            len -= CHACHA_BLOCK_SIZE;
+            in += CHACHA_BLOCK_SIZE;
+            out += CHACHA_BLOCK_SIZE;
+        }
+    } else {
+        while (len >= CHACHA_BLOCK_SIZE) {
+            for (n = 0; n < CHACHA_BLOCK_SIZE; n += sizeof(size_t)) {
+                *(size_t *)(out + n) =
+                    *(size_t *)(in + n) ^ *(size_t *)(iv + n);
+                //printf("%zu ", *(size_t *)(iv + n));
+            }
+            chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+            iv = out;
+            len -= CHACHA_BLOCK_SIZE;
+            in += CHACHA_BLOCK_SIZE;
+            out += CHACHA_BLOCK_SIZE;
+        }
+    }
+#endif
+    while (len) {
+        for (n = 0; n < CHACHA_BLOCK_SIZE && n < len; ++n) {
+            out[n] = in[n] ^ iv[n];
+        }
+        for (; n < CHACHA_BLOCK_SIZE; ++n) {
+            out[n] = iv[n];
+        }
+        chacha20_encrypt((const u32*)out, out, CHACHA_ROUNDS);
+        iv = out;
+        if (len <= CHACHA_BLOCK_SIZE) {
+            break;
+        }
+        len -= CHACHA_BLOCK_SIZE;
+        in += CHACHA_BLOCK_SIZE;
+        out += CHACHA_BLOCK_SIZE;
+    }
+    memcpy(ivec, iv, CHACHA_BLOCK_SIZE);
+
+}
+
+void chacha20_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t in_len,
+                          const uint8_t key[CHACHA_KEY_SIZE], uint8_t* ivec)
+{
+    chacha20_cbc128_encrypt(in, out, in_len, key, ivec);
+}

chacha-sys/src/lib.rs

@@ -0,0 +1,21 @@
+extern "C" {
+    fn chacha20_cbc_encrypt(
+        input: *const u8,
+        output: *mut u8,
+        in_len: usize,
+        key: *const u8,
+        ivec: *mut u8,
+    );
+}
+
+pub fn chacha_cbc_encrypt(input: &[u8], output: &mut [u8], key: &[u8], ivec: &mut [u8]) {
+    unsafe {
+        chacha20_cbc_encrypt(
+            input.as_ptr(),
+            output.as_mut_ptr(),
+            input.len(),
+            key.as_ptr(),
+            ivec.as_mut_ptr(),
+        );
+    }
+}

chacha/.gitignore

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

chacha/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "solana-chacha"
+version = "1.0.4"
+description = "Solana Chacha APIs"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+log = "0.4.8"
+rand = "0.6.5"
+rand_chacha = "0.1.1"
+solana-chacha-sys = { path = "../chacha-sys", version = "1.0.4" }
+solana-ledger = { path = "../ledger", version = "1.0.4" }
+solana-logger = { path = "../logger", version = "1.0.4" }
+solana-perf = { path = "../perf", version = "1.0.4" }
+solana-sdk = { path = "../sdk", version = "1.0.4" }
+
+[dev-dependencies]
+hex-literal = "0.2.1"
+
+[lib]
+name = "solana_chacha"

chacha/src/chacha.rs

@@ -0,0 +1,185 @@
+use solana_ledger::blockstore::Blockstore;
+use solana_sdk::clock::Slot;
+use std::fs::File;
+use std::io;
+use std::io::{BufWriter, Write};
+use std::path::Path;
+use std::sync::Arc;
+
+pub use solana_chacha_sys::chacha_cbc_encrypt;
+
+pub const CHACHA_BLOCK_SIZE: usize = 64;
+pub const CHACHA_KEY_SIZE: usize = 32;
+
+pub fn chacha_cbc_encrypt_ledger(
+    blockstore: &Arc<Blockstore>,
+    start_slot: Slot,
+    slots_per_segment: u64,
+    out_path: &Path,
+    ivec: &mut [u8; CHACHA_BLOCK_SIZE],
+) -> io::Result<usize> {
+    let mut out_file =
+        BufWriter::new(File::create(out_path).expect("Can't open ledger encrypted data file"));
+    const BUFFER_SIZE: usize = 8 * 1024;
+    let mut buffer = [0; BUFFER_SIZE];
+    let mut encrypted_buffer = [0; BUFFER_SIZE];
+    let key = [0; CHACHA_KEY_SIZE];
+    let mut total_size = 0;
+    let mut current_slot = start_slot;
+    let mut start_index = 0;
+    loop {
+        match blockstore.get_data_shreds(current_slot, start_index, std::u64::MAX, &mut buffer) {
+            Ok((last_index, mut size)) => {
+                debug!(
+                    "chacha: encrypting slice: {} num_shreds: {} data_len: {}",
+                    current_slot,
+                    last_index.saturating_sub(start_index),
+                    size
+                );
+                debug!("read {} bytes", size);
+
+                if size == 0 {
+                    if current_slot.saturating_sub(start_slot) < slots_per_segment {
+                        current_slot += 1;
+                        start_index = 0;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                if size < BUFFER_SIZE {
+                    // round to the nearest key_size boundary
+                    size = (size + CHACHA_KEY_SIZE - 1) & !(CHACHA_KEY_SIZE - 1);
+                }
+                total_size += size;
+
+                chacha_cbc_encrypt(&buffer[..size], &mut encrypted_buffer[..size], &key, ivec);
+                if let Err(res) = out_file.write(&encrypted_buffer[..size]) {
+                    warn!("Error writing file! {:?}", res);
+                    return Err(res);
+                }
+
+                start_index = last_index + 1;
+            }
+            Err(e) => {
+                info!("Error encrypting file: {:?}", e);
+                break;
+            }
+        }
+    }
+    Ok(total_size)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::chacha::chacha_cbc_encrypt_ledger;
+    use rand::SeedableRng;
+    use rand_chacha::ChaChaRng;
+    use solana_ledger::blockstore::Blockstore;
+    use solana_ledger::entry::Entry;
+    use solana_ledger::get_tmp_ledger_path;
+    use solana_sdk::hash::{hash, Hash, Hasher};
+    use solana_sdk::pubkey::Pubkey;
+    use solana_sdk::signature::{Keypair, Signer};
+    use solana_sdk::system_transaction;
+    use std::fs::remove_file;
+    use std::fs::File;
+    use std::io::Read;
+    use std::sync::Arc;
+
+    fn make_tiny_deterministic_test_entries(num: usize) -> Vec<Entry> {
+        let zero = Hash::default();
+        let one = hash(&zero.as_ref());
+
+        let seed = [2u8; 32];
+
+        let mut generator = ChaChaRng::from_seed(seed);
+        let keypair = Keypair::generate(&mut generator);
+
+        let mut id = one;
+        let mut num_hashes = 0;
+        (0..num)
+            .map(|_| {
+                Entry::new_mut(
+                    &mut id,
+                    &mut num_hashes,
+                    vec![system_transaction::transfer(
+                        &keypair,
+                        &keypair.pubkey(),
+                        1,
+                        one,
+                    )],
+                )
+            })
+            .collect()
+    }
+
+    use std::{env, fs::create_dir_all, path::PathBuf};
+    fn tmp_file_path(name: &str) -> PathBuf {
+        let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
+        let mut path = PathBuf::new();
+        path.push(out_dir);
+        path.push("tmp");
+        create_dir_all(&path).unwrap();
+
+        path.push(format!("{}-{}", name, Pubkey::new_rand()));
+        path
+    }
+
+    #[test]
+    fn test_encrypt_ledger() {
+        solana_logger::setup();
+        let ledger_path = get_tmp_ledger_path!();
+        let ticks_per_slot = 16;
+        let slots_per_segment = 32;
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        let out_path = tmp_file_path("test_encrypt_ledger");
+
+        let seed = [2u8; 32];
+
+        let mut generator = ChaChaRng::from_seed(seed);
+        let keypair = Keypair::generate(&mut generator);
+
+        let entries = make_tiny_deterministic_test_entries(slots_per_segment);
+        blockstore
+            .write_entries(
+                0,
+                0,
+                0,
+                ticks_per_slot,
+                None,
+                true,
+                &Arc::new(keypair),
+                entries,
+                0,
+            )
+            .unwrap();
+
+        let mut key = hex!(
+            "abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234
+                            abcd1234abcd1234abcd1234abcd1234 abcd1234abcd1234abcd1234abcd1234"
+        );
+        chacha_cbc_encrypt_ledger(
+            &blockstore,
+            0,
+            slots_per_segment as u64,
+            &out_path,
+            &mut key,
+        )
+        .unwrap();
+        let mut out_file = File::open(&out_path).unwrap();
+        let mut buf = vec![];
+        let size = out_file.read_to_end(&mut buf).unwrap();
+        let mut hasher = Hasher::default();
+        hasher.hash(&buf[..size]);
+
+        //  golden needs to be updated if shred structure changes....
+        let golden: Hash = "2rq8nR6rns2T5zsbQAGBDZb41NVtacneLgkCH17CVxZm"
+            .parse()
+            .unwrap();
+
+        assert_eq!(hasher.result(), golden);
+        remove_file(&out_path).unwrap();
+    }
+}

chacha/src/lib.rs

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

ci/README.md

@@ -14,47 +14,45 @@ products over to a GPU instance for testing.
 
 ## Buildkite Agent Management
 
-### Buildkite GCP Setup
+### Buildkite Azure 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
-
-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.
-
-The process to update a disk image is as follows (TODO: make this less manual):
-
-1. Create a new VM Instance using the disk image to modify.
-2. Once the VM boots, ssh to it and modify the disk as desired.
-3. Stop the VM Instance running the modified disk.  Remember the name of the VM disk
-4. From another machine, `gcloud auth login`, then create a new Disk Image based
-off the modified VM Instance:
+Create a new Azure-based "queue=default" agent by running the following command:
+```
+$ az vm create \
+   --resource-group ci \
+   --name XYZ \
+   --image boilerplate \
+   --admin-username $(whoami) \
+   --ssh-key-value ~/.ssh/id_rsa.pub
 ```
- $ gcloud compute images create ci-default-$(date +%Y%m%d%H%M) --source-disk xxx --source-disk-zone us-east1-b --family ci-default
 
-```
-or
-```
-  $ gcloud compute images create ci-cuda-$(date +%Y%m%d%H%M) --source-disk xxx --source-disk-zone us-east1-b --family ci-cuda
-```
-5. Delete the new VM instance.
-6. Go to the Instance templates tab, find the existing template named
-`ci-default-vX` or `ci-cuda-vY` and select it.  Use the "Copy" button to create
-a new Instance template called `ci-default-vX+1` or `ci-cuda-vY+1` with the
-newly created Disk image.
-7. Go to the Instance Groups tag and find the applicable group, `ci-default` or
-`ci-cuda`.  Edit the Instance Group in two steps: (a) Set the number of
-instances to 0 and wait for them all to terminate, (b) Update the Instance
-template and restore the number of instances to the original value.
-8. Clean up the previous version by deleting it from Instance Templates and
-Images. 
+The "boilerplate" image contains all the required packages pre-installed so the
+new machine should immediately show up in the Buildkite agent list once it has
+been provisioned and be ready for service.
 
+Creating a "queue=cuda" agent follows the same process but additionally:
+1. Resize the image from the Azure port to include a GPU
+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
+
+1. Create a new VM Instance as described above
+1. Modify it as required
+1. When ready, ssh into the instance and start a root shell with `sudo -i`.  Then
+   prepare it for deallocation by running:
+   `waagent -deprovision+user; cd /etc; ln -s ../run/systemd/resolve/stub-resolv.conf resolv.conf`
+1. Run `az vm deallocate --resource-group ci --name XYZ`
+1. Run `az vm generalize --resource-group ci --name XYZ`
+1. Run `az image create --resource-group ci --source XYZ --name boilerplate`
+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
 
 **AWS CloudFormation is currently inactive, although it may be restored in the
@@ -86,4 +84,42 @@ 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
+
+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
+
+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.
+
+The manual process to update a disk image is as follows:
+
+1. Create a new VM Instance using the disk image to modify.
+2. Once the VM boots, ssh to it and modify the disk as desired.
+3. Stop the VM Instance running the modified disk.  Remember the name of the VM disk
+4. From another machine, `gcloud auth login`, then create a new Disk Image based
+off the modified VM Instance:
+```
+ $ gcloud compute images create ci-default-$(date +%Y%m%d%H%M) --source-disk xxx --source-disk-zone us-east1-b --family ci-default
+
+```
+or
+```
+  $ gcloud compute images create ci-cuda-$(date +%Y%m%d%H%M) --source-disk xxx --source-disk-zone us-east1-b --family ci-cuda
+```
+5. Delete the new VM instance.
+6. Go to the Instance templates tab, find the existing template named
+`ci-default-vX` or `ci-cuda-vY` and select it.  Use the "Copy" button to create
+a new Instance template called `ci-default-vX+1` or `ci-cuda-vY+1` with the
+newly created Disk image.
+7. Go to the Instance Groups tag and find the applicable group, `ci-default` or
+`ci-cuda`.  Edit the Instance Group in two steps: (a) Set the number of
+instances to 0 and wait for them all to terminate, (b) Update the Instance
+template and restore the number of instances to the original value.
+8. Clean up the previous version by deleting it from Instance Templates and
+Images.
+
 

ci/_

@@ -0,0 +1,11 @@
+# Buildkite log management helper
+#
+# See https://buildkite.com/docs/pipelines/managing-log-output
+#
+# |source| me
+#
+
+_() {
+  echo "--- $*"
+  "$@"
+}

ci/affects-files.sh

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

ci/audit.sh

@@ -1,32 +0,0 @@
-#!/bin/bash -e
-#
-# Audits project dependencies for security vulnerabilities
-#
-
-cd "$(dirname "$0")/.."
-
-export RUST_BACKTRACE=1
-rustc --version
-cargo --version
-
-_() {
-  echo "--- $*"
-  "$@"
-}
-
-maybe_cargo_install() {
-  for cmd in "$@"; do
-    set +e
-    cargo "$cmd" --help > /dev/null 2>&1
-    declare exitcode=$?
-    set -e
-    if [[ $exitcode -eq 101 ]]; then
-      _ cargo install cargo-"$cmd"
-    fi
-  done
-}
-
-maybe_cargo_install audit tree
-
-_ cargo tree
-_ cargo audit || true

ci/buildkite-release.yml

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

ci/buildkite-secondary.yml

@@ -0,0 +1,20 @@
+#
+# Build steps that run after the primary pipeline on pushes and tags.
+# Pull requests to not run these steps.
+steps:
+  - command: "sdk/docker-solana/build.sh"
+    timeout_in_minutes: 60
+    name: "publish docker"
+  - command: "ci/publish-crate.sh"
+    timeout_in_minutes: 240
+    name: "publish crate"
+    branches: "!master"
+  - command: "ci/publish-bpf-sdk.sh"
+    timeout_in_minutes: 5
+    name: "publish bpf sdk"
+  - command: "ci/publish-tarball.sh"
+    timeout_in_minutes: 60
+    name: "publish tarball"
+  - command: "ci/publish-docs.sh"
+    timeout_in_minutes: 15
+    name: "publish docs"

ci/buildkite-snap.yml

@@ -1,4 +0,0 @@
-steps:
-  - command: "ci/snap.sh"
-    timeout_in_minutes: 40
-    name: "snap [public]"

ci/buildkite.yml

@@ -1,45 +1,39 @@
+# Build steps that run on pushes and pull requests.
+#
+# Release tags use buildkite-release.yml instead
 steps:
-  - command: "ci/docker-run.sh solanalabs/rust:1.29.1 ci/test-stable.sh"
-    name: "stable [public]"
-    env:
-      CARGO_TARGET_CACHE_NAME: "stable"
-    timeout_in_minutes: 30
-  - command: "ci/docker-run.sh solanalabs/rust-nightly ci/test-bench.sh"
-    name: "bench [public]"
-    env:
-      CARGO_TARGET_CACHE_NAME: "nightly"
-    timeout_in_minutes: 30
   - command: "ci/shellcheck.sh"
-    name: "shellcheck [public]"
+    name: "shellcheck"
+    timeout_in_minutes: 5
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-checks.sh"
+    name: "checks"
     timeout_in_minutes: 20
-  - command: "ci/docker-run.sh solanalabs/rust-nightly:2018-09-03 ci/test-nightly.sh || true"
-    name: "nightly [public]"
-    env:
-      CARGO_TARGET_CACHE_NAME: "nightly"
-    timeout_in_minutes: 30
+  - wait
   - command: "ci/test-stable-perf.sh"
-    name: "stable-perf [public]"
-    env:
-      CARGO_TARGET_CACHE_NAME: "stable-perf"
-    timeout_in_minutes: 20
+    name: "stable-perf"
+    timeout_in_minutes: 40
+    artifact_paths: "log-*.txt"
     agents:
       - "queue=cuda"
-  # TODO: Fix and re-enable test-large-network.sh
-  # - command: "ci/test-large-network.sh || true"
-  #   name: "large-network [public] [ignored]"
-  #   env:
-  #     CARGO_TARGET_CACHE_NAME: "stable"
-  #   timeout_in_minutes: 20
-  #   agents:
-  #     - "queue=large"
-  - command: "ci/pr-snap.sh"
+  - command: "ci/test-bench.sh"
+    name: "bench"
+    timeout_in_minutes: 30
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-stable.sh"
+    name: "stable"
+    timeout_in_minutes: 60
+    artifact_paths: "log-*.txt"
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-move.sh"
+    name: "move"
     timeout_in_minutes: 20
-    name: "snap [public]"
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_stable_docker_image ci/test-local-cluster.sh"
+    name: "local-cluster"
+    timeout_in_minutes: 30
+    artifact_paths: "log-*.txt"
+  - command: ". ci/rust-version.sh; ci/docker-run.sh $$rust_nightly_docker_image ci/test-coverage.sh"
+    name: "coverage"
+    timeout_in_minutes: 30
   - wait
-  - command: "ci/publish-crate.sh"
-    timeout_in_minutes: 20
-    name: "publish crate [public]"
-  - trigger: "solana-snap"
+  - trigger: "solana-secondary"
     branches: "!pull/*"
     async: true
     build:

ci/channel-info.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 #
 # Computes the current branch names of the edge, beta and stable
 # channels, as well as the latest tagged release for beta and stable.
@@ -82,10 +82,26 @@ for tag in "${tags[@]}"; do
   fi
 done
 
-echo EDGE_CHANNEL=master
-echo BETA_CHANNEL="${beta:+v$beta}"
-echo STABLE_CHANNEL="${stable:+v$stable}"
-echo BETA_CHANNEL_LATEST_TAG="${beta_tag:+v$beta_tag}"
-echo STABLE_CHANNEL_LATEST_TAG="${stable_tag:+v$stable_tag}"
+EDGE_CHANNEL=master
+BETA_CHANNEL=${beta:+v$beta}
+STABLE_CHANNEL=${stable:+v$stable}
+BETA_CHANNEL_LATEST_TAG=${beta_tag:+v$beta_tag}
+STABLE_CHANNEL_LATEST_TAG=${stable_tag:+v$stable_tag}
+
+
+if [[ $CI_BRANCH = "$STABLE_CHANNEL" ]]; then
+  CHANNEL=stable
+elif [[ $CI_BRANCH = "$EDGE_CHANNEL" ]]; then
+  CHANNEL=edge
+elif [[ $CI_BRANCH = "$BETA_CHANNEL" ]]; then
+  CHANNEL=beta
+fi
+
+echo EDGE_CHANNEL="$EDGE_CHANNEL"
+echo BETA_CHANNEL="$BETA_CHANNEL"
+echo BETA_CHANNEL_LATEST_TAG="$BETA_CHANNEL_LATEST_TAG"
+echo STABLE_CHANNEL="$STABLE_CHANNEL"
+echo STABLE_CHANNEL_LATEST_TAG="$STABLE_CHANNEL_LATEST_TAG"
+echo CHANNEL="$CHANNEL"
 
 exit 0

ci/check-ssh-keys.sh

@@ -0,0 +1,4 @@
+if grep -q rsa net/scripts/solana-user-authorized_keys.sh; then
+   echo "No rsa keys allowed, small key sizes are insecure."
+   exit 1
+fi

ci/crate-version.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+#
+# Outputs the current crate version from a given Cargo.toml
+#
+set -e
+
+Cargo_toml=$1
+[[ -n $Cargo_toml ]] || {
+  echo "Usage: $0 path/to/Cargo.toml"
+  exit 0
+}
+
+[[ -r $Cargo_toml ]] || {
+  echo "Error: unable to read $Cargo_toml"
+  exit 1
+}
+
+while read -r name equals value _; do
+  if [[ $name = version && $equals = = ]]; then
+    echo "${value//\"/}"
+    exit 0
+  fi
+done < <(cat "$Cargo_toml")
+
+echo Unable to locate version in Cargo.toml 1>&2
+exit 1

ci/docker-run.sh

@@ -1,4 +1,5 @@
-#!/bin/bash -e
+#!/usr/bin/env bash
+set -e
 
 usage() {
   echo "Usage: $0 [--nopull] [docker image name] [command]"
@@ -63,14 +64,24 @@ fi
 ARGS+=(
   --env BUILDKITE
   --env BUILDKITE_AGENT_ACCESS_TOKEN
-  --env BUILDKITE_BRANCH
   --env BUILDKITE_JOB_ID
-  --env BUILDKITE_TAG
-  --env CODECOV_TOKEN
+  --env CI
+  --env CI_BRANCH
+  --env CI_BUILD_ID
+  --env CI_COMMIT
+  --env CI_JOB_ID
+  --env CI_PULL_REQUEST
+  --env CI_REPO_SLUG
   --env CRATES_IO_TOKEN
-  --env SNAPCRAFT_CREDENTIALS_KEY
 )
 
+# Also propagate environment variables needed for codecov
+# https://docs.codecov.io/docs/testing-with-docker#section-codecov-inside-docker
+# We normalize CI to `1`; but codecov expects it to be `true` to detect Buildkite...
+# Unfortunately, codecov.io fails sometimes:
+#   curl: (7) Failed to connect to codecov.io port 443: Connection timed out
+CODECOV_ENVS=$(CI=true bash <(while ! curl -sS --retry 5 --retry-delay 2 --retry-connrefused https://codecov.io/env; do sleep 10; done))
+
 if $INTERACTIVE; then
   if [[ -n $1 ]]; then
     echo
@@ -78,8 +89,10 @@ if $INTERACTIVE; then
     echo
   fi
   set -x
-  exec docker run --interactive --tty "${ARGS[@]}" "$IMAGE" bash
+  # shellcheck disable=SC2086
+  exec docker run --interactive --tty "${ARGS[@]}" $CODECOV_ENVS "$IMAGE" bash
 fi
 
 set -x
-exec docker run "${ARGS[@]}" "$IMAGE" "$@"
+# shellcheck disable=SC2086
+exec docker run "${ARGS[@]}" $CODECOV_ENVS "$IMAGE" "$@"

ci/docker-rust-nightly/Dockerfile

@@ -1,10 +1,12 @@
-FROM solanalabs/rust
+FROM solanalabs/rust:1.41.1
 ARG date
 
-RUN set -x && \
-    rustup install nightly-$date && \
-    rustup default nightly-$date && \
-    rustup component add clippy-preview --toolchain=nightly-$date && \
-    rustc --version && \
-    cargo --version && \
-    cargo +nightly-$date install cargo-cov
+RUN set -x \
+ && rustup install nightly-$date \
+ && rustup component add clippy --toolchain=nightly-$date \
+ && rustup show \
+ && rustc --version \
+ && cargo --version \
+ && cargo install grcov \
+ && rustc +nightly-$date --version \
+ && cargo +nightly-$date --version

ci/docker-rust-nightly/README.md

@@ -15,12 +15,12 @@ To update the pinned version:
 1. Run `ci/docker-rust-nightly/build.sh` to rebuild the nightly image locally,
    or potentially `ci/docker-rust-nightly/build.sh YYYY-MM-DD` if there's a
    specific YYYY-MM-DD that is desired (default is today's build).
-1. Run `SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-nightly.sh`
+1. Update `ci/rust-version.sh` to reflect the new nightly `YYY-MM-DD`
+1. Run `SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-coverage.sh`
    to confirm the new nightly image builds.  Fix any issues as needed
 1. Run `docker login` to enable pushing images to Docker Hub, if you're authorized.
 1. Run `CI=true ci/docker-rust-nightly/build.sh YYYY-MM-DD` to push the new nightly image to dockerhub.com.
-1. Modify the `solanalabs/rust-nightly:YYYY-MM-DD` reference in `ci/buildkite.yml` from the previous to
-   new *YYYY-MM-DD* value, send a PR with this change and any codebase adjustments needed.
+1. Send a PR with the `ci/rust-version.sh` change and any codebase adjustments needed.
 
 ## Troubleshooting
 

ci/docker-rust-nightly/build.sh

@@ -1,4 +1,5 @@
-#!/bin/bash -ex
+#!/usr/bin/env bash
+set -ex
 
 cd "$(dirname "$0")"
 

ci/docker-rust/Dockerfile

@@ -1,24 +1,40 @@
 # Note: when the rust version is changed also modify
-# ci/buildkite.yml to pick up the new image tag
-FROM rust:1.29.1
+# ci/rust-version.sh to pick up the new image tag
+FROM rust:1.41.1
 
-RUN set -x && \
-    apt update && \
-    apt-get install apt-transport-https && \
-    echo deb https://apt.buildkite.com/buildkite-agent stable main > /etc/apt/sources.list.d/buildkite-agent.list && \
-    echo deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-6.0 main > /etc/apt/sources.list.d/llvm.list && \
-    apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 32A37959C2FA5C3C99EFBC32A79206696452D198 && \
-    wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
-    apt update && \
-    apt install -y \
+# Add Google Protocol Buffers for Libra's metrics library.
+ENV PROTOC_VERSION 3.8.0
+ENV PROTOC_ZIP protoc-$PROTOC_VERSION-linux-x86_64.zip
+
+RUN set -x \
+ && apt update \
+ && apt-get install apt-transport-https \
+ && echo deb https://apt.buildkite.com/buildkite-agent stable main > /etc/apt/sources.list.d/buildkite-agent.list \
+ && apt-key adv --no-tty --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 32A37959C2FA5C3C99EFBC32A79206696452D198 \
+ && apt update \
+ && apt install -y \
       buildkite-agent \
+      clang-7 \
       cmake \
-      llvm-6.0 \
+      lcov \
+      libudev-dev \
+      libclang-common-7-dev \
+      mscgen \
+      net-tools \
       rsync \
       sudo \
-      && \
-    rustup component add rustfmt-preview && \
-    rustup component add clippy-preview && \
-    rm -rf /var/lib/apt/lists/* && \
-    rustc --version && \
-    cargo --version
+      golang \
+      unzip \
+      \
+ && rm -rf /var/lib/apt/lists/* \
+ && rustup component add rustfmt \
+ && rustup component add clippy \
+ && cargo install cargo-audit \
+ && cargo install svgbob_cli \
+ && cargo install mdbook \
+ && rustc --version \
+ && cargo --version \
+ && curl -OL https://github.com/google/protobuf/releases/download/v$PROTOC_VERSION/$PROTOC_ZIP \
+ && unzip -o $PROTOC_ZIP -d /usr/local bin/protoc \
+ && unzip -o $PROTOC_ZIP -d /usr/local include/* \
+ && rm -f $PROTOC_ZIP

ci/docker-rust/README.md

@@ -1,6 +1,7 @@
 Docker image containing rust and some preinstalled packages used in CI.
 
-This image may be manually updated by running `./build.sh` if you are a member
-of the [Solana Labs](https://hub.docker.com/u/solanalabs/) Docker Hub
-organization, but it is also automatically updated periodically by
-[this automation](https://buildkite.com/solana-labs/solana-ci-docker-rust).
+This image manually maintained:
+1. Edit `Dockerfile` to match the desired rust version
+2. Run `./build.sh` to publish the new image, if you are a member of the [Solana
+   Labs](https://hub.docker.com/u/solanalabs/) Docker Hub organization.
+

ci/docker-rust/build.sh

@@ -1,4 +1,5 @@
-#!/bin/bash -ex
+#!/usr/bin/env bash
+set -ex
 
 cd "$(dirname "$0")"
 
@@ -7,5 +8,5 @@ docker build -t solanalabs/rust .
 read -r rustc version _ < <(docker run solanalabs/rust rustc --version)
 [[ $rustc = rustc ]]
 docker tag solanalabs/rust:latest solanalabs/rust:"$version"
-
-docker push solanalabs/rust
+docker push solanalabs/rust:"$version"
+docker push solanalabs/rust:latest

ci/docker-snapcraft/Dockerfile

@@ -1,7 +0,0 @@
-FROM snapcraft/xenial-amd64
-
-# Update snapcraft to latest version
-RUN apt-get update -qq \
- && apt-get install -y snapcraft daemontools \
- && rm -rf /var/lib/apt/lists/* \
- && snapcraft --version

ci/docker-snapcraft/build.sh

@@ -1,6 +0,0 @@
-#!/bin/bash -ex
-
-cd "$(dirname "$0")"
-
-docker build -t solanalabs/snapcraft .
-docker push solanalabs/snapcraft

ci/env.sh

@@ -0,0 +1,89 @@
+#
+# Normalized CI environment variables
+#
+# |source| me
+#
+
+if [[ -n $CI ]]; then
+  export CI=1
+  if [[ -n $TRAVIS ]]; then
+    export CI_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
+      export CI_PULL_REQUEST=true
+    else
+      export CI_PULL_REQUEST=
+    fi
+    export CI_OS_NAME=$TRAVIS_OS_NAME
+    export CI_REPO_SLUG=$TRAVIS_REPO_SLUG
+    export CI_TAG=$TRAVIS_TAG
+  elif [[ -n $BUILDKITE ]]; then
+    export CI_BRANCH=$BUILDKITE_BRANCH
+    export CI_BUILD_ID=$BUILDKITE_BUILD_ID
+    export CI_COMMIT=$BUILDKITE_COMMIT
+    export CI_JOB_ID=$BUILDKITE_JOB_ID
+    # The standard BUILDKITE_PULL_REQUEST environment variable is always "false" due
+    # 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_PULL_REQUEST=true
+    else
+      export CI_PULL_REQUEST=
+    fi
+    export CI_OS_NAME=linux
+    if [[ -n $BUILDKITE_TRIGGERED_FROM_BUILD_PIPELINE_SLUG ]]; then
+      # The solana-secondary pipeline should use the slug of the pipeline that
+      # triggered it
+      export CI_REPO_SLUG=$BUILDKITE_ORGANIZATION_SLUG/$BUILDKITE_TRIGGERED_FROM_BUILD_PIPELINE_SLUG
+    else
+      export CI_REPO_SLUG=$BUILDKITE_ORGANIZATION_SLUG/$BUILDKITE_PIPELINE_SLUG
+    fi
+    # TRIGGERED_BUILDKITE_TAG is a workaround to propagate BUILDKITE_TAG into
+    # the solana-secondary pipeline
+    if [[ -n $TRIGGERED_BUILDKITE_TAG ]]; then
+      export CI_TAG=$TRIGGERED_BUILDKITE_TAG
+    else
+      export CI_TAG=$BUILDKITE_TAG
+    fi
+  elif [[ -n $APPVEYOR ]]; then
+    export CI_BRANCH=$APPVEYOR_REPO_BRANCH
+    export CI_BUILD_ID=$APPVEYOR_BUILD_ID
+    export CI_COMMIT=$APPVEYOR_REPO_COMMIT
+    export CI_JOB_ID=$APPVEYOR_JOB_ID
+    if [[ -n $APPVEYOR_PULL_REQUEST_NUMBER ]]; then
+      export CI_PULL_REQUEST=true
+    else
+      export CI_PULL_REQUEST=
+    fi
+    if [[ $CI_LINUX = True ]]; then
+      export CI_OS_NAME=linux
+    else
+      export CI_OS_NAME=windows
+    fi
+    export CI_REPO_SLUG=$APPVEYOR_REPO_NAME
+    export CI_TAG=$APPVEYOR_REPO_TAG_NAME
+  fi
+else
+  export CI=
+  export CI_BRANCH=
+  export CI_BUILD_ID=
+  export CI_COMMIT=
+  export CI_JOB_ID=
+  export CI_OS_NAME=
+  export CI_PULL_REQUEST=
+  export CI_REPO_SLUG=
+  export CI_TAG=
+fi
+
+cat <<EOF
+CI=$CI
+CI_BRANCH=$CI_BRANCH
+CI_BUILD_ID=$CI_BUILD_ID
+CI_COMMIT=$CI_COMMIT
+CI_JOB_ID=$CI_JOB_ID
+CI_OS_NAME=$CI_OS_NAME
+CI_PULL_REQUEST=$CI_PULL_REQUEST
+CI_TAG=$CI_TAG
+EOF

ci/format-url.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+#
+# Formats a URL to be clickable from a Buildkite log
+#
+
+if [[ $# -eq 0 ]]; then
+  echo "Usage: $0 url"
+  exit 1
+fi
+
+if [[ -z $BUILDKITE ]]; then
+  echo "$1"
+else
+  # shellcheck disable=SC2001
+  URL="$(echo "$1" | sed 's/;/%3b/g')" # Escape ;
+
+  printf '\033]1339;url='
+  echo -n "$URL"
+  printf '\a\n'
+fi

ci/hoover.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 #
 # Regular maintenance performed on a buildkite agent to control disk usage
 #

ci/is-pr.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -e
-#
-# The standard BUILDKITE_PULL_REQUEST environment variable is always "false" due
-# to how solana-ci-gate is used to trigger PR builds rather than using the
-# standard Buildkite PR trigger.
-#
-
-[[ $BUILDKITE_BRANCH =~ pull/* ]]

ci/iterations-localnet.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -e
+
+testCmd="$*"
+genPipeline=false
+
+cd "$(dirname "$0")/.."
+
+# Clear cached json keypair files
+rm -rf "$HOME/.config/solana"
+
+source ci/_
+export RUST_BACKTRACE=1
+export RUSTFLAGS="-D warnings"
+export PATH=$PWD/target/debug:$PATH
+export USE_INSTALL=1
+
+if [[ -n $BUILDKITE && -z $testCmd ]]; then
+  genPipeline=true
+  echo "
+steps:
+  "
+fi
+
+build() {
+  $genPipeline && return
+  source ci/rust-version.sh stable
+  source scripts/ulimit-n.sh
+  _ cargo +$rust_stable build
+}
+
+runTest() {
+  declare runTestName="$1"
+  declare runTestCmd="$2"
+  if $genPipeline; then
+    echo "
+  - command: \"$0 '$runTestCmd'\"
+    name: \"$runTestName\"
+    timeout_in_minutes: 45
+"
+    return
+  fi
+
+  if [[ -n $testCmd && "$testCmd" != "$runTestCmd" ]]; then
+    echo Skipped "$runTestName"...
+    return
+  fi
+  #shellcheck disable=SC2068 # Don't want to double quote $runTestCmd
+  $runTestCmd
+}
+
+build
+
+runTest "basic" \
+  "ci/localnet-sanity.sh -i 128"
+
+runTest "restart" \
+  "ci/localnet-sanity.sh -i 128 -k 16"
+
+runTest "incremental restart, extra node" \
+  "ci/localnet-sanity.sh -i 128 -k 16 -R -x"

ci/localnet-sanity.sh

@@ -1,51 +1,301 @@
-#!/bin/bash -e
-#
-# Perform a quick sanity test on a leader, drone, validator and client running
-# locally on the same machine
-#
+#!/usr/bin/env bash
+set -e
+
+skipSetup=false
+iterations=1
+restartInterval=never
+rollingRestart=false
+extraNodes=0
+walletRpcPort=:8899
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 [options...]
+
+Start a local cluster and run sanity on it
+
+  options:
+   -i [number] - Number of times to run sanity (default: $iterations)
+   -k [number] - Restart the cluster after this number of sanity iterations (default: $restartInterval)
+   -R          - Restart the cluster by incrementially stopping and restarting
+                 nodes (at the cadence specified by -k).  When disabled all
+                 nodes will be first killed then restarted (default: $rollingRestart)
+   -b          - Disable leader rotation
+   -x          - Add an extra validator (may be supplied multiple times)
+   -r          - Select the RPC endpoint hosted by a node that starts as
+                 a validator node.  If unspecified the RPC endpoint hosted by
+                 the bootstrap validator will be used.
+   -c          - Reuse existing node/ledger configuration from a previous sanity
+                 run
+
+EOF
+  exit $exitcode
+}
 
 cd "$(dirname "$0")"/..
-source ci/upload_ci_artifact.sh
+
+while getopts "ch?i:k:brxR" opt; do
+  case $opt in
+  h | \?)
+    usage
+    ;;
+  c)
+    skipSetup=true
+    ;;
+  i)
+    iterations=$OPTARG
+    ;;
+  k)
+    restartInterval=$OPTARG
+    ;;
+  x)
+    extraNodes=$((extraNodes + 1))
+    ;;
+  r)
+    walletRpcPort=":18899"
+    ;;
+  R)
+    rollingRestart=true
+    ;;
+  *)
+    usage "Error: unhandled option: $opt"
+    ;;
+  esac
+done
+
+source ci/upload-ci-artifact.sh
 source scripts/configure-metrics.sh
+source multinode-demo/common.sh
 
-multinode-demo/setup.sh
+nodes=(
+  "multinode-demo/faucet.sh"
+  "multinode-demo/bootstrap-validator.sh \
+    --no-restart \
+    --init-complete-file init-complete-node1.log \
+    --dynamic-port-range 8000-8050"
+  "multinode-demo/validator.sh \
+    --enable-rpc-exit \
+    --no-restart \
+    --dynamic-port-range 8050-8100
+    --init-complete-file init-complete-node2.log \
+    --rpc-port 18899"
+)
+
+if [[ extraNodes -gt 0 ]]; then
+  for i in $(seq 1 $extraNodes); do
+    portStart=$((8100 + i * 50))
+    portEnd=$((portStart + 49))
+    nodes+=(
+      "multinode-demo/validator.sh \
+        --no-restart \
+        --dynamic-port-range $portStart-$portEnd
+        --label dyn$i \
+        --init-complete-file init-complete-node$((2 + i)).log"
+    )
+  done
+fi
+numNodes=$((2 + extraNodes))
 
-backgroundCommands="drone leader validator validator-x"
 pids=()
+logs=()
 
-for cmd in $backgroundCommands; do
+getNodeLogFile() {
+  declare nodeIndex=$1
+  declare cmd=$2
+  declare baseCmd
+  baseCmd=$(basename "${cmd// */}" .sh)
+  echo "log-$baseCmd-$nodeIndex.txt"
+}
+
+startNode() {
+  declare nodeIndex=$1
+  declare cmd=$2
   echo "--- Start $cmd"
-  rm -f log-"$cmd".txt
-  multinode-demo/"$cmd".sh > log-"$cmd".txt 2>&1 &
+  declare log
+  log=$(getNodeLogFile "$nodeIndex" "$cmd")
+  rm -f "$log"
+  $cmd > "$log" 2>&1 &
   declare pid=$!
   pids+=("$pid")
   echo "pid: $pid"
-done
+  echo "log: $log"
+}
 
-killBackgroundCommands() {
-  set +e
-  for pid in "${pids[@]}"; do
-    if kill "$pid"; then
-      wait "$pid"
-    else
-      echo -e "^^^ +++\\nWarning: unable to kill $pid"
+waitForNodeToInit() {
+  declare initCompleteFile=$1
+  while [[ ! -r $initCompleteFile ]]; do
+    if [[ $SECONDS -ge 240 ]]; then
+      echo "^^^ +++"
+      echo "Error: $initCompleteFile not found in $SECONDS seconds"
+      exit 1
+    fi
+    echo "Waiting for $initCompleteFile ($SECONDS)..."
+    sleep 2
+  done
+  echo "Found $initCompleteFile"
+}
+
+initCompleteFiles=()
+waitForAllNodesToInit() {
+  echo "--- ${#initCompleteFiles[@]} nodes booting"
+  SECONDS=
+  for initCompleteFile in "${initCompleteFiles[@]}"; do
+    waitForNodeToInit "$initCompleteFile"
+  done
+  echo "All nodes finished booting in $SECONDS seconds"
+}
+
+startNodes() {
+  declare addLogs=false
+  if [[ ${#logs[@]} -eq 0 ]]; then
+    addLogs=true
+  fi
+  initCompleteFiles=()
+  maybeExpectedGenesisHash=
+  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
+    startNode "$i" "$cmd $maybeExpectedGenesisHash"
+    if $addLogs; then
+      logs+=("$(getNodeLogFile "$i" "$cmd")")
+    fi
+
+    # 1 == bootstrap validator, wait until it boots before starting
+    # other validators
+    if [[ "$i" -eq 1 ]]; then
+      SECONDS=
+      waitForNodeToInit "$initCompleteFile"
+
+      (
+        set -x
+        $solana_cli --keypair config/bootstrap-validator/identity-keypair.json \
+          --url http://127.0.0.1:8899 genesis-hash
+      ) | tee genesis-hash.log
+      maybeExpectedGenesisHash="--expected-genesis-hash $(tail -n1 genesis-hash.log)"
     fi
   done
+
+  waitForAllNodesToInit
+}
+
+killNode() {
+  declare pid=$1
+  set +e
+  if kill "$pid"; then
+    echo "Waiting for $pid to exit..."
+    wait "$pid"
+    echo "$pid exited with $?"
+  fi
   set -e
+}
+
+killNodes() {
+  [[ ${#pids[@]} -gt 0 ]] || return
+
+  # Try to use the RPC exit API to cleanly exit the first two nodes
+  # (dynamic nodes, -x, are just killed since their RPC port is not known)
+  echo "--- RPC exit"
+  for port in 8899 18899; do
+    (
+      set -x
+      curl --retry 5 --retry-delay 2 --retry-connrefused \
+        -X POST -H 'Content-Type: application/json' \
+        -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' \
+        http://localhost:$port
+    )
+  done
+
+  # Give the nodes a splash of time to cleanly exit before killing them
+  sleep 2
+
+  echo "--- Killing nodes: ${pids[*]}"
+  for pid in "${pids[@]}"; do
+    killNode "$pid"
+  done
+  echo "done killing nodes"
   pids=()
 }
 
+rollingNodeRestart() {
+  if [[ ${#logs[@]} -ne ${#nodes[@]} ]]; then
+    echo "^^^ +++"
+    echo "Error: log/nodes array length mismatch"
+    exit 1
+  fi
+  if [[ ${#pids[@]} -ne ${#nodes[@]} ]]; then
+    echo "^^^ +++"
+    echo "Error: pids/nodes array length mismatch"
+    exit 1
+  fi
+
+  declare oldPids=("${pids[@]}")
+  for i in $(seq 0 $((${#logs[@]} - 1))); do
+    declare pid=${oldPids[$i]}
+    declare cmd=${nodes[$i]}
+    if [[ $i -eq 0 ]]; then
+      # First cmd should be the faucet, don't restart it.
+      [[ "$cmd" = "multinode-demo/faucet.sh" ]]
+      pids+=("$pid")
+    else
+      echo "--- Restarting $pid: $cmd"
+      killNode "$pid"
+      # Delay 20 seconds to ensure the remaining cluster nodes will
+      # hit CRDS_GOSSIP_PULL_CRDS_TIMEOUT_MS (currently 15 seconds) for the
+      # node that was just stopped
+      echo "(sleeping for 20 seconds)"
+      sleep 20
+
+      declare initCompleteFile="init-complete-node$i.log"
+      rm -f "$initCompleteFile"
+      initCompleteFiles+=("$initCompleteFile")
+      startNode "$i" "$cmd"
+    fi
+  done
+
+  # 'Atomically' remove the old pids from the pids array
+  declare oldPidsList
+  oldPidsList="$(printf ":%s" "${oldPids[@]}"):"
+  declare newPids=("${pids[0]}") # 0 = faucet pid
+  for pid in "${pids[@]}"; do
+    [[ $oldPidsList =~ :$pid: ]] || {
+      newPids+=("$pid")
+    }
+  done
+  pids=("${newPids[@]}")
+
+  waitForAllNodesToInit
+}
+
+verifyLedger() {
+  for ledger in bootstrap-validator validator; do
+    echo "--- $ledger ledger verification"
+    (
+      set -x
+      $solana_ledger_tool --ledger "$SOLANA_CONFIG_DIR"/$ledger verify
+    ) || flag_error
+  done
+}
+
 shutdown() {
   exitcode=$?
-  killBackgroundCommands
+  killNodes
 
   set +e
 
   echo "--- Upload artifacts"
-  for cmd in $backgroundCommands; do
-    declare logfile=log-$cmd.txt
-    upload_ci_artifact "$logfile"
-    tail "$logfile"
+  for log in "${logs[@]}"; do
+    upload-ci-artifact "$log"
+    tail "$log"
   done
 
   exit $exitcode
@@ -55,39 +305,88 @@ trap shutdown EXIT INT
 
 set -e
 
+declare iteration=1
+
 flag_error() {
-  echo Failed
+  echo "Failed (iteration: $iteration/$iterations)"
   echo "^^^ +++"
   exit 1
 }
 
-echo "--- Wallet sanity"
-(
-  set -x
-  scripts/wallet-sanity.sh
-) || flag_error
+if ! $skipSetup; then
+  clear_config_dir "$SOLANA_CONFIG_DIR"
+  multinode-demo/setup.sh --hashes-per-tick sleep
+else
+  verifyLedger
+fi
+startNodes
+lastTransactionCount=
+while [[ $iteration -le $iterations ]]; do
+  echo "--- Node count ($iteration)"
+  (
+    set -x
+    client_keypair=/tmp/client-id.json-$$
+    $solana_keygen new --no-passphrase -fso $client_keypair || exit $?
+    $solana_gossip spy -n 127.0.0.1:8001 --num-nodes-exactly $numNodes || exit $?
+    rm -rf $client_keypair
+  ) || flag_error
 
-echo "--- Node count"
-(
-  source multinode-demo/common.sh
-  set -x
-  client_id=/tmp/client-id.json-$$
-  $solana_keygen -o $client_id
-  $solana_bench_tps --identity $client_id --num-nodes 3 --reject-extra-nodes --converge-only
-  rm -rf $client_id
-) || flag_error
+  echo "--- RPC API: bootstrap-validator getTransactionCount ($iteration)"
+  (
+    set -x
+    curl --retry 5 --retry-delay 2 --retry-connrefused \
+      -X POST -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","id":1, "method":"getTransactionCount"}' \
+      -o log-transactionCount.txt \
+      http://localhost:8899
+    cat log-transactionCount.txt
+  ) || flag_error
 
-killBackgroundCommands
+  echo "--- RPC API: validator getTransactionCount ($iteration)"
+  (
+    set -x
+    curl --retry 5 --retry-delay 2 --retry-connrefused \
+      -X POST -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","id":1, "method":"getTransactionCount"}' \
+      http://localhost:18899
+  ) || flag_error
 
-echo "--- Ledger verification"
-(
-  source multinode-demo/common.sh
-  set -x
-  cp -R "$SOLANA_CONFIG_DIR"/ledger /tmp/ledger-$$
-  $solana_ledger_tool --ledger /tmp/ledger-$$ verify
-  rm -rf /tmp/ledger-$$
-) || flag_error
+  # Verify transaction count as reported by the bootstrap-validator node is advancing
+  transactionCount=$(sed -e 's/{"jsonrpc":"2.0","result":\([0-9]*\),"id":1}/\1/' log-transactionCount.txt)
+  if [[ -n $lastTransactionCount ]]; then
+    echo "--- Transaction count check: $lastTransactionCount < $transactionCount"
+    if [[ $lastTransactionCount -ge $transactionCount ]]; then
+      echo "Error: Transaction count is not advancing"
+      echo "* lastTransactionCount: $lastTransactionCount"
+      echo "* transactionCount: $transactionCount"
+      flag_error
+    fi
+  fi
+  lastTransactionCount=$transactionCount
+
+  echo "--- Wallet sanity ($iteration)"
+  (
+    set -x
+    timeout 60s scripts/wallet-sanity.sh --url http://127.0.0.1"$walletRpcPort"
+  ) || flag_error
+
+  iteration=$((iteration + 1))
+
+  if [[ $restartInterval != never && $((iteration % restartInterval)) -eq 0 ]]; then
+    if $rollingRestart; then
+      rollingNodeRestart
+    else
+      killNodes
+      verifyLedger
+      startNodes
+    fi
+  fi
+done
+
+killNodes
+verifyLedger
 
 echo +++
-echo Ok
+echo "Ok ($iterations iterations)"
+
 exit 0

ci/nits.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+#
+# Project nits enforced here
+#
+set -e
+
+cd "$(dirname "$0")/.."
+source ci/_
+
+# Logging hygiene: Please don't print from --lib, use the `log` crate instead
+declare prints=(
+  'print!'
+  'println!'
+  'eprint!'
+  'eprintln!'
+  'dbg!'
+)
+
+# Parts of the tree that are expected to be print free
+declare print_free_tree=(
+  ':core/src/**.rs'
+  ':faucet/src/**.rs'
+  ':ledger/src/**.rs'
+  ':metrics/src/**.rs'
+  ':net-utils/src/**.rs'
+  ':runtime/src/**.rs'
+  ':sdk/bpf/rust/rust-utils/**.rs'
+  ':sdk/**.rs'
+  ':programs/**.rs'
+  ':^**bin**.rs'
+  ':^**bench**.rs'
+  ':^**test**.rs'
+  ':^**/build.rs'
+)
+
+if _ git --no-pager grep -n "${prints[@]/#/-e}" -- "${print_free_tree[@]}"; then
+    exit 1
+fi
+
+
+# Code readability: please be explicit about the type instead of using
+# Default::default()
+#
+# Ref: https://github.com/solana-labs/solana/issues/2630
+if _ git --no-pager grep -n 'Default::default()' -- '*.rs'; then
+    exit 1
+fi
+
+
+# Github Issues should be used to track outstanding work items instead of
+# marking up the code
+#
+# Ref: https://github.com/solana-labs/solana/issues/6474
+#
+# shellcheck disable=1001
+declare useGithubIssueInsteadOf=(
+  X\XX
+  T\BD
+  F\IXME
+  #T\ODO  # TODO: Disable TODOs once all other TODOs are purged
+)
+
+if _ git --no-pager grep -n --max-depth=0 "${useGithubIssueInsteadOf[@]/#/-e }" -- '*.rs' '*.sh' '*.md'; then
+    exit 1
+fi
+
+# TODO: Remove this `git grep` once TODOs are banned above
+#       (this command is only used to highlight the current offenders)
+_ git --no-pager grep -n --max-depth=0 "-e TODO" -- '*.rs' '*.sh' '*.md' || true
+echo "^^^ +++"
+# END TODO