Add tic-tac-toe dashboard program

.buildkite/env/.gitignore

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

.buildkite/env/README.md

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

@@ -1,12 +0,0 @@
-{
-    "_public_key": "ae29f4f7ad2fc92de70d470e411c8426d5d48db8817c9e3dae574b122192335f",
-    "environment": {
-      "CODECOV_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:3K68mE38LJ2RB98VWmjuNLFBNn1XTGR4:cR4r05/TOZQKmEZp1v4CSgUJtC6QJiOaL85QjXW0qZ061fMnsBA8AtAPMDoDq4WCGOZM1A==]",
-      "CRATES_IO_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:GGRTYDjMXksevzR6kq4Jx+FaIQZz50RU:xkbwDxcgoCyU+aT2tiI9mymigrEl6YiOr3axe3aX70ELIBKbCdPGilXP/wixvKi94g2u]",
-      "GEOLOCATION_API_KEY": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:U2PZLi5MU3Ru/zK1SilianEeizcMvxml:AJKf2OAtDHmJh0KyXrBnNnistItZvVVP3cZ7ZLtrVupjmWN/PzmKwSsXeCNObWS+]",
-      "GITHUB_TOKEN": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:0NJNlpD/O19mvOakCGBYDhIDfySxWFSC:Dz4NXv9x6ncRQ1u9sVoWOcqmkg0sI09qmefghB0GXZgPcFGgn6T0mw7ynNnbUvjyH8dLruKHauk=]",
-      "INFLUX_DATABASE": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:SzwHIeOVpmbTcGQOGngoFgYumsLZJUGq:t7Rpk49njsWvoM+ztv5Uwuiz]",
-      "INFLUX_PASSWORD": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:/MUs+q7pdGrUjzwcq+6pgIFxur4hxdqu:am22z2E2dtmw1f1J1Mq5JLcUHZsrEjQAJ0pp21M4AZeJbNO6bVb44d9zSkHj7xdN6U+GNlCk+wU=]",
-      "INFLUX_USERNAME": "EJ[1:Z7OneT3RdJJ0DipCHQ7rC84snQ+FPbgHwZADQiz54wk=:XjghH20xGVWro9B+epGlJaJcW8Wze0Bi:ZIdOtXudTY5TqKseDU7gVvQXfmXV99Xh]"
-    }
-}

.buildkite/hooks/post-checkout

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

.buildkite/hooks/pre-command

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

@@ -1,18 +0,0 @@
-#!/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")"/..
-source ci/_
-
-_ ci/buildkite-pipeline.sh pipeline.yml
-echo +++ pipeline
-cat pipeline.yml
-
-_ buildkite-agent pipeline upload pipeline.yml

.codecov.yml

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

.github/ISSUE_TEMPLATE.md

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

.github/PULL_REQUEST_TEMPLATE.md

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

.github/dependabot.yml

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

.github/stale.yml

@@ -1,25 +0,0 @@
-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
-  - blocked
-
-# 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,31 +1,16 @@
-/docs/html/
-/docs/src/tests.ok
-/docs/src/cli/usage.md
-/docs/src/.gitbook/assets/*.svg
-/farf/
-/solana-release/
-/solana-release.tar.bz2
-/solana-metrics/
-/solana-metrics.tar.bz2
+Cargo.lock
 /target/
 
 **/*.rs.bk
 .cargo
 
+# node configuration files
 /config/
+/config-private/
+/config-drone/
+/config-validator/
+/config-client/
+/multinode-demo/test/config-client/
 
-# log files
-*.log
-log-*.txt
-log-*/
-
-# intellij files
-/.idea/
-/solana.iml
-/.vscode/
-
-# fetch-spl.sh artifacts
-/spl-genesis-args.sh
-/spl_*.so
-
-.DS_Store
+# test temp files, ledgers, etc.
+/farf/

.mergify.yml

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

.travis.yml

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

.travis/affects.sh

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

.travis/commitlint.sh

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

.travis/export-github-repo.sh

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

CONTRIBUTING.md

@@ -1,248 +1,53 @@
-# Solana Coding Guidelines
+Solana Coding Guidelines
+===
 
-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
+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
 conventions.
 
-## Pull Requests
+Rust coding conventions
+---
 
-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 formatted using the latest version of `rustfmt`. Once installed, it will be
+  updated automatically when you update the compiler with `rustup`.
 
-```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
-```
+* All Rust code is linted with Clippy. If you'd prefer to ignore its advice, do so explicitly:
 
-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,000 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)] ```
+  ```rust
+  #[cfg_attr(feature = "cargo-clippy", allow(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
-abbreviating 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 abreviating 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.
 
-[Terms currently in use](docs/src/terminology.md)
+Some terms we currently use regularly in the codebase:
 
