Allow lower shred count (#9410) (#9451)

automerge

.appveyor.yml

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

.buildkite/env/secrets.ejson

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

.buildkite/pipeline-upload.sh

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

.gitbook.yaml

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

.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

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

.gitignore

@@ -1,6 +1,5 @@
 /docs/html/
 /docs/src/tests.ok
-/docs/src/cli/usage.md
 /docs/src/.gitbook/assets/*.svg
 /farf/
 /solana-release/
@@ -23,9 +22,3 @@ log-*/
 /.idea/
 /solana.iml
 /.vscode/
-
-# fetch-spl.sh artifacts
-/spl-genesis-args.sh
-/spl_*.so
-
-.DS_Store

.mergify.yml

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

.travis.yml

@@ -1,132 +1,43 @@
+os:
+  - osx
+  - windows
+
+language: rust
+rust:
+  - stable
+
+install:
+  - source ci/rust-version.sh
+
+script:
+  - source ci/env.sh
+  - ci/publish-tarball.sh
+
 branches:
   only:
     - master
     - /^v\d+\.\d+/
 
 notifications:
-  email: false
   slack:
     on_success: change
-    if: NOT type = pull_request
     secure: F4IjOE05MyaMOdPRL+r8qhs7jBvv4yDM3RmFKE1zNXnfUOqV4X38oQM1EI+YVsgpMQLj/pxnEB7wcTE4Bf86N6moLssEULCpvAuMVoXj4QbWdomLX+01WbFa6fLVeNQIg45NHrz2XzVBhoKOrMNnl+QI5mbR2AlS5oqsudHsXDnyLzZtd4Y5SDMdYG1zVWM01+oNNjgNfjcCGmOE/K0CnOMl6GPi3X9C34tJ19P2XT7MTDsz1/IfEF7fro2Q8DHEYL9dchJMoisXSkem5z7IDQkGzXsWdWT4NnndUvmd1MlTCE9qgoXDqRf95Qh8sB1Dz08HtvgfaosP2XjtNTfDI9BBYS15Ibw9y7PchAJE1luteNjF35EOy6OgmCLw/YpnweqfuNViBZz+yOPWXVC0kxnPIXKZ1wyH9ibeH6E4hr7a8o9SV/6SiWIlbYF+IR9jPXyTCLP/cc3sYljPWxDnhWFwFdRVIi3PbVAhVu7uWtVUO17Oc9gtGPgs/GrhOMkJfwQPXaudRJDpVZowxTX4x9kefNotlMAMRgq+Drbmgt4eEBiCNp0ITWgh17BiE1U09WS3myuduhoct85+FoVeaUkp1sxzHVtGsNQH0hcz7WcpZyOM+AwistJA/qzeEDQao5zi1eKWPbO2xAhi2rV1bDH6bPf/4lDBwLRqSiwvlWU=
 
-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
+deploy:
+  - provider: s3
+    access_key_id: $AWS_ACCESS_KEY_ID
+    secret_access_key: $AWS_SECRET_ACCESS_KEY
+    bucket: release.solana.com
+    region: us-west-1
+    skip_cleanup: true
+    acl: public_read
+    local_dir: travis-s3-upload
+    on:
+      all_branches: true
+  - provider: releases
+    api_key: $GITHUB_TOKEN
+    skip_cleanup: true
+    file_glob: true
+    file: travis-release-upload/*
+    on:
+      tags: true

.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

@@ -45,7 +45,7 @@ $ git pull --rebase upstream master
 
 If there are no functional changes, PRs can be very large and that's no
 problem. If, however, your changes are making meaningful changes or additions,
-then about 1,000 lines of changes is about the most you should ask a Solana
+then about 1000 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?

Cargo.toml

@@ -3,14 +3,13 @@ members = [
     "bench-exchange",
     "bench-streamer",
     "bench-tps",
-    "accounts-bench",
     "banking-bench",
-    "clap-utils",
+    "chacha",
+    "chacha-cuda",
+    "chacha-sys",
     "cli-config",
     "client",
     "core",
-    "dos",
-    "download-utils",
     "faucet",
     "perf",
     "validator",
@@ -25,38 +24,35 @@ members = [
     "logger",
     "log-analyzer",
     "merkle-tree",
-    "stake-o-matic",
-    "storage-bigtable",
-    "streamer",
     "measure",
     "metrics",
     "net-shaper",
-    "notifier",
-    "poh-bench",
     "programs/bpf_loader",
     "programs/budget",
+    "programs/btc_spv",
+    "programs/btc_spv_bin",
     "programs/config",
     "programs/exchange",
     "programs/failure",
     "programs/noop",
     "programs/ownable",
     "programs/stake",
+    "programs/storage",
     "programs/vest",
     "programs/vote",
+    "archiver",
+    "archiver-lib",
+    "archiver-utils",
     "remote-wallet",
-    "ramp-tps",
     "runtime",
     "sdk",
+    "sdk-c",
     "scripts",
-    "stake-accounts",
     "stake-monitor",
     "sys-tuner",
-    "tokens",
     "transaction-status",
-    "account-decoder",
     "upload-perf",
     "net-utils",
-    "version",
     "vote-signer",
     "cli",
     "rayon-threadlimit",
@@ -65,4 +61,6 @@ members = [
 
 exclude = [
     "programs/bpf",
+    "programs/move_loader",
+    "programs/librapay",
 ]

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,17 +1,62 @@
-<p align="center">
-  <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
-  </a>
-</p>
-
 [![Solana crate](https://img.shields.io/crates/v/solana-core.svg)](https://crates.io/crates/solana-core)
 [![Solana documentation](https://docs.rs/solana-core/badge.svg)](https://docs.rs/solana-core)
 [![Build status](https://badge.buildkite.com/8cc350de251d61483db98bdfc895b9ea0ac8ffa4a32ee850ed.svg?branch=master)](https://buildkite.com/solana-labs/solana/builds?branch=master)
 [![codecov](https://codecov.io/gh/solana-labs/solana/branch/master/graph/badge.svg)](https://codecov.io/gh/solana-labs/solana)
 
-# Building
+Blockchain Rebuilt for Scale
+===
 
-## **1. Install rustc, cargo and rustfmt.**
+Solana&trade; is a new blockchain architecture built from the ground up for scale. The architecture supports
+up to 710 thousand transactions per second on a gigabit network.
+
+Documentation
+===
+
+Before you jump into the code, review the documentation [Solana: Blockchain Rebuilt for Scale](https://docs.solana.com).
+
+(The _latest_ development version of the docs is [available here](https://docs.solana.com/v/master).)
+
+Release Binaries
+===
+Official release binaries are available at [Github Releases](https://github.com/solana-labs/solana/releases).
+
+Additionally we provide pre-release binaries for the latest code on the edge and
+beta channels.  Note that these pre-release binaries may be less stable than an
+official release.
+
+### Edge channel
+#### Linux (x86_64-unknown-linux-gnu)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-unknown-linux-gnu.tar.bz2)
+* [solana-install-init](http://release.solana.com/edge/solana-install-init-x86_64-unknown-linux-gnu) as a stand-alone executable
+#### mac OS (x86_64-apple-darwin)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-apple-darwin.tar.bz2)
+* [solana-install-init](http://release.solana.com/edge/solana-install-init-x86_64-apple-darwin) as a stand-alone executable
+#### Windows (x86_64-pc-windows-msvc)
+* [solana.tar.bz2](http://release.solana.com/edge/solana-release-x86_64-pc-windows-msvc.tar.bz2)
+* [solana-install-init.exe](http://release.solana.com/edge/solana-install-init-x86_64-pc-windows-msvc.exe) as a stand-alone executable
+#### All platforms
+* [solana-metrics.tar.bz2](http://release.solana.com.s3.amazonaws.com/edge/solana-metrics.tar.bz2)
+
+### Beta channel
+#### Linux (x86_64-unknown-linux-gnu)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-unknown-linux-gnu.tar.bz2)
+* [solana-install-init](http://release.solana.com/beta/solana-install-init-x86_64-unknown-linux-gnu) as a stand-alone executable
+#### mac OS (x86_64-apple-darwin)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-apple-darwin.tar.bz2)
+* [solana-install-init](http://release.solana.com/beta/solana-install-init-x86_64-apple-darwin) as a stand-alone executable
+#### Windows (x86_64-pc-windows-msvc)
+* [solana.tar.bz2](http://release.solana.com/beta/solana-release-x86_64-pc-windows-msvc.tar.bz2)
+* [solana-install-init.exe](http://release.solana.com/beta/solana-install-init-x86_64-pc-windows-msvc.exe) as a stand-alone executable
+#### All platforms
+* [solana-metrics.tar.bz2](http://release.solana.com.s3.amazonaws.com/beta/solana-metrics.tar.bz2)
+
+Developing
+===
+
+Building
+---
+
+Install rustc, cargo and rustfmt:
 
 ```bash
 $ curl https://sh.rustup.rs -sSf | sh
@@ -32,39 +77,112 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang
 ```
 
-## **2. Download the source code.**
+Download the source code:
 
 ```bash
 $ git clone https://github.com/solana-labs/solana.git
 $ cd solana
 ```
 
-## **3. Build.**
+Build
 
 ```bash
 $ cargo build
 ```
 
-## **4. Run a minimal local cluster.**
+Then to run a minimal local cluster
 ```bash
 $ ./run.sh
 ```
 
-# Testing
+Testing
+---
 
-**Run the test suite:**
+Run the test suite:
 
 ```bash
 $ cargo test
 ```
 
-### Starting a local testnet
-Start your own testnet locally, instructions are in the [online docs](https://docs.solana.com/bench-tps).
+Local Testnet
+---
+
+Start your own testnet locally, instructions are in the online docs [Solana: Blockchain Rebuild for Scale: Getting Started](https://docs.solana.com/building-from-source).
+
+Remote Testnets
+---
 
-### Accessing the remote testnet
 * `testnet` - public stable testnet accessible via devnet.solana.com. Runs 24/7
 
-# Benchmarking
+
+## Deploy process
+
+They are deployed with the `ci/testnet-manager.sh` script through a list of [scheduled
+buildkite jobs](https://buildkite.com/solana-labs/testnet-management/settings/schedules).
+Each testnet can be manually manipulated from buildkite as well.
+
+## How do I reset the testnet?
+Manually trigger the [testnet-management](https://buildkite.com/solana-labs/testnet-management) pipeline
+and when prompted select the desired testnet
+
+## How can I scale the tx generation rate?
+
+Increase the TX rate by increasing the number of cores on the client machine which is running
+`bench-tps` or run multiple clients. Decrease by lowering cores or using the rayon env
+variable `RAYON_NUM_THREADS=<xx>`
+
+## How can I test a change on the testnet?
+
+Currently, a merged PR is the only way to test a change on the testnet.  But you
+can run your own testnet using the scripts in the `net/` directory.
+
+## Adjusting the number of clients or validators on the testnet
+Edit `ci/testnet-manager.sh`
+
+
+## Metrics Server Maintenance
+Sometimes the dashboard becomes unresponsive. This happens due to glitch in the metrics server.
+The current solution is to reset the metrics server. Use the following steps.
+
+1. The server is hosted in a GCP VM instance. Check if the VM instance is down by trying to SSH
+ into it from the GCP console. The name of the VM is ```metrics-solana-com```.
+2. If the VM is inaccessible, reset it from the GCP console.
+3. Once VM is up (or, was already up), the metrics services can be restarted from build automation.
+    1. Navigate to https://buildkite.com/solana-labs/metrics-dot-solana-dot-com in your web browser
+    2. Click on ```New Build```
+    3. This will show a pop up dialog. Click on ```options``` drop down.
+    4. Type in ```FORCE_START=true``` in ```Environment Variables``` text box.
+    5. Click ```Create Build```
+    6. This will restart the metrics services, and the dashboards should be accessible afterwards.
+
+## Debugging Testnet
+Testnet may exhibit different symptoms of failures. Primary statistics to check are
+1. Rise in Confirmation Time
+2. Nodes are not voting
+3. Panics, and OOM notifications
+
+Check the following if there are any signs of failure.
+1. Did testnet deployment fail?
+    1. View buildkite logs for the last deployment: https://buildkite.com/solana-labs/testnet-management
+    2. Use the relevant branch
+    3. If the deployment failed, look at the build logs. The build artifacts for each remote node is uploaded.
+       It's a good first step to triage from these logs.
+2. You may have to log into remote node if the deployment succeeded, but something failed during runtime.
+    1. Get the private key for the testnet deployment from ```metrics-solana-com``` GCP instance.
+    2. SSH into ```metrics-solana-com``` using GCP console and do the following.
+    ```bash
+    sudo bash
+    cd ~buildkite-agent/.ssh
+    ls
+    ```
+    3. Copy the relevant private key to your local machine
+    4. Find the public IP address of the AWS instance for the remote node using AWS console
+    5. ```ssh -i <private key file> ubuntu@<ip address of remote node>```
+    6. The logs are in ```~solana\solana``` folder
+
+
+Benchmarking
+---
 
 First install the nightly build of rustc. `cargo bench` requires use of the
 unstable features only available in the nightly build.
@@ -79,11 +197,13 @@ Run the benchmarks:
 $ cargo +nightly bench
 ```
 
-# Release Process
-
+Release Process
+---
 The release process for this project is described [here](RELEASE.md).
 
-# Code coverage
+
+Code coverage
+---
 
 To generate code coverage statistics:
 
@@ -92,6 +212,7 @@ $ scripts/coverage.sh
 $ open target/cov/lcov-local/index.html
 ```
 
+
 Why coverage? While most see coverage as a code quality metric, we see it primarily as a developer
 productivity metric. When a developer makes a change to the codebase, presumably it's a *solution* to
 some problem.  Our unit-test suite is how we encode the set of *problems* the codebase solves. Running
@@ -104,6 +225,7 @@ better way to solve the same problem, a Pull Request with your solution would mo
 welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please
 send us that patch!
 
-# Disclaimer
+Disclaimer
+===
 
 All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.

RELEASE.md

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

account-decoder/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "solana-account-decoder"
-version = "1.3.1"
-description = "Solana account decoder"
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-repository = "https://github.com/solana-labs/solana"
-homepage = "https://solana.com/"
-license = "Apache-2.0"
-edition = "2018"
-
-[dependencies]
-bincode = "1.3.1"
-bs58 = "0.3.1"
-Inflector = "0.11.4"
-lazy_static = "1.4.0"
-solana-sdk = { path = "../sdk", version = "1.3.1" }
-solana-vote-program = { path = "../programs/vote", version = "1.3.1" }
-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,88 +0,0 @@
-#[macro_use]
-extern crate lazy_static;
-#[macro_use]
-extern crate serde_derive;
-
-pub mod parse_account_data;
-pub mod parse_nonce;
-pub mod parse_token;
-pub mod parse_vote;
-
-use crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount};
-use solana_sdk::{account::Account, clock::Epoch, 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),
-}
-
-impl From<Vec<u8>> for UiAccountData {
-    fn from(data: Vec<u8>) -> Self {
-        Self::Binary(bs58::encode(data).into_string())
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub enum UiAccountEncoding {
-    Binary,
-    JsonParsed,
-}
-
-impl UiAccount {
-    pub fn encode(
-        account: Account,
-        encoding: UiAccountEncoding,
-        additional_data: Option<AccountAdditionalData>,
-    ) -> Self {
-        let data = match encoding {
-            UiAccountEncoding::Binary => account.data.into(),
-            UiAccountEncoding::JsonParsed => {
-                if let Ok(parsed_data) =
-                    parse_account_data(&account.owner, &account.data, additional_data)
-                {
-                    UiAccountData::Json(parsed_data)
-                } else {
-                    account.data.into()
-                }
-            }
-        };
-        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(),
-        }?;
-        Some(Account {
-            lamports: self.lamports,
-            data,
-            owner: Pubkey::from_str(&self.owner).ok()?,
-            executable: self.executable,
-            rent_epoch: self.rent_epoch,
-        })
-    }
-}

account-decoder/src/parse_account_data.rs

@@ -1,113 +0,0 @@
-use crate::{
-    parse_nonce::parse_nonce,
-    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};
-use std::collections::HashMap;
-use thiserror::Error;
-
-lazy_static! {
-    static ref SYSTEM_PROGRAM_ID: Pubkey = system_program::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(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
-        m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::SplToken);
-        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,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum ParsableAccount {
-    Nonce,
-    SplToken,
-    Vote,
-}
-
-#[derive(Default)]
-pub struct AccountAdditionalData {
-    pub spl_token_decimals: Option<u8>,
-}
-
-pub fn parse_account_data(
-    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::Nonce => serde_json::to_value(parse_nonce(data)?)?,
-        ParsableAccount::SplToken => {
-            serde_json::to_value(parse_token(data, additional_data.spl_token_decimals)?)?
-        }
-        ParsableAccount::Vote => serde_json::to_value(parse_vote(data)?)?,
-    };
-    Ok(ParsedAccount {
-        program: format!("{:?}", program_name).to_kebab_case(),
-        parsed: parsed_json,
-    })
-}
-
-#[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 other_program = Pubkey::new_rand();
-        let data = vec![0; 4];
-        assert!(parse_account_data(&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(&solana_vote_program::id(), &vote_account_data, None).unwrap();
-        assert_eq!(parsed.program, "vote".to_string());
-
-        let nonce_data = Versions::new_current(State::Initialized(Data::default()));
-        let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
-        let parsed = parse_account_data(&system_program::id(), &nonce_account_data, None).unwrap();
-        assert_eq!(parsed.program, "nonce".to_string());
-    }
-}

account-decoder/src/parse_nonce.rs

@@ -1,66 +0,0 @@
-use crate::parse_account_data::ParseAccountError;
-use solana_sdk::{
-    fee_calculator::FeeCalculator,
-    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,
-        })),
-    }
-}
-
-/// 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: FeeCalculator,
-}
-
-#[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: FeeCalculator::default(),
-            }),
-        );
-
-        let bad_data = vec![0; 4];
-        assert!(parse_nonce(&bad_data).is_err());
-    }
-}

account-decoder/src/parse_token.rs

@@ -1,242 +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(),
-            )
-        })?;
-        let ui_token_amount = token_amount_to_ui_amount(account.amount, decimals);
-        Ok(TokenAccountType::Account(UiTokenAccount {
-            mint: account.mint.to_string(),
-            owner: account.owner.to_string(),
-            token_amount: ui_token_amount,
-            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: account.delegated_amount,
-        }))
-    } 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,
-    pub delegate: Option<String>,
-    pub is_initialized: bool,
-    pub is_native: bool,
-    pub delegated_amount: u64,
-}
-
-#[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: 0,
-            }),
-        );
-
-        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;
-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,
-            previous_credits: *previous_credits,
-        })
-        .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: u64,
-    previous_credits: u64,
-}
-
-#[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());
-    }
-}

accounts-bench/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-accounts-bench"
-version = "1.3.1"
-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.1" }
-solana-runtime = { path = "../runtime", version = "1.3.1" }
-solana-measure = { path = "../measure", version = "1.3.1" }
-solana-sdk = { path = "../sdk", version = "1.3.1" }
-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);
-        }
-    }
-}

archiver-lib/Cargo.toml

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

archiver-lib/src/archiver.rs

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

archiver-lib/src/lib.rs

@@ -1,10 +1,11 @@
-pub mod packet;
-pub mod recvmmsg;
-pub mod sendmmsg;
-pub mod streamer;
-
 #[macro_use]
 extern crate log;
 
+#[macro_use]
+extern crate serde_derive;
+
 #[macro_use]
 extern crate solana_metrics;
+
+pub mod archiver;
+mod result;

archiver-lib/src/result.rs

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

archiver-utils/Cargo.toml

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

archiver-utils/src/lib.rs

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

archiver/Cargo.toml

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

archiver/src/main.rs

@@ -0,0 +1,131 @@
+use clap::{crate_description, crate_name, App, Arg};
+use console::style;
+use solana_archiver_lib::archiver::Archiver;
+use solana_clap_utils::{
+    input_parsers::keypair_of, input_validators::is_keypair_or_ask_keyword,
+    keypair::SKIP_SEED_PHRASE_VALIDATION_ARG,
+};
+use solana_core::{
+    cluster_info::{Node, VALIDATOR_PORT_RANGE},
+    contact_info::ContactInfo,
+};
+use solana_sdk::{
+    commitment_config::CommitmentConfig,
+    signature::{Keypair, Signer},
+};
+use std::{
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    path::PathBuf,
+    sync::Arc,
+};
+
+fn main() {
+    solana_logger::setup();
+
+    let matches = App::new(crate_name!())
+        .about(crate_description!())
+        .version(solana_clap_utils::version!())
+        .arg(
+            Arg::with_name("identity_keypair")
+                .short("i")
+                .long("identity")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair_or_ask_keyword)
+                .help("File containing an identity (keypair)"),
+        )
+        .arg(
+            Arg::with_name("entrypoint")
+                .short("n")
+                .long("entrypoint")
+                .value_name("HOST:PORT")
+                .takes_value(true)
+                .required(true)
+                .validator(solana_net_utils::is_host_port)
+                .help("Rendezvous with the cluster at this entry point"),
+        )
+        .arg(
+            Arg::with_name("ledger")
+                .short("l")
+                .long("ledger")
+                .value_name("DIR")
+                .takes_value(true)
+                .required(true)
+                .help("use DIR as persistent ledger location"),
+        )
+        .arg(
+            Arg::with_name("storage_keypair")
+                .short("s")
+                .long("storage-keypair")
+                .value_name("PATH")
+                .takes_value(true)
+                .validator(is_keypair_or_ask_keyword)
+                .help("File containing the storage account keypair"),
+        )
+        .arg(
+            Arg::with_name(SKIP_SEED_PHRASE_VALIDATION_ARG.name)
+                .long(SKIP_SEED_PHRASE_VALIDATION_ARG.long)
+                .help(SKIP_SEED_PHRASE_VALIDATION_ARG.help),
+        )
+        .get_matches();
+
+    let ledger_path = PathBuf::from(matches.value_of("ledger").unwrap());
+
+    let identity_keypair = keypair_of(&matches, "identity_keypair").unwrap_or_else(Keypair::new);
+
+    let storage_keypair = keypair_of(&matches, "storage_keypair").unwrap_or_else(|| {
+        clap::Error::with_description(
+            "The `storage-keypair` argument was not found",
+            clap::ErrorKind::ArgumentNotFound,
+        )
+        .exit();
+    });
+
+    let entrypoint_addr = matches
+        .value_of("entrypoint")
+        .map(|entrypoint| {
+            solana_net_utils::parse_host_port(entrypoint)
+                .expect("failed to parse entrypoint address")
+        })
+        .unwrap();
+
+    let gossip_addr = {
+        let ip = solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap();
+        let mut addr = SocketAddr::new(ip, 0);
+        addr.set_ip(solana_net_utils::get_public_ip_addr(&entrypoint_addr).unwrap());
+        addr
+    };
+    let node = Node::new_archiver_with_external_ip(
+        &identity_keypair.pubkey(),
+        &gossip_addr,
+        VALIDATOR_PORT_RANGE,
+        IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
+    );
+
+    println!(
+        "{} version {} (branch={}, commit={})",
+        style(crate_name!()).bold(),
+        solana_clap_utils::version!(),
+        option_env!("CI_BRANCH").unwrap_or("unknown"),
+        option_env!("CI_COMMIT").unwrap_or("unknown")
+    );
+    solana_metrics::set_host_id(identity_keypair.pubkey().to_string());
+    println!(
+        "replicating the data with identity_keypair={:?} gossip_addr={:?}",
+        identity_keypair.pubkey(),
+        gossip_addr
+    );
+
+    let entrypoint_info = ContactInfo::new_gossip_entry_point(&entrypoint_addr);
+    let archiver = Archiver::new(
+        &ledger_path,
+        node,
+        entrypoint_info,
+        Arc::new(identity_keypair),
+        Arc::new(storage_keypair),
+        CommitmentConfig::recent(),
+    )
+    .unwrap();
+
+    archiver.join();
+}

banking-bench/Cargo.toml

@@ -1,28 +1,20 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-banking-bench"
-version = "1.3.1"
+version = "1.0.16"
 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.1" }
-solana-clap-utils = { path = "../clap-utils", version = "1.3.1" }
-solana-streamer = { path = "../streamer", version = "1.3.1" }
-solana-perf = { path = "../perf", version = "1.3.1" }
-solana-ledger = { path = "../ledger", version = "1.3.1" }
-solana-logger = { path = "../logger", version = "1.3.1" }
-solana-runtime = { path = "../runtime", version = "1.3.1" }
-solana-measure = { path = "../measure", version = "1.3.1" }
-solana-sdk = { path = "../sdk", version = "1.3.1" }
-solana-version = { path = "../version", version = "1.3.1" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+rayon = "1.2.0"
+solana-core = { path = "../core", version = "1.0.16" }
+solana-ledger = { path = "../ledger", version = "1.0.16" }
+solana-logger = { path = "../logger", version = "1.0.16" }
+solana-runtime = { path = "../runtime", version = "1.0.16" }
+solana-measure = { path = "../measure", version = "1.0.16" }
+solana-sdk = { path = "../sdk", version = "1.0.16" }
+rand = "0.6.5"
+crossbeam-channel = "0.3"

banking-bench/src/main.rs

@@ -1,37 +1,30 @@
-use clap::{crate_description, crate_name, value_t, App, Arg};
 use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
 use rayon::prelude::*;
-use solana_core::{
-    banking_stage::{create_test_recorder, BankingStage},
-    cluster_info::ClusterInfo,
-    cluster_info::Node,
-    poh_recorder::PohRecorder,
-    poh_recorder::WorkingBankEntry,
-};
-use solana_ledger::{
-    blockstore::Blockstore,
-    genesis_utils::{create_genesis_config, GenesisConfigInfo},
-    get_tmp_ledger_path,
-};
+use solana_core::banking_stage::{create_test_recorder, BankingStage};
+use solana_core::cluster_info::ClusterInfo;
+use solana_core::cluster_info::Node;
+use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
+use solana_core::packet::to_packets_chunked;
+use solana_core::poh_recorder::PohRecorder;
+use solana_core::poh_recorder::WorkingBankEntry;
+use solana_ledger::bank_forks::BankForks;
+use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
 use solana_measure::measure::Measure;
-use solana_perf::packet::to_packets_chunked;
-use solana_runtime::{bank::Bank, 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},
-};
+use solana_runtime::bank::Bank;
+use solana_sdk::hash::Hash;
+use solana_sdk::pubkey::Pubkey;
+use solana_sdk::signature::Keypair;
+use solana_sdk::signature::Signature;
+use solana_sdk::system_transaction;
+use solana_sdk::timing::{duration_as_us, timestamp};
+use solana_sdk::transaction::Transaction;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc::Receiver;
+use std::sync::{Arc, Mutex, RwLock};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
 
 fn check_txs(
     receiver: &Arc<Receiver<WorkingBankEntry>>,
@@ -64,22 +57,15 @@ fn check_txs(
     no_bank
 }
 
-fn make_accounts_txs(
-    total_num_transactions: usize,
-    hash: Hash,
-    same_payer: bool,
-) -> Vec<Transaction> {
+fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> {
     let to_pubkey = Pubkey::new_rand();
-    let payer_key = Keypair::new();
-    let dummy = system_transaction::transfer(&payer_key, &to_pubkey, 1, hash);
-    (0..total_num_transactions)
+    let dummy = system_transaction::transfer(mint_keypair, &to_pubkey, 1, hash);
+    (0..txes)
         .into_par_iter()
         .map(|_| {
             let mut new = dummy.clone();
             let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            if !same_payer {
-                new.message.account_keys[0] = Pubkey::new_rand();
-            }
+            new.message.account_keys[0] = Pubkey::new_rand();
             new.message.account_keys[1] = Pubkey::new_rand();
             new.signatures = vec![Signature::new(&sig[0..64])];
             new
@@ -103,61 +89,13 @@ fn bytes_as_usize(bytes: &[u8]) -> usize {
     bytes[0] as usize | (bytes[1] as usize) << 8
 }
 
-#[allow(clippy::cognitive_complexity)]
 fn main() {
     solana_logger::setup();
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("num_chunks")
-                .long("num-chunks")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Number of transaction chunks."),
-        )
-        .arg(
-            Arg::with_name("packets_per_chunk")
-                .long("packets-per-chunk")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Packets per chunk"),
-        )
-        .arg(
-            Arg::with_name("skip_sanity")
-                .long("skip-sanity")
-                .takes_value(false)
-                .help("Skip transaction sanity execution"),
-        )
-        .arg(
-            Arg::with_name("same_payer")
-                .long("same-payer")
-                .takes_value(false)
-                .help("Use the same payer for transfers"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .arg(
-            Arg::with_name("num_threads")
-                .long("num-threads")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .get_matches();
-
-    let num_threads =
-        value_t!(matches, "num_threads", usize).unwrap_or(BankingStage::num_threads() as usize);
+    let num_threads = BankingStage::num_threads() as usize;
     //   a multiple of packet chunk duplicates to avoid races
-    let num_chunks = value_t!(matches, "num_chunks", usize).unwrap_or(16);
-    let packets_per_chunk = value_t!(matches, "packets_per_chunk", usize).unwrap_or(192);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(1000);
-
-    let total_num_transactions = num_chunks * num_threads * packets_per_chunk;
+    const CHUNKS: usize = 8 * 2;
+    const PACKETS_PER_BATCH: usize = 192;
+    let txes = PACKETS_PER_BATCH * num_threads * CHUNKS;
     let mint_total = 1_000_000_000_000;
     let GenesisConfigInfo {
         genesis_config,
@@ -167,49 +105,38 @@ fn main() {
 
     let (verified_sender, verified_receiver) = unbounded();
     let (vote_sender, vote_receiver) = unbounded();
-    let (replay_vote_sender, _replay_vote_receiver) = unbounded();
     let bank0 = Bank::new(&genesis_config);
-    let mut bank_forks = BankForks::new(bank0);
+    let mut bank_forks = BankForks::new(0, bank0);
     let mut bank = bank_forks.working_bank();
 
-    info!("threads: {} txs: {}", num_threads, total_num_transactions);
+    info!("threads: {} txs: {}", num_threads, txes);
 
-    let same_payer = matches.is_present("same_payer");
-    let mut transactions =
-        make_accounts_txs(total_num_transactions, genesis_config.hash(), same_payer);
+    let mut transactions = make_accounts_txs(txes, &mint_keypair, genesis_config.hash());
 
     // fund all the accounts
     transactions.iter().for_each(|tx| {
-        let mut fund = system_transaction::transfer(
+        let fund = system_transaction::transfer(
             &mint_keypair,
             &tx.message.account_keys[0],
-            mint_total / total_num_transactions as u64,
+            mint_total / txes as u64,
             genesis_config.hash(),
         );
-        // Ignore any pesky duplicate signature errors in the case we are using single-payer
-        let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-        fund.signatures = vec![Signature::new(&sig[0..64])];
         let x = bank.process_transaction(&fund);
         x.unwrap();
     });
-
-    let skip_sanity = matches.is_present("skip_sanity");
-    if !skip_sanity {
-        //sanity check, make sure all the transactions can execute sequentially
-        transactions.iter().for_each(|tx| {
-            let res = bank.process_transaction(&tx);
-            assert!(res.is_ok(), "sanity test transactions error: {:?}", res);
-        });
-        bank.clear_signatures();
-        //sanity check, make sure all the transactions can execute in parallel
-        let res = bank.process_transactions(&transactions);
-        for r in res {
-            assert!(r.is_ok(), "sanity parallel execution error: {:?}", r);
-        }
-        bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute sequentially
+    transactions.iter().for_each(|tx| {
+        let res = bank.process_transaction(&tx);
+        assert!(res.is_ok(), "sanity test transactions");
+    });
+    bank.clear_signatures();
+    //sanity check, make sure all the transactions can execute in parallel
+    let res = bank.process_transactions(&transactions);
+    for r in res {
+        assert!(r.is_ok(), "sanity parallel execution");
     }
-
-    let mut verified: Vec<_> = to_packets_chunked(&transactions, packets_per_chunk);
+    bank.clear_signatures();
+    let mut verified: Vec<_> = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
     let ledger_path = get_tmp_ledger_path!();
     {
         let blockstore = Arc::new(
@@ -218,18 +145,17 @@ fn main() {
         let (exit, poh_recorder, poh_service, signal_receiver) =
             create_test_recorder(&bank, &blockstore, None);
         let cluster_info = ClusterInfo::new_with_invalid_keypair(Node::new_localhost().info);
-        let cluster_info = Arc::new(cluster_info);
+        let cluster_info = Arc::new(RwLock::new(cluster_info));
         let banking_stage = BankingStage::new(
             &cluster_info,
             &poh_recorder,
             verified_receiver,
             vote_receiver,
             None,
-            replay_vote_sender,
         );
         poh_recorder.lock().unwrap().set_bank(&bank);
 
-        let chunk_len = verified.len() / num_chunks;
+        let chunk_len = verified.len() / CHUNKS;
         let mut start = 0;
 
         // This is so that the signal_receiver does not go out of scope after the closure.
@@ -238,17 +164,17 @@ fn main() {
         let signal_receiver = Arc::new(signal_receiver);
         let mut total_us = 0;
         let mut tx_total_us = 0;
-        let base_tx_count = bank.transaction_count();
         let mut txs_processed = 0;
         let mut root = 1;
         let collector = Pubkey::new_rand();
+        const ITERS: usize = 1_000;
         let config = Config {
-            packets_per_batch: packets_per_chunk,
+            packets_per_batch: PACKETS_PER_BATCH,
             chunk_len,
             num_threads,
         };
         let mut total_sent = 0;
-        for _ in 0..iterations {
+        for _ in 0..ITERS {
             let now = Instant::now();
             let mut sent = 0;
 
@@ -289,11 +215,7 @@ fn main() {
                     sleep(Duration::from_millis(5));
                 }
             }
-            if check_txs(
-                &signal_receiver,
-                total_num_transactions / num_chunks,
-                &poh_recorder,
-            ) {
+            if check_txs(&signal_receiver, txes / CHUNKS, &poh_recorder) {
                 debug!(
                     "resetting bank {} tx count: {} txs_proc: {}",
                     bank.slot(),
@@ -324,7 +246,7 @@ fn main() {
                 poh_recorder.lock().unwrap().set_bank(&bank);
                 assert!(poh_recorder.lock().unwrap().bank().is_some());
                 if bank.slot() > 32 {
-                    bank_forks.set_root(root, &None, None);
+                    bank_forks.set_root(root, &None);
                     root += 1;
                 }
                 debug!(
@@ -345,7 +267,7 @@ fn main() {
             debug!(
                 "time: {} us checked: {} sent: {}",
                 duration_as_us(&now.elapsed()),
-                total_num_transactions / num_chunks,
+                txes / CHUNKS,
                 sent,
             );
             total_sent += sent;
@@ -356,26 +278,20 @@ fn main() {
                     let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
                     tx.signatures[0] = Signature::new(&sig[0..64]);
                 }
-                verified = to_packets_chunked(&transactions.clone(), packets_per_chunk);
+                verified = to_packets_chunked(&transactions.clone(), PACKETS_PER_BATCH);
             }
 
             start += chunk_len;
             start %= verified.len();
         }
-        let txs_processed = bank_forks.working_bank().transaction_count();
-        debug!("processed: {} base: {}", txs_processed, base_tx_count);
         eprintln!(
-            "{{'name': 'banking_bench_total', 'median': '{:.2}'}}",
+            "{{'name': 'banking_bench_total', 'median': '{}'}}",
             (1000.0 * 1000.0 * total_sent as f64) / (total_us as f64),
         );
         eprintln!(
-            "{{'name': 'banking_bench_tx_total', 'median': '{:.2}'}}",
+            "{{'name': 'banking_bench_tx_total', 'median': '{}'}}",
             (1000.0 * 1000.0 * total_sent as f64) / (tx_total_us as f64),
         );
-        eprintln!(
-            "{{'name': 'banking_bench_success_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * (txs_processed - base_tx_count) as f64) / (total_us as f64),
-        );
 
         drop(verified_sender);
         drop(vote_sender);

bench-exchange/Cargo.toml

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

bench-exchange/src/bench.rs

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

bench-exchange/src/main.rs

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

bench-exchange/tests/bench_exchange.rs

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

bench-streamer/Cargo.toml

@@ -1,19 +1,15 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-streamer"
-version = "1.3.1"
+version = "1.0.16"
 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.1" }
-solana-streamer = { path = "../streamer", version = "1.3.1" }
-solana-logger = { path = "../logger", version = "1.3.1" }
-solana-net-utils = { path = "../net-utils", version = "1.3.1" }
-solana-version = { path = "../version", version = "1.3.1" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+clap = "2.33.0"
+solana-clap-utils = { path = "../clap-utils", version = "1.0.16" }
+solana-core = { path = "../core", version = "1.0.16" }
+solana-logger = { path = "../logger", version = "1.0.16" }
+solana-net-utils = { path = "../net-utils", version = "1.0.16" }

bench-streamer/src/main.rs

@@ -1,6 +1,6 @@
 use clap::{crate_description, crate_name, App, Arg};
-use solana_streamer::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE};
-use solana_streamer::streamer::{receiver, PacketReceiver};
+use solana_core::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE};
+use solana_core::streamer::{receiver, PacketReceiver};
 use std::cmp::max;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
@@ -52,7 +52,7 @@ fn main() -> Result<()> {
 
     let matches = App::new(crate_name!())
         .about(crate_description!())
-        .version(solana_version::version!())
+        .version(solana_clap_utils::version!())
         .arg(
             Arg::with_name("num-recv-sockets")
                 .long("num-recv-sockets")

bench-tps/Cargo.toml

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

bench-tps/src/bench.rs

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

bench-tps/src/cli.rs

@@ -1,10 +1,7 @@
 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 solana_sdk::signature::{read_keypair_file, Keypair};
 use std::{net::SocketAddr, process::exit, time::Duration};
 
 const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;
@@ -26,9 +23,8 @@ pub struct Config {
     pub read_from_client_file: bool,
     pub target_lamports_per_signature: u64,
     pub multi_client: bool,
+    pub use_move: bool,
     pub num_lamports_per_account: u64,
-    pub target_slots_per_epoch: u64,
-    pub target_node: Option<Pubkey>,
 }
 
 impl Default for Config {
@@ -49,9 +45,8 @@ impl Default for Config {
             read_from_client_file: false,
             target_lamports_per_signature: FeeRateGovernor::default().target_lamports_per_signature,
             multi_client: true,
+            use_move: false,
             num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
-            target_slots_per_epoch: 0,
-            target_node: None,
         }
     }
 }
@@ -112,19 +107,16 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                 .long("sustained")
                 .help("Use sustained performance mode vs. peak mode. This overlaps the tx generation with transfers."),
         )
+        .arg(
+            Arg::with_name("use-move")
+                .long("use-move")
+                .help("Use Move language transactions to perform transfers."),
+        )
         .arg(
             Arg::with_name("no-multi-client")
                 .long("no-multi-client")
                 .help("Disable multi-client support, only transact with the entrypoint."),
         )
-        .arg(
-            Arg::with_name("target_node")
-                .long("target-node")
-                .requires("no-multi-client")
-                .takes_value(true)
-                .value_name("PUBKEY")
-                .help("Specify an exact node to send transactions to."),
-        )
         .arg(
             Arg::with_name("tx_count")
                 .long("tx_count")
@@ -180,15 +172,6 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                     "Number of lamports per account.",
                 ),
         )
-        .arg(
-            Arg::with_name("target_slots_per_epoch")
-                .long("target-slots-per-epoch")
-                .value_name("SLOTS")
-                .takes_value(true)
-                .help(
-                    "Wait until epochs are this many slots long.",
-                ),
-        )
 }
 
 /// Parses a clap `ArgMatches` structure into a `Config`
@@ -269,21 +252,12 @@ pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
         args.target_lamports_per_signature = v.to_string().parse().expect("can't parse lamports");
     }
 
+    args.use_move = matches.is_present("use-move");
     args.multi_client = !matches.is_present("no-multi-client");
-    args.target_node = matches
-        .value_of("target_node")
-        .map(|target_str| target_str.parse().unwrap());
 
     if let Some(v) = matches.value_of("num_lamports_per_account") {
         args.num_lamports_per_account = v.to_string().parse().expect("can't parse lamports");
     }
 
-    if let Some(t) = matches.value_of("target_slots_per_epoch") {
-        args.target_slots_per_epoch = t
-            .to_string()
-            .parse()
-            .expect("can't parse target slots per epoch");
-    }
-
     args
 }

bench-tps/src/main.rs

@@ -15,7 +15,7 @@ fn main() {
     solana_logger::setup_with_default("solana=info");
     solana_metrics::set_panic_hook("bench-tps");
 
-    let matches = cli::build_args(solana_version::version!()).get_matches();
+    let matches = cli::build_args(solana_clap_utils::version!()).get_matches();
     let cli_config = cli::extract_args(&matches);
 
     let cli::Config {
@@ -29,9 +29,9 @@ fn main() {
         write_to_client_file,
         read_from_client_file,
         target_lamports_per_signature,
+        use_move,
         multi_client,
         num_lamports_per_account,
-        target_node,
         ..
     } = &cli_config;
 
@@ -67,10 +67,11 @@ fn main() {
     }
 
     info!("Connecting to the cluster");
-    let nodes = discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
-        eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
-        exit(1);
-    });
+    let (nodes, _archivers) =
+        discover_cluster(&entrypoint_addr, *num_nodes).unwrap_or_else(|err| {
+            eprintln!("Failed to discover {} nodes: {:?}", num_nodes, err);
+            exit(1);
+        });
 
     let client = if *multi_client {
         let (client, num_clients) = get_multi_client(&nodes);
@@ -82,24 +83,11 @@ fn main() {
             exit(1);
         }
         Arc::new(client)
-    } else if let Some(target_node) = target_node {
-        info!("Searching for target_node: {:?}", target_node);
-        let mut target_client = None;
-        for node in nodes {
-            if node.id == *target_node {
-                target_client = Some(Arc::new(get_client(&[node])));
-                break;
-            }
-        }
-        target_client.unwrap_or_else(|| {
-            eprintln!("Target node {} not found", target_node);
-            exit(1);
-        })
     } else {
         Arc::new(get_client(&nodes))
     };
 
-    let keypairs = if *read_from_client_file {
+    let (keypairs, move_keypairs) = if *read_from_client_file && !use_move {
         let path = Path::new(&client_ids_and_stake_file);
         let file = File::open(path).unwrap();
 
@@ -128,8 +116,8 @@ fn main() {
         // Sort keypairs so that do_bench_tps() uses the same subset of accounts for each run.
         // This prevents the amount of storage needed for bench-tps accounts from creeping up
         // across multiple runs.
-        keypairs.sort_by_key(|x| x.pubkey().to_string());
-        keypairs
+        keypairs.sort_by(|x, y| x.pubkey().to_string().cmp(&y.pubkey().to_string()));
+        (keypairs, None)
     } else {
         generate_and_fund_keypairs(
             client.clone(),
@@ -137,6 +125,7 @@ fn main() {
             &id,
             keypair_count,
             *num_lamports_per_account,
+            *use_move,
         )
         .unwrap_or_else(|e| {
             eprintln!("Error could not fund keys: {:?}", e);
@@ -144,5 +133,5 @@ fn main() {
         })
     };
 
-    do_bench_tps(client, cli_config, keypairs);
+    do_bench_tps(client, cli_config, keypairs, move_keypairs);
 }

bench-tps/tests/bench_tps.rs

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

chacha-cuda/Cargo.toml

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

chacha-cuda/src/chacha_cuda.rs

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

chacha-cuda/src/lib.rs

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

chacha-sys/Cargo.toml

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

chacha-sys/build.rs

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

chacha-sys/cpu-crypt/.gitignore

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

chacha-sys/cpu-crypt/Makefile

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

chacha-sys/cpu-crypt/chacha.h

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

chacha-sys/cpu-crypt/chacha20_core.c

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

chacha-sys/cpu-crypt/chacha_cbc.c

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

chacha-sys/src/lib.rs

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

chacha/.gitignore

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

chacha/Cargo.toml

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

chacha/src/chacha.rs

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

chacha/src/lib.rs

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

ci/README.md

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

ci/affects-files.sh

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

ci/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-release.yml

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

ci/buildkite-secondary.yml

@@ -2,13 +2,6 @@
 # Build steps that run after the primary pipeline on pushes and tags.
 # Pull requests to not run these steps.
 steps:
-  - command: "ci/publish-tarball.sh"
-    timeout_in_minutes: 60
-    name: "publish tarball"
-  - command: "ci/publish-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"
@@ -16,3 +9,12 @@ steps:
     timeout_in_minutes: 240
     name: "publish crate"
     branches: "!master"
+  - command: "ci/publish-bpf-sdk.sh"
+    timeout_in_minutes: 5
+    name: "publish bpf sdk"
+  - command: "ci/publish-tarball.sh"
+    timeout_in_minutes: 60
+    name: "publish tarball"
+  - command: "ci/publish-docs.sh"
+    timeout_in_minutes: 15
+    name: "publish docs"

ci/buildkite-tests.yml

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

ci/buildkite.yml

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

ci/dependabot-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

@@ -49,7 +49,7 @@ else
   # ~/.cargo
   ARGS+=(--volume "$PWD:/home")
 fi
-ARGS+=(--env "HOME=/home" --env "CARGO_HOME=/home/.cargo")
+ARGS+=(--env "CARGO_HOME=/home/.cargo")
 
 # kcov tries to set the personality of the binary which docker
 # doesn't allow by default.
@@ -60,12 +60,6 @@ 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
@@ -73,7 +67,6 @@ ARGS+=(
   --env BUILDKITE_JOB_ID
   --env CI
   --env CI_BRANCH
-  --env CI_BASE_BRANCH
   --env CI_TAG
   --env CI_BUILD_ID
   --env CI_COMMIT

ci/docker-rust-nightly/Dockerfile

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

ci/docker-rust-nightly/README.md

@@ -2,27 +2,23 @@ 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-coverage.sh`
    to confirm the new nightly image builds.  Fix any issues as needed
 1. Run `docker login` to enable pushing images to Docker Hub, if you're authorized.
 1. Run `CI=true ci/docker-rust-nightly/build.sh YYYY-MM-DD` to push the new nightly image to dockerhub.com.

ci/docker-rust/Dockerfile

@@ -1,6 +1,6 @@
 # Note: when the rust version is changed also modify
 # ci/rust-version.sh to pick up the new image tag
-FROM rust:1.45.1
+FROM rust:1.42.0
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0
@@ -32,7 +32,6 @@ RUN set -x \
  && cargo install cargo-audit \
  && cargo install svgbob_cli \
  && cargo install mdbook \
- && cargo install mdbook-linkcheck \
  && rustc --version \
  && cargo --version \
  && curl -OL https://github.com/google/protobuf/releases/download/v$PROTOC_VERSION/$PROTOC_ZIP \

ci/docker-rust/README.md

@@ -1,11 +1,7 @@
 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
+2. Run `./build.sh` to publish the new image, if you are a member of the [Solana
    Labs](https://hub.docker.com/u/solanalabs/) Docker Hub organization.
 

ci/env.sh

@@ -8,11 +8,10 @@ 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
+    if $TRAVIS_PULL_REQUEST; then
       export CI_PULL_REQUEST=true
     else
       export CI_PULL_REQUEST=
@@ -29,10 +28,8 @@ if [[ -n $CI ]]; then
     # to how solana-ci-gate is used to trigger PR builds rather than using the
     # standard Buildkite PR trigger.
     if [[ $CI_BRANCH =~ pull/* ]]; then
-      export CI_BASE_BRANCH=$BUILDKITE_PULL_REQUEST_BASE_BRANCH
       export CI_PULL_REQUEST=true
     else
-      export CI_BASE_BRANCH=$BUILDKITE_BRANCH
       export CI_PULL_REQUEST=
     fi
     export CI_OS_NAME=linux

ci/iterations-localnet.sh

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

ci/localnet-sanity.sh

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

ci/maybe-trigger-tests.sh

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

ci/publish-docs.sh

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

ci/publish-tarball.sh

@@ -45,16 +45,7 @@ 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
-  )
+  TARGET=x86_64-pc-windows-gnu
   ;;
 *)
   echo CI_OS_NAME unset
@@ -62,14 +53,11 @@ windows)
   ;;
 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}"/
+  rm -rf solana-release/
+  mkdir solana-release/
 
   COMMIT="$(git rev-parse HEAD)"
 
@@ -77,18 +65,18 @@ echo --- Creating release tarball
     echo "channel: $CHANNEL_OR_TAG"
     echo "commit: $COMMIT"
     echo "target: $TARGET"
-  ) > "${RELEASE_BASENAME}"/version.yml
+  ) > solana-release/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}"
+  scripts/cargo-install-all.sh +"$rust_stable" --use-move solana-release
 
-  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
+  tar cvf solana-release-$TARGET.tar solana-release
+  bzip2 solana-release-$TARGET.tar
+  cp solana-release/bin/solana-install-init solana-install-init-$TARGET
+  cp solana-release/version.yml solana-release-$TARGET.yml
 )
 
 # Metrics tarball is platform agnostic, only publish it from Linux
@@ -106,9 +94,10 @@ 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
+for file in solana-release-$TARGET.tar.bz2 solana-release-$TARGET.yml solana-install-init-"$TARGET"* $MAYBE_TARBALLS; do
+  upload-ci-artifact "$file"
+
   if [[ -n $DO_NOT_PUBLISH_TAR ]]; then
-    upload-ci-artifact "$file"
     echo "Skipped $file due to DO_NOT_PUBLISH_TAR"
     continue
   fi

ci/run-sanity.sh

@@ -2,12 +2,10 @@
 set -e
 
 cd "$(dirname "$0")/.."
-# shellcheck source=multinode-demo/common.sh
-source multinode-demo/common.sh
 
-rm -rf config/run/init-completed config/ledger config/snapshot-ledger
+rm -f config/run/init-completed
 
-timeout 120 ./run.sh &
+timeout 15 ./run.sh &
 pid=$!
 
 attempts=20
@@ -19,16 +17,6 @@ while [[ ! -f config/run/init-completed ]]; do
   fi
 done
 
-snapshot_slot=1
-
-# wait a bit longer than snapshot_slot
-while [[ $($solana_cli --url http://localhost:8899 slot --commitment recent) -le $((snapshot_slot + 1)) ]]; do
-  sleep 1
-done
 curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1, "method":"validatorExit"}' http://localhost:8899
 
 wait $pid
-
-$solana_ledger_tool create-snapshot --ledger config/ledger "$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,30 +1,28 @@
 #
 # This file maintains the rust versions for use by CI.
 #
+# Build with stable rust, updating the stable toolchain if necessary:
+#   $ source ci/rust-version.sh stable
+#   $ cargo +"$rust_stable" build
+#
+# Build with nightly rust, updating the nightly toolchain if necessary:
+#   $ source ci/rust-version.sh nightly
+#   $ cargo +"$rust_nightly" build
+#
 # Obtain the environment variables without any automatic toolchain updating:
 #   $ source ci/rust-version.sh
 #
-# Obtain the environment variables updating both stable and nightly, only stable, or
-# only nightly:
-#   $ source ci/rust-version.sh all
-#   $ source ci/rust-version.sh stable
-#   $ source ci/rust-version.sh nightly
-
-# Then to build with either stable or nightly:
-#   $ cargo +"$rust_stable" build
-#   $ cargo +"$rust_nightly" build
-#
 
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.45.1
+  stable_version=1.42.0
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2020-07-27
+  nightly_version=2020-03-12
 fi
 
 
@@ -38,8 +36,7 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
 
   rustup_install() {
     declare toolchain=$1
-    if ! cargo +"$toolchain" -V > /dev/null; then
-      echo "$0: Missing toolchain? Installing...: $toolchain" >&2
+    if ! cargo +"$toolchain" -V; then
       rustup install "$toolchain"
       cargo +"$toolchain" -V
     fi
@@ -54,12 +51,8 @@ export rust_nightly_docker_image=solanalabs/rust-nightly:"$nightly_version"
   nightly)
      rustup_install "$rust_nightly"
     ;;
-  all)
-     rustup_install "$rust_stable"
-     rustup_install "$rust_nightly"
-    ;;
   *)
-    echo "$0: Note: ignoring unknown argument: $1" >&2
+    echo "Note: ignoring unknown argument: $1"
     ;;
   esac
 )

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

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

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

@@ -1,84 +0,0 @@
-#!/usr/bin/env bash
-
-HERE="$(dirname "$0")"
-
-# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
-source "$HERE"/utils.sh
-
-ensure_env || exit 1
-
-set -e
-
-# Install buildkite-agent
-echo "deb https://apt.buildkite.com/buildkite-agent stable main" | tee /etc/apt/sources.list.d/buildkite-agent.list
-apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 32A37959C2FA5C3C99EFBC32A79206696452D198
-apt-get update
-apt-get install -y buildkite-agent
-
-
-# Configure the installation
-echo "Go to https://buildkite.com/organizations/solana-labs/agents"
-echo "Click Reveal Agent Token"
-echo "Paste the Agent Token, then press Enter:"
-
-read -r agent_token
-sudo sed -i "s/xxx/$agent_token/g" /etc/buildkite-agent/buildkite-agent.cfg
-
-cat > /etc/buildkite-agent/hooks/environment <<EOF
-set -e
-
-export BUILDKITE_GIT_CLEAN_FLAGS="-ffdqx"
-
-# Hack for non-docker rust builds
-export PATH='$PATH':~buildkite-agent/.cargo/bin
-
-# Add path to snaps
-source /etc/profile.d/apps-bin-path.sh
-
-if [[ '$BUILDKITE_BRANCH' =~ pull/* ]]; then
-  export BUILDKITE_REFSPEC="+'$BUILDKITE_BRANCH':refs/remotes/origin/'$BUILDKITE_BRANCH'"
-fi
-EOF
-
-chown buildkite-agent:buildkite-agent /etc/buildkite-agent/hooks/environment
-
-# Create SSH key
-sudo -u buildkite-agent mkdir -p ~buildkite-agent/.ssh
-sudo -u buildkite-agent ssh-keygen -t ecdsa -q -N "" -f ~buildkite-agent/.ssh/id_ecdsa
-
-# Set buildkite-agent user's shell
-sudo usermod --shell /bin/bash buildkite-agent
-
-# Install Rust for buildkite-agent
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o /tmp/rustup-init.sh
-sudo -u buildkite-agent HOME=~buildkite-agent sh /tmp/rustup-init.sh -y
-
-# Add to docker and sudoers group
-addgroup buildkite-agent docker
-addgroup buildkite-agent sudo
-
-# Edit the systemd unit file to include LimitNOFILE
-cat > /lib/systemd/system/buildkite-agent.service <<EOF
-[Unit]
-Description=Buildkite Agent
-Documentation=https://buildkite.com/agent
-After=syslog.target
-After=network.target
-
-[Service]
-Type=simple
-User=buildkite-agent
-Environment=HOME=/var/lib/buildkite-agent
-ExecStart=/usr/bin/buildkite-agent start
-RestartSec=5
-Restart=on-failure
-RestartForceExitStatus=SIGPIPE
-TimeoutStartSec=10
-TimeoutStopSec=0
-KillMode=process
-LimitNOFILE=65536
-
-[Install]
-WantedBy=multi-user.target
-DefaultInstance=1
-EOF

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

@@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-
-HERE="$(dirname "$0")"
-SOLANA_ROOT="$HERE"/../..
-
-# shellcheck source=ci/setup-new-buildkite-agent/utils.sh
-source "$HERE"/utils.sh
-
-ensure_env || exit 1
-
-set -ex
-
-apt update
-apt upgrade -y
-
-cat >/etc/apt/apt.conf.d/99-solana <<'EOF'
-// Set and persist extra caps on iftop binary
-Dpkg::Post-Invoke { "which iftop 2>&1 >/dev/null && setcap cap_net_raw=eip $(which iftop) || true"; };
-EOF
-
-apt install -y build-essential pkg-config clang cmake sysstat linux-tools-common \
-  linux-generic-hwe-18.04-edge linux-tools-generic-hwe-18.04-edge \
-  iftop heaptrack jq ruby python3-venv gcc-multilib libudev-dev
-
-gem install ejson ejson2env
-mkdir -p /opt/ejson/keys
-
-"$SOLANA_ROOT"/net/scripts/install-docker.sh
-usermod -aG docker "$SETUP_USER"
-"$SOLANA_ROOT"/net/scripts/install-certbot.sh
-"$HERE"/setup-sudoers.sh
-"$HERE"/setup-ssh.sh
-
-"$HERE"/disable-nouveau.sh
-"$HERE"/disable-networkd-wait.sh
-
-"$SOLANA_ROOT"/net/scripts/install-earlyoom.sh
-"$SOLANA_ROOT"/net/scripts/install-nodejs.sh
-"$SOLANA_ROOT"/net/scripts/localtime.sh
-"$SOLANA_ROOT"/net/scripts/install-redis.sh
-"$SOLANA_ROOT"/net/scripts/install-rsync.sh
-"$SOLANA_ROOT"/net/scripts/install-libssl-compatability.sh
-
-"$HERE"/setup-procfs-knobs.sh
-"$HERE"/setup-limits.sh
-
-[[ -n $CUDA ]] && "$HERE"/setup-cuda.sh
-
-exit 0

ci/test-bench.sh

@@ -2,11 +2,30 @@
 set -e
 cd "$(dirname "$0")/.."
 
+annotate() {
+  ${BUILDKITE:-false} && {
+    buildkite-agent annotate "$@"
+  }
+}
+
+ci/affects-files.sh \
+  .rs$ \
+  Cargo.lock$ \
+  Cargo.toml$ \
+  ^ci/rust-version.sh \
+  ^ci/test-bench.sh \
+|| {
+  annotate --style info --context test-bench \
+    "Bench skipped as no .rs files were modified"
+  exit 0
+}
+
+
 source ci/_
 source ci/upload-ci-artifact.sh
 
 eval "$(ci/channel-info.sh)"
-source ci/rust-version.sh all
+source ci/rust-version.sh nightly
 
 set -o pipefail
 export RUST_BACKTRACE=1
@@ -48,9 +67,8 @@ _ cargo +$rust_nightly bench --manifest-path core/Cargo.toml ${V:+--verbose} \
 _ cargo +$rust_nightly bench --manifest-path programs/bpf/Cargo.toml ${V:+--verbose} --features=bpf_c \
   -- -Z unstable-options --format=json --nocapture | tee -a "$BENCH_FILE"
 
-# Run banking/accounts bench. Doesn't require nightly, but use since it is already built.
+# Run banking bench. Doesn't require nightly, but use since it is already built.
 _ cargo +$rust_nightly run --release --manifest-path banking-bench/Cargo.toml ${V:+--verbose} | tee -a "$BENCH_FILE"
-_ cargo +$rust_nightly run --release --manifest-path accounts-bench/Cargo.toml ${V:+--verbose} -- --num_accounts 10000 --num_slots 4 | tee -a "$BENCH_FILE"
 
 # `solana-upload-perf` disabled as it can take over 30 minutes to complete for some
 # reason

ci/test-checks.sh

@@ -1,5 +1,4 @@
 #!/usr/bin/env bash
-
 set -e
 
 cd "$(dirname "$0")/.."
@@ -7,55 +6,27 @@ cd "$(dirname "$0")/.."
 source ci/_
 source ci/rust-version.sh stable
 source ci/rust-version.sh nightly
-eval "$(ci/channel-info.sh)"
-
-echo --- build environment
-(
-  set -x
-
-  rustup run "$rust_stable" rustc --version --verbose
-  rustup run "$rust_nightly" rustc --version --verbose
-
-  cargo +"$rust_stable" --version --verbose
-  cargo +"$rust_nightly" --version --verbose
-
-  cargo +"$rust_stable" clippy --version --verbose
-  cargo +"$rust_nightly" clippy --version --verbose
-
-  # audit is done only with stable
-  cargo +"$rust_stable" audit --version
-)
 
 export RUST_BACKTRACE=1
-export RUSTFLAGS="-D warnings -A incomplete_features"
+export RUSTFLAGS="-D warnings"
 
-# Only force up-to-date lock files on edge
-if [[ $CI_BASE_BRANCH = "$EDGE_CHANNEL" ]]; then
-  # Exclude --benches as it's not available in rust stable yet
-  if _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" check --locked --tests --bins --examples; then
-    true
-  else
-    check_status=$?
-    echo "$0: Some Cargo.lock might be outdated; sync them (or just be a compilation error?)" >&2
-    echo "$0: protip: $ ./scripts/cargo-for-all-lock-files.sh [--ignore-exit-code] ... \\" >&2
-    echo "$0:   [tree (for outdated Cargo.lock sync)|check (for compilation error)|update -p foo --precise x.y.z (for your Cargo.toml update)] ..." >&2
-    exit "$check_status"
-  fi
-else
-  echo "Note: cargo-for-all-lock-files.sh skipped because $CI_BASE_BRANCH != $EDGE_CHANNEL"
-fi
+# Look for failed mergify.io backports
+_ git show HEAD --check --oneline
 
-# Ensure nightly and --benches
-_ scripts/cargo-for-all-lock-files.sh +"$rust_nightly" check --locked --all-targets
-
-_ ci/order-crates-for-publishing.py
 _ cargo +"$rust_stable" fmt --all -- --check
 
-# -Z... is needed because of clippy bug: https://github.com/rust-lang/rust-clippy/issues/4612
-# run nightly clippy for `sdk/` as there's a moderate amount of nightly-only code there
-_ cargo +"$rust_nightly" clippy -Zunstable-options --workspace --all-targets -- --deny=warnings
+# Clippy gets stuck for unknown reasons if sdk-c is included in the build, so check it separately.
+# See https://github.com/solana-labs/solana/issues/5503
+_ cargo +"$rust_stable" clippy --version
+_ cargo +"$rust_stable" clippy --all --exclude solana-sdk-c -- --deny=warnings
+_ cargo +"$rust_stable" clippy --manifest-path sdk-c/Cargo.toml -- --deny=warnings
 
-_ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008
+_ cargo +"$rust_stable" audit --version
+_ cargo +"$rust_stable" audit --ignore RUSTSEC-2020-0002 --ignore RUSTSEC-2020-0008
+_ ci/nits.sh
+_ ci/order-crates-for-publishing.py
+_ docs/build.sh
+_ ci/check-ssh-keys.sh
 
 {
   cd programs/bpf
@@ -66,6 +37,7 @@ _ scripts/cargo-for-all-lock-files.sh +"$rust_stable" audit --ignore RUSTSEC-202
       cd "$project"
       _ cargo +"$rust_stable" fmt -- --check
       _ cargo +"$rust_nightly" test
+      _ cargo +"$rust_nightly" clippy --version
       _ cargo +"$rust_nightly" clippy -- --deny=warnings --allow=clippy::missing_safety_doc
     )
   done

ci/test-coverage.sh

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

ci/test-move.sh

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

ci/test-sanity.sh

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

ci/test-stable.sh

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

ci/testnet-deploy.sh

@@ -0,0 +1,429 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"/..
+source ci/upload-ci-artifact.sh
+
+zone=
+bootstrapValidatorAddress=
+bootstrapValidatorMachineType=
+clientNodeCount=0
+idleClients=false
+additionalValidatorCount=10
+publicNetwork=false
+stopNetwork=false
+reuseLedger=false
+skipCreate=false
+skipStart=false
+externalNode=false
+failOnValidatorBootupFailure=true
+tarChannelOrTag=edge
+delete=false
+enableGpu=false
+bootDiskType=""
+blockstreamer=false
+fetchLogs=true
+maybeHashesPerTick=
+maybeDisableAirdrops=
+maybeInternalNodesStakeLamports=
+maybeInternalNodesLamports=
+maybeExternalPrimordialAccountsFile=
+maybeSlotsPerEpoch=
+maybeTargetLamportsPerSignature=
+maybeSlotsPerEpoch=
+maybeLetsEncrypt=
+maybeValidatorAdditionalDiskSize=
+maybeNoSnapshot=
+maybeLimitLedgerSize=
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 -p network-name -C cloud -z zone1 [-z zone2] ... [-z zoneN] [options...]
+
+Deploys a CD testnet
+
+  mandatory arguments:
+  -p [network-name]  - name of the network
+  -C [cloud] - cloud provider to use (gce, ec2)
+  -z [zone]  - cloud provider zone to deploy the network into.  Must specify at least one zone
+
+  options:
+   -t edge|beta|stable|vX.Y.Z  - Deploy the latest tarball release for the
+                                 specified release channel (edge|beta|stable) or release tag
+                                 (vX.Y.Z)
+                                 (default: $tarChannelOrTag)
+   -n [number]          - Number of additional validators (default: $additionalValidatorCount)
+   -c [number]          - Number of client bencher nodes (default: $clientNodeCount)
+   -u                   - Include a Blockstreamer (default: $blockstreamer)
+   -P                   - Use public network IP addresses (default: $publicNetwork)
+   -G                   - Enable GPU, and set count/type of GPUs to use (e.g n1-standard-16 --accelerator count=2,type=nvidia-tesla-v100)
+   -g                   - Enable GPU (default: $enableGpu)
+   -a [address]         - Set the bootstrap validator's external IP address to this GCE address
+   -d [disk-type]       - Specify a boot disk type (default None) Use pd-ssd to get ssd on GCE.
+   -D                   - Delete the network
+   -r                   - Reuse existing node/ledger configuration from a
+                          previous |start| (ie, don't run ./multinode-demo/setup.sh).
+   -x                   - External node.  Default: false
+   -e                   - Skip create.  Assume the nodes have already been created
+   -s                   - Skip start.  Nodes will still be created or configured, but network software will not be started.
+   -S                   - Stop network software without tearing down nodes.
+   -f                   - Discard validator nodes that didn't bootup successfully
+   --no-airdrop
+                        - If set, disables airdrops.  Nodes must be funded in genesis config when airdrops are disabled.
+   --internal-nodes-stake-lamports NUM_LAMPORTS
+                        - Amount to stake internal nodes.
+   --internal-nodes-lamports NUM_LAMPORTS
+                        - Amount to fund internal nodes in genesis config
+   --external-accounts-file FILE_PATH
+                        - Path to external Primordial Accounts file, if it exists.
+   --hashes-per-tick NUM_HASHES|sleep|auto
+                        - Override the default --hashes-per-tick for the cluster
+   --lamports NUM_LAMPORTS
+                        - Specify the number of lamports to mint (default 500000000000000000)
+   --skip-deploy-update
+                        - If set, will skip software update deployment
+   --skip-remote-log-retrieval
+                        - If set, will not fetch logs from remote nodes
+   --letsencrypt [dns name]
+                        - Attempt to generate a TLS certificate using this DNS name
+   --validator-additional-disk-size-gb [number]
+                        - Size of additional disk in GB for all validators
+   --no-snapshot-fetch
+                        - If set, disables booting validators from a snapshot
+
+   Note: the SOLANA_METRICS_CONFIG environment variable is used to configure
+         metrics
+EOF
+  exit $exitcode
+}
+
+zone=()
+
+shortArgs=()
+while [[ -n $1 ]]; do
+  if [[ ${1:0:2} = -- ]]; then
+    if [[ $1 = --hashes-per-tick ]]; then
+      maybeHashesPerTick="$1 $2"
+      shift 2
+    elif [[ $1 = --slots-per-epoch ]]; then
+      maybeSlotsPerEpoch="$1 $2"
+      shift 2
+    elif [[ $1 = --target-lamports-per-signature ]]; then
+      maybeTargetLamportsPerSignature="$1 $2"
+      shift 2
+    elif [[ $1 = --no-airdrop ]]; then
+      maybeDisableAirdrops=$1
+      shift 1
+    elif [[ $1 = --internal-nodes-stake-lamports ]]; then
+      maybeInternalNodesStakeLamports="$1 $2"
+      shift 2
+    elif [[ $1 = --internal-nodes-lamports ]]; then
+      maybeInternalNodesLamports="$1 $2"
+      shift 2
+    elif [[ $1 = --external-accounts-file ]]; then
+      maybeExternalPrimordialAccountsFile="$1 $2"
+      shift 2
+    elif [[ $1 = --skip-remote-log-retrieval ]]; then
+      fetchLogs=false
+      shift 1
+    elif [[ $1 = --letsencrypt ]]; then
+      maybeLetsEncrypt="$1 $2"
+      shift 2
+    elif [[ $1 = --validator-additional-disk-size-gb ]]; then
+      maybeValidatorAdditionalDiskSize="$1 $2"
+      shift 2
+    elif [[ $1 == --machine-type* ]]; then # Bypass quoted long args for GPUs
+      shortArgs+=("$1")
+      shift
+    elif [[ $1 = --no-snapshot-fetch ]]; then
+      maybeNoSnapshot=$1
+      shift 1
+    elif [[ $1 = --limit-ledger-size ]]; then
+      maybeLimitLedgerSize=$1
+      shift 1
+    elif [[ $1 = --idle-clients ]]; then
+      idleClients=true
+      shift 1
+    else
+      usage "Unknown long option: $1"
+    fi
+  else
+    shortArgs+=("$1")
+    shift
+  fi
+done
+
+while getopts "h?p:Pn:c:t:gG:a:Dd:rusxz:p:C:Sfe" opt "${shortArgs[@]}"; do
+  case $opt in
+  h | \?)
+    usage
+    ;;
+  p)
+    netName=$OPTARG
+    ;;
+  C)
+    cloudProvider=$OPTARG
+    ;;
+  z)
+    zone+=("$OPTARG")
+    ;;
+  P)
+    publicNetwork=true
+    ;;
+  n)
+    additionalValidatorCount=$OPTARG
+    ;;
+  c)
+    clientNodeCount=$OPTARG
+    ;;
+  t)
+    case $OPTARG in
+    edge|beta|stable|v*)
+      tarChannelOrTag=$OPTARG
+      ;;
+    *)
+      usage "Invalid release channel: $OPTARG"
+      ;;
+    esac
+    ;;
+  g)
+    enableGpu=true
+    ;;
+  G)
+    enableGpu=true
+    bootstrapValidatorMachineType=$OPTARG
+    ;;
+  a)
+    bootstrapValidatorAddress=$OPTARG
+    ;;
+  d)
+    bootDiskType=$OPTARG
+    ;;
+  D)
+    delete=true
+    ;;
+  r)
+    reuseLedger=true
+    ;;
+  e)
+    skipCreate=true
+    ;;
+  s)
+    skipStart=true
+    ;;
+  x)
+    externalNode=true
+    ;;
+  f)
+    failOnValidatorBootupFailure=false
+    ;;
+  u)
+    blockstreamer=true
+    ;;
+  S)
+    stopNetwork=true
+    ;;
+  *)
+    usage "Unknown option: $opt"
+    ;;
+  esac
+done
+
+[[ -n $netName ]] || usage
+[[ -n $cloudProvider ]] || usage "Cloud provider not specified"
+[[ -n ${zone[*]} ]] || usage "At least one zone must be specified"
+
+shutdown() {
+  exitcode=$?
+
+  set +e
+  if [[ -d net/log ]]; then
+    mv net/log net/log-deploy
+    for logfile in net/log-deploy/*; do
+      if [[ -f $logfile ]]; then
+        upload-ci-artifact "$logfile"
+        tail "$logfile"
+      fi
+    done
+  fi
+  exit $exitcode
+}
+rm -rf net/{log,-deploy}
+trap shutdown EXIT INT
+
+set -x
+
+# Fetch reusable testnet keypairs
+if [[ ! -d net/keypairs ]]; then
+  git clone git@github.com:solana-labs/testnet-keypairs.git net/keypairs
+fi
+
+# Build a string to pass zone opts to $cloudProvider.sh: "-z zone1 -z zone2 ..."
+zone_args=()
+for val in "${zone[@]}"; do
+  zone_args+=("-z $val")
+done
+
+if $stopNetwork; then
+  skipCreate=true
+fi
+
+if $delete; then
+  skipCreate=false
+fi
+
+# Create the network
+if ! $skipCreate; then
+  echo "--- $cloudProvider.sh delete"
+  # shellcheck disable=SC2068
+  time net/"$cloudProvider".sh delete ${zone_args[@]} -p "$netName" ${externalNode:+-x}
+  if $delete; then
+    exit 0
+  fi
+
+  echo "--- $cloudProvider.sh create"
+  create_args=(
+    -p "$netName"
+    -c "$clientNodeCount"
+    -n "$additionalValidatorCount"
+    --dedicated
+    --self-destruct-hours 0
+  )
+
+  if [[ -n $bootstrapValidatorAddress ]]; then
+    create_args+=(-a "$bootstrapValidatorAddress")
+  fi
+
+  # shellcheck disable=SC2206
+  create_args+=(${zone_args[@]})
+
+  if [[ -n $maybeLetsEncrypt ]]; then
+    # shellcheck disable=SC2206 # Do not want to quote $maybeLetsEncrypt
+    create_args+=($maybeLetsEncrypt)
+  fi
+
+  if $blockstreamer; then
+    create_args+=(-u)
+  fi
+
+  if [[ -n $bootDiskType ]]; then
+    create_args+=(-d "$bootDiskType")
+  fi
+
+  if $enableGpu; then
+    if [[ -z $bootstrapValidatorMachineType ]]; then
+      create_args+=(-g)
+    else
+      create_args+=(-G "$bootstrapValidatorMachineType")
+    fi
+  fi
+
+  if $publicNetwork; then
+    create_args+=(-P)
+  fi
+
+  if $externalNode; then
+    create_args+=(-x)
+  fi
+
+  if ! $failOnValidatorBootupFailure; then
+    create_args+=(-f)
+  fi
+
+  if [[ -n $maybeValidatorAdditionalDiskSize ]]; then
+    # shellcheck disable=SC2206 # Do not want to quote
+    create_args+=($maybeValidatorAdditionalDiskSize)
+  fi
+
+  time net/"$cloudProvider".sh create "${create_args[@]}"
+else
+  echo "--- $cloudProvider.sh config"
+  config_args=(
+    -p "$netName"
+  )
+  # shellcheck disable=SC2206
+  config_args+=(${zone_args[@]})
+  if $publicNetwork; then
+    config_args+=(-P)
+  fi
+
+  if $externalNode; then
+    config_args+=(-x)
+  fi
+
+  if ! $failOnValidatorBootupFailure; then
+    config_args+=(-f)
+  fi
+
+  time net/"$cloudProvider".sh config "${config_args[@]}"
+fi
+net/init-metrics.sh -e
+
+echo "+++ $cloudProvider.sh info"
+net/"$cloudProvider".sh info
+
+if $stopNetwork; then
+  echo --- net.sh stop
+  time net/net.sh stop
+  exit 0
+fi
+
+ok=true
+if ! $skipStart; then
+  (
+    if $skipCreate; then
+      op=restart
+    else
+      op=start
+    fi
+    echo "--- net.sh $op"
+    args=(
+      "$op"
+      -t "$tarChannelOrTag"
+    )
+
+    if ! $publicNetwork; then
+      args+=(-o rejectExtraNodes)
+    fi
+    if [[ -n $NO_INSTALL_CHECK ]]; then
+      args+=(-o noInstallCheck)
+    fi
+    if $reuseLedger; then
+      args+=(-r)
+    fi
+
+    if ! $failOnValidatorBootupFailure; then
+      args+=(-F)
+    fi
+
+    # shellcheck disable=SC2206 # Do not want to quote
+    args+=(
+      $maybeHashesPerTick
+      $maybeDisableAirdrops
+      $maybeInternalNodesStakeLamports
+      $maybeInternalNodesLamports
+      $maybeExternalPrimordialAccountsFile
+      $maybeSlotsPerEpoch
+      $maybeTargetLamportsPerSignature
+      $maybeNoSnapshot
+      $maybeLimitLedgerSize
+    )
+
+    if $idleClients; then
+      args+=(-c "idle=$clientNodeCount=")
+    fi
+
+    time net/net.sh "${args[@]}"
+  ) || ok=false
+
+  if $fetchLogs; then
+    net/net.sh logs
+  fi
+fi
+
+$ok

ci/testnet-manager.sh

@@ -0,0 +1,401 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"/..
+
+if [[ -z $BUILDKITE ]]; then
+  echo BUILDKITE not defined
+  exit 1
+fi
+
+if [[ -z $SOLANA_METRICS_PARTIAL_CONFIG ]]; then
+  echo SOLANA_METRICS_PARTIAL_CONFIG not defined
+  exit 1
+fi
+
+if [[ -z $TESTNET ]]; then
+  TESTNET=$(buildkite-agent meta-data get "testnet" --default "")
+fi
+
+if [[ -z $TESTNET_OP ]]; then
+  TESTNET_OP=$(buildkite-agent meta-data get "testnet-operation" --default "")
+fi
+
+if [[ -z $TESTNET || -z $TESTNET_OP ]]; then
+  (
+    cat <<EOF
+steps:
+  - block: "Manage Testnet"
+    fields:
+      - select: "Network"
+        key: "testnet"
+        options:
+          - label: "testnet"
+            value: "testnet"
+          - label: "testnet-edge"
+            value: "testnet-edge"
+          - label: "testnet-beta"
+            value: "testnet-beta"
+      - select: "Operation"
+        key: "testnet-operation"
+        default: "sanity-or-restart"
+        options:
+          - label: "Create testnet and then start software.  If the testnet already exists it will be deleted and re-created"
+            value: "create-and-start"
+          - label: "Create testnet, but do not start software.  If the testnet already exists it will be deleted and re-created"
+            value: "create"
+          - label: "Start network software on an existing testnet.  If software is already running it will be restarted"
+            value: "start"
+          - label: "Stop network software without deleting testnet nodes"
+            value: "stop"
+          - label: "Update the network software.  Restart network software on failure"
+            value: "update-or-restart"
+          - label: "Sanity check.  Restart network software on failure"
+            value: "sanity-or-restart"
+          - label: "Sanity check only"
+            value: "sanity"
+          - label: "Delete the testnet"
+            value: "delete"
+          - label: "Enable/unlock the testnet"
+            value: "enable"
+          - label: "Delete and then lock the testnet from further operation until it is re-enabled"
+            value: "disable"
+  - command: "ci/$(basename "$0")"
+    agents:
+      - "queue=$BUILDKITE_AGENT_META_DATA_QUEUE"
+EOF
+  ) | buildkite-agent pipeline upload
+  exit 0
+fi
+
+ci/channel-info.sh
+eval "$(ci/channel-info.sh)"
+
+
+EC2_ZONES=(
+  us-west-1a
+  us-west-2a
+  us-east-1a
+  us-east-2a
+  sa-east-1a
+  eu-west-1a
+  eu-west-2a
+  eu-central-1a
+  ap-northeast-2a
+  ap-southeast-2a
+  ap-south-1a
+  ca-central-1a
+)
+
+# GCE zones with _lots_ of quota
+GCE_ZONES=(
+  us-west1-a
+  us-central1-a
+  us-east1-b
+  europe-west4-a
+
+  us-west1-b
+  us-central1-b
+  us-east1-c
+  europe-west4-b
+
+  us-west1-c
+  us-east1-d
+  europe-west4-c
+)
+
+# GCE zones with enough quota for one CPU-only validator
+GCE_LOW_QUOTA_ZONES=(
+  asia-east2-a
+  asia-northeast1-b
+  asia-northeast2-b
+  asia-south1-c
+  asia-southeast1-b
+  australia-southeast1-b
+  europe-north1-a
+  europe-west2-b
+  europe-west3-c
+  europe-west6-a
+  northamerica-northeast1-a
+  southamerica-east1-b
+)
+
+case $TESTNET in
+testnet-edge)
+  CHANNEL_OR_TAG=edge
+  CHANNEL_BRANCH=$EDGE_CHANNEL
+  ;;
+testnet-beta)
+  CHANNEL_OR_TAG=beta
+  CHANNEL_BRANCH=$BETA_CHANNEL
+  ;;
+testnet)
+  CHANNEL_OR_TAG=$STABLE_CHANNEL_LATEST_TAG
+  CHANNEL_BRANCH=$STABLE_CHANNEL
+  export CLOUDSDK_CORE_PROJECT=testnet-solana-com
+  ;;
+*)
+  echo "Error: Invalid TESTNET=$TESTNET"
+  exit 1
+  ;;
+esac
+
+EC2_ZONE_ARGS=()
+for val in "${EC2_ZONES[@]}"; do
+  EC2_ZONE_ARGS+=("-z $val")
+done
+GCE_ZONE_ARGS=()
+for val in "${GCE_ZONES[@]}"; do
+  GCE_ZONE_ARGS+=("-z $val")
+done
+GCE_LOW_QUOTA_ZONE_ARGS=()
+for val in "${GCE_LOW_QUOTA_ZONES[@]}"; do
+  GCE_LOW_QUOTA_ZONE_ARGS+=("-z $val")
+done
+
+if [[ -z $TESTNET_DB_HOST ]]; then
+  TESTNET_DB_HOST="https://metrics.solana.com:8086"
+fi
+
+export SOLANA_METRICS_CONFIG="db=$TESTNET,host=$TESTNET_DB_HOST,$SOLANA_METRICS_PARTIAL_CONFIG"
+echo "SOLANA_METRICS_CONFIG: $SOLANA_METRICS_CONFIG"
+source scripts/configure-metrics.sh
+
+if [[ -n $TESTNET_TAG ]]; then
+  CHANNEL_OR_TAG=$TESTNET_TAG
+else
+
+  if [[ $CI_BRANCH != "$CHANNEL_BRANCH" ]]; then
+    (
+      cat <<EOF
+steps:
+  - trigger: "$BUILDKITE_PIPELINE_SLUG"
+    async: true
+    build:
+      message: "$BUILDKITE_MESSAGE"
+      branch: "$CHANNEL_BRANCH"
+      env:
+        TESTNET: "$TESTNET"
+        TESTNET_OP: "$TESTNET_OP"
+        TESTNET_DB_HOST: "$TESTNET_DB_HOST"
+        GCE_NODE_COUNT: "$GCE_NODE_COUNT"
+        GCE_LOW_QUOTA_NODE_COUNT: "$GCE_LOW_QUOTA_NODE_COUNT"
+        RUST_LOG: "$RUST_LOG"
+EOF
+    ) | buildkite-agent pipeline upload
+    exit 0
+  fi
+fi
+
+maybe_deploy_software() {
+  declare arg=$1
+  declare ok=true
+  (
+    echo "--- net.sh restart"
+    set -x
+    time net/net.sh restart --skip-setup -t "$CHANNEL_OR_TAG" --skip-poh-verify "$arg"
+  ) || ok=false
+  if ! $ok; then
+    net/net.sh logs
+  fi
+  $ok
+}
+
+sanity() {
+  echo "--- sanity $TESTNET"
+  case $TESTNET in
+  testnet-edge)
+    (
+      set -x
+      NO_INSTALL_CHECK=1 \
+        ci/testnet-sanity.sh edge-devnet-solana-com gce -P us-west1-b
+      maybe_deploy_software
+    )
+    ;;
+  testnet-beta)
+    (
+      set -x
+      NO_INSTALL_CHECK=1 \
+        ci/testnet-sanity.sh beta-devnet-solana-com gce -P us-west1-b
+      maybe_deploy_software --deploy-if-newer
+    )
+    ;;
+  testnet)
+    (
+      set -x
+      ci/testnet-sanity.sh devnet-solana-com gce -P us-west1-b
+    )
+    ;;
+  *)
+    echo "Error: Invalid TESTNET=$TESTNET"
+    exit 1
+    ;;
+  esac
+}
+
+deploy() {
+  declare maybeCreate=$1
+  declare maybeStart=$2
+  declare maybeStop=$3
+  declare maybeDelete=$4
+
+  echo "--- deploy \"$maybeCreate\" \"$maybeStart\" \"$maybeStop\" \"$maybeDelete\""
+
+  # Create or recreate the nodes
+  if [[ -z $maybeCreate ]]; then
+    skipCreate=skip
+  else
+    skipCreate=""
+  fi
+
+  # Start or restart the network software on the nodes
+  if [[ -z $maybeStart ]]; then
+    skipStart=skip
+  else
+    skipStart=""
+  fi
+
+  case $TESTNET in
+  testnet-edge)
+    (
+      set -x
+      ci/testnet-deploy.sh -p edge-devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 3 -c 0 -u -P \
+        -a edge-devnet-solana-com --letsencrypt edge.devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    ;;
+  testnet-beta)
+    (
+      set -x
+      ci/testnet-deploy.sh -p beta-devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 3 -c 0 -u -P \
+        -a beta-devnet-solana-com --letsencrypt beta.devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    ;;
+  testnet)
+    (
+      set -x
+      ci/testnet-deploy.sh -p devnet-solana-com -C gce -z us-west1-b \
+        -t "$CHANNEL_OR_TAG" -n 0 -c 0 -u -P \
+        -a testnet-solana-com --letsencrypt devnet.solana.com \
+        --limit-ledger-size \
+        ${skipCreate:+-e} \
+        ${skipStart:+-s} \
+        ${maybeStop:+-S} \
+        ${maybeDelete:+-D}
+    )
+    (
+      echo "--- net.sh update"
+      set -x
+      time net/net.sh update -t "$CHANNEL_OR_TAG" --platform linux --platform osx #--platform windows
+    )
+    ;;
+  *)
+    echo "Error: Invalid TESTNET=$TESTNET"
+    exit 1
+    ;;
+  esac
+}
+
+ENABLED_LOCKFILE="${HOME}/${TESTNET}.is_enabled"
+
+create-and-start() {
+  deploy create start
+}
+create() {
+  deploy create
+}
+start() {
+  deploy "" start
+}
+stop() {
+  deploy "" ""
+}
+delete() {
+  deploy "" "" "" delete
+}
+enable_testnet() {
+  touch "${ENABLED_LOCKFILE}"
+  echo "+++ $TESTNET now enabled"
+}
+disable_testnet() {
+  rm -f "${ENABLED_LOCKFILE}"
+  echo "+++ $TESTNET now disabled"
+}
+is_testnet_enabled() {
+  if [[ ! -f ${ENABLED_LOCKFILE} ]]; then
+    echo "+++ ${TESTNET} is currently disabled.  Enable ${TESTNET} by running ci/testnet-manager.sh with \$TESTNET_OP=enable, then re-run with current settings."
+    exit 0
+  fi
+}
+
+case $TESTNET_OP in
+enable)
+  enable_testnet
+  ;;
+disable)
+  disable_testnet
+  delete
+  ;;
+create-and-start)
+  is_testnet_enabled
+  create-and-start
+  ;;
+create)
+  is_testnet_enabled
+  create
+  ;;
+start)
+  is_testnet_enabled
+  start
+  ;;
+stop)
+  is_testnet_enabled
+  stop
+  ;;
+sanity)
+  is_testnet_enabled
+  sanity
+  ;;
+delete)
+  is_testnet_enabled
+  delete
+  ;;
+update-or-restart)
+  is_testnet_enabled
+  if start; then
+    echo Update successful
+  else
+    echo "+++ Update failed, restarting the network"
+    $metricsWriteDatapoint "testnet-manager update-failure=1"
+    create-and-start
+  fi
+  ;;
+sanity-or-restart)
+  is_testnet_enabled
+  if sanity; then
+    echo Pass
+  else
+    echo "+++ Sanity failed, updating the network"
+    $metricsWriteDatapoint "testnet-manager sanity-failure=1"
+    create-and-start
+  fi
+  ;;
+*)
+  echo "Error: Invalid TESTNET_OP=$TESTNET_OP"
+  exit 1
+  ;;
+esac
+
+echo --- fin
+exit 0

ci/testnet-sanity.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")/.."
+source ci/upload-ci-artifact.sh
+
+usage() {
+  exitcode=0
+  if [[ -n "$1" ]]; then
+    exitcode=1
+    echo "Error: $*"
+  fi
+  cat <<EOF
+usage: $0 [name] [cloud] [zone1] ... [zoneN]
+
+Sanity check a testnet
+
+  name            - name of the network
+  cloud           - cloud provider to use (gce, ec2)
+  zone1 .. zoneN  - cloud provider zones to check
+
+  Note: the SOLANA_METRICS_CONFIG environment variable is used to configure
+        metrics
+EOF
+  exit $exitcode
+}
+
+netName=$1
+cloudProvider=$2
+[[ -n $netName ]] || usage ""
+[[ -n $cloudProvider ]] || usage "Cloud provider not specified"
+shift 2
+
+maybePublicNetwork=
+if [[ $1 = -P ]]; then
+  maybePublicNetwork=-P
+  shift
+fi
+[[ -n $1 ]] || usage "zone1 not specified"
+
+shutdown() {
+  exitcode=$?
+
+  set +e
+  if [[ -d net/log ]]; then
+    mv net/log net/log-sanity
+    for logfile in net/log-sanity/*; do
+      if [[ -f $logfile ]]; then
+        upload-ci-artifact "$logfile"
+        tail "$logfile"
+      fi
+    done
+  fi
+  exit $exitcode
+}
+rm -rf net/{log,-sanity}
+rm -f net/config/config
+trap shutdown EXIT INT
+
+set -x
+for zone in "$@"; do
+  echo "--- $cloudProvider config [$zone]"
+  timeout 5m net/"$cloudProvider".sh config $maybePublicNetwork -n 1 -p "$netName" -z "$zone"
+  net/init-metrics.sh -e
+  echo "+++ $cloudProvider.sh info"
+  net/"$cloudProvider".sh info
+  echo "--- net.sh sanity [$cloudProvider:$zone]"
+  ok=true
+  timeout 5m net/net.sh sanity \
+    ${REJECT_EXTRA_NODES:+-o rejectExtraNodes} \
+    ${NO_INSTALL_CHECK:+-o noInstallCheck} \
+    $zone || ok=false
+
+  if ! $ok; then
+    net/net.sh logs
+  fi
+  $ok
+done

ci/upload-github-release-asset.sh

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