+* 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,68 +1,148 @@
+[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 = [
-    "bench-exchange",
-    "bench-streamer",
-    "bench-tps",
-    "accounts-bench",
-    "banking-bench",
-    "clap-utils",
-    "cli-config",
-    "client",
-    "core",
-    "dos",
-    "download-utils",
-    "faucet",
-    "perf",
-    "validator",
-    "genesis",
-    "genesis-programs",
-    "gossip",
-    "install",
-    "keygen",
-    "ledger",
-    "ledger-tool",
-    "local-cluster",
-    "logger",
-    "log-analyzer",
-    "merkle-tree",
-    "stake-o-matic",
-    "storage-bigtable",
-    "streamer",
-    "measure",
-    "metrics",
-    "net-shaper",
-    "notifier",
-    "poh-bench",
-    "programs/bpf_loader",
-    "programs/budget",
-    "programs/config",
-    "programs/exchange",
-    "programs/failure",
+    ".",
+    "common",
     "programs/noop",
-    "programs/ownable",
-    "programs/stake",
-    "programs/vest",
-    "programs/vote",
-    "remote-wallet",
-    "ramp-tps",
-    "runtime",
-    "sdk",
-    "scripts",
-    "stake-accounts",
-    "stake-monitor",
-    "sys-tuner",
-    "tokens",
-    "transaction-status",
-    "account-decoder",
-    "upload-perf",
-    "net-utils",
-    "version",
-    "vote-signer",
-    "cli",
-    "rayon-threadlimit",
-    "watchtower",
+    "programs/print",
+    "programs/move_funds",
 ]
-
-exclude = [
-    "programs/bpf",
+default-members = [
+    ".",
+    "common",
+    "programs/noop",
+    "programs/print",
+    "programs/move_funds",
 ]

LICENSE

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

README.md

@@ -1,25 +1,282 @@
-<p align="center">
-  <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
-  </a>
-</p>
-
-[![Solana crate](https://img.shields.io/crates/v/solana-core.svg)](https://crates.io/crates/solana-core)
-[![Solana documentation](https://docs.rs/solana-core/badge.svg)](https://docs.rs/solana-core)
-[![Build status](https://badge.buildkite.com/8cc350de251d61483db98bdfc895b9ea0ac8ffa4a32ee850ed.svg?branch=master)](https://buildkite.com/solana-labs/solana/builds?branch=master)
+[![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)
 [![codecov](https://codecov.io/gh/solana-labs/solana/branch/master/graph/badge.svg)](https://codecov.io/gh/solana-labs/solana)
 
-# Building
+Blockchain, Rebuilt for Scale
+===
 
-## **1. Install rustc, cargo and rustfmt.**
+Solana&trade; is a new blockchain architecture built from the ground up for scale. The architecture supports
+up to 710 thousand transactions per second on a gigabit network.
+
+Disclaimer
+===
+
+All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
+
+Introduction
+===
+
+It's possible for a centralized database to process 710,000 transactions per second on a standard gigabit network if the transactions are, on average, no more than 176 bytes. A centralized database can also replicate itself and maintain high availability without significantly compromising that transaction rate using the distributed system technique known as Optimistic Concurrency Control [\[H.T.Kung, J.T.Robinson (1981)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.65.4735). At Solana, we're demonstrating that these same theoretical limits apply just as well to blockchain on an adversarial network. The key ingredient? Finding a way to share time when nodes can't trust one-another. Once nodes can trust time, suddenly ~40 years of distributed systems research becomes applicable to blockchain!
+
+> Perhaps the most striking difference between algorithms obtained by our method and ones based upon timeout is that using timeout produces a traditional distributed algorithm in which the processes operate asynchronously, while our method produces a globally synchronous one in which every process does the same thing at (approximately) the same time. Our method seems to contradict the whole purpose of distributed processing, which is to permit different processes to operate independently and perform different functions. However, if a distributed system is really a single system, then the processes must be synchronized in some way. Conceptually, the easiest way to synchronize processes is to get them all to do the same thing at the same time. Therefore, our method is used to implement a kernel that performs the necessary synchronization--for example, making sure that two different processes do not try to modify a file at the same time. Processes might spend only a small fraction of their time executing the synchronizing kernel; the rest of the time, they can operate independently--e.g., accessing different files. This is an approach we have advocated even when fault-tolerance is not required. The method's basic simplicity makes it easier to understand the precise properties of a system, which is crucial if one is to know just how fault-tolerant the system is. [\[L.Lamport (1984)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.71.1078)
+
+Furthermore, and much to our surprise, it can be implemented using a mechanism that has existed in Bitcoin since day one. The Bitcoin feature is called nLocktime and it can be used to postdate transactions using block height instead of a timestamp. As a Bitcoin client, you'd use block height instead of a timestamp if you don't trust the network. Block height turns out to be an instance of what's being called a Verifiable Delay Function in cryptography circles. It's a cryptographically secure way to say time has passed. In Solana, we use a far more granular verifiable delay function, a SHA 256 hash chain, to checkpoint the ledger and coordinate consensus. With it, we implement Optimistic Concurrency Control and are now well in route towards that theoretical limit of 710,000 transactions per second.
+
+
+Testnet Demos
+===
+
+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.
+
+For all four variations, you'd need the latest Rust toolchain and the Solana
+source code:
+
+First, install Rust's package manager Cargo.
 
 ```bash
 $ curl https://sh.rustup.rs -sSf | sh
 $ source $HOME/.cargo/env
-$ rustup component add rustfmt
 ```
 
-If your rustc version is lower than 1.39.0, please update it:
+Now checkout the code from github:
+
+```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.
+
+Developing
+===
+
+Building
+---
+
+Install rustc, cargo and rustfmt:
+
+```bash
+$ curl https://sh.rustup.rs -sSf | sh
+$ source $HOME/.cargo/env
+$ rustup component add rustfmt-preview
+```
+
+If your rustc version is lower than 1.26.1, please update it:
 
 ```bash
 $ rustup update
@@ -28,46 +285,62 @@ $ rustup update
 On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, etc.  On Ubuntu:
 
 ```bash
-$ sudo apt-get update
-$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
+$ sudo apt-get install libssl-dev pkg-config zlib1g-dev
 ```
 
-## **2. Download the source code.**
+Download the source code:
 
 ```bash
 $ git clone https://github.com/solana-labs/solana.git
 $ cd solana
 ```
 
-## **3. Build.**
+Testing
+---
 
-```bash
-$ cargo build
-```
-
-## **4. Run a minimal local cluster.**
-```bash
-$ ./run.sh
-```
-
-# Testing
-
-**Run the test suite:**
+Run the test suite:
 
 ```bash
 $ cargo test
 ```
 
-### Starting a local testnet
-Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/bench-tps).
+To emulate all the tests that will run on a Pull Request, run:
 
-### Accessing the remote testnet
-* `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7
+```bash
+$ ./ci/run-local.sh
+```
 
-# Benchmarking
+Debugging
+---
 
-First install the nightly build of rustc. `cargo bench` requires use of the
-unstable features only available in the nightly build.
+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.
+
+For example, to enable info everywhere and debug only in the solana::banking_stage module:
+
+```bash
+$ export RUST_LOG=info,solana::banking_stage=debug
+```
+
+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_:
+
+```bash
+$ sudo gdb
+attach <PID>
+set logging on
+thread apply all bt
+```
+
+This will dump all the threads stack traces into gdb.txt
+
+Benchmarking
+---
+
+First install the nightly build of rustc. `cargo bench` requires unstable features:
 
 ```bash
 $ rustup install nightly
@@ -76,22 +349,34 @@ $ rustup install nightly
 Run the benchmarks:
 
 ```bash
-$ cargo +nightly bench
+$ cargo +nightly bench --features="unstable"
 ```
 
-# Release Process
+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
+Code coverage
+---
 
-To generate code coverage statistics:
+To generate code coverage statistics, install cargo-cov. Note: the tool currently only works
+in Rust nightly.
 
 ```bash
-$ scripts/coverage.sh
-$ open target/cov/lcov-local/index.html
+$ cargo +nightly install cargo-cov
 ```
 
+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
 some problem.  Our unit-test suite is how we encode the set of *problems* the codebase solves. Running
@@ -103,7 +388,3 @@ problem is solved by this code?" On the other hand, if a test does fail and you
 better way to solve the same problem, a Pull Request with your solution would most certainly be
 welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please
 send us that patch!
-
-# Disclaimer
-
-All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.

RELEASE.md

@@ -1,151 +1,32 @@
 # Solana Release process
 
-## Branches and Tags
+## Introduction
 
-```
-========================= 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)
+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).
 
-```
+## Release Steps
 
-### master branch
-All new development occurs on the `master` branch.
+### Changing channels
 
-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.
+When cutting a new channel branch these pre-steps are required:
 
-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`!)"
+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.
 
-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`.
+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".
 
-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.
+### Updating channels (i.e. "making 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.
+We use [github's Releases UI](https://github.com/solana-labs/solana/releases) for tagging a release.
 
-### 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>
-    ```
-
-Alternatively use the Github UI.
-
-### Update master branch to the next release minor version
-
-1. After the new branch has been created and pushed, update the Cargo.toml files on **master** to the next semantic version (e.g. 0.9.0 -> 0.10.0) with:
-     ```
-     $ scripts/increment-cargo-version.sh minor
-     $ ./scripts/cargo-for-all-lock-files.sh update
-     ```
-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 'Bump version to X.Y+1.0'
-    git push -u origin version_update
-    ```
-1. Confirm that your freshly cut release branch is shown as `BETA_CHANNEL` and the previous release branch as `STABLE_CHANNEL`:
-    ```
-    ci/channel_info.sh
-    ```
-
-## Steps to Create a Release
-
-### Create the Release Tag on GitHub
-
-1. Go to [GitHub Releases](https://github.com/solana-labs/solana/releases) for tagging a release.
-1. Click "Draft new release".  The release tag must exactly match the `version`
-   field in `/Cargo.toml` prefixed by `v`.
-   1.  If the Cargo.toml version field is **0.12.3**, then the release tag must be **v0.12.3**
-1. Make sure the Target Branch field matches the branch you want to make a release on.
-   1.  If you want to release v0.12.0, the target branch must be v0.12
-1. If this is the first release on the branch (e.g. v0.13.**0**), paste in [this
-   template](https://raw.githubusercontent.com/solana-labs/solana/master/.github/RELEASE_TEMPLATE.md).  Engineering Lead can provide summary contents for release notes if needed.  If this is a patch release, review all the commits since the previous release on this branch and add details as needed.
-1. Click "Save Draft", then confirm the release notes look good and the tag name and branch are correct.
-1. Ensure the release is marked **"This is a pre-release"**.  This flag will then need to be be removed once the the Linux binary artifacts appear later.
-1. Go back into edit the release and click "Publish release" when ready.
-
-
-### Update release branch with the next patch version
-
-1. After the new release has been tagged, update the Cargo.toml files on **release branch** to the next semantic version (e.g. 0.9.0 -> 0.9.1) with:
-     ```
-     $ scripts/increment-cargo-version.sh patch
-     $ ./scripts/cargo-for-all-lock-files.sh tree
-     ```
-1. Push all the changed Cargo.toml and Cargo.lock files to the **release branch** with something like:
-    ```
-    git co -b version_update origin/vX.Y
-    git add -u
-    git commit -m 'Bump version to X.Y.Z+1'
-    git push -u <user-remote> version_update
-    ```
-1. Open a PR against origin/vX.Y and then merge the PR after passing CI.
-
-### Prepare for the next release
-1.  Go to [GitHub Releases](https://github.com/solana-labs/solana/releases) and create a new draft release for `X.Y.Z+1` with empty release nodes.  This allows people to incrementally add new release notes until it's time for the next release
-1.  Go to the [Github Milestones](https://github.com/solana-labs/solana/milestones).  Create a new milestone for the `X.Y.Z+1`, move over
-unresolved issues still in the `X.Y.Z` milestone, then close the `X.Y.Z` milestone.
-
-### Verify release automation success
-Go to [Solana Releases](https://github.com/solana-labs/solana/releases) and click on the latest release that you just published.
-Verify that all of the build artifacts are present, then the uncheck **"This is a pre-release"** for the release.
-
-Build artifacts can take up to 60 minutes after creating the tag before
-appearing.  To check for progress:
-* The `solana-secondary` Buildkite pipeline handles creating the Linux release artifacts and updated crates.  Look for a job under the tag name of the release: https://buildkite.com/solana-labs/solana-secondary.
-* The macOS and Windows release artifacts are produced by Travis CI: https://travis-ci.com/github/solana-labs/solana/branches
-
-[Crates.io](https://crates.io/crates/solana) should have an updated Solana version.  This can take 2-3 hours, and sometimes fails in the `solana-secondary` job.
-If this happens and the error is non-fatal, click "Retry" on the "publish crate" job
-
-### Update software on devnet.solana.com/testnet.solama.com/mainnet-beta.solana.com
-See the documentation at https://github.com/solana-labs/cluster-ops/
+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.

account-decoder/Cargo.toml

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

account-decoder/src/lib.rs

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

account-decoder/src/parse_account_data.rs

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

account-decoder/src/parse_config.rs

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

account-decoder/src/parse_nonce.rs

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

account-decoder/src/parse_stake.rs

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

account-decoder/src/parse_sysvar.rs

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

account-decoder/src/parse_token.rs

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

account-decoder/src/parse_vote.rs

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

account-decoder/src/validator_info.rs

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

accounts-bench/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-accounts-bench"
-version = "1.3.2"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-
-[dependencies]
-log = "0.4.6"
-rayon = "1.3.1"
-solana-logger = { path = "../logger", version = "1.3.2" }
-solana-runtime = { path = "../runtime", version = "1.3.2" }
-solana-measure = { path = "../measure", version = "1.3.2" }
-solana-sdk = { path = "../sdk", version = "1.3.2" }
-rand = "0.7.0"
-clap = "2.33.1"
-crossbeam-channel = "0.4"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

accounts-bench/src/main.rs

@@ -1,105 +0,0 @@
-use clap::{value_t, App, Arg};
-use rayon::prelude::*;
-use solana_measure::measure::Measure;
-use solana_runtime::{
-    accounts::{create_test_accounts, update_accounts, Accounts},
-    accounts_index::Ancestors,
-};
-use solana_sdk::pubkey::Pubkey;
-use std::fs;
-use std::path::PathBuf;
-
-fn main() {
-    solana_logger::setup();
-
-    let matches = App::new("crate")
-        .about("about")
-        .version("version")
-        .arg(
-            Arg::with_name("num_slots")
-                .long("num_slots")
-                .takes_value(true)
-                .value_name("SLOTS")
-                .help("Number of slots to store to."),
-        )
-        .arg(
-            Arg::with_name("num_accounts")
-                .long("num_accounts")
-                .takes_value(true)
-                .value_name("NUM_ACCOUNTS")
-                .help("Total number of accounts"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .value_name("ITERATIONS")
-                .help("Number of bench iterations"),
-        )
-        .arg(
-            Arg::with_name("clean")
-                .long("clean")
-                .takes_value(false)
-                .help("Run clean"),
-        )
-        .get_matches();
-
-    let num_slots = value_t!(matches, "num_slots", usize).unwrap_or(4);
-    let num_accounts = value_t!(matches, "num_accounts", usize).unwrap_or(10_000);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(20);
-    let clean = matches.is_present("clean");
-    println!("clean: {:?}", clean);
-
-    let path = PathBuf::from("farf/accounts-bench");
-    if fs::remove_dir_all(path.clone()).is_err() {
-        println!("Warning: Couldn't remove {:?}", path);
-    }
-    let accounts = Accounts::new(vec![path]);
-    println!("Creating {} accounts", num_accounts);
-    let mut create_time = Measure::start("create accounts");
-    let pubkeys: Vec<_> = (0..num_slots)
-        .into_par_iter()
-        .map(|slot| {
-            let mut pubkeys: Vec<Pubkey> = vec![];
-            create_test_accounts(
-                &accounts,
-                &mut pubkeys,
-                num_accounts / num_slots,
-                slot as u64,
-            );
-            pubkeys
-        })
-        .collect();
-    let pubkeys: Vec<_> = pubkeys.into_iter().flatten().collect();
-    create_time.stop();
-    println!(
-        "created {} accounts in {} slots {}",
-        (num_accounts / num_slots) * num_slots,
-        num_slots,
-        create_time
-    );
-    let mut ancestors: Ancestors = vec![(0, 0)].into_iter().collect();
-    for i in 1..num_slots {
-        ancestors.insert(i as u64, i - 1);
-        accounts.add_root(i as u64);
-    }
-    for x in 0..iterations {
-        if clean {
-            let mut time = Measure::start("clean");
-            accounts.accounts_db.clean_accounts();
-            time.stop();
-            println!("{}", time);
-            for slot in 0..num_slots {
-                update_accounts(&accounts, &pubkeys, ((x + 1) * num_slots + slot) as u64);
-                accounts.add_root((x * num_slots + slot) as u64);
-            }
-        } else {
-            let mut pubkeys: Vec<Pubkey> = vec![];
-            let mut time = Measure::start("hash");
-            let hash = accounts.accounts_db.update_accounts_hash(0, &ancestors);
-            time.stop();
-            println!("hash: {} {}", hash, time);
-            create_test_accounts(&accounts, &mut pubkeys, 1, 0);
-        }
-    }
-}

banking-bench/.gitignore

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

banking-bench/Cargo.toml

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

banking-bench/src/main.rs

@@ -1,390 +0,0 @@
-use clap::{crate_description, crate_name, value_t, App, Arg};
-use crossbeam_channel::unbounded;
-use log::*;
-use rand::{thread_rng, Rng};
-use rayon::prelude::*;
-use solana_core::{
-    banking_stage::{create_test_recorder, BankingStage},
-    cluster_info::ClusterInfo,
-    cluster_info::Node,
-    poh_recorder::PohRecorder,
-    poh_recorder::WorkingBankEntry,
-};
-use solana_ledger::{
-    blockstore::Blockstore,
-    genesis_utils::{create_genesis_config, GenesisConfigInfo},
-    get_tmp_ledger_path,
-};
-use solana_measure::measure::Measure;
-use solana_perf::packet::to_packets_chunked;
-use solana_runtime::{bank::Bank, bank_forks::BankForks};
-use solana_sdk::{
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Keypair,
-    signature::Signature,
-    system_transaction,
-    timing::{duration_as_us, timestamp},
-    transaction::Transaction,
-};
-use std::{
-    sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex},
-    thread::sleep,
-    time::{Duration, Instant},
-};
-
-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(
-    total_num_transactions: usize,
-    hash: Hash,
-    same_payer: bool,
-) -> Vec<Transaction> {
-    let to_pubkey = Pubkey::new_rand();
-    let payer_key = Keypair::new();
-    let dummy = system_transaction::transfer(&payer_key, &to_pubkey, 1, hash);
-    (0..total_num_transactions)
-        .into_par_iter()
-        .map(|_| {
-            let mut new = dummy.clone();
-            let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            if !same_payer {
-                new.message.account_keys[0] = Pubkey::new_rand();
-            }
-            new.message.account_keys[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
-}
-
-#[allow(clippy::cognitive_complexity)]
-fn main() {
-    solana_logger::setup();
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("num_chunks")
-                .long("num-chunks")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Number of transaction chunks."),
-        )
-        .arg(
-            Arg::with_name("packets_per_chunk")
-                .long("packets-per-chunk")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Packets per chunk"),
-        )
-        .arg(
-            Arg::with_name("skip_sanity")
-                .long("skip-sanity")
-                .takes_value(false)
-                .help("Skip transaction sanity execution"),
-        )
-        .arg(
-            Arg::with_name("same_payer")
-                .long("same-payer")
-                .takes_value(false)
-                .help("Use the same payer for transfers"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .arg(
-            Arg::with_name("num_threads")
-                .long("num-threads")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .get_matches();
-
-    let num_threads =
-        value_t!(matches, "num_threads", usize).unwrap_or(BankingStage::num_threads() as usize);
-    //   a multiple of packet chunk duplicates to avoid races
-    let num_chunks = value_t!(matches, "num_chunks", usize).unwrap_or(16);
-    let packets_per_chunk = value_t!(matches, "packets_per_chunk", usize).unwrap_or(192);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(1000);
-
-    let total_num_transactions = num_chunks * num_threads * packets_per_chunk;
-    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 (replay_vote_sender, _replay_vote_receiver) = unbounded();
-    let bank0 = Bank::new(&genesis_config);
-    let mut bank_forks = BankForks::new(bank0);
-    let mut bank = bank_forks.working_bank();
-
-    info!("threads: {} txs: {}", num_threads, total_num_transactions);
-
-    let same_payer = matches.is_present("same_payer");
-    let mut transactions =
-        make_accounts_txs(total_num_transactions, genesis_config.hash(), same_payer);
-
-    // fund all the accounts
-    transactions.iter().for_each(|tx| {
-        let mut fund = system_transaction::transfer(
-            &mint_keypair,
-            &tx.message.account_keys[0],
-            mint_total / total_num_transactions as u64,
-            genesis_config.hash(),
-        );
-        // Ignore any pesky duplicate signature errors in the case we are using single-payer
-        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-        fund.signatures = vec![Signature::new(&sig[0..64])];
-        let x = bank.process_transaction(&fund);
-        x.unwrap();
-    });
-
-    let skip_sanity = matches.is_present("skip_sanity");
-    if !skip_sanity {
-        //sanity check, make sure all the transactions can execute sequentially
-        transactions.iter().for_each(|tx| {
-            let res = bank.process_transaction(&tx);
-            assert!(res.is_ok(), "sanity test transactions error: {:?}", res);
-        });
-        bank.clear_signatures();
-        //sanity check, make sure all the transactions can execute in parallel
-        let res = bank.process_transactions(&transactions);
-        for r in res {
-            assert!(r.is_ok(), "sanity parallel execution error: {:?}", r);
-        }
-        bank.clear_signatures();
-    }
-
-    let mut verified: Vec<_> = to_packets_chunked(&transactions, packets_per_chunk);
-    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(cluster_info);
-        let banking_stage = BankingStage::new(
-            &cluster_info,
-            &poh_recorder,
-            verified_receiver,
-            vote_receiver,
-            None,
-            replay_vote_sender,
-        );
-        poh_recorder.lock().unwrap().set_bank(&bank);
-
-        let chunk_len = verified.len() / num_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 base_tx_count = bank.transaction_count();
-        let mut txs_processed = 0;
-        let mut root = 1;
-        let collector = Pubkey::new_rand();
-        let config = Config {
-            packets_per_batch: packets_per_chunk,
-            chunk_len,
-            num_threads,
-        };
-        let mut total_sent = 0;
-        for _ in 0..iterations {
-            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,
-                total_num_transactions / num_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, 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()),
-                total_num_transactions / num_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_chunk);
-            }
-
-            start += chunk_len;
-            start %= verified.len();
-        }
-        let txs_processed = bank_forks.working_bank().transaction_count();
-        debug!("processed: {} base: {}", txs_processed, base_tx_count);
-        eprintln!(
-            "{{'name': 'banking_bench_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * total_sent as f64) / (total_us as f64),
-        );
-        eprintln!(
-            "{{'name': 'banking_bench_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * total_sent as f64) / (tx_total_us as f64),
-        );
-        eprintln!(
-            "{{'name': 'banking_bench_success_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * (txs_processed - base_tx_count) as f64) / (total_us as f64),
-        );
-
-        drop(verified_sender);
-        drop(vote_sender);
-        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

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

bench-exchange/Cargo.toml

@@ -1,38 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-bench-exchange"
-version = "1.3.2"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-publish = false
-
-[dependencies]
-clap = "2.33.1"
-itertools = "0.9.0"
-log = "0.4.8"
-num-derive = "0.3"
-num-traits = "0.2"
-rand = "0.7.0"
-rayon = "1.3.1"
-serde_json = "1.0.56"
-serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
-solana-core = { path = "../core", version = "1.3.2" }
-solana-genesis = { path = "../genesis", version = "1.3.2" }
-solana-client = { path = "../client", version = "1.3.2" }
-solana-faucet = { path = "../faucet", version = "1.3.2" }
-solana-exchange-program = { path = "../programs/exchange", version = "1.3.2" }
-solana-logger = { path = "../logger", version = "1.3.2" }
-solana-metrics = { path = "../metrics", version = "1.3.2" }
-solana-net-utils = { path = "../net-utils", version = "1.3.2" }
-solana-runtime = { path = "../runtime", version = "1.3.2" }
-solana-sdk = { path = "../sdk", version = "1.3.2" }
-solana-version = { path = "../version", version = "1.3.2" }
-
-[dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "1.3.2" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

bench-exchange/README.md

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

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

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

bench-exchange/src/main.rs

@@ -1,82 +0,0 @@
-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_version::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 = 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

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

@@ -1,103 +0,0 @@
-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_builtin_program("exchange_program", 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

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

bench-streamer/Cargo.toml

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

bench-tps/.gitignore

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

bench-tps/Cargo.toml

@@ -1,36 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-bench-tps"
-version = "1.3.2"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-
-[dependencies]
-bincode = "1.3.1"
-clap = "2.33.1"
-log = "0.4.8"
-rayon = "1.3.1"
-serde_json = "1.0.56"
-serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "1.3.2" }
-solana-core = { path = "../core", version = "1.3.2" }
-solana-genesis = { path = "../genesis", version = "1.3.2" }
-solana-client = { path = "../client", version = "1.3.2" }
-solana-faucet = { path = "../faucet", version = "1.3.2" }
-solana-logger = { path = "../logger", version = "1.3.2" }
-solana-metrics = { path = "../metrics", version = "1.3.2" }
-solana-measure = { path = "../measure", version = "1.3.2" }
-solana-net-utils = { path = "../net-utils", version = "1.3.2" }
-solana-runtime = { path = "../runtime", version = "1.3.2" }
-solana-sdk = { path = "../sdk", version = "1.3.2" }
-solana-version = { path = "../version", version = "1.3.2" }
-
-[dev-dependencies]
-serial_test = "0.4.0"
-serial_test_derive = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "1.3.2" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

bench-tps/src/bench.rs

@@ -1,992 +0,0 @@
-use crate::cli::Config;
-use log::*;
-use rayon::prelude::*;
-use solana_client::perf_utils::{sample_txs, SampleStats};
-use solana_core::gen_keys::GenKeys;
-use solana_faucet::faucet::request_airdrop_transaction;
-use solana_measure::measure::Measure;
-use solana_metrics::{self, datapoint_info};
-use solana_sdk::{
-    client::Client,
-    clock::{DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT, MAX_PROCESSING_AGE},
-    commitment_config::CommitmentConfig,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    message::Message,
-    pubkey::Pubkey,
-    signature::{Keypair, Signer},
-    system_instruction, system_transaction,
-    timing::{duration_as_ms, duration_as_s, duration_as_us, timestamp},
-    transaction::Transaction,
-};
-use std::{
-    collections::{HashSet, VecDeque},
-    net::SocketAddr,
-    process::exit,
-    sync::{
-        atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering},
-        Arc, Mutex, RwLock,
-    },
-    thread::{sleep, Builder, JoinHandle},
-    time::{Duration, Instant},
-};
-
-// The point at which transactions become "too old", in seconds.
-const MAX_TX_QUEUE_AGE: u64 =
-    MAX_PROCESSING_AGE as u64 * DEFAULT_TICKS_PER_SLOT / DEFAULT_TICKS_PER_SECOND;
-
-pub const MAX_SPENDS_PER_TX: u64 = 4;
-
-#[derive(Debug)]
-pub enum BenchTpsError {
-    AirdropFailure,
-}
-
-pub type Result<T> = std::result::Result<T, BenchTpsError>;
-
-pub type SharedTransactions = Arc<RwLock<VecDeque<Vec<(Transaction, u64)>>>>;
-
-fn get_recent_blockhash<T: Client>(client: &T) -> (Hash, FeeCalculator) {
-    loop {
-        match client.get_recent_blockhash_with_commitment(CommitmentConfig::recent()) {
-            Ok((blockhash, fee_calculator, _last_valid_slot)) => {
-                return (blockhash, fee_calculator)
-            }
-            Err(err) => {
-                info!("Couldn't get recent blockhash: {:?}", err);
-                sleep(Duration::from_secs(1));
-            }
-        };
-    }
-}
-
-fn wait_for_target_slots_per_epoch<T>(target_slots_per_epoch: u64, client: &Arc<T>)
-where
-    T: 'static + Client + Send + Sync,
-{
-    if target_slots_per_epoch != 0 {
-        info!(
-            "Waiting until epochs are {} slots long..",
-            target_slots_per_epoch
-        );
-        loop {
-            if let Ok(epoch_info) = client.get_epoch_info() {
-                if epoch_info.slots_in_epoch >= target_slots_per_epoch {
-                    info!("Done epoch_info: {:?}", epoch_info);
-                    break;
-                }
-                info!(
-                    "Waiting for epoch: {} now: {}",
-                    target_slots_per_epoch, epoch_info.slots_in_epoch
-                );
-            }
-            sleep(Duration::from_secs(3));
-        }
-    }
-}
-
-fn create_sampler_thread<T>(
-    client: &Arc<T>,
-    exit_signal: &Arc<AtomicBool>,
-    sample_period: u64,
-    maxes: &Arc<RwLock<Vec<(String, SampleStats)>>>,
-) -> JoinHandle<()>
-where
-    T: 'static + Client + Send + Sync,
-{
-    info!("Sampling TPS every {} second...", sample_period);
-    let exit_signal = exit_signal.clone();
-    let maxes = maxes.clone();
-    let client = client.clone();
-    Builder::new()
-        .name("solana-client-sample".to_string())
-        .spawn(move || {
-            sample_txs(&exit_signal, &maxes, sample_period, &client);
-        })
-        .unwrap()
-}
-
-fn generate_chunked_transfers(
-    recent_blockhash: Arc<RwLock<Hash>>,
-    shared_txs: &SharedTransactions,
-    shared_tx_active_thread_count: Arc<AtomicIsize>,
-    source_keypair_chunks: Vec<Vec<&Keypair>>,
-    dest_keypair_chunks: &mut Vec<VecDeque<&Keypair>>,
-    threads: usize,
-    duration: Duration,
-    sustained: bool,
-) {
-    // generate and send transactions for the specified duration
-    let start = Instant::now();
-    let keypair_chunks = source_keypair_chunks.len();
-    let mut reclaim_lamports_back_to_source_account = false;
-    let mut chunk_index = 0;
-    while start.elapsed() < duration {
-        generate_txs(
-            shared_txs,
-            &recent_blockhash,
-            &source_keypair_chunks[chunk_index],
-            &dest_keypair_chunks[chunk_index],
-            threads,
-            reclaim_lamports_back_to_source_account,
-        );
-
-        // In sustained mode, overlap the transfers with generation. This has higher average
-        // performance but lower peak performance in tested environments.
-        if sustained {
-            // Ensure that we don't generate more transactions than we can handle.
-            while shared_txs.read().unwrap().len() > 2 * threads {
-                sleep(Duration::from_millis(1));
-            }
-        } else {
-            while !shared_txs.read().unwrap().is_empty()
-                || shared_tx_active_thread_count.load(Ordering::Relaxed) > 0
-            {
-                sleep(Duration::from_millis(1));
-            }
-        }
-
-        // Rotate destination keypairs so that the next round of transactions will have different
-        // transaction signatures even when blockhash is reused.
-        dest_keypair_chunks[chunk_index].rotate_left(1);
-
-        // Move on to next chunk
-        chunk_index = (chunk_index + 1) % keypair_chunks;
-
-        // Switch directions after transfering for each "chunk"
-        if chunk_index == 0 {
-            reclaim_lamports_back_to_source_account = !reclaim_lamports_back_to_source_account;
-        }
-    }
-}
-
-fn create_sender_threads<T>(
-    client: &Arc<T>,
-    shared_txs: &SharedTransactions,
-    thread_batch_sleep_ms: usize,
-    total_tx_sent_count: &Arc<AtomicUsize>,
-    threads: usize,
-    exit_signal: &Arc<AtomicBool>,
-    shared_tx_active_thread_count: &Arc<AtomicIsize>,
-) -> Vec<JoinHandle<()>>
-where
-    T: 'static + Client + Send + Sync,
-{
-    (0..threads)
-        .map(|_| {
-            let exit_signal = exit_signal.clone();
-            let shared_txs = shared_txs.clone();
-            let shared_tx_active_thread_count = shared_tx_active_thread_count.clone();
-            let total_tx_sent_count = total_tx_sent_count.clone();
-            let client = client.clone();
-            Builder::new()
-                .name("solana-client-sender".to_string())
-                .spawn(move || {
-                    do_tx_transfers(
-                        &exit_signal,
-                        &shared_txs,
-                        &shared_tx_active_thread_count,
-                        &total_tx_sent_count,
-                        thread_batch_sleep_ms,
-                        &client,
-                    );
-                })
-                .unwrap()
-        })
-        .collect()
-}
-
-pub fn do_bench_tps<T>(client: Arc<T>, config: Config, gen_keypairs: Vec<Keypair>) -> u64
-where
-    T: 'static + Client + Send + Sync,
-{
-    let Config {
-        id,
-        threads,
-        thread_batch_sleep_ms,
-        duration,
-        tx_count,
-        sustained,
-        target_slots_per_epoch,
-        ..
-    } = config;
-
-    let mut source_keypair_chunks: Vec<Vec<&Keypair>> = Vec::new();
-    let mut dest_keypair_chunks: Vec<VecDeque<&Keypair>> = Vec::new();
-    assert!(gen_keypairs.len() >= 2 * tx_count);
-    for chunk in gen_keypairs.chunks_exact(2 * tx_count) {
-        source_keypair_chunks.push(chunk[..tx_count].iter().collect());
-        dest_keypair_chunks.push(chunk[tx_count..].iter().collect());
-    }
-
-    let first_tx_count = loop {
-        match client.get_transaction_count() {
-            Ok(count) => break count,
-            Err(err) => {
-                info!("Couldn't get transaction count: {:?}", err);
-                sleep(Duration::from_secs(1));
-            }
-        }
-    };
-    info!("Initial transaction count {}", first_tx_count);
-
-    let exit_signal = Arc::new(AtomicBool::new(false));
-
-    // Setup a thread per validator to sample every period
-    // collect the max transaction rate and total tx count seen
-    let maxes = Arc::new(RwLock::new(Vec::new()));
-    let sample_period = 1; // in seconds
-    let sample_thread = create_sampler_thread(&client, &exit_signal, sample_period, &maxes);
-
-    let shared_txs: SharedTransactions = Arc::new(RwLock::new(VecDeque::new()));
-
-    let recent_blockhash = Arc::new(RwLock::new(get_recent_blockhash(client.as_ref()).0));
-    let shared_tx_active_thread_count = Arc::new(AtomicIsize::new(0));
-    let total_tx_sent_count = Arc::new(AtomicUsize::new(0));
-
-    let blockhash_thread = {
-        let exit_signal = exit_signal.clone();
-        let recent_blockhash = recent_blockhash.clone();
-        let client = client.clone();
-        let id = id.pubkey();
-        Builder::new()
-            .name("solana-blockhash-poller".to_string())
-            .spawn(move || {
-                poll_blockhash(&exit_signal, &recent_blockhash, &client, &id);
-            })
-            .unwrap()
-    };
-
-    let s_threads = create_sender_threads(
-        &client,
-        &shared_txs,
-        thread_batch_sleep_ms,
-        &total_tx_sent_count,
-        threads,
-        &exit_signal,
-        &shared_tx_active_thread_count,
-    );
-
-    wait_for_target_slots_per_epoch(target_slots_per_epoch, &client);
-
-    let start = Instant::now();
-
-    generate_chunked_transfers(
-        recent_blockhash,
-        &shared_txs,
-        shared_tx_active_thread_count,
-        source_keypair_chunks,
-        &mut dest_keypair_chunks,
-        threads,
-        duration,
-        sustained,
-    );
-
-    // Stop the sampling threads so it will collect the stats
-    exit_signal.store(true, Ordering::Relaxed);
-
-    info!("Waiting for sampler threads...");
-    if let Err(err) = sample_thread.join() {
-        info!("  join() failed with: {:?}", err);
-    }
-
-    // join the tx send threads
-    info!("Waiting for transmit threads...");
-    for t in s_threads {
-        if let Err(err) = t.join() {
-            info!("  join() failed with: {:?}", err);
-        }
-    }
-
-    info!("Waiting for blockhash thread...");
-    if let Err(err) = blockhash_thread.join() {
-        info!("  join() failed with: {:?}", err);
-    }
-
-    let balance = client.get_balance(&id.pubkey()).unwrap_or(0);
-    metrics_submit_lamport_balance(balance);
-
-    compute_and_report_stats(
-        &maxes,
-        sample_period,
-        &start.elapsed(),
-        total_tx_sent_count.load(Ordering::Relaxed),
-    );
-
-    let r_maxes = maxes.read().unwrap();
-    r_maxes.first().unwrap().1.txs
-}
-
-fn metrics_submit_lamport_balance(lamport_balance: u64) {
-    info!("Token balance: {}", lamport_balance);
-    datapoint_info!(
-        "bench-tps-lamport_balance",
-        ("balance", lamport_balance, i64)
-    );
-}
-
-fn generate_system_txs(
-    source: &[&Keypair],
-    dest: &VecDeque<&Keypair>,
-    reclaim: bool,
-    blockhash: &Hash,
-) -> Vec<(Transaction, u64)> {
-    let pairs: Vec<_> = if !reclaim {
-        source.iter().zip(dest.iter()).collect()
-    } else {
-        dest.iter().zip(source.iter()).collect()
-    };
-
-    pairs
-        .par_iter()
-        .map(|(from, to)| {
-            (
-                system_transaction::transfer(from, &to.pubkey(), 1, *blockhash),
-                timestamp(),
-            )
-        })
-        .collect()
-}
-
-fn generate_txs(
-    shared_txs: &SharedTransactions,
-    blockhash: &Arc<RwLock<Hash>>,
-    source: &[&Keypair],
-    dest: &VecDeque<&Keypair>,
-    threads: usize,
-    reclaim: bool,
-) {
-    let blockhash = *blockhash.read().unwrap();
-    let tx_count = source.len();
-    info!(
-        "Signing transactions... {} (reclaim={}, blockhash={})",
-        tx_count, reclaim, &blockhash
-    );
-    let signing_start = Instant::now();
-
-    let transactions = generate_system_txs(source, dest, reclaim, &blockhash);
-
-    let duration = signing_start.elapsed();
-    let ns = duration.as_secs() * 1_000_000_000 + u64::from(duration.subsec_nanos());
-    let bsps = (tx_count) as f64 / ns as f64;
-    let nsps = ns as f64 / (tx_count) as f64;
-    info!(
-        "Done. {:.2} thousand signatures per second, {:.2} us per signature, {} ms total time, {}",
-        bsps * 1_000_000_f64,
-        nsps / 1_000_f64,
-        duration_as_ms(&duration),
-        blockhash,
-    );
-    datapoint_info!(
-        "bench-tps-generate_txs",
-        ("duration", duration_as_us(&duration), i64)
-    );
-
-    let sz = transactions.len() / threads;
-    let chunks: Vec<_> = transactions.chunks(sz).collect();
-    {
-        let mut shared_txs_wl = shared_txs.write().unwrap();
-        for chunk in chunks {
-            shared_txs_wl.push_back(chunk.to_vec());
-        }
-    }
-}
-
-fn poll_blockhash<T: Client>(
-    exit_signal: &Arc<AtomicBool>,
-    blockhash: &Arc<RwLock<Hash>>,
-    client: &Arc<T>,
-    id: &Pubkey,
-) {
-    let mut blockhash_last_updated = Instant::now();
-    let mut last_error_log = Instant::now();
-    loop {
-        let blockhash_updated = {
-            let old_blockhash = *blockhash.read().unwrap();
-            if let Ok((new_blockhash, _fee)) = client.get_new_blockhash(&old_blockhash) {
-                *blockhash.write().unwrap() = new_blockhash;
-                blockhash_last_updated = Instant::now();
-                true
-            } else {
-                if blockhash_last_updated.elapsed().as_secs() > 120 {
-                    eprintln!("Blockhash is stuck");
-                    exit(1)
-                } else if blockhash_last_updated.elapsed().as_secs() > 30
-                    && last_error_log.elapsed().as_secs() >= 1
-                {
-                    last_error_log = Instant::now();
-                    error!("Blockhash is not updating");
-                }
-                false
-            }
-        };
-
-        if blockhash_updated {
-            let balance = client.get_balance(id).unwrap_or(0);
-            metrics_submit_lamport_balance(balance);
-        }
-
-        if exit_signal.load(Ordering::Relaxed) {
-            break;
-        }
-
-        sleep(Duration::from_millis(50));
-    }
-}
-
-fn do_tx_transfers<T: Client>(
-    exit_signal: &Arc<AtomicBool>,
-    shared_txs: &SharedTransactions,
-    shared_tx_thread_count: &Arc<AtomicIsize>,
-    total_tx_sent_count: &Arc<AtomicUsize>,
-    thread_batch_sleep_ms: usize,
-    client: &Arc<T>,
-) {
-    loop {
-        if thread_batch_sleep_ms > 0 {
-            sleep(Duration::from_millis(thread_batch_sleep_ms as u64));
-        }
-        let txs = {
-            let mut shared_txs_wl = shared_txs.write().expect("write lock in do_tx_transfers");
-            shared_txs_wl.pop_front()
-        };
-        if let Some(txs0) = txs {
-            shared_tx_thread_count.fetch_add(1, Ordering::Relaxed);
-            info!(
-                "Transferring 1 unit {} times... to {}",
-                txs0.len(),
-                client.as_ref().tpu_addr(),
-            );
-            let tx_len = txs0.len();
-            let transfer_start = Instant::now();
-            let mut old_transactions = false;
-            for tx in txs0 {
-                let now = timestamp();
-                // Transactions that are too old will be rejected by the cluster Don't bother
-                // sending them.
-                if now > tx.1 && now - tx.1 > 1000 * MAX_TX_QUEUE_AGE {
-                    old_transactions = true;
-                    continue;
-                }
-                client
-                    .async_send_transaction(tx.0)
-                    .expect("async_send_transaction in do_tx_transfers");
-            }
-            if old_transactions {
-                let mut shared_txs_wl = shared_txs.write().expect("write lock in do_tx_transfers");
-                shared_txs_wl.clear();
-            }
-            shared_tx_thread_count.fetch_add(-1, Ordering::Relaxed);
-            total_tx_sent_count.fetch_add(tx_len, Ordering::Relaxed);
-            info!(
-                "Tx send done. {} ms {} tps",
-                duration_as_ms(&transfer_start.elapsed()),
-                tx_len as f32 / duration_as_s(&transfer_start.elapsed()),
-            );
-            datapoint_info!(
-                "bench-tps-do_tx_transfers",
-                ("duration", duration_as_us(&transfer_start.elapsed()), i64),
-                ("count", tx_len, i64)
-            );
-        }
-        if exit_signal.load(Ordering::Relaxed) {
-            break;
-        }
-    }
-}
-
-fn verify_funding_transfer<T: Client>(client: &Arc<T>, tx: &Transaction, amount: u64) -> bool {
-    for a in &tx.message().account_keys[1..] {
-        match client.get_balance_with_commitment(a, CommitmentConfig::recent()) {
-            Ok(balance) => return balance >= amount,
-            Err(err) => error!("failed to get balance {:?}", err),
-        }
-    }
-    false
-}
-
-trait FundingTransactions<'a> {
-    fn fund<T: 'static + Client + Send + Sync>(
-        &mut self,
-        client: &Arc<T>,
-        to_fund: &[(&'a Keypair, Vec<(Pubkey, u64)>)],
-        to_lamports: u64,
-    );
-    fn make(&mut self, to_fund: &[(&'a Keypair, Vec<(Pubkey, u64)>)]);
-    fn sign(&mut self, blockhash: Hash);
-    fn send<T: Client>(&self, client: &Arc<T>);
-    fn verify<T: 'static + Client + Send + Sync>(&mut self, client: &Arc<T>, to_lamports: u64);
-}
-
-impl<'a> FundingTransactions<'a> for Vec<(&'a Keypair, Transaction)> {
-    fn fund<T: 'static + Client + Send + Sync>(
-        &mut self,
-        client: &Arc<T>,
-        to_fund: &[(&'a Keypair, Vec<(Pubkey, u64)>)],
-        to_lamports: u64,
-    ) {
-        self.make(to_fund);
-
-        let mut tries = 0;
-        while !self.is_empty() {
-            info!(
-                "{} {} each to {} accounts in {} txs",
-                if tries == 0 {
-                    "transferring"
-                } else {
-                    " retrying"
-                },
-                to_lamports,
-                self.len() * MAX_SPENDS_PER_TX as usize,
-                self.len(),
-            );
-
-            let (blockhash, _fee_calculator) = get_recent_blockhash(client.as_ref());
-
-            // re-sign retained to_fund_txes with updated blockhash
-            self.sign(blockhash);
-            self.send(&client);
-
-            // Sleep a few slots to allow transactions to process
-            sleep(Duration::from_secs(1));
-
-            self.verify(&client, to_lamports);
-
-            // retry anything that seems to have dropped through cracks
-            //  again since these txs are all or nothing, they're fine to
-            //  retry
-            tries += 1;
-        }
-        info!("transferred");
-    }
-
-    fn make(&mut self, to_fund: &[(&'a Keypair, Vec<(Pubkey, u64)>)]) {
-        let mut make_txs = Measure::start("make_txs");
-        let to_fund_txs: Vec<(&Keypair, Transaction)> = to_fund
-            .par_iter()
-            .map(|(k, t)| {
-                let instructions = system_instruction::transfer_many(&k.pubkey(), &t);
-                let message = Message::new(&instructions, Some(&k.pubkey()));
-                (*k, Transaction::new_unsigned(message))
-            })
-            .collect();
-        make_txs.stop();
-        debug!(
-            "make {} unsigned txs: {}us",
-            to_fund_txs.len(),
-            make_txs.as_us()
-        );
-        self.extend(to_fund_txs);
-    }
-
-    fn sign(&mut self, blockhash: Hash) {
-        let mut sign_txs = Measure::start("sign_txs");
-        self.par_iter_mut().for_each(|(k, tx)| {
-            tx.sign(&[*k], blockhash);
-        });
-        sign_txs.stop();
-        debug!("sign {} txs: {}us", self.len(), sign_txs.as_us());
-    }
-
-    fn send<T: Client>(&self, client: &Arc<T>) {
-        let mut send_txs = Measure::start("send_txs");
-        self.iter().for_each(|(_, tx)| {
-            client.async_send_transaction(tx.clone()).expect("transfer");
-        });
-        send_txs.stop();
-        debug!("send {} txs: {}us", self.len(), send_txs.as_us());
-    }
-
-    fn verify<T: 'static + Client + Send + Sync>(&mut self, client: &Arc<T>, to_lamports: u64) {
-        let starting_txs = self.len();
-        let verified_txs = Arc::new(AtomicUsize::new(0));
-        let too_many_failures = Arc::new(AtomicBool::new(false));
-        let loops = if starting_txs < 1000 { 3 } else { 1 };
-        // Only loop multiple times for small (quick) transaction batches
-        let time = Arc::new(Mutex::new(Instant::now()));
-        for _ in 0..loops {
-            let time = time.clone();
-            let failed_verify = Arc::new(AtomicUsize::new(0));
-            let client = client.clone();
-            let verified_txs = &verified_txs;
-            let failed_verify = &failed_verify;
-            let too_many_failures = &too_many_failures;
-            let verified_set: HashSet<Pubkey> = self
-                .par_iter()
-                .filter_map(move |(k, tx)| {
-                    if too_many_failures.load(Ordering::Relaxed) {
-                        return None;
-                    }
-
-                    let verified = if verify_funding_transfer(&client, &tx, to_lamports) {
-                        verified_txs.fetch_add(1, Ordering::Relaxed);
-                        Some(k.pubkey())
-                    } else {
-                        failed_verify.fetch_add(1, Ordering::Relaxed);
-                        None
-                    };
-
-                    let verified_txs = verified_txs.load(Ordering::Relaxed);
-                    let failed_verify = failed_verify.load(Ordering::Relaxed);
-                    let remaining_count = starting_txs.saturating_sub(verified_txs + failed_verify);
-                    if failed_verify > 100 && failed_verify > verified_txs {
-                        too_many_failures.store(true, Ordering::Relaxed);
-                        warn!(
-                            "Too many failed transfers... {} remaining, {} verified, {} failures",
-                            remaining_count, verified_txs, failed_verify
-                        );
-                    }
-                    if remaining_count > 0 {
-                        let mut time_l = time.lock().unwrap();
-                        if time_l.elapsed().as_secs() > 2 {
-                            info!(
-                                "Verifying transfers... {} remaining, {} verified, {} failures",
-                                remaining_count, verified_txs, failed_verify
-                            );
-                            *time_l = Instant::now();
-                        }
-                    }
-
-                    verified
-                })
-                .collect();
-
-            self.retain(|(k, _)| !verified_set.contains(&k.pubkey()));
-            if self.is_empty() {
-                break;
-            }
-            info!("Looping verifications");
-
-            let verified_txs = verified_txs.load(Ordering::Relaxed);
-            let failed_verify = failed_verify.load(Ordering::Relaxed);
-            let remaining_count = starting_txs.saturating_sub(verified_txs + failed_verify);
-            info!(
-                "Verifying transfers... {} remaining, {} verified, {} failures",
-                remaining_count, verified_txs, failed_verify
-            );
-            sleep(Duration::from_millis(100));
-        }
-    }
-}
-
-/// fund the dests keys by spending all of the source keys into MAX_SPENDS_PER_TX
-/// on every iteration.  This allows us to replay the transfers because the source is either empty,
-/// or full
-pub fn fund_keys<T: 'static + Client + Send + Sync>(
-    client: Arc<T>,
-    source: &Keypair,
-    dests: &[Keypair],
-    total: u64,
-    max_fee: u64,
-    lamports_per_account: u64,
-) {
-    let mut funded: Vec<&Keypair> = vec![source];
-    let mut funded_funds = total;
-    let mut not_funded: Vec<&Keypair> = dests.iter().collect();
-    while !not_funded.is_empty() {
-        // Build to fund list and prepare funding sources for next iteration
-        let mut new_funded: Vec<&Keypair> = vec![];
-        let mut to_fund: Vec<(&Keypair, Vec<(Pubkey, u64)>)> = vec![];
-        let to_lamports = (funded_funds - lamports_per_account - max_fee) / MAX_SPENDS_PER_TX;
-        for f in funded {
-            let start = not_funded.len() - MAX_SPENDS_PER_TX as usize;
-            let dests: Vec<_> = not_funded.drain(start..).collect();
-            let spends: Vec<_> = dests.iter().map(|k| (k.pubkey(), to_lamports)).collect();
-            to_fund.push((f, spends));
-            new_funded.extend(dests.into_iter());
-        }
-
-        // try to transfer a "few" at a time with recent blockhash
-        //  assume 4MB network buffers, and 512 byte packets
-        const FUND_CHUNK_LEN: usize = 4 * 1024 * 1024 / 512;
-
-        to_fund.chunks(FUND_CHUNK_LEN).for_each(|chunk| {
-            Vec::<(&Keypair, Transaction)>::with_capacity(chunk.len()).fund(
-                &client,
-                chunk,
-                to_lamports,
-            );
-        });
-
-        info!("funded: {} left: {}", new_funded.len(), not_funded.len());
-        funded = new_funded;
-        funded_funds = to_lamports;
-    }
-}
-
-pub fn airdrop_lamports<T: Client>(
-    client: &T,
-    faucet_addr: &SocketAddr,
-    id: &Keypair,
-    desired_balance: u64,
-) -> Result<()> {
-    let starting_balance = client.get_balance(&id.pubkey()).unwrap_or(0);
-    metrics_submit_lamport_balance(starting_balance);
-    info!("starting balance {}", starting_balance);
-
-    if starting_balance < desired_balance {
-        let airdrop_amount = desired_balance - starting_balance;
-        info!(
-            "Airdropping {:?} lamports from {} for {}",
-            airdrop_amount,
-            faucet_addr,
-            id.pubkey(),
-        );
-
-        let (blockhash, _fee_calculator) = get_recent_blockhash(client);
-        match request_airdrop_transaction(&faucet_addr, &id.pubkey(), airdrop_amount, blockhash) {
-            Ok(transaction) => {
-                let mut tries = 0;
-                loop {
-                    tries += 1;
-                    let signature = client.async_send_transaction(transaction.clone()).unwrap();
-                    let result = client.poll_for_signature_confirmation(&signature, 1);
-
-                    if result.is_ok() {
-                        break;
-                    }
-                    if tries >= 5 {
-                        panic!(
-                            "Error requesting airdrop: to addr: {:?} amount: {} {:?}",
-                            faucet_addr, airdrop_amount, result
-                        )
-                    }
-                }
-            }
-            Err(err) => {
-                panic!(
-                    "Error requesting airdrop: {:?} to addr: {:?} amount: {}",
-                    err, faucet_addr, airdrop_amount
-                );
-            }
-        };
-
-        let current_balance = client
-            .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent())
-            .unwrap_or_else(|e| {
-                info!("airdrop error {}", e);
-                starting_balance
-            });
-        info!("current balance {}...", current_balance);
-
-        metrics_submit_lamport_balance(current_balance);
-        if current_balance - starting_balance != airdrop_amount {
-            info!(
-                "Airdrop failed! {} {} {}",
-                id.pubkey(),
-                current_balance,
-                starting_balance
-            );
-            return Err(BenchTpsError::AirdropFailure);
-        }
-    }
-    Ok(())
-}
-
-fn compute_and_report_stats(
-    maxes: &Arc<RwLock<Vec<(String, SampleStats)>>>,
-    sample_period: u64,
-    tx_send_elapsed: &Duration,
-    total_tx_send_count: usize,
-) {
-    // Compute/report stats
-    let mut max_of_maxes = 0.0;
-    let mut max_tx_count = 0;
-    let mut nodes_with_zero_tps = 0;
-    let mut total_maxes = 0.0;
-    info!(" Node address        |       Max TPS | Total Transactions");
-    info!("---------------------+---------------+--------------------");
-
-    for (sock, stats) in maxes.read().unwrap().iter() {
-        let maybe_flag = match stats.txs {
-            0 => "!!!!!",
-            _ => "",
-        };
-
-        info!(
-            "{:20} | {:13.2} | {} {}",
-            sock, stats.tps, stats.txs, maybe_flag
-        );
-
-        if stats.tps == 0.0 {
-            nodes_with_zero_tps += 1;
-        }
-        total_maxes += stats.tps;
-
-        if stats.tps > max_of_maxes {
-            max_of_maxes = stats.tps;
-        }
-        if stats.txs > max_tx_count {
-            max_tx_count = stats.txs;
-        }
-    }
-
-    if total_maxes > 0.0 {
-        let num_nodes_with_tps = maxes.read().unwrap().len() - nodes_with_zero_tps;
-        let average_max = total_maxes / num_nodes_with_tps as f32;
-        info!(
-            "\nAverage max TPS: {:.2}, {} nodes had 0 TPS",
-            average_max, nodes_with_zero_tps
-        );
-    }
-
-    let total_tx_send_count = total_tx_send_count as u64;
-    let drop_rate = if total_tx_send_count > max_tx_count {
-        (total_tx_send_count - max_tx_count) as f64 / total_tx_send_count as f64
-    } else {
-        0.0
-    };
-    info!(
-        "\nHighest TPS: {:.2} sampling period {}s max transactions: {} clients: {} drop rate: {:.2}",
-        max_of_maxes,
-        sample_period,
-        max_tx_count,
-        maxes.read().unwrap().len(),
-        drop_rate,
-    );
-    info!(
-        "\tAverage TPS: {}",
-        max_tx_count as f32 / duration_as_s(tx_send_elapsed)
-    );
-}
-
-pub fn generate_keypairs(seed_keypair: &Keypair, count: u64) -> (Vec<Keypair>, u64) {
-    let mut seed = [0u8; 32];
-    seed.copy_from_slice(&seed_keypair.to_bytes()[..32]);
-    let mut rnd = GenKeys::new(seed);
-
-    let mut total_keys = 0;
-    let mut extra = 0; // This variable tracks the number of keypairs needing extra transaction fees funded
-    let mut delta = 1;
-    while total_keys < count {
-        extra += delta;
-        delta *= MAX_SPENDS_PER_TX;
-        total_keys += delta;
-    }
-    (rnd.gen_n_keypairs(total_keys), extra)
-}
-
-pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
-    client: Arc<T>,
-    faucet_addr: Option<SocketAddr>,
-    funding_key: &Keypair,
-    keypair_count: usize,
-    lamports_per_account: u64,
-) -> Result<Vec<Keypair>> {
-    info!("Creating {} keypairs...", keypair_count);
-    let (mut keypairs, extra) = generate_keypairs(funding_key, keypair_count as u64);
-    info!("Get lamports...");
-
-    // Sample the first keypair, to prevent lamport loss on repeated solana-bench-tps executions
-    let first_key = keypairs[0].pubkey();
-    let first_keypair_balance = client.get_balance(&first_key).unwrap_or(0);
-
-    // Sample the last keypair, to check if funding was already completed
-    let last_key = keypairs[keypair_count - 1].pubkey();
-    let last_keypair_balance = client.get_balance(&last_key).unwrap_or(0);
-
-    // Repeated runs will eat up keypair balances from transaction fees. In order to quickly
-    //   start another bench-tps run without re-funding all of the keypairs, check if the
-    //   keypairs still have at least 80% of the expected funds. That should be enough to
-    //   pay for the transaction fees in a new run.
-    let enough_lamports = 8 * lamports_per_account / 10;
-    if first_keypair_balance < enough_lamports || last_keypair_balance < enough_lamports {
-        let fee_rate_governor = client.get_fee_rate_governor().unwrap();
-        let max_fee = fee_rate_governor.max_lamports_per_signature;
-        let extra_fees = extra * max_fee;
-        let total_keypairs = keypairs.len() as u64 + 1; // Add one for funding keypair
-        let total = lamports_per_account * total_keypairs + extra_fees;
-
-        let funding_key_balance = client.get_balance(&funding_key.pubkey()).unwrap_or(0);
-        info!(
-            "Funding keypair balance: {} max_fee: {} lamports_per_account: {} extra: {} total: {}",
-            funding_key_balance, max_fee, lamports_per_account, extra, total
-        );
-
-        if client.get_balance(&funding_key.pubkey()).unwrap_or(0) < total {
-            airdrop_lamports(client.as_ref(), &faucet_addr.unwrap(), funding_key, total)?;
-        }
-
-        fund_keys(
-            client,
-            funding_key,
-            &keypairs,
-            total,
-            max_fee,
-            lamports_per_account,
-        );
-    }
-
-    // 'generate_keypairs' generates extra keys to be able to have size-aligned funding batches for fund_keys.
-    keypairs.truncate(keypair_count);
-
-    Ok(keypairs)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_runtime::bank::Bank;
-    use solana_runtime::bank_client::BankClient;
-    use solana_sdk::client::SyncClient;
-    use solana_sdk::fee_calculator::FeeRateGovernor;
-    use solana_sdk::genesis_config::create_genesis_config;
-
-    #[test]
-    fn test_bench_tps_bank_client() {
-        let (genesis_config, id) = create_genesis_config(10_000);
-        let bank = Bank::new(&genesis_config);
-        let client = Arc::new(BankClient::new(bank));
-
-        let mut config = Config::default();
-        config.id = id;
-        config.tx_count = 10;
-        config.duration = Duration::from_secs(5);
-
-        let keypair_count = config.tx_count * config.keypair_multiplier;
-        let keypairs =
-            generate_and_fund_keypairs(client.clone(), None, &config.id, keypair_count, 20)
-                .unwrap();
-
-        do_bench_tps(client, config, keypairs);
-    }
-
-    #[test]
-    fn test_bench_tps_fund_keys() {
-        let (genesis_config, id) = create_genesis_config(10_000);
-        let bank = Bank::new(&genesis_config);
-        let client = Arc::new(BankClient::new(bank));
-        let keypair_count = 20;
-        let lamports = 20;
-
-        let keypairs =
-            generate_and_fund_keypairs(client.clone(), None, &id, keypair_count, lamports).unwrap();
-
-        for kp in &keypairs {
-            assert_eq!(
-                client
-                    .get_balance_with_commitment(&kp.pubkey(), CommitmentConfig::recent())
-                    .unwrap(),
-                lamports
-            );
-        }
-    }
-
-    #[test]
-    fn test_bench_tps_fund_keys_with_fees() {
-        let (mut genesis_config, id) = create_genesis_config(10_000);
-        let fee_rate_governor = FeeRateGovernor::new(11, 0);
-        genesis_config.fee_rate_governor = fee_rate_governor;
-        let bank = Bank::new(&genesis_config);
-        let client = Arc::new(BankClient::new(bank));
-        let keypair_count = 20;
-        let lamports = 20;
-
-        let keypairs =
-            generate_and_fund_keypairs(client.clone(), None, &id, keypair_count, lamports).unwrap();
-
-        for kp in &keypairs {
-            assert_eq!(client.get_balance(&kp.pubkey()).unwrap(), lamports);
-        }
-    }
-}

bench-tps/src/cli.rs

@@ -1,289 +0,0 @@
-use clap::{crate_description, crate_name, App, Arg, ArgMatches};
-use solana_faucet::faucet::FAUCET_PORT;
-use solana_sdk::fee_calculator::FeeRateGovernor;
-use solana_sdk::{
-    pubkey::Pubkey,
-    signature::{read_keypair_file, Keypair},
-};
-use std::{net::SocketAddr, process::exit, time::Duration};
-
-const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;
-
-/// 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 num_lamports_per_account: u64,
-    pub target_slots_per_epoch: u64,
-    pub target_node: Option<Pubkey>,
-}
-
-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,
-            num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
-            target_slots_per_epoch: 0,
-            target_node: None,
-        }
-    }
-}
-
-/// 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("no-multi-client")
-                .long("no-multi-client")
-                .help("Disable multi-client support, only transact with the entrypoint."),
-        )
-        .arg(
-            Arg::with_name("target_node")
-                .long("target-node")
-                .requires("no-multi-client")
-                .takes_value(true)
-                .value_name("PUBKEY")
-                .help("Specify an exact node to send transactions to."),
-        )
-        .arg(
-            Arg::with_name("tx_count")
-                .long("tx_count")
-                .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.",
-                ),
-        )
-        .arg(
-            Arg::with_name("target_slots_per_epoch")
-                .long("target-slots-per-epoch")
-                .value_name("SLOTS")
-                .takes_value(true)
-                .help(
-                    "Wait until epochs are this many slots long.",
-                ),
-        )
-}
-
-/// Parses a clap `ArgMatches` structure into a `Config`
-/// # 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.multi_client = !matches.is_present("no-multi-client");
-    args.target_node = matches
-        .value_of("target_node")
-        .map(|target_str| target_str.parse().unwrap());
-
-    if let Some(v) = matches.value_of("num_lamports_per_account") {
-        args.num_lamports_per_account = v.to_string().parse().expect("can't parse lamports");
-    }
-
-    if let Some(t) = matches.value_of("target_slots_per_epoch") {
-        args.target_slots_per_epoch = t
-            .to_string()
-            .parse()
-            .expect("can't parse target slots per epoch");
-    }
-
-    args
-}

bench-tps/src/lib.rs

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

bench-tps/src/main.rs

@@ -1,148 +0,0 @@
-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_version::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,
-        multi_client,
-        num_lamports_per_account,
-        target_node,
-        ..
-    } = &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 = 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 if let Some(target_node) = target_node {
-        info!("Searching for target_node: {:?}", target_node);
-        let mut target_client = None;
-        for node in nodes {
-            if node.id == *target_node {
-                target_client = Some(Arc::new(get_client(&[node])));
-                break;
-            }
-        }
-        target_client.unwrap_or_else(|| {
-            eprintln!("Target node {} not found", target_node);
-            exit(1);
-        })
-    } else {
-        Arc::new(get_client(&nodes))
-    };
-
-    let keypairs = if *read_from_client_file {
-        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_key(|x| x.pubkey().to_string());
-        keypairs
-    } else {
-        generate_and_fund_keypairs(
-            client.clone(),
-            Some(*faucet_addr),
-            &id,
-            keypair_count,
-            *num_lamports_per_account,
-        )
-        .unwrap_or_else(|e| {
-            eprintln!("Error could not fund keys: {:?}", e);
-            exit(1);
-        })
-    };
-
-    do_bench_tps(client, cli_config, keypairs);
-}

bench-tps/tests/bench_tps.rs

@@ -1,68 +0,0 @@
-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};
-use solana_sdk::signature::{Keypair, Signer};
-use std::sync::{mpsc::channel, Arc};
-use std::time::Duration;
-
-fn test_bench_tps_local_cluster(config: Config) {
-    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 = generate_and_fund_keypairs(
-        client.clone(),
-        Some(faucet_addr),
-        &config.id,
-        keypair_count,
-        lamports_per_account,
-    )
-    .unwrap();
-
-    let _total = do_bench_tps(client, config, 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);
-}

benches/bank.rs

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

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

@@ -0,0 +1,25 @@
+#![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/signature.rs

@@ -1,8 +1,8 @@
 #![feature(test)]
-
+extern crate solana;
 extern crate test;
 
-use solana_core::gen_keys::GenKeys;
+use solana::signature::GenKeys;
 use test::Bencher;
 
 #[bench]

benches/sigverify.rs

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

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

ci/README.md

@@ -2,7 +2,7 @@
 Our CI infrastructure is built around [BuildKite](https://buildkite.com) with some
 additional GitHub integration provided by https://github.com/mvines/ci-gate
 
-# Agent Queues
+## Agent Queues
 
 We define two [Agent Queues](https://buildkite.com/docs/agent/v3/queues):
 `queue=default` and `queue=cuda`.  The `default` queue should be favored and
@@ -12,128 +12,20 @@ be run on the `default` queue, and the [buildkite artifact
 system](https://buildkite.com/docs/builds/artifacts) used to transfer build
 products over to a GPU instance for testing.
 
-# Buildkite Agent Management
+## Buildkite Agent Management
 
-## Manual Node Setup for Colocated Hardware
-
-This section describes how to set up a new machine that does not have a
-pre-configured image with all the requirements installed.  Used for custom-built
-hardware at a colocation or office facility.  Also works for vanilla Ubuntu cloud
-instances.
-
-### Pre-Requisites
-
- - Install Ubuntu 18.04 LTS Server
- - Log in as a local or remote user with `sudo` privileges
-
-### Install Core Requirements
-
-##### Non-GPU enabled machines
-```bash
-sudo ./setup-new-buildkite-agent/setup-new-machine.sh
-```
-
-##### GPU-enabled machines
- - 1 or more NVIDIA GPUs should be installed in the machine (tested with 2080Ti)
-```bash
-sudo CUDA=1 ./setup-new-buildkite-agent/setup-new-machine.sh
-```
-
-### Configure Node for Buildkite-agent based CI
-
-- Install `buildkite-agent` and set up it user environment with:
-```bash
-sudo ./setup-new-buildkite-agent/setup-buildkite.sh
-```
-- Copy the pubkey contents from `~buildkite-agent/.ssh/id_ecdsa.pub` and
-add the pubkey as an authorized SSH key on github.
-- Edit `/etc/buildkite-agent/buildkite-agent.cfg` and/or `/etc/systemd/system/buildkite-agent@*` to the desired configuration of the agent(s)
-- Copy `ejson` keys from another CI node at `/opt/ejson/keys/`
-to the same location on the new node.
-- Start the new agent(s) with `sudo systemctl enable --now buildkite-agent`
-
-# Reference
-
-This section contains details regarding previous CI setups that have been used,
-and that we may return to one day.
-
-## Buildkite Azure Setup
-
-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
-```
-
-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
-
-## Buildkite AWS CloudFormation Setup
-
-**AWS CloudFormation is currently inactive, although it may be restored in the
-future**
-
-AWS CloudFormation can be used to scale machines up and down based on the
-current CI load.  If no machine is currently running it can take up to 60
-seconds to spin up a new instance, please remain calm during this time.
-
-### AMI
-We use a custom AWS AMI built via https://github.com/solana-labs/elastic-ci-stack-for-aws/tree/solana/cuda.
-
-Use the following process to update this AMI as dependencies change:
-```bash
-$ export AWS_ACCESS_KEY_ID=my_access_key
-$ export AWS_SECRET_ACCESS_KEY=my_secret_access_key
-$ git clone https://github.com/solana-labs/elastic-ci-stack-for-aws.git -b solana/cuda
-$ cd elastic-ci-stack-for-aws/
-$ make build
-$ make build-ami
-```
-
-Watch for the *"amazon-ebs: AMI:"* log message to extract the name of the new
-AMI.  For example:
-```
-amazon-ebs: AMI: ami-07118545e8b4ce6dc
-```
-The new AMI should also now be visible in your EC2 Dashboard.  Go to the desired
-AWS CloudFormation stack, update the **ImageId** field to the new AMI id, and
-*apply* the stack changes.
-
-## Buildkite GCP Setup
+### Buildkite GCP Setup
 
 CI runs on Google Cloud Platform via two Compute Engine Instance groups:
 `ci-default` and `ci-cuda`.  Autoscaling is currently disabled and the number of
 VM Instances in each group is manually adjusted.
 
-### Updating a CI Disk Image
+#### Updating a CI Disk Image
 
 Each Instance group has its own disk image, `ci-default-vX` and
 `ci-cuda-vY`, where *X* and *Y* are incremented each time the image is changed.
 
-The manual process to update a disk image is as follows:
+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.
@@ -158,6 +50,40 @@ newly created Disk image.
 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.
+Images. 
+
+
+## Reference
+
+### Buildkite AWS CloudFormation Setup
+
+**AWS CloudFormation is currently inactive, although it may be restored in the
+future**
+
+AWS CloudFormation can be used to scale machines up and down based on the
+current CI load.  If no machine is currently running it can take up to 60
+seconds to spin up a new instance, please remain calm during this time.
+
+#### AMI
+We use a custom AWS AMI built via https://github.com/solana-labs/elastic-ci-stack-for-aws/tree/solana/cuda.
+
+Use the following process to update this AMI as dependencies change:
+```bash
+$ export AWS_ACCESS_KEY_ID=my_access_key
+$ export AWS_SECRET_ACCESS_KEY=my_secret_access_key
+$ git clone https://github.com/solana-labs/elastic-ci-stack-for-aws.git -b solana/cuda
+$ cd elastic-ci-stack-for-aws/
+$ make build
+$ make build-ami
+```
+
+Watch for the *"amazon-ebs: AMI:"* log message to extract the name of the new
+AMI.  For example:
+```
+amazon-ebs: AMI: ami-07118545e8b4ce6dc
+```
+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.
 
 

ci/_

@@ -1,17 +0,0 @@
-# Buildkite log management helper
-#
-# See https://buildkite.com/docs/pipelines/managing-log-output
-#
-# |source| me
-#
-
-base_dir=$(realpath --strip "$(dirname "$0")/..")
-
-_() {
-  if [[ $(pwd) = $base_dir ]]; then
-    echo "--- $*"
-  else
-    echo "--- $* (wd: $(pwd))"
-  fi
-  "$@"
-}

ci/audit.sh

@@ -0,0 +1,32 @@
+#!/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-pipeline.sh

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

ci/buildkite-secondary.yml

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

ci/buildkite-snap.yml

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

ci/buildkite.yml

@@ -0,0 +1,50 @@
+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]"
+    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
+  - command: "ci/test-stable-perf.sh"
+    name: "stable-perf [public]"
+    env:
+      CARGO_TARGET_CACHE_NAME: "stable-perf"
+    timeout_in_minutes: 20
+    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"
+    timeout_in_minutes: 20
+    name: "snap [public]"
+  - wait
+  - command: "ci/publish-crate.sh"
+    timeout_in_minutes: 20
+    name: "publish crate [public]"
+  - trigger: "solana-snap"
+    branches: "!pull/*"
+    async: true
+    build:
+      message: "${BUILDKITE_MESSAGE}"
+      commit: "${BUILDKITE_COMMIT}"
+      branch: "${BUILDKITE_BRANCH}"
+      env:
+        TRIGGERED_BUILDKITE_TAG: "${BUILDKITE_TAG}"

ci/channel-info.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/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,26 +82,10 @@ for tag in "${tags[@]}"; do
   fi
 done
 
-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"
+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}"
 
 exit 0

ci/check-ssh-keys.sh

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

@@ -1,26 +0,0 @@
-#!/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/dependabot-pr.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-cd "$(dirname "$0")/.."
-
-if ! echo "$BUILDKITE_BRANCH" | grep -E '^pull/[0-9]+/head$'; then
-  echo "not pull request!?" >&2
-  exit 1
-fi
-
-source ci/rust-version.sh stable
-
-ci/docker-run.sh $rust_nightly_docker_image ci/dependabot-updater.sh
-
-if [[ $(git status --short :**/Cargo.lock | wc -l) -eq 0 ]]; then
-  echo --- ok
-  exit 0
-fi
-
-echo --- "(FAILING) Backpropagating dependabot-triggered Cargo.lock updates"
-
-name="dependabot-buildkite"
-api_base="https://api.github.com/repos/solana-labs/solana/pulls"
-pr_num=$(echo "$BUILDKITE_BRANCH" | grep -Eo '[0-9]+')
-branch=$(curl -s "$api_base/$pr_num" | python -c 'import json,sys;print json.load(sys.stdin)["head"]["ref"]')
-
-git add :**/Cargo.lock
-EMAIL="dependabot-buildkite@noreply.solana.com" \
-  GIT_AUTHOR_NAME="$name" \
-  GIT_COMMITTER_NAME="$name" \
-  git commit -m "[auto-commit] Update all Cargo lock files"
-git push origin "HEAD:$branch"
-
-echo "Source branch is updated; failing this build for the next"
-exit 1

ci/dependabot-updater.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")/.."
-source ci/_
-
-commit_range="$(git merge-base HEAD origin/master)..HEAD"
-parsed_update_args="$(
-  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
-    grep -o '[Bb]ump.*$' |
-    sed -r 's/[Bb]ump ([^ ]+) from ([^ ]+) to ([^ ]+)/-p \1:\2 --precise \3/'
-)"
-# relaxed_parsed_update_args is temporal measure...
-relaxed_parsed_update_args="$(
-  git log "$commit_range" --author "dependabot-preview" --oneline -n1 |
-    grep -o '[Bb]ump.*$' |
-    sed -r 's/[Bb]ump ([^ ]+) from [^ ]+ to ([^ ]+)/-p \1 --precise \2/'
-)"
-package=$(echo "$parsed_update_args" | awk '{print $2}' | grep -o "^[^:]*")
-if [[ -n $parsed_update_args ]]; then
-  # find other Cargo.lock files and update them, excluding the default Cargo.lock
-  # shellcheck disable=SC2086
-  for lock in $(git grep --files-with-matches '^name = "'$package'"$' :**/Cargo.lock); do
-    # it's possible our current versions are out of sync across lock files,
-    # in that case try to sync them up with $relaxed_parsed_update_args
-    _ scripts/cargo-for-all-lock-files.sh \
-      "$lock" -- \
-      update $parsed_update_args ||
-      _ scripts/cargo-for-all-lock-files.sh \
-        "$lock" -- \
-        update $relaxed_parsed_update_args
-  done
-fi
-
-echo --- ok

ci/docker-run.sh

@@ -1,5 +1,4 @@
-#!/usr/bin/env bash
-set -e
+#!/bin/bash -e
 
 usage() {
   echo "Usage: $0 [--nopull] [docker image name] [command]"
@@ -49,7 +48,7 @@ else
   # ~/.cargo
   ARGS+=(--volume "$PWD:/home")
 fi
-ARGS+=(--env "HOME=/home" --env "CARGO_HOME=/home/.cargo")
+ARGS+=(--env "CARGO_HOME=/home/.cargo")
 
 # kcov tries to set the personality of the binary which docker
 # doesn't allow by default.
@@ -60,36 +59,18 @@ if [[ -z "$SOLANA_DOCKER_RUN_NOSETUID" ]]; then
   ARGS+=(--user "$(id -u):$(id -g)")
 fi
 
-if [[ -n $SOLANA_ALLOCATE_TTY ]]; then
-  # Colored output, progress bar and Ctrl-C:
-  # https://stackoverflow.com/a/41099052/10242004
-  ARGS+=(--interactive --tty)
-fi
-
 # Environment variables to propagate into the container
 ARGS+=(
   --env BUILDKITE
   --env BUILDKITE_AGENT_ACCESS_TOKEN
+  --env BUILDKITE_BRANCH
   --env BUILDKITE_JOB_ID
-  --env CI
-  --env CI_BRANCH
-  --env CI_BASE_BRANCH
-  --env CI_TAG
-  --env CI_BUILD_ID
-  --env CI_COMMIT
-  --env CI_JOB_ID
-  --env CI_PULL_REQUEST
-  --env CI_REPO_SLUG
+  --env BUILDKITE_TAG
+  --env CODECOV_TOKEN
   --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
@@ -97,10 +78,8 @@ if $INTERACTIVE; then
     echo
   fi
   set -x
-  # shellcheck disable=SC2086
-  exec docker run --interactive --tty "${ARGS[@]}" $CODECOV_ENVS "$IMAGE" bash
+  exec docker run --interactive --tty "${ARGS[@]}" "$IMAGE" bash
 fi
 
 set -x
-# shellcheck disable=SC2086
-exec docker run "${ARGS[@]}" $CODECOV_ENVS "$IMAGE" "$@"
+exec docker run "${ARGS[@]}" "$IMAGE" "$@"

ci/docker-rust-nightly/Dockerfile

@@ -1,13 +1,10 @@
-FROM solanalabs/rust:1.45.1
+FROM solanalabs/rust
 ARG date
 
-RUN set -x \
- && rustup install nightly-$date \
- && rustup component add clippy --toolchain=nightly-$date \
- && rustup component add rustfmt --toolchain=nightly-$date \
- && rustup show \
- && rustc --version \
- && cargo --version \
- && cargo install grcov \
- && rustc +nightly-$date --version \
- && cargo +nightly-$date --version
+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

ci/docker-rust-nightly/README.md

@@ -2,31 +2,25 @@ Docker image containing rust nightly and some preinstalled crates used in CI.
 
 This image may be manually updated by running `CI=true ./build.sh` if you are a member
 of the [Solana Labs](https://hub.docker.com/u/solanalabs/) Docker Hub
-organization.
+organization, but it is also automatically updated periodically by
+[this automation](https://buildkite.com/solana-labs/solana-ci-docker-rust-nightly).
 
 ## Moving to a newer nightly
 
-NOTE: Follow instructions in docker-rust/README.md before this when updating the stable
-rust version as well.
-
 We pin the version of nightly (see the `ARG nightly=xyz` line in `Dockerfile`)
 to avoid the build breaking at unexpected times, as occasionally nightly will
 introduce breaking changes.
 
 To update the pinned version:
-1. Edit `Dockerfile` to match the desired stable rust version to base on if needed.
 1. Run `ci/docker-rust-nightly/build.sh` to rebuild the nightly image locally,
    or potentially `ci/docker-rust-nightly/build.sh YYYY-MM-DD` if there's a
    specific YYYY-MM-DD that is desired (default is today's build).
-   Check https://rust-lang.github.io/rustup-components-history/ for build
-   status
-1. Update `ci/rust-version.sh` to reflect the new nightly `YYY-MM-DD`
-1. Run `SOLANA_ALLOCATE_TTY=1 SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-checks.sh`
-   and `SOLANA_ALLOCATE_TTY=1 SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-coverage.sh [args]...`
+1. Run `SOLANA_DOCKER_RUN_NOSETUID=1 ci/docker-run.sh --nopull solanalabs/rust-nightly:YYYY-MM-DD ci/test-nightly.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. Send a PR with the `ci/rust-version.sh` change and any codebase adjustments needed.
+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.
 
 ## Troubleshooting
 

ci/docker-rust-nightly/build.sh

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

ci/docker-rust/Dockerfile

@@ -1,41 +1,24 @@
 # Note: when the rust version is changed also modify
-# ci/rust-version.sh to pick up the new image tag
-FROM rust:1.45.1
+# ci/buildkite.yml to pick up the new image tag
+FROM rust:1.29.1
 
-# 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 \
+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 \
       buildkite-agent \
-      clang-7 \
       cmake \
-      lcov \
-      libudev-dev \
-      libclang-common-7-dev \
-      mscgen \
-      net-tools \
+      llvm-6.0 \
       rsync \
       sudo \
-      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 \
- && cargo install mdbook-linkcheck \
- && 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
+      && \
+    rustup component add rustfmt-preview && \
+    rustup component add clippy-preview && \
+    rm -rf /var/lib/apt/lists/* && \
+    rustc --version && \
+    cargo --version

ci/docker-rust/README.md

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

ci/docker-rust/build.sh

@@ -1,5 +1,4 @@
-#!/usr/bin/env bash
-set -ex
+#!/bin/bash -ex
 
 cd "$(dirname "$0")"
 
@@ -8,5 +7,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:"$version"
-docker push solanalabs/rust:latest
+
+docker push solanalabs/rust

ci/docker-snapcraft/Dockerfile

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

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

ci/env.sh

@@ -1,92 +0,0 @@
-#
-# Normalized CI environment variables
-#
-# |source| me
-#
-
-if [[ -n $CI ]]; then
-  export CI=1
-  if [[ -n $TRAVIS ]]; then
-    export CI_BRANCH=$TRAVIS_BRANCH
-    export CI_BASE_BRANCH=$TRAVIS_BRANCH
-    export CI_BUILD_ID=$TRAVIS_BUILD_ID
-    export CI_COMMIT=$TRAVIS_COMMIT
-    export CI_JOB_ID=$TRAVIS_JOB_ID
-    if [[ $TRAVIS_PULL_REQUEST != false ]]; 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_BASE_BRANCH=$BUILDKITE_PULL_REQUEST_BASE_BRANCH
-      export CI_PULL_REQUEST=true
-    else
-      export CI_BASE_BRANCH=$BUILDKITE_BRANCH
-      export CI_PULL_REQUEST=
-    fi
-    export CI_OS_NAME=linux
-    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

@@ -1,20 +0,0 @@
-#!/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 @@
-#!/usr/bin/env bash
+#!/bin/bash
 #
 # Regular maintenance performed on a buildkite agent to control disk usage
 #

ci/is-pr.sh

@@ -0,0 +1,8 @@
+#!/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/localnet-sanity.sh

@@ -1,299 +1,51 @@
-#!/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
-}
+#!/bin/bash -e
+#
+# Perform a quick sanity test on a leader, drone, validator and client running
+# locally on the same machine
+#
 
 cd "$(dirname "$0")"/..
-
-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 ci/upload_ci_artifact.sh
 source scripts/configure-metrics.sh
-source multinode-demo/common.sh
 
-nodes=(
-  "multinode-demo/bootstrap-validator.sh \
-    --no-restart \
-    --init-complete-file init-complete-node0.log \
-    --dynamic-port-range 8000-8050"
-  "multinode-demo/validator.sh \
-    --enable-rpc-exit \
-    --no-restart \
-    --dynamic-port-range 8050-8100
-    --init-complete-file init-complete-node1.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$((1 + i)).log"
-    )
-  done
-fi
-numNodes=$((2 + extraNodes))
+multinode-demo/setup.sh
 
+backgroundCommands="drone leader validator validator-x"
 pids=()
-logs=()
 
-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
+for cmd in $backgroundCommands; do
   echo "--- Start $cmd"
-  declare log
-  log=$(getNodeLogFile "$nodeIndex" "$cmd")
-  rm -f "$log"
-  $cmd > "$log" 2>&1 &
+  rm -f log-"$cmd".txt
+  multinode-demo/"$cmd".sh > log-"$cmd".txt 2>&1 &
   declare pid=$!
   pids+=("$pid")
   echo "pid: $pid"
-  echo "log: $log"
-}
+done
 
-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]}
-
-    declare initCompleteFile="init-complete-node$i.log"
-    rm -f "$initCompleteFile"
-    initCompleteFiles+=("$initCompleteFile")
-
-    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.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
+killBackgroundCommands() {
   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")
+    if kill "$pid"; then
+      wait "$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"
+      echo -e "^^^ +++\\nWarning: unable to kill $pid"
     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
+  set -e
+  pids=()
 }
 
 shutdown() {
   exitcode=$?
-  killNodes
+  killBackgroundCommands
 
   set +e
 
   echo "--- Upload artifacts"
-  for log in "${logs[@]}"; do
-    upload-ci-artifact "$log"
-    tail "$log"
+  for cmd in $backgroundCommands; do
+    declare logfile=log-$cmd.txt
+    upload_ci_artifact "$logfile"
+    tail "$logfile"
   done
 
   exit $exitcode
@@ -303,88 +55,39 @@ trap shutdown EXIT INT
 
 set -e
 
-declare iteration=1
-
 flag_error() {
-  echo "Failed (iteration: $iteration/$iterations)"
+  echo Failed
   echo "^^^ +++"
   exit 1
 }
 
-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 "--- Wallet sanity"
+(
+  set -x
+  scripts/wallet-sanity.sh
+) || 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
+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: 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
+killBackgroundCommands
 
-  # 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 "--- 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
 
 echo +++
-echo "Ok ($iterations iterations)"
-
+echo Ok
 exit 0

ci/nits.sh

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

ci/order-crates-for-publishing.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python2.7
-#
-# This script figures the order in which workspace crates must be published to
-# crates.io.  Along the way it also ensures there are no circular dependencies
-# that would cause a |cargo publish| to fail.
-#
-# On success an ordered list of Cargo.toml files is written to stdout
-#
-
-import os
-import json
-import subprocess
-import sys;
-
-def load_metadata():
-    return json.loads(subprocess.Popen(
-        'cargo metadata --no-deps --format-version=1',
-        shell=True, stdout=subprocess.PIPE).communicate()[0])
-
-def get_packages():
-    metadata = load_metadata()
-
-    manifest_path = dict()
-
-    # Build dictionary of packages and their immediate solana-only dependencies
-    dependency_graph = dict()
-    for pkg in metadata['packages']:
-        manifest_path[pkg['name']] = pkg['manifest_path'];
-        dependency_graph[pkg['name']] = [x['name'] for x in pkg['dependencies'] if x['name'].startswith('solana')];
-
-    # Check for direct circular dependencies
-    circular_dependencies = set()
-    for package, dependencies in dependency_graph.items():
-        for dependency in dependencies:
-            if dependency in dependency_graph and package in dependency_graph[dependency]:
-                circular_dependencies.add(' <--> '.join(sorted([package, dependency])))
-
-    for dependency in circular_dependencies:
-        sys.stderr.write('Error: Circular dependency: {}\n'.format(dependency))
-
-    if len(circular_dependencies) != 0:
-        sys.exit(1)
-
-    # Order dependencies
-    sorted_dependency_graph = []
-    max_iterations = pow(len(dependency_graph),2)
-    while dependency_graph:
-        if max_iterations == 0:
-            # One day be more helpful and find the actual cycle for the user...
-            sys.exit('Error: Circular dependency suspected between these packages: \n {}\n'.format('\n '.join(dependency_graph.keys())))
-
-        max_iterations -= 1
-        for package, dependencies in dependency_graph.items():
-            for dependency in dependencies:
-                if dependency in dependency_graph:
-                    break
-            else:
-                del dependency_graph[package]
-                sorted_dependency_graph.append((package, manifest_path[package]))
-
-
-    return sorted_dependency_graph
-
-for package, manifest in get_packages():
-    print os.path.relpath(manifest)

ci/pr-snap.sh

@@ -0,0 +1,18 @@
+#!/bin/bash -e
+#
+# Only run snap.sh for pull requests that modify files under /snap
+#
+
+cd "$(dirname "$0")"
+
+if ./is-pr.sh; then
+  affected_files="$(buildkite-agent meta-data get affected_files)"
+  echo "Affected files in this PR: $affected_files"
+  if [[ ! ":$affected_files:" =~ :snap/ ]]; then
+    echo "Skipping snap build as no files under /snap were modified"
+    exit 0
+  fi
+  exec ./snap.sh
+else
+  echo "Skipping snap build as this is not a pull request"
+fi

ci/publish-bpf-sdk.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$0")/.."
-eval "$(ci/channel-info.sh)"
-
-if [[ -n "$CI_TAG" ]]; then
-  CHANNEL_OR_TAG=$CI_TAG
-else
-  CHANNEL_OR_TAG=$CHANNEL
-fi
-
-(
-  set -x
-  sdk/bpf/scripts/package.sh
-  [[ -f bpf-sdk.tar.bz2 ]]
-)
-
-echo --- AWS S3 Store
-if [[ -z $CHANNEL_OR_TAG ]]; then
-  echo Skipped
-else
-  (
-    set -x
-    docker run \
-      --rm \
-      --env AWS_ACCESS_KEY_ID \
-      --env AWS_SECRET_ACCESS_KEY \
-      --volume "$PWD:/solana" \
-      eremite/aws-cli:2018.12.18 \
-      /usr/bin/s3cmd --acl-public put /solana/bpf-sdk.tar.bz2 \
-      s3://solana-sdk/"$CHANNEL_OR_TAG"/bpf-sdk.tar.bz2
-  )
-fi
-
-exit 0

ci/publish-crate.sh

@@ -1,85 +1,19 @@
-#!/usr/bin/env bash
-set -e
+#!/bin/bash -e
+
 cd "$(dirname "$0")/.."
-source ci/semver_bash/semver.sh
-source ci/rust-version.sh stable
 
-# shellcheck disable=SC2086
-is_crate_version_uploaded() {
-  name=$1
-  version=$2
-  curl https://crates.io/api/v1/crates/${name}/${version} | \
-  python3 -c "import sys,json; print('version' in json.load(sys.stdin));"
-}
-
-# Only package/publish if this is a tagged release
-[[ -n $CI_TAG ]] || {
-  echo CI_TAG unset, skipped
+if [[ -z "$BUILDKITE_TAG" ]]; then
+  # Skip publish if this is not a tagged release
   exit 0
-}
+fi
 
-semverParseInto "$CI_TAG" MAJOR MINOR PATCH SPECIAL
-expectedCrateVersion="$MAJOR.$MINOR.$PATCH$SPECIAL"
-
-[[ -n "$CRATES_IO_TOKEN" ]] || {
+if [[ -z "$CRATES_IO_TOKEN" ]]; then
   echo CRATES_IO_TOKEN undefined
   exit 1
-}
+fi
 
-Cargo_tomls=$(ci/order-crates-for-publishing.py)
-
-for Cargo_toml in $Cargo_tomls; do
-  echo "--- $Cargo_toml"
-  grep -q "^version = \"$expectedCrateVersion\"$" "$Cargo_toml" || {
-    echo "Error: $Cargo_toml version is not $expectedCrateVersion"
-    exit 1
-  }
-
-  crate_name=$(grep -m 1 '^name = ' "$Cargo_toml" | cut -f 3 -d ' ' | tr -d \")
-
-  if grep -q "^publish = false" "$Cargo_toml"; then
-    echo "$crate_name is is marked as unpublishable"
-    continue
-  fi
-
-  if [[ $(is_crate_version_uploaded "$crate_name" "$expectedCrateVersion") = True ]] ; then
-    echo "${crate_name} version ${expectedCrateVersion} is already on crates.io"
-    continue
-  fi
-
-  (
-    set -x
-    crate=$(dirname "$Cargo_toml")
-    # The rocksdb package does not build with the stock rust docker image so use
-    # the solana rust docker image
-    cargoCommand="cargo publish --token $CRATES_IO_TOKEN"
-    ci/docker-run.sh "$rust_stable_docker_image" bash -exc "cd $crate; $cargoCommand"
-  ) || true # <-- Don't fail.  We want to be able to retry the job in cases when a publish fails halfway due to network/cloud issues
-
-  numRetries=30
-  for ((i = 1 ; i <= numRetries ; i++)); do
-    echo "Attempt ${i} of ${numRetries}"
-    if [[ $(is_crate_version_uploaded "$crate_name" "$expectedCrateVersion") = True ]] ; then
-      echo "Found ${crate_name} version ${expectedCrateVersion} on crates.io REST API"
-
-      really_uploaded=0
-      (
-        set -x
-        rm -rf crate-test
-        cargo +"$rust_stable" init crate-test
-        cd crate-test/
-        echo "${crate_name} = \"${expectedCrateVersion}\"" >> Cargo.toml
-        echo "[workspace]" >> Cargo.toml
-        cargo +"$rust_stable" check
-      ) && really_uploaded=1
-      if ((really_uploaded)); then
-        break;
-      fi
-      echo "${crate_name} not yet available for download from crates.io"
-    fi
-    echo "Did not find ${crate_name} version ${expectedCrateVersion} on crates.io.  Sleeping for 2 seconds."
-    sleep 2
-  done
-done
+# TODO: Ensure the published version matches the contents of BUILDKITE_TAG
+ci/docker-run.sh rust \
+  bash -exc "cargo package; cargo publish --token $CRATES_IO_TOKEN"
 
 exit 0

ci/publish-metrics-dashboard.sh

@@ -1,74 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$0")/.."
-
-if [[ -z $BUILDKITE ]]; then
-  echo BUILDKITE not defined
-  exit 1
-fi
-
-if [[ -z $PUBLISH_CHANNEL ]]; then
-  PUBLISH_CHANNEL=$(buildkite-agent meta-data get "channel" --default "")
-fi
-
-if [[ -z $PUBLISH_CHANNEL ]]; then
-  (
-    cat <<EOF
-steps:
-  - block: "Select Dashboard"
-    fields:
-      - select: "Channel"
-        key: "channel"
-        options:
-          - label: "stable"
-            value: "stable"
-          - label: "edge"
-            value: "edge"
-          - label: "beta"
-            value: "beta"
-  - command: "ci/$(basename "$0")"
-EOF
-  ) | buildkite-agent pipeline upload
-  exit 0
-fi
-
-
-ci/channel-info.sh
-eval "$(ci/channel-info.sh)"
-
-case $PUBLISH_CHANNEL in
-edge)
-  CHANNEL_BRANCH=$EDGE_CHANNEL
-  ;;
-beta)
-  CHANNEL_BRANCH=$BETA_CHANNEL
-  ;;
-stable)
-  # Set to whatever branch 'testnet' is on.
-  CHANNEL_BRANCH=$BETA_CHANNEL
-  ;;
-*)
-  echo "Error: Invalid PUBLISH_CHANNEL=$PUBLISH_CHANNEL"
-  exit 1
-  ;;
-esac
-
-if [[ $CI_BRANCH != "$CHANNEL_BRANCH" ]]; then
-  (
-    cat <<EOF
-steps:
-  - trigger: "$BUILDKITE_PIPELINE_SLUG"
-    async: true
-    build:
-      message: "$BUILDKITE_MESSAGE"
-      branch: "$CHANNEL_BRANCH"
-      env:
-        PUBLISH_CHANNEL: "$PUBLISH_CHANNEL"
-EOF
-  ) | buildkite-agent pipeline upload
-  exit 0
-fi
-
-set -x
-exec metrics/publish-metrics-dashboard.sh "$PUBLISH_CHANNEL"

ci/publish-tarball.sh

@@ -1,152 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$0")/.."
-
-if [[ -n $APPVEYOR ]]; then
-  # Bootstrap rust build environment
-  source ci/env.sh
-  source ci/rust-version.sh
-
-  appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  export USERPROFILE="D:\\"
-  ./rustup-init -yv --default-toolchain $rust_stable --default-host x86_64-pc-windows-msvc
-  export PATH="$PATH:/d/.cargo/bin"
-  rustc -vV
-  cargo -vV
-fi
-
-DRYRUN=
-if [[ -z $CI_BRANCH ]]; then
-  DRYRUN="echo"
-  CHANNEL=unknown
-fi
-
-eval "$(ci/channel-info.sh)"
-
-TAG=
-if [[ -n "$CI_TAG" ]]; then
-  CHANNEL_OR_TAG=$CI_TAG
-  TAG="$CI_TAG"
-else
-  CHANNEL_OR_TAG=$CHANNEL
-fi
-
-if [[ -z $CHANNEL_OR_TAG ]]; then
-  echo +++ Unable to determine channel or tag to publish into, exiting.
-  exit 0
-fi
-
-case "$CI_OS_NAME" in
-osx)
-  TARGET=x86_64-apple-darwin
-  ;;
-linux)
-  TARGET=x86_64-unknown-linux-gnu
-  ;;
-windows)
-  TARGET=x86_64-pc-windows-msvc
-  # Enable symlinks used by some build.rs files
-  # source: https://stackoverflow.com/a/52097145/10242004
-  (
-    set -x
-    git --version
-    git config core.symlinks true
-    find . -type l -delete
-    git reset --hard
-  )
-  ;;
-*)
-  echo CI_OS_NAME unset
-  exit 1
-  ;;
-esac
-
-RELEASE_BASENAME="${RELEASE_BASENAME:=solana-release}"
-TARBALL_BASENAME="${TARBALL_BASENAME:="$RELEASE_BASENAME"}"
-
-echo --- Creating release tarball
-(
-  set -x
-  rm -rf "${RELEASE_BASENAME:?}"/
-  mkdir "${RELEASE_BASENAME}"/
-
-  COMMIT="$(git rev-parse HEAD)"
-
-  (
-    echo "channel: $CHANNEL_OR_TAG"
-    echo "commit: $COMMIT"
-    echo "target: $TARGET"
-  ) > "${RELEASE_BASENAME}"/version.yml
-
-  # Make CHANNEL available to include in the software version information
-  export CHANNEL
-
-  source ci/rust-version.sh stable
-  scripts/cargo-install-all.sh +"$rust_stable" "${RELEASE_BASENAME}"
-
-  tar cvf "${TARBALL_BASENAME}"-$TARGET.tar "${RELEASE_BASENAME}"
-  bzip2 "${TARBALL_BASENAME}"-$TARGET.tar
-  cp "${RELEASE_BASENAME}"/bin/solana-install-init solana-install-init-$TARGET
-  cp "${RELEASE_BASENAME}"/version.yml "${TARBALL_BASENAME}"-$TARGET.yml
-)
-
-# Metrics tarball is platform agnostic, only publish it from Linux
-MAYBE_TARBALLS=
-if [[ "$CI_OS_NAME" = linux ]]; then
-  metrics/create-metrics-tarball.sh
-  (
-    set -x
-    sdk/bpf/scripts/package.sh
-    [[ -f bpf-sdk.tar.bz2 ]]
-
-  )
-  MAYBE_TARBALLS="bpf-sdk.tar.bz2 solana-metrics.tar.bz2"
-fi
-
-source ci/upload-ci-artifact.sh
-
-for file in "${TARBALL_BASENAME}"-$TARGET.tar.bz2 "${TARBALL_BASENAME}"-$TARGET.yml solana-install-init-"$TARGET"* $MAYBE_TARBALLS; do
-  if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
-    upload-ci-artifact "$file"
-    echo "Skipped $file due to DO_NOT_PUBLISH_TAR"
-    continue
-  fi
-
-  if [[ -n $BUILDKITE ]]; then
-    echo --- AWS S3 Store: "$file"
-    (
-      set -x
-      $DRYRUN docker run \
-        --rm \
-        --env AWS_ACCESS_KEY_ID \
-        --env AWS_SECRET_ACCESS_KEY \
-        --volume "$PWD:/solana" \
-        eremite/aws-cli:2018.12.18 \
-        /usr/bin/s3cmd --acl-public put /solana/"$file" s3://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
-
-      echo Published to:
-      $DRYRUN ci/format-url.sh http://release.solana.com/"$CHANNEL_OR_TAG"/"$file"
-    )
-
-    if [[ -n $TAG ]]; then
-      ci/upload-github-release-asset.sh "$file"
-    fi
-  elif [[ -n $TRAVIS ]]; then
-    # .travis.yml uploads everything in the travis-s3-upload/ directory to release.solana.com
-    mkdir -p travis-s3-upload/"$CHANNEL_OR_TAG"
-    cp -v "$file" travis-s3-upload/"$CHANNEL_OR_TAG"/
-
-    if [[ -n $TAG ]]; then
-      # .travis.yaml uploads everything in the travis-release-upload/ directory to
-      # the associated Github Release
-      mkdir -p travis-release-upload/
-      cp -v "$file" travis-release-upload/
-    fi
-  elif [[ -n $APPVEYOR ]]; then
-    # Add artifacts for .appveyor.yml to upload
-    appveyor PushArtifact "$file" -FileName "$CHANNEL_OR_TAG"/"$file"
-  fi
-done
-
-echo --- ok

ci/run-local.sh

@@ -0,0 +1,19 @@
+#!/bin/bash -e
+#
+# Run the entire buildkite CI pipeline locally for pre-testing before sending a
+# Github pull request
+#
+
+cd "$(dirname "$0")/.."
+BKRUN=ci/node_modules/.bin/bkrun
+
+if [[ ! -x $BKRUN ]]; then
+  (
+    set -x
+    cd ci/
+    npm install bkrun
+  )
+fi
+
+set -x
+exec ./ci/node_modules/.bin/bkrun ci/buildkite.yml

ci/run-sanity.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$0")/.."
-# shellcheck source=multinode-demo/common.sh
-source multinode-demo/common.sh
-
-rm -rf config/run/init-completed config/ledger config/snapshot-ledger
-
-timeout 120 ./run.sh &
-pid=$!
-
-attempts=20
-while [[ ! -f config/run/init-completed ]]; do
-  sleep 1
-  if ((--attempts == 0)); then
-     echo "Error: validator failed to boot"
-     exit 1
-  fi
-done
-
-snapshot_slot=1
-
-# wait a bit longer than snapshot_slot
-while [[ $($solana_cli --url http://localhost:8899 slot --commitment recent) -le $((snapshot_slot + 1)) ]]; do
-  sleep 1
-done
-curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' http://localhost:8899
-
-wait $pid
-
-$solana_ledger_tool create-snapshot --ledger config/ledger "$snapshot_slot" config/snapshot-ledger
-cp config/ledger/genesis.tar.bz2 config/snapshot-ledger
-$solana_ledger_tool verify --ledger config/snapshot-ledger

ci/rust-version.sh

@@ -1,65 +0,0 @@
-#
-# This file maintains the rust versions for use by CI.
-#
-# Obtain the environment variables without any automatic toolchain updating:
-#   $ source ci/rust-version.sh
-#
-# Obtain the environment variables updating both stable and nightly, only stable, or
-# only nightly:
-#   $ source ci/rust-version.sh all
-#   $ source ci/rust-version.sh stable
-#   $ source ci/rust-version.sh nightly
-
-# Then to build with either stable or nightly:
-#   $ cargo +"$rust_stable" build
-#   $ cargo +"$rust_nightly" build
-#
-
-if [[ -n $RUST_STABLE_VERSION ]]; then
-  stable_version="$RUST_STABLE_VERSION"
-else
-  stable_version=1.45.1
-fi
-
-if [[ -n $RUST_NIGHTLY_VERSION ]]; then
-  nightly_version="$RUST_NIGHTLY_VERSION"
-else
-  nightly_version=2020-07-27
-fi
-
-
-export rust_stable="$stable_version"
-export rust_stable_docker_image=solanalabs/rust:"$stable_version"
-
-export rust_nightly=nightly-"$nightly_version"
-export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
-
-[[ -z $1 ]] || (
-
-  rustup_install() {
-    declare toolchain=$1
-    if ! cargo +"$toolchain" -V > /dev/null; then
-      echo "$0: Missing toolchain? Installing...: $toolchain" >&2
-      rustup install "$toolchain"
-      cargo +"$toolchain" -V
-    fi
-  }
-
-  set -e
-  cd "$(dirname "${BASH_SOURCE[0]}")"
-  case $1 in
-  stable)
-     rustup_install "$rust_stable"
-     ;;
-  nightly)
-     rustup_install "$rust_nightly"
-    ;;
-  all)
-     rustup_install "$rust_stable"
-     rustup_install "$rust_nightly"
-    ;;
-  *)
-    echo "$0: Note: ignoring unknown argument: $1" >&2
-    ;;
-  esac
-)