Specify version for solana-sdk-macro to enable crate.io publishing (#7617)

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

.buildkite/hooks/post-command

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

.buildkite/hooks/pre-command

@@ -11,29 +11,23 @@ export PS4="++"
 #
 # Restore target/ from the previous CI build on this machine
 #
-eval "$(ci/channel-info.sh)"
-export CARGO_TARGET_CACHE=$HOME/cargo-target-cache/"$CHANNEL"-"$BUILDKITE_LABEL"
 (
   set -x
+  d=$HOME/cargo-target-cache/"$BUILDKITE_LABEL"
   MAX_CACHE_SIZE=18 # gigabytes
 
-  if [[ -d $CARGO_TARGET_CACHE ]]; then
-    du -hs "$CARGO_TARGET_CACHE"
-    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$CARGO_TARGET_CACHE")
-    echo "--- ${cacheSizeInGB}GB: $CARGO_TARGET_CACHE"
+  if [[ -d $d ]]; then
+    du -hs "$d"
+    read -r cacheSizeInGB _ < <(du -s --block-size=1800000000 "$d")
+    echo "--- ${cacheSizeInGB}GB: $d"
     if [[ $cacheSizeInGB -gt $MAX_CACHE_SIZE ]]; then
-      echo "--- $CARGO_TARGET_CACHE is too large, removing it"
-      rm -rf "$CARGO_TARGET_CACHE"
+      echo "--- $d is too large, removing it"
+      rm -rf "$d"
     fi
   else
-    echo "--- $CARGO_TARGET_CACHE not present"
+    echo "--- $d not present"
   fi
 
-  mkdir -p "$CARGO_TARGET_CACHE"/target
-  rsync -a --delete --link-dest="$CARGO_TARGET_CACHE" "$CARGO_TARGET_CACHE"/target .
-
-  # Don't reuse BPF target build artifacts due to incremental build issues with
-  # `std:
-  #    "found possibly newer version of crate `std` which `xyz` depends on
-  rm -rf target/bpfel-unknown-unknown
+  mkdir -p "$d"/target
+  rsync -a --delete --link-dest="$d" "$d"/target .
 )

.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: ./book/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

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

.gitignore

@@ -1,3 +1,5 @@
+/book/html/
+/book/src/tests.ok
 /farf/
 /solana-release/
 /solana-release.tar.bz2
@@ -10,8 +12,6 @@
 
 /config/
 
-.cache
-
 # log files
 *.log
 log-*.txt
@@ -21,9 +21,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,35 +19,27 @@ pull_request_rules:
       label:
         add:
           - automerge
-  - name: v1.4 backport
+  - name: v0.21 backport
     conditions:
-      - label=v1.4
+      - base=master
+      - label=v0.21
     actions:
       backport:
-        ignore_conflicts: true
         branches:
-          - v1.4
-  - name: v1.5 backport
+          - v0.21
+  - name: v0.22 backport
     conditions:
-      - label=v1.5
+      - base=master
+      - label=v0.22
     actions:
       backport:
-        ignore_conflicts: true
         branches:
-          - v1.5
-  - name: v1.6 backport
+          - v0.22
+  - name: v0.23 backport
     conditions:
-      - label=v1.6
+      - base=master
+      - label=v0.23
     actions:
       backport:
-        ignore_conflicts: true
         branches:
-          - v1.6
-  - name: v1.7 backport
-    conditions:
-      - label=v1.7
-    actions:
-      backport:
-        ignore_conflicts: true
-        branches:
-          - v1.7
+          - v0.23

.travis.yml

@@ -1,136 +1,42 @@
+os:
+  - osx
+
+language: rust
+rust:
+  - stable
+
+install:
+  - source ci/rust-version.sh
+
+script:
+  - source ci/env.sh
+  - ci/publish-tarball.sh
+
 branches:
   only:
     - master
     - /^v\d+\.\d+/
 
 notifications:
-  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
-        - PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH"
-        - readlink -f .
-      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:
-        - source ci/env.sh
-        - .travis/channel_restriction.sh edge beta || travis_terminate 0
-        - .travis/affects.sh docs/ .travis || travis_terminate 0
-        - cd docs/
-        - source .travis/before_install.sh
-
-      script:
-        - source .travis/script.sh
+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/channel_restriction.sh

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

.travis/commitlint.sh

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

.travis/export-github-repo.sh

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

CONTRIBUTING.md

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

Cargo.toml

@@ -1,26 +1,17 @@
 [workspace]
 members = [
-    "accounts-cluster-bench",
     "bench-exchange",
     "bench-streamer",
     "bench-tps",
-    "accounts-bench",
     "banking-bench",
-    "banks-client",
-    "banks-interface",
-    "banks-server",
-    "clap-utils",
-    "cli-config",
-    "cli-output",
+    "chacha-sys",
     "client",
     "core",
-    "dos",
-    "download-utils",
-    "faucet",
-    "frozen-abi",
+    "drone",
     "perf",
     "validator",
     "genesis",
+    "genesis-programs",
     "gossip",
     "install",
     "keygen",
@@ -29,46 +20,35 @@ members = [
     "local-cluster",
     "logger",
     "log-analyzer",
-    "merkle-root-bench",
     "merkle-tree",
-    "stake-o-matic",
-    "storage-bigtable",
-    "storage-proto",
-    "streamer",
     "measure",
     "metrics",
     "net-shaper",
-    "notifier",
-    "poh-bench",
-    "program-test",
-    "programs/secp256k1",
     "programs/bpf_loader",
     "programs/budget",
+    "programs/btc_spv",
+    "programs/btc_spv_bin",
     "programs/config",
+    "programs/config_tests",
     "programs/exchange",
     "programs/failure",
     "programs/noop",
-    "programs/ownable",
+    "programs/ownable_api",
     "programs/stake",
+    "programs/stake_tests",
+    "programs/storage",
+    "programs/storage_tests",
     "programs/vest",
     "programs/vote",
-    "remote-wallet",
-    "ramp-tps",
+    "archiver",
     "runtime",
-    "runtime/store-tool",
     "sdk",
-    "sdk/cargo-build-bpf",
-    "sdk/cargo-test-bpf",
+    "sdk-c",
     "scripts",
-    "stake-accounts",
-    "stake-monitor",
-    "sys-tuner",
-    "tokens",
-    "transaction-status",
-    "account-decoder",
     "upload-perf",
     "net-utils",
-    "version",
+    "fixed-buf",
+    "vote-signer",
     "cli",
     "rayon-threadlimit",
     "watchtower",
@@ -76,7 +56,6 @@ members = [
 
 exclude = [
     "programs/bpf",
+    "programs/move_loader",
+    "programs/librapay_api",
 ]
-
-[profile.dev]
-split-debuginfo = "unpacked"

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,76 @@
-<p align="center">
-  <a href="https://solana.com">
-    <img alt="Solana" src="https://i.imgur.com/OMnvVEz.png" width="250" />
-  </a>
-</p>
-
 [![Solana crate](https://img.shields.io/crates/v/solana-core.svg)](https://crates.io/crates/solana-core)
 [![Solana documentation](https://docs.rs/solana-core/badge.svg)](https://docs.rs/solana-core)
 [![Build status](https://badge.buildkite.com/8cc350de251d61483db98bdfc895b9ea0ac8ffa4a32ee850ed.svg?branch=master)](https://buildkite.com/solana-labs/solana/builds?branch=master)
 [![codecov](https://codecov.io/gh/solana-labs/solana/branch/master/graph/badge.svg)](https://codecov.io/gh/solana-labs/solana)
 
-# Building
+Blockchain Rebuilt for Scale
+===
 
-## **1. Install rustc, cargo and rustfmt.**
+Solana&trade; is a new blockchain architecture built from the ground up for scale. The architecture supports
+up to 710 thousand transactions per second on a gigabit network.
+
+Disclaimer
+===
+
+All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
+
+Introduction
+===
+
+It's possible for a centralized database to process 710,000 transactions per second on a standard gigabit network if the transactions are, on average, no more than 176 bytes. A centralized database can also replicate itself and maintain high availability without significantly compromising that transaction rate using the distributed system technique known as Optimistic Concurrency Control [\[H.T.Kung, J.T.Robinson (1981)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.65.4735). At Solana, we're demonstrating that these same theoretical limits apply just as well to blockchain on an adversarial network. The key ingredient? Finding a way to share time when nodes can't trust one-another. Once nodes can trust time, suddenly ~40 years of distributed systems research becomes applicable to blockchain!
+
+> Perhaps the most striking difference between algorithms obtained by our method and ones based upon timeout is that using timeout produces a traditional distributed algorithm in which the processes operate asynchronously, while our method produces a globally synchronous one in which every process does the same thing at (approximately) the same time. Our method seems to contradict the whole purpose of distributed processing, which is to permit different processes to operate independently and perform different functions. However, if a distributed system is really a single system, then the processes must be synchronized in some way. Conceptually, the easiest way to synchronize processes is to get them all to do the same thing at the same time. Therefore, our method is used to implement a kernel that performs the necessary synchronization--for example, making sure that two different processes do not try to modify a file at the same time. Processes might spend only a small fraction of their time executing the synchronizing kernel; the rest of the time, they can operate independently--e.g., accessing different files. This is an approach we have advocated even when fault-tolerance is not required. The method's basic simplicity makes it easier to understand the precise properties of a system, which is crucial if one is to know just how fault-tolerant the system is. [\[L.Lamport (1984)\]](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.71.1078)
+
+Furthermore, and much to our surprise, it can be implemented using a mechanism that has existed in Bitcoin since day one. The Bitcoin feature is called nLocktime and it can be used to postdate transactions using block height instead of a timestamp. As a Bitcoin client, you'd use block height instead of a timestamp if you don't trust the network. Block height turns out to be an instance of what's being called a Verifiable Delay Function in cryptography circles. It's a cryptographically secure way to say time has passed. In Solana, we use a far more granular verifiable delay function, a SHA 256 hash chain, to checkpoint the ledger and coordinate consensus. With it, we implement Optimistic Concurrency Control and are now well en route towards that theoretical limit of 710,000 transactions per second.
+
+Architecture
+===
+
+Before you jump into the code, review the online book [Solana: Blockchain Rebuilt for Scale](https://docs.solana.com/book/).
+
+(The _latest_ development version of the online book is also [available here](https://docs.solana.com/book/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
@@ -19,7 +78,7 @@ $ source $HOME/.cargo/env
 $ rustup component add rustfmt
 ```
 
-Please sure you are always using the latest stable rust version by running:
+If your rustc version is lower than 1.39.0, please update it:
 
 ```bash
 $ rustup update
@@ -28,44 +87,118 @@ $ rustup update
 On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, etc.  On Ubuntu:
 
 ```bash
-$ sudo apt-get update
-$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make
+$ sudo apt-get install libssl-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/cluster/bench-tps).
+Local Testnet
+---
 
-### Accessing the remote development cluster
-* `devnet` - stable public cluster for development accessible via
-devnet.solana.com. Runs 24/7. Learn more about the [public clusters](https://docs.solana.com/clusters)
+Start your own testnet locally, instructions are in the book [Solana: Blockchain Rebuild for Scale: Getting Started](https://docs.solana.com/book/getting-started).
 
-# Benchmarking
+Remote Testnets
+---
+
+We maintain several testnets:
+
+* `testnet` - public stable testnet accessible via testnet.solana.com. Runs 24/7
+* `testnet-beta` - public beta channel testnet accessible via beta.testnet.solana.com. Runs 24/7
+* `testnet-edge` - public edge channel testnet accessible via edge.testnet.solana.com. Runs 24/7
+
+## Deploy process
+
+They are deployed with the `ci/testnet-manager.sh` script through a list of [scheduled
+buildkite jobs](https://buildkite.com/solana-labs/testnet-management/settings/schedules).
+Each testnet can be manually manipulated from buildkite as well.
+
+## How do I reset the testnet?
+Manually trigger the [testnet-management](https://buildkite.com/solana-labs/testnet-management) pipeline
+and when prompted select the desired testnet
+
+## How can I scale the tx generation rate?
+
+Increase the TX rate by increasing the number of cores on the client machine which is running
+`bench-tps` or run multiple clients. Decrease by lowering cores or using the rayon env
+variable `RAYON_NUM_THREADS=<xx>`
+
+## How can I test a change on the testnet?
+
+Currently, a merged PR is the only way to test a change on the testnet.  But you
+can run your own testnet using the scripts in the `net/` directory.
+
+## Adjusting the number of clients or validators on the testnet
+Edit `ci/testnet-manager.sh`
+
+
+## Metrics Server Maintenance
+Sometimes the dashboard becomes unresponsive. This happens due to glitch in the metrics server.
+The current solution is to reset the metrics server. Use the following steps.
+
+1. The server is hosted in a GCP VM instance. Check if the VM instance is down by trying to SSH
+ into it from the GCP console. The name of the VM is ```metrics-solana-com```.
+2. If the VM is inaccessible, reset it from the GCP console.
+3. Once VM is up (or, was already up), the metrics services can be restarted from build automation.
+    1. Navigate to https://buildkite.com/solana-labs/metrics-dot-solana-dot-com in your web browser
+    2. Click on ```New Build```
+    3. This will show a pop up dialog. Click on ```options``` drop down.
+    4. Type in ```FORCE_START=true``` in ```Environment Variables``` text box.
+    5. Click ```Create Build```
+    6. This will restart the metrics services, and the dashboards should be accessible afterwards.
+
+## Debugging Testnet
+Testnet may exhibit different symptoms of failures. Primary statistics to check are
+1. Rise in Confirmation Time
+2. Nodes are not voting
+3. Panics, and OOM notifications
+
+Check the following if there are any signs of failure.
+1. Did testnet deployment fail?
+    1. View buildkite logs for the last deployment: https://buildkite.com/solana-labs/testnet-management
+    2. Use the relevant branch
+    3. If the deployment failed, look at the build logs. The build artifacts for each remote node is uploaded.
+       It's a good first step to triage from these logs.
+2. You may have to log into remote node if the deployment succeeded, but something failed during runtime.
+    1. Get the private key for the testnet deployment from ```metrics-solana-com``` GCP instance.
+    2. SSH into ```metrics-solana-com``` using GCP console and do the following.
+    ```bash
+    sudo bash
+    cd ~buildkite-agent/.ssh
+    ls
+    ```
+    3. Copy the relevant private key to your local machine
+    4. Find the public IP address of the AWS instance for the remote node using AWS console
+    5. ```ssh -i <private key file> ubuntu@<ip address of remote node>```
+    6. The logs are in ```~solana\solana``` folder
+
+
+Benchmarking
+---
 
 First install the nightly build of rustc. `cargo bench` requires use of the
 unstable features only available in the nightly build.
@@ -80,11 +213,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:
 
@@ -93,6 +228,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,44 +240,3 @@ problem is solved by this code?" On the other hand, if a test does fail and you
 better way to solve the same problem, a Pull Request with your solution would most certainly be
 welcome! Likewise, if rewriting a test can better communicate what code it's protecting, please
 send us that patch!
-
-# Disclaimer
-
-All claims, content, designs, algorithms, estimates, roadmaps,
-specifications, and performance measurements described in this project
-are done with the Solana Foundation's ("SF") best efforts. It is up to
-the reader to check and validate their accuracy and truthfulness.
-Furthermore nothing in this project constitutes a solicitation for
-investment.
-
-Any content produced by SF or developer resources that SF provides, are
-for educational and inspiration purposes only. SF does not encourage,
-induce or sanction the deployment, integration or use of any such
-applications (including the code comprising the Solana blockchain
-protocol) in violation of applicable laws or regulations and hereby
-prohibits any such deployment, integration or use. This includes use of
-any such applications by the reader (a) in violation of export control
-or sanctions laws of the United States or any other applicable
-jurisdiction, (b) if the reader is located in or ordinarily resident in
-a country or territory subject to comprehensive sanctions administered
-by the U.S. Office of Foreign Assets Control (OFAC), or (c) if the
-reader is or is working on behalf of a Specially Designated National
-(SDN) or a person subject to similar blocking or denied party
-prohibitions.
-
-The reader should be aware that U.S. export control and sanctions laws
-prohibit U.S. persons (and other persons that are subject to such laws)
-from transacting with persons in certain countries and territories or
-that are on the SDN list. As a project based primarily on open-source
-software, it is possible that such sanctioned persons may nevertheless
-bypass prohibitions, obtain the code comprising the Solana blockchain
-protocol (or other project code or applications) and deploy, integrate,
-or otherwise use it. Accordingly, there is a risk to individuals that
-other persons using the Solana blockchain protocol may be sanctioned
-persons and that transactions with such persons would be a violation of
-U.S. export controls and sanctions law. This risk applies to
-individuals, organizations, and other ecosystem participants that
-deploy, integrate, or use the Solana blockchain protocol code directly
-(e.g., as a node operator), and individuals that transact on the Solana
-blockchain through light clients, third party interfaces, and/or wallet
-software.

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,56 +102,103 @@ 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. Fill the release notes.
-   1.  If this is the first release on the branch (e.g. v0.13.**0**), paste in [this
+1. If this is the first release on the branch (e.g. v0.13.**0**), paste in [this
    template](https://raw.githubusercontent.com/solana-labs/solana/master/.github/RELEASE_TEMPLATE.md).  Engineering Lead can provide summary contents for release notes if needed.
-   1. 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 all desired commits (usually backports) are landed on the branch by now.
-1. Ensure the release is marked **"This is a pre-release"**.  This flag will need to be be removed manually after confirming the the Linux binary artifacts appear at a later step.
-1. Go back into edit the release and click "Publish release" while being marked as a pre-release.
-1. Confirm there is new git tag with intended version number at the intended revision after running `git fetch` locally.
-
+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 notes.  This allows people to incrementally add new release notes until it's time for the next release
-    1. Also, point the branch field to the same branch and mark the relese as **"This is a pre-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 `book/src/running-archiver.md` and `book/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.solana.com/mainnet-beta.solana.com
-See the documentation at https://github.com/solana-labs/cluster-ops/
+#### Publish updated Book
+We maintain three copies of the "book" as official documentation:
+
+1) "Book" is the documentation for the latest official release.  This should get manually updated whenever a new release is made.  It is published here:
+https://solana-labs.github.io/book/
+
+2) "Book-edge" tracks the tip of the master branch and updates automatically.
+https://solana-labs.github.io/book-edge/
+
+3) "Book-beta" tracks the tip of the beta branch and updates automatically.
+https://solana-labs.github.io/book-beta/
+
+To manually trigger an update of the "Book", create a new job of the manual-update-book pipeline.
+Set the tag of the latest release as the PUBLISH_BOOK_TAG environment variable.
+```bash
+PUBLISH_BOOK_TAG=v0.16.6
+```
+https://buildkite.com/solana-labs/manual-update-book
+
+### Update software on testnet.solana.com
+
+The testnet running on testnet.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
+testnet.solana.com is available

SECURITY.md

@@ -1,155 +0,0 @@
-# Security Policy
-
-1. [Reporting security problems](#reporting)
-4. [Security Bug Bounties](#bounty)
-2. [Incident Response Process](#process)
-
-<a name="reporting"></a>
-## Reporting security problems to Solana
-
-**DO NOT CREATE AN ISSUE** to report a security problem. Instead, please send an
-email to security@solana.com and provide your github username so we can add you
-to a new draft security advisory for further discussion.
-
-Expect a response as fast as possible, within one business day at the latest.
-
-<a name="bounty"></a>
-## Security Bug Bounties
-We offer bounties for critical security issues. Please see below for more details.
-
-Loss of Funds:
-$500,000 USD in locked SOL tokens (locked for 12 months)
-* Theft of funds without users signature from any account
-* Theft of funds without users interaction in system, token, stake, vote programs
-* Theft of funds that requires users signature - creating a vote program that drains the delegated stakes.
-
-Consensus/Safety Violations:
-$250,000 USD in locked SOL tokens (locked for 12 months)
-* Consensus safety violation
-* Tricking a validator to accept an optimistic confirmation or rooted slot without a double vote, etc..
-
-Other Attacks:
- $100,000 USD in locked SOL tokens (locked for 12 months)
-* Protocol liveness attacks,
-* Eclipse attacks,
-* Remote attacks that partition the network,
-
-DoS Attacks:
-$25,000 USD in locked SOL tokens (locked for 12 months)
-* Remote resource exaustion via Non-RPC protocols
-
-RPC DoS/Crashes:
-$5,000 USD in locked SOL tokens (locked for 12 months)
-* RPC attacks
-
-Out of Scope:
-The following components are out of scope for the bounty program
-* Metrics: `/metrics` in the monorepo as well as https://metrics.solana.com
-* Explorer: `/explorer` in the monorepo as well as https://explorer.solana.com
-* Any encrypted credentials, auth tokens, etc. checked into the repo
-* Bugs in dependencies. Please take them upstream!
-* Attacks that require social engineering
-
-Eligibility:
-* The participant submitting the bug bounty shall follow the process outlined within this document
-* Valid exploits can be eligible even if they are not successfully executed on the cluster
-* Multiple submissions for the same class of exploit are still eligible for compensation, though may be compensated at a lower rate, however these will be assessed on a case-by-case basis
-* Participants must complete KYC and sign the participation agreement here when the registrations are open https://solana.com/validator-registration. Security exploits will still be assessed and open for submission at all times. This needs only be done prior to distribution of tokens.
-
-Notes:
-* All locked tokens can be staked during the lockup period
-
-<a name="process"></a>
-## Incident Response Process
-
-In case an incident is discovered or reported, the following process will be
-followed to contain, respond and remediate:
-
-### 1. Establish a new draft security advisory
-In response to an email to security@solana.com, a member of the `solana-labs/admins` group will
-1. Create a new draft security advisory for the incident at https://github.com/solana-labs/solana/security/advisories
-1. Add the reporter's github user and the `solana-labs/security-incident-response` group to the draft security advisory
-1. Create a private fork of the repository (grey button towards the bottom of the page)
-1. Respond to the reporter by email, sharing a link to the draft security advisory
-
-### 2. Triage
-Within the draft security advisory, discuss and determine the severity of the
-issue. If necessary, members of the `solana-labs/security-incident-response`
-group may add other github users to the advisory to assist.
-
-If it is determined that this not a critical network issue then the advisory
-should be closed and if more follow-up is required a normal Solana public github
-issue should be created.
-
-### 3. Prepare Fixes
-For the affected branches, typically all three (edge, beta and stable), prepare
-a fix for the issue and push them to the corresponding branch in the private
-repository associated with the draft security advisory.
-
-There is no CI available in the private repository so you must build from source
-and manually verify fixes.
-
-Code review from the reporter is ideal, as well as from multiple members of the
-core development team.
-
-### 4. Notify Security Group Validators
-Once an ETA is available for the fix, a member of the
-`solana-labs/security-incident-response` group should notify the validators so
-they can prepare for an update using the "Solana Red Alert" notification system.
-
-The teams are all over the world and it's critical to provide actionable
-information at the right time. Don't be the person that wakes everybody up at
-2am when a fix won't be available for hours.
-
-### 5. Ship the patch
-Once the fix is accepted, a member of the
-`solana-labs/security-incident-response` group should prepare a single patch
-file for each affected branch. The commit title for the patch should only
-contain the advisory id, and not disclose any further details about the
-incident.
-
-Copy the patches to https://release.solana.com/ under a subdirectory named after
-the advisory id (example:
-https://release.solana.com/GHSA-hx59-f5g4-jghh/v1.4.patch). Contact a member of
-the `solana-labs/admins` group if you require access to release.solana.com
-
-Using the "Solana Red Alert" channel:
-1. Notify validators that there's an issue and a patch will be provided in X minutes
-2. If X minutes expires and there's no patch, notify of the delay and provide a
-   new ETA
-3. Provide links to patches of https://release.solana.com/ for each affected branch
-
-Validators can be expected to build the patch from source against the latest
-release for the affected branch.
-
-Since the software version will not change after the patch is applied, request
-that each validator notify in the existing channel once they've updated. Manually
-monitor the roll out until a sufficient amount of stake has updated - typically
-at least 33.3% or 66.6% depending on the issue.
-
-### 6. Public Disclosure and Release
-Once the fix has been deployed to the security group validators, the patches from the security
-advisory may be merged into the main source repository. A new official release
-for each affected branch should be shipped and all validators requested to
-upgrade as quickly as possible.
-
-### 7. Security Advisory Bounty Accounting and Cleanup
-
-If this issue is eligible for a bounty, prefix the title of the security
-advisory with one of the following, depending on the severity:
-* `[Bounty Category: Critical: Loss of Funds]`
-* `[Bounty Category: Critical: Loss of Availability]`
-* `[Bounty Category: Critical: DoS]`
-* `[Bounty Category: Critical: Other]`
-* `[Bounty Category: Non-critical]`
-* `[Bounty Category: RPC]`
-
-Confirm with the reporter that they agree with the severity assessment, and
-discuss as required to reach a conclusion.
-
-We currently do not use the Github workflow to publish security advisories.
-Once the issue and fix have been disclosed, and a bounty category is assessed if
-appropriate, the GitHub security advisory is no longer needed and can be closed.
-
-Bounties are currently awarded once a quarter (TODO: link to this process, or
-inline the workflow)

account-decoder/Cargo.toml

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

account-decoder/src/lib.rs

@@ -1,245 +0,0 @@
-#![allow(clippy::integer_arithmetic)]
-#[macro_use]
-extern crate lazy_static;
-#[macro_use]
-extern crate serde_derive;
-
-pub mod parse_account_data;
-pub mod parse_bpf_loader;
-pub mod parse_config;
-pub mod parse_nonce;
-pub mod parse_stake;
-pub mod parse_sysvar;
-pub mod parse_token;
-pub mod parse_vote;
-pub mod validator_info;
-
-use {
-    crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount},
-    solana_sdk::{
-        account::ReadableAccount, account::WritableAccount, clock::Epoch,
-        fee_calculator::FeeCalculator, pubkey::Pubkey,
-    },
-    std::{
-        io::{Read, Write},
-        str::FromStr,
-    },
-};
-
-pub type StringAmount = String;
-pub type StringDecimals = String;
-
-/// A duplicate representation of an Account for pretty JSON serialization
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct UiAccount {
-    pub lamports: u64,
-    pub data: UiAccountData,
-    pub owner: String,
-    pub executable: bool,
-    pub rent_epoch: Epoch,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", untagged)]
-pub enum UiAccountData {
-    LegacyBinary(String), // Legacy. Retained for RPC backwards compatibility
-    Json(ParsedAccount),
-    Binary(String, UiAccountEncoding),
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub enum UiAccountEncoding {
-    Binary, // Legacy. Retained for RPC backwards compatibility
-    Base58,
-    Base64,
-    JsonParsed,
-    #[serde(rename = "base64+zstd")]
-    Base64Zstd,
-}
-
-impl UiAccount {
-    pub fn encode<T: ReadableAccount>(
-        pubkey: &Pubkey,
-        account: T,
-        encoding: UiAccountEncoding,
-        additional_data: Option<AccountAdditionalData>,
-        data_slice_config: Option<UiDataSliceConfig>,
-    ) -> Self {
-        let data = match encoding {
-            UiAccountEncoding::Binary => UiAccountData::LegacyBinary(
-                bs58::encode(slice_data(&account.data(), data_slice_config)).into_string(),
-            ),
-            UiAccountEncoding::Base58 => UiAccountData::Binary(
-                bs58::encode(slice_data(&account.data(), data_slice_config)).into_string(),
-                encoding,
-            ),
-            UiAccountEncoding::Base64 => UiAccountData::Binary(
-                base64::encode(slice_data(&account.data(), data_slice_config)),
-                encoding,
-            ),
-            UiAccountEncoding::Base64Zstd => {
-                let mut encoder = zstd::stream::write::Encoder::new(Vec::new(), 0).unwrap();
-                match encoder
-                    .write_all(slice_data(&account.data(), data_slice_config))
-                    .and_then(|()| encoder.finish())
-                {
-                    Ok(zstd_data) => UiAccountData::Binary(base64::encode(zstd_data), encoding),
-                    Err(_) => UiAccountData::Binary(
-                        base64::encode(slice_data(&account.data(), data_slice_config)),
-                        UiAccountEncoding::Base64,
-                    ),
-                }
-            }
-            UiAccountEncoding::JsonParsed => {
-                if let Ok(parsed_data) =
-                    parse_account_data(pubkey, &account.owner(), &account.data(), additional_data)
-                {
-                    UiAccountData::Json(parsed_data)
-                } else {
-                    UiAccountData::Binary(
-                        base64::encode(&account.data()),
-                        UiAccountEncoding::Base64,
-                    )
-                }
-            }
-        };
-        UiAccount {
-            lamports: account.lamports(),
-            data,
-            owner: account.owner().to_string(),
-            executable: account.executable(),
-            rent_epoch: account.rent_epoch(),
-        }
-    }
-
-    pub fn decode<T: WritableAccount>(&self) -> Option<T> {
-        let data = match &self.data {
-            UiAccountData::Json(_) => None,
-            UiAccountData::LegacyBinary(blob) => bs58::decode(blob).into_vec().ok(),
-            UiAccountData::Binary(blob, encoding) => match encoding {
-                UiAccountEncoding::Base58 => bs58::decode(blob).into_vec().ok(),
-                UiAccountEncoding::Base64 => base64::decode(blob).ok(),
-                UiAccountEncoding::Base64Zstd => base64::decode(blob)
-                    .ok()
-                    .map(|zstd_data| {
-                        let mut data = vec![];
-                        zstd::stream::read::Decoder::new(zstd_data.as_slice())
-                            .and_then(|mut reader| reader.read_to_end(&mut data))
-                            .map(|_| data)
-                            .ok()
-                    })
-                    .flatten(),
-                UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
-            },
-        }?;
-        Some(T::create(
-            self.lamports,
-            data,
-            Pubkey::from_str(&self.owner).ok()?,
-            self.executable,
-            self.rent_epoch,
-        ))
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiFeeCalculator {
-    pub lamports_per_signature: StringAmount,
-}
-
-impl From<FeeCalculator> for UiFeeCalculator {
-    fn from(fee_calculator: FeeCalculator) -> Self {
-        Self {
-            lamports_per_signature: fee_calculator.lamports_per_signature.to_string(),
-        }
-    }
-}
-
-impl Default for UiFeeCalculator {
-    fn default() -> Self {
-        Self {
-            lamports_per_signature: "0".to_string(),
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UiDataSliceConfig {
-    pub offset: usize,
-    pub length: usize,
-}
-
-fn slice_data(data: &[u8], data_slice_config: Option<UiDataSliceConfig>) -> &[u8] {
-    if let Some(UiDataSliceConfig { offset, length }) = data_slice_config {
-        if offset >= data.len() {
-            &[]
-        } else if length > data.len() - offset {
-            &data[offset..]
-        } else {
-            &data[offset..offset + length]
-        }
-    } else {
-        data
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use solana_sdk::account::{Account, AccountSharedData};
-
-    #[test]
-    fn test_slice_data() {
-        let data = vec![1, 2, 3, 4, 5];
-        let slice_config = Some(UiDataSliceConfig {
-            offset: 0,
-            length: 5,
-        });
-        assert_eq!(slice_data(&data, slice_config), &data[..]);
-
-        let slice_config = Some(UiDataSliceConfig {
-            offset: 0,
-            length: 10,
-        });
-        assert_eq!(slice_data(&data, slice_config), &data[..]);
-
-        let slice_config = Some(UiDataSliceConfig {
-            offset: 1,
-            length: 2,
-        });
-        assert_eq!(slice_data(&data, slice_config), &data[1..3]);
-
-        let slice_config = Some(UiDataSliceConfig {
-            offset: 10,
-            length: 2,
-        });
-        assert_eq!(slice_data(&data, slice_config), &[] as &[u8]);
-    }
-
-    #[test]
-    fn test_base64_zstd() {
-        let encoded_account = UiAccount::encode(
-            &Pubkey::default(),
-            AccountSharedData::from(Account {
-                data: vec![0; 1024],
-                ..Account::default()
-            }),
-            UiAccountEncoding::Base64Zstd,
-            None,
-            None,
-        );
-        assert!(matches!(
-            encoded_account.data,
-            UiAccountData::Binary(_, UiAccountEncoding::Base64Zstd)
-        ));
-
-        let decoded_account = encoded_account.decode::<Account>().unwrap();
-        assert_eq!(decoded_account.data(), &vec![0; 1024]);
-        let decoded_account = encoded_account.decode::<AccountSharedData>().unwrap();
-        assert_eq!(decoded_account.data(), &vec![0; 1024]);
-    }
-}

account-decoder/src/parse_account_data.rs

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

account-decoder/src/parse_bpf_loader.rs

@@ -1,181 +0,0 @@
-use crate::{
-    parse_account_data::{ParsableAccount, ParseAccountError},
-    UiAccountData, UiAccountEncoding,
-};
-use bincode::{deserialize, serialized_size};
-use solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey};
-
-pub fn parse_bpf_upgradeable_loader(
-    data: &[u8],
-) -> Result<BpfUpgradeableLoaderAccountType, ParseAccountError> {
-    let account_state: UpgradeableLoaderState = deserialize(data).map_err(|_| {
-        ParseAccountError::AccountNotParsable(ParsableAccount::BpfUpgradeableLoader)
-    })?;
-    let parsed_account = match account_state {
-        UpgradeableLoaderState::Uninitialized => BpfUpgradeableLoaderAccountType::Uninitialized,
-        UpgradeableLoaderState::Buffer { authority_address } => {
-            let offset = if authority_address.is_some() {
-                UpgradeableLoaderState::buffer_data_offset().unwrap()
-            } else {
-                // This case included for code completeness; in practice, a Buffer account will
-                // always have authority_address.is_some()
-                UpgradeableLoaderState::buffer_data_offset().unwrap()
-                    - serialized_size(&Pubkey::default()).unwrap() as usize
-            };
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: authority_address.map(|pubkey| pubkey.to_string()),
-                data: UiAccountData::Binary(
-                    base64::encode(&data[offset as usize..]),
-                    UiAccountEncoding::Base64,
-                ),
-            })
-        }
-        UpgradeableLoaderState::Program {
-            programdata_address,
-        } => BpfUpgradeableLoaderAccountType::Program(UiProgram {
-            program_data: programdata_address.to_string(),
-        }),
-        UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address,
-        } => {
-            let offset = if upgrade_authority_address.is_some() {
-                UpgradeableLoaderState::programdata_data_offset().unwrap()
-            } else {
-                UpgradeableLoaderState::programdata_data_offset().unwrap()
-                    - serialized_size(&Pubkey::default()).unwrap() as usize
-            };
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: upgrade_authority_address.map(|pubkey| pubkey.to_string()),
-                data: UiAccountData::Binary(
-                    base64::encode(&data[offset as usize..]),
-                    UiAccountEncoding::Base64,
-                ),
-            })
-        }
-    };
-    Ok(parsed_account)
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase", tag = "type", content = "info")]
-pub enum BpfUpgradeableLoaderAccountType {
-    Uninitialized,
-    Buffer(UiBuffer),
-    Program(UiProgram),
-    ProgramData(UiProgramData),
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiBuffer {
-    pub authority: Option<String>,
-    pub data: UiAccountData,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiProgram {
-    pub program_data: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiProgramData {
-    pub slot: u64,
-    pub authority: Option<String>,
-    pub data: UiAccountData,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use bincode::serialize;
-    use solana_sdk::pubkey::Pubkey;
-
-    #[test]
-    fn test_parse_bpf_upgradeable_loader_accounts() {
-        let bpf_loader_state = UpgradeableLoaderState::Uninitialized;
-        let account_data = serialize(&bpf_loader_state).unwrap();
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Uninitialized
-        );
-
-        let program = vec![7u8; 64]; // Arbitrary program data
-
-        let authority = Pubkey::new_unique();
-        let bpf_loader_state = UpgradeableLoaderState::Buffer {
-            authority_address: Some(authority),
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: Some(authority.to_string()),
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        // This case included for code completeness; in practice, a Buffer account will always have
-        // authority_address.is_some()
-        let bpf_loader_state = UpgradeableLoaderState::Buffer {
-            authority_address: None,
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Buffer(UiBuffer {
-                authority: None,
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        let programdata_address = Pubkey::new_unique();
-        let bpf_loader_state = UpgradeableLoaderState::Program {
-            programdata_address,
-        };
-        let account_data = serialize(&bpf_loader_state).unwrap();
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::Program(UiProgram {
-                program_data: programdata_address.to_string(),
-            })
-        );
-
-        let authority = Pubkey::new_unique();
-        let slot = 42;
-        let bpf_loader_state = UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address: Some(authority),
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: Some(authority.to_string()),
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-
-        let bpf_loader_state = UpgradeableLoaderState::ProgramData {
-            slot,
-            upgrade_authority_address: None,
-        };
-        let mut account_data = serialize(&bpf_loader_state).unwrap();
-        account_data.extend_from_slice(&program);
-        assert_eq!(
-            parse_bpf_upgradeable_loader(&account_data).unwrap(),
-            BpfUpgradeableLoaderAccountType::ProgramData(UiProgramData {
-                slot,
-                authority: None,
-                data: UiAccountData::Binary(base64::encode(&program), UiAccountEncoding::Base64),
-            })
-        );
-    }
-}

account-decoder/src/parse_config.rs

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

account-decoder/src/parse_nonce.rs

@@ -1,73 +0,0 @@
-use crate::{parse_account_data::ParseAccountError, UiFeeCalculator};
-use solana_sdk::{
-    instruction::InstructionError,
-    nonce::{state::Versions, State},
-};
-
-pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> {
-    let nonce_state: Versions = bincode::deserialize(data)
-        .map_err(|_| ParseAccountError::from(InstructionError::InvalidAccountData))?;
-    let nonce_state = nonce_state.convert_to_current();
-    match nonce_state {
-        // This prevents parsing an allocated System-owned account with empty data of any non-zero
-        // length as `uninitialized` nonce. An empty account of the wrong length can never be
-        // initialized as a nonce account, and an empty account of the correct length may not be an
-        // uninitialized nonce account, since it can be assigned to another program.
-        State::Uninitialized => Err(ParseAccountError::from(
-            InstructionError::InvalidAccountData,
-        )),
-        State::Initialized(data) => Ok(UiNonceState::Initialized(UiNonceData {
-            authority: data.authority.to_string(),
-            blockhash: data.blockhash.to_string(),
-            fee_calculator: data.fee_calculator.into(),
-        })),
-    }
-}
-
-/// A duplicate representation of NonceState for pretty JSON serialization
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase", tag = "type", content = "info")]
-pub enum UiNonceState {
-    Uninitialized,
-    Initialized(UiNonceData),
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiNonceData {
-    pub authority: String,
-    pub blockhash: String,
-    pub fee_calculator: UiFeeCalculator,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use solana_sdk::{
-        hash::Hash,
-        nonce::{
-            state::{Data, Versions},
-            State,
-        },
-        pubkey::Pubkey,
-    };
-
-    #[test]
-    fn test_parse_nonce() {
-        let nonce_data = Versions::new_current(State::Initialized(Data::default()));
-        let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
-        assert_eq!(
-            parse_nonce(&nonce_account_data).unwrap(),
-            UiNonceState::Initialized(UiNonceData {
-                authority: Pubkey::default().to_string(),
-                blockhash: Hash::default().to_string(),
-                fee_calculator: UiFeeCalculator {
-                    lamports_per_signature: 0.to_string(),
-                },
-            }),
-        );
-
-        let bad_data = vec![0; 4];
-        assert!(parse_nonce(&bad_data).is_err());
-    }
-}

account-decoder/src/parse_stake.rs

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

account-decoder/src/parse_sysvar.rs

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

account-decoder/src/parse_token.rs

@@ -1,443 +0,0 @@
-use crate::{
-    parse_account_data::{ParsableAccount, ParseAccountError},
-    StringAmount, StringDecimals,
-};
-use solana_sdk::pubkey::Pubkey;
-use spl_token_v2_0::{
-    solana_program::{
-        program_option::COption, program_pack::Pack, pubkey::Pubkey as SplTokenPubkey,
-    },
-    state::{Account, AccountState, Mint, Multisig},
-};
-use std::str::FromStr;
-
-// A helper function to convert spl_token_v2_0::id() as spl_sdk::pubkey::Pubkey to
-// solana_sdk::pubkey::Pubkey
-pub fn spl_token_id_v2_0() -> Pubkey {
-    Pubkey::from_str(&spl_token_v2_0::id().to_string()).unwrap()
-}
-
-// A helper function to convert spl_token_v2_0::native_mint::id() as spl_sdk::pubkey::Pubkey to
-// solana_sdk::pubkey::Pubkey
-pub fn spl_token_v2_0_native_mint() -> Pubkey {
-    Pubkey::from_str(&spl_token_v2_0::native_mint::id().to_string()).unwrap()
-}
-
-// A helper function to convert a solana_sdk::pubkey::Pubkey to spl_sdk::pubkey::Pubkey
-pub fn spl_token_v2_0_pubkey(pubkey: &Pubkey) -> SplTokenPubkey {
-    SplTokenPubkey::from_str(&pubkey.to_string()).unwrap()
-}
-
-// A helper function to convert a spl_sdk::pubkey::Pubkey to solana_sdk::pubkey::Pubkey
-pub fn pubkey_from_spl_token_v2_0(pubkey: &SplTokenPubkey) -> Pubkey {
-    Pubkey::from_str(&pubkey.to_string()).unwrap()
-}
-
-pub fn parse_token(
-    data: &[u8],
-    mint_decimals: Option<u8>,
-) -> Result<TokenAccountType, ParseAccountError> {
-    if data.len() == Account::get_packed_len() {
-        let account = Account::unpack(data)
-            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
-        let decimals = mint_decimals.ok_or_else(|| {
-            ParseAccountError::AdditionalDataMissing(
-                "no mint_decimals provided to parse spl-token account".to_string(),
-            )
-        })?;
-        Ok(TokenAccountType::Account(UiTokenAccount {
-            mint: account.mint.to_string(),
-            owner: account.owner.to_string(),
-            token_amount: token_amount_to_ui_amount(account.amount, decimals),
-            delegate: match account.delegate {
-                COption::Some(pubkey) => Some(pubkey.to_string()),
-                COption::None => None,
-            },
-            state: account.state.into(),
-            is_native: account.is_native(),
-            rent_exempt_reserve: match account.is_native {
-                COption::Some(reserve) => Some(token_amount_to_ui_amount(reserve, decimals)),
-                COption::None => None,
-            },
-            delegated_amount: if account.delegate.is_none() {
-                None
-            } else {
-                Some(token_amount_to_ui_amount(
-                    account.delegated_amount,
-                    decimals,
-                ))
-            },
-            close_authority: match account.close_authority {
-                COption::Some(pubkey) => Some(pubkey.to_string()),
-                COption::None => None,
-            },
-        }))
-    } else if data.len() == Mint::get_packed_len() {
-        let mint = Mint::unpack(data)
-            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
-        Ok(TokenAccountType::Mint(UiMint {
-            mint_authority: match mint.mint_authority {
-                COption::Some(pubkey) => Some(pubkey.to_string()),
-                COption::None => None,
-            },
-            supply: mint.supply.to_string(),
-            decimals: mint.decimals,
-            is_initialized: mint.is_initialized,
-            freeze_authority: match mint.freeze_authority {
-                COption::Some(pubkey) => Some(pubkey.to_string()),
-                COption::None => None,
-            },
-        }))
-    } else if data.len() == Multisig::get_packed_len() {
-        let multisig = Multisig::unpack(data)
-            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
-        Ok(TokenAccountType::Multisig(UiMultisig {
-            num_required_signers: multisig.m,
-            num_valid_signers: multisig.n,
-            is_initialized: multisig.is_initialized,
-            signers: multisig
-                .signers
-                .iter()
-                .filter_map(|pubkey| {
-                    if pubkey != &SplTokenPubkey::default() {
-                        Some(pubkey.to_string())
-                    } else {
-                        None
-                    }
-                })
-                .collect(),
-        }))
-    } else {
-        Err(ParseAccountError::AccountNotParsable(
-            ParsableAccount::SplToken,
-        ))
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase", tag = "type", content = "info")]
-pub enum TokenAccountType {
-    Account(UiTokenAccount),
-    Mint(UiMint),
-    Multisig(UiMultisig),
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiTokenAccount {
-    pub mint: String,
-    pub owner: String,
-    pub token_amount: UiTokenAmount,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub delegate: Option<String>,
-    pub state: UiAccountState,
-    pub is_native: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub rent_exempt_reserve: Option<UiTokenAmount>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub delegated_amount: Option<UiTokenAmount>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub close_authority: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub enum UiAccountState {
-    Uninitialized,
-    Initialized,
-    Frozen,
-}
-
-impl From<AccountState> for UiAccountState {
-    fn from(state: AccountState) -> Self {
-        match state {
-            AccountState::Uninitialized => UiAccountState::Uninitialized,
-            AccountState::Initialized => UiAccountState::Initialized,
-            AccountState::Frozen => UiAccountState::Frozen,
-        }
-    }
-}
-
-pub fn real_number_string(amount: u64, decimals: u8) -> StringDecimals {
-    let decimals = decimals as usize;
-    if decimals > 0 {
-        // Left-pad zeros to decimals + 1, so we at least have an integer zero
-        let mut s = format!("{:01$}", amount, decimals + 1);
-        // Add the decimal point (Sorry, "," locales!)
-        s.insert(s.len() - decimals, '.');
-        s
-    } else {
-        amount.to_string()
-    }
-}
-
-pub fn real_number_string_trimmed(amount: u64, decimals: u8) -> StringDecimals {
-    let mut s = real_number_string(amount, decimals);
-    if decimals > 0 {
-        let zeros_trimmed = s.trim_end_matches('0');
-        s = zeros_trimmed.trim_end_matches('.').to_string();
-    }
-    s
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiTokenAmount {
-    pub ui_amount: Option<f64>,
-    pub decimals: u8,
-    pub amount: StringAmount,
-    pub ui_amount_string: StringDecimals,
-}
-
-impl UiTokenAmount {
-    pub fn real_number_string(&self) -> String {
-        real_number_string(
-            u64::from_str(&self.amount).unwrap_or_default(),
-            self.decimals as u8,
-        )
-    }
-
-    pub fn real_number_string_trimmed(&self) -> String {
-        if !self.ui_amount_string.is_empty() {
-            self.ui_amount_string.clone()
-        } else {
-            real_number_string_trimmed(
-                u64::from_str(&self.amount).unwrap_or_default(),
-                self.decimals as u8,
-            )
-        }
-    }
-}
-
-pub fn token_amount_to_ui_amount(amount: u64, decimals: u8) -> UiTokenAmount {
-    let amount_decimals = 10_usize
-        .checked_pow(decimals as u32)
-        .map(|dividend| amount as f64 / dividend as f64);
-    UiTokenAmount {
-        ui_amount: amount_decimals,
-        decimals,
-        amount: amount.to_string(),
-        ui_amount_string: real_number_string_trimmed(amount, decimals),
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiMint {
-    pub mint_authority: Option<String>,
-    pub supply: StringAmount,
-    pub decimals: u8,
-    pub is_initialized: bool,
-    pub freeze_authority: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct UiMultisig {
-    pub num_required_signers: u8,
-    pub num_valid_signers: u8,
-    pub is_initialized: bool,
-    pub signers: Vec<String>,
-}
-
-pub fn get_token_account_mint(data: &[u8]) -> Option<Pubkey> {
-    if data.len() == Account::get_packed_len() {
-        Some(Pubkey::new(&data[0..32]))
-    } else {
-        None
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_parse_token() {
-        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
-        let owner_pubkey = SplTokenPubkey::new(&[3; 32]);
-        let mut account_data = vec![0; Account::get_packed_len()];
-        let mut account = Account::unpack_unchecked(&account_data).unwrap();
-        account.mint = mint_pubkey;
-        account.owner = owner_pubkey;
-        account.amount = 42;
-        account.state = AccountState::Initialized;
-        account.is_native = COption::None;
-        account.close_authority = COption::Some(owner_pubkey);
-        Account::pack(account, &mut account_data).unwrap();
-
-        assert!(parse_token(&account_data, None).is_err());
-        assert_eq!(
-            parse_token(&account_data, Some(2)).unwrap(),
-            TokenAccountType::Account(UiTokenAccount {
-                mint: mint_pubkey.to_string(),
-                owner: owner_pubkey.to_string(),
-                token_amount: UiTokenAmount {
-                    ui_amount: Some(0.42),
-                    decimals: 2,
-                    amount: "42".to_string(),
-                    ui_amount_string: "0.42".to_string()
-                },
-                delegate: None,
-                state: UiAccountState::Initialized,
-                is_native: false,
-                rent_exempt_reserve: None,
-                delegated_amount: None,
-                close_authority: Some(owner_pubkey.to_string()),
-            }),
-        );
-
-        let mut mint_data = vec![0; Mint::get_packed_len()];
-        let mut mint = Mint::unpack_unchecked(&mint_data).unwrap();
-        mint.mint_authority = COption::Some(owner_pubkey);
-        mint.supply = 42;
-        mint.decimals = 3;
-        mint.is_initialized = true;
-        mint.freeze_authority = COption::Some(owner_pubkey);
-        Mint::pack(mint, &mut mint_data).unwrap();
-
-        assert_eq!(
-            parse_token(&mint_data, None).unwrap(),
-            TokenAccountType::Mint(UiMint {
-                mint_authority: Some(owner_pubkey.to_string()),
-                supply: 42.to_string(),
-                decimals: 3,
-                is_initialized: true,
-                freeze_authority: Some(owner_pubkey.to_string()),
-            }),
-        );
-
-        let signer1 = SplTokenPubkey::new(&[1; 32]);
-        let signer2 = SplTokenPubkey::new(&[2; 32]);
-        let signer3 = SplTokenPubkey::new(&[3; 32]);
-        let mut multisig_data = vec![0; Multisig::get_packed_len()];
-        let mut signers = [SplTokenPubkey::default(); 11];
-        signers[0] = signer1;
-        signers[1] = signer2;
-        signers[2] = signer3;
-        let mut multisig = Multisig::unpack_unchecked(&multisig_data).unwrap();
-        multisig.m = 2;
-        multisig.n = 3;
-        multisig.is_initialized = true;
-        multisig.signers = signers;
-        Multisig::pack(multisig, &mut multisig_data).unwrap();
-
-        assert_eq!(
-            parse_token(&multisig_data, None).unwrap(),
-            TokenAccountType::Multisig(UiMultisig {
-                num_required_signers: 2,
-                num_valid_signers: 3,
-                is_initialized: true,
-                signers: vec![
-                    signer1.to_string(),
-                    signer2.to_string(),
-                    signer3.to_string()
-                ],
-            }),
-        );
-
-        let bad_data = vec![0; 4];
-        assert!(parse_token(&bad_data, None).is_err());
-    }
-
-    #[test]
-    fn test_get_token_account_mint() {
-        let mint_pubkey = SplTokenPubkey::new(&[2; 32]);
-        let mut account_data = vec![0; Account::get_packed_len()];
-        let mut account = Account::unpack_unchecked(&account_data).unwrap();
-        account.mint = mint_pubkey;
-        Account::pack(account, &mut account_data).unwrap();
-
-        let expected_mint_pubkey = Pubkey::new(&[2; 32]);
-        assert_eq!(
-            get_token_account_mint(&account_data),
-            Some(expected_mint_pubkey)
-        );
-    }
-
-    #[test]
-    fn test_ui_token_amount_real_string() {
-        assert_eq!(&real_number_string(1, 0), "1");
-        assert_eq!(&real_number_string_trimmed(1, 0), "1");
-        let token_amount = token_amount_to_ui_amount(1, 0);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(1, 0)
-        );
-        assert_eq!(token_amount.ui_amount, Some(1.0));
-        assert_eq!(&real_number_string(10, 0), "10");
-        assert_eq!(&real_number_string_trimmed(10, 0), "10");
-        let token_amount = token_amount_to_ui_amount(10, 0);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(10, 0)
-        );
-        assert_eq!(token_amount.ui_amount, Some(10.0));
-        assert_eq!(&real_number_string(1, 9), "0.000000001");
-        assert_eq!(&real_number_string_trimmed(1, 9), "0.000000001");
-        let token_amount = token_amount_to_ui_amount(1, 9);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(1, 9)
-        );
-        assert_eq!(token_amount.ui_amount, Some(0.000000001));
-        assert_eq!(&real_number_string(1_000_000_000, 9), "1.000000000");
-        assert_eq!(&real_number_string_trimmed(1_000_000_000, 9), "1");
-        let token_amount = token_amount_to_ui_amount(1_000_000_000, 9);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(1_000_000_000, 9)
-        );
-        assert_eq!(token_amount.ui_amount, Some(1.0));
-        assert_eq!(&real_number_string(1_234_567_890, 3), "1234567.890");
-        assert_eq!(&real_number_string_trimmed(1_234_567_890, 3), "1234567.89");
-        let token_amount = token_amount_to_ui_amount(1_234_567_890, 3);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(1_234_567_890, 3)
-        );
-        assert_eq!(token_amount.ui_amount, Some(1234567.89));
-        assert_eq!(
-            &real_number_string(1_234_567_890, 25),
-            "0.0000000000000001234567890"
-        );
-        assert_eq!(
-            &real_number_string_trimmed(1_234_567_890, 25),
-            "0.000000000000000123456789"
-        );
-        let token_amount = token_amount_to_ui_amount(1_234_567_890, 20);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(1_234_567_890, 20)
-        );
-        assert_eq!(token_amount.ui_amount, None);
-    }
-
-    #[test]
-    fn test_ui_token_amount_real_string_zero() {
-        assert_eq!(&real_number_string(0, 0), "0");
-        assert_eq!(&real_number_string_trimmed(0, 0), "0");
-        let token_amount = token_amount_to_ui_amount(0, 0);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(0, 0)
-        );
-        assert_eq!(token_amount.ui_amount, Some(0.0));
-        assert_eq!(&real_number_string(0, 9), "0.000000000");
-        assert_eq!(&real_number_string_trimmed(0, 9), "0");
-        let token_amount = token_amount_to_ui_amount(0, 9);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(0, 9)
-        );
-        assert_eq!(token_amount.ui_amount, Some(0.0));
-        assert_eq!(&real_number_string(0, 25), "0.0000000000000000000000000");
-        assert_eq!(&real_number_string_trimmed(0, 25), "0");
-        let token_amount = token_amount_to_ui_amount(0, 20);
-        assert_eq!(
-            token_amount.ui_amount_string,
-            real_number_string_trimmed(0, 20)
-        );
-        assert_eq!(token_amount.ui_amount, None);
-    }
-}

account-decoder/src/parse_vote.rs

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

account-decoder/src/validator_info.rs

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

accounts-bench/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-accounts-bench"
-version = "1.6.9"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-publish = false
-
-[dependencies]
-log = "0.4.11"
-rayon = "1.5.0"
-solana-logger = { path = "../logger", version = "=1.6.9" }
-solana-runtime = { path = "../runtime", version = "=1.6.9" }
-solana-measure = { path = "../measure", version = "=1.6.9" }
-solana-sdk = { path = "../sdk", version = "=1.6.9" }
-solana-version = { path = "../version", version = "=1.6.9" }
-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,143 +0,0 @@
-#![allow(clippy::integer_arithmetic)]
-#[macro_use]
-extern crate log;
-use clap::{crate_description, crate_name, value_t, App, Arg};
-use rayon::prelude::*;
-use solana_measure::measure::Measure;
-use solana_runtime::{
-    accounts::{create_test_accounts, update_accounts_bench, Accounts},
-    accounts_index::{AccountSecondaryIndexes, Ancestors},
-};
-use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
-use std::{env, fs, path::PathBuf};
-
-fn main() {
-    solana_logger::setup();
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_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(env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_owned()))
-        .join("accounts-bench");
-    println!("cleaning file system: {:?}", path);
-    if fs::remove_dir_all(path.clone()).is_err() {
-        println!("Warning: Couldn't remove {:?}", path);
-    }
-    let accounts = Accounts::new_with_config(
-        vec![path],
-        &ClusterType::Testnet,
-        AccountSecondaryIndexes::default(),
-        false,
-    );
-    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);
-    }
-    let mut elapsed = vec![0; iterations];
-    let mut elapsed_store = vec![0; iterations];
-    for x in 0..iterations {
-        if clean {
-            let mut time = Measure::start("clean");
-            accounts.accounts_db.clean_accounts(None);
-            time.stop();
-            println!("{}", time);
-            for slot in 0..num_slots {
-                update_accounts_bench(&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 results = accounts.accounts_db.update_accounts_hash(0, &ancestors);
-            time.stop();
-            let mut time_store = Measure::start("hash using store");
-            let results_store = accounts.accounts_db.update_accounts_hash_with_index_option(
-                false,
-                false,
-                solana_sdk::clock::Slot::default(),
-                &ancestors,
-                None,
-            );
-            time_store.stop();
-            if results != results_store {
-                error!("results different: \n{:?}\n{:?}", results, results_store);
-            }
-            println!(
-                "hash,{},{},{},{}%",
-                results.0,
-                time,
-                time_store,
-                (time_store.as_us() as f64 / time.as_us() as f64 * 100.0f64) as u32
-            );
-            create_test_accounts(&accounts, &mut pubkeys, 1, 0);
-            elapsed[x] = time.as_us();
-            elapsed_store[x] = time_store.as_us();
-        }
-    }
-
-    for x in elapsed {
-        info!("update_accounts_hash(us),{}", x);
-    }
-    for x in elapsed_store {
-        info!("calculate_accounts_hash_without_index(us),{}", x);
-    }
-}

accounts-cluster-bench/.gitignore

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

accounts-cluster-bench/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-edition = "2018"
-name = "solana-accounts-cluster-bench"
-version = "1.6.9"
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-publish = false
-
-[dependencies]
-clap = "2.33.1"
-log = "0.4.11"
-rand = "0.7.0"
-rayon = "1.4.1"
-solana-account-decoder = { path = "../account-decoder", version = "=1.6.9" }
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.9" }
-solana-client = { path = "../client", version = "=1.6.9" }
-solana-core = { path = "../core", version = "=1.6.9" }
-solana-measure = { path = "../measure", version = "=1.6.9" }
-solana-logger = { path = "../logger", version = "=1.6.9" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.9" }
-solana-faucet = { path = "../faucet", version = "=1.6.9" }
-solana-runtime = { path = "../runtime", version = "=1.6.9" }
-solana-sdk = { path = "../sdk", version = "=1.6.9" }
-solana-transaction-status = { path = "../transaction-status", version = "=1.6.9" }
-solana-version = { path = "../version", version = "=1.6.9" }
-spl-token-v2-0 = { package = "spl-token", version = "=3.1.0", features = ["no-entrypoint"] }
-
-[dev-dependencies]
-solana-local-cluster = { path = "../local-cluster", version = "=1.6.9" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

accounts-cluster-bench/src/main.rs

@@ -1,742 +0,0 @@
-#![allow(clippy::integer_arithmetic)]
-use clap::{crate_description, crate_name, value_t, values_t_or_exit, App, Arg};
-use log::*;
-use rand::{thread_rng, Rng};
-use rayon::prelude::*;
-use solana_account_decoder::parse_token::spl_token_v2_0_pubkey;
-use solana_clap_utils::input_parsers::pubkey_of;
-use solana_client::rpc_client::RpcClient;
-use solana_core::gossip_service::discover;
-use solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT};
-use solana_measure::measure::Measure;
-use solana_runtime::inline_spl_token_v2_0;
-use solana_sdk::{
-    commitment_config::CommitmentConfig,
-    message::Message,
-    pubkey::Pubkey,
-    rpc_port::DEFAULT_RPC_PORT,
-    signature::{read_keypair_file, Keypair, Signature, Signer},
-    system_instruction, system_program,
-    timing::timestamp,
-    transaction::Transaction,
-};
-use solana_transaction_status::parse_token::spl_token_v2_0_instruction;
-use std::{
-    net::SocketAddr,
-    process::exit,
-    sync::{
-        atomic::{AtomicBool, AtomicU64, Ordering},
-        Arc, RwLock,
-    },
-    thread::{sleep, Builder, JoinHandle},
-    time::{Duration, Instant},
-};
-
-// Create and close messages both require 2 signatures; if transaction construction changes, update
-// this magic number
-const NUM_SIGNATURES: u64 = 2;
-
-pub fn airdrop_lamports(
-    client: &RpcClient,
-    faucet_addr: &SocketAddr,
-    id: &Keypair,
-    desired_balance: u64,
-) -> bool {
-    let starting_balance = client.get_balance(&id.pubkey()).unwrap_or(0);
-    info!("starting balance {}", starting_balance);
-
-    if starting_balance < desired_balance {
-        let airdrop_amount = desired_balance - starting_balance;
-        info!(
-            "Airdropping {:?} lamports from {} for {}",
-            airdrop_amount,
-            faucet_addr,
-            id.pubkey(),
-        );
-
-        let (blockhash, _fee_calculator) = client.get_recent_blockhash().unwrap();
-        match request_airdrop_transaction(&faucet_addr, &id.pubkey(), airdrop_amount, blockhash) {
-            Ok(transaction) => {
-                let mut tries = 0;
-                loop {
-                    tries += 1;
-                    let result = client.send_and_confirm_transaction(&transaction);
-
-                    if result.is_ok() {
-                        break;
-                    }
-                    if tries >= 5 {
-                        panic!(
-                            "Error requesting airdrop: to addr: {:?} amount: {} {:?}",
-                            faucet_addr, airdrop_amount, result
-                        )
-                    }
-                }
-            }
-            Err(err) => {
-                panic!(
-                    "Error requesting airdrop: {:?} to addr: {:?} amount: {}",
-                    err, faucet_addr, airdrop_amount
-                );
-            }
-        };
-
-        let current_balance = client.get_balance(&id.pubkey()).unwrap_or_else(|e| {
-            panic!("airdrop error {}", e);
-        });
-        info!("current balance {}...", current_balance);
-
-        if current_balance - starting_balance != airdrop_amount {
-            info!(
-                "Airdrop failed? {} {} {} {}",
-                id.pubkey(),
-                current_balance,
-                starting_balance,
-                airdrop_amount,
-            );
-        }
-    }
-    true
-}
-
-// signature, timestamp, id
-type PendingQueue = Vec<(Signature, u64, u64)>;
-
-struct TransactionExecutor {
-    sig_clear_t: JoinHandle<()>,
-    sigs: Arc<RwLock<PendingQueue>>,
-    cleared: Arc<RwLock<Vec<u64>>>,
-    exit: Arc<AtomicBool>,
-    counter: AtomicU64,
-    client: RpcClient,
-}
-
-impl TransactionExecutor {
-    fn new(entrypoint_addr: SocketAddr) -> Self {
-        let sigs = Arc::new(RwLock::new(Vec::new()));
-        let cleared = Arc::new(RwLock::new(Vec::new()));
-        let exit = Arc::new(AtomicBool::new(false));
-        let sig_clear_t = Self::start_sig_clear_thread(&exit, &sigs, &cleared, entrypoint_addr);
-        let client =
-            RpcClient::new_socket_with_commitment(entrypoint_addr, CommitmentConfig::confirmed());
-        Self {
-            sigs,
-            cleared,
-            sig_clear_t,
-            exit,
-            counter: AtomicU64::new(0),
-            client,
-        }
-    }
-
-    fn num_outstanding(&self) -> usize {
-        self.sigs.read().unwrap().len()
-    }
-
-    fn push_transactions(&self, txs: Vec<Transaction>) -> Vec<u64> {
-        let mut ids = vec![];
-        let new_sigs = txs.into_iter().filter_map(|tx| {
-            let id = self.counter.fetch_add(1, Ordering::Relaxed);
-            ids.push(id);
-            match self.client.send_transaction(&tx) {
-                Ok(sig) => {
-                    return Some((sig, timestamp(), id));
-                }
-                Err(e) => {
-                    info!("error: {:#?}", e);
-                }
-            }
-            None
-        });
-        let mut sigs_w = self.sigs.write().unwrap();
-        sigs_w.extend(new_sigs);
-        ids
-    }
-
-    fn drain_cleared(&self) -> Vec<u64> {
-        std::mem::take(&mut *self.cleared.write().unwrap())
-    }
-
-    fn close(self) {
-        self.exit.store(true, Ordering::Relaxed);
-        self.sig_clear_t.join().unwrap();
-    }
-
-    fn start_sig_clear_thread(
-        exit: &Arc<AtomicBool>,
-        sigs: &Arc<RwLock<PendingQueue>>,
-        cleared: &Arc<RwLock<Vec<u64>>>,
-        entrypoint_addr: SocketAddr,
-    ) -> JoinHandle<()> {
-        let sigs = sigs.clone();
-        let exit = exit.clone();
-        let cleared = cleared.clone();
-        Builder::new()
-            .name("sig_clear".to_string())
-            .spawn(move || {
-                let client = RpcClient::new_socket_with_commitment(
-                    entrypoint_addr,
-                    CommitmentConfig::confirmed(),
-                );
-                let mut success = 0;
-                let mut error_count = 0;
-                let mut timed_out = 0;
-                let mut last_log = Instant::now();
-                while !exit.load(Ordering::Relaxed) {
-                    let sigs_len = sigs.read().unwrap().len();
-                    if sigs_len > 0 {
-                        let mut sigs_w = sigs.write().unwrap();
-                        let mut start = Measure::start("sig_status");
-                        let statuses: Vec<_> = sigs_w
-                            .chunks(200)
-                            .flat_map(|sig_chunk| {
-                                let only_sigs: Vec<_> = sig_chunk.iter().map(|s| s.0).collect();
-                                client
-                                    .get_signature_statuses(&only_sigs)
-                                    .expect("status fail")
-                                    .value
-                            })
-                            .collect();
-                        let mut num_cleared = 0;
-                        let start_len = sigs_w.len();
-                        let now = timestamp();
-                        let mut new_ids = vec![];
-                        let mut i = 0;
-                        let mut j = 0;
-                        while i != sigs_w.len() {
-                            let mut retain = true;
-                            let sent_ts = sigs_w[i].1;
-                            if let Some(e) = &statuses[j] {
-                                debug!("error: {:?}", e);
-                                if e.status.is_ok() {
-                                    success += 1;
-                                } else {
-                                    error_count += 1;
-                                }
-                                num_cleared += 1;
-                                retain = false;
-                            } else if now - sent_ts > 30_000 {
-                                retain = false;
-                                timed_out += 1;
-                            }
-                            if !retain {
-                                new_ids.push(sigs_w.remove(i).2);
-                            } else {
-                                i += 1;
-                            }
-                            j += 1;
-                        }
-                        let final_sigs_len = sigs_w.len();
-                        drop(sigs_w);
-                        cleared.write().unwrap().extend(new_ids);
-                        start.stop();
-                        debug!(
-                            "sigs len: {:?} success: {} took: {}ms cleared: {}/{}",
-                            final_sigs_len,
-                            success,
-                            start.as_ms(),
-                            num_cleared,
-                            start_len,
-                        );
-                        if last_log.elapsed().as_millis() > 5000 {
-                            info!(
-                                "success: {} error: {} timed_out: {}",
-                                success, error_count, timed_out,
-                            );
-                            last_log = Instant::now();
-                        }
-                    }
-                    sleep(Duration::from_millis(200));
-                }
-            })
-            .unwrap()
-    }
-}
-
-struct SeedTracker {
-    max_created: Arc<AtomicU64>,
-    max_closed: Arc<AtomicU64>,
-}
-
-fn make_create_message(
-    keypair: &Keypair,
-    base_keypair: &Keypair,
-    max_created_seed: Arc<AtomicU64>,
-    num_instructions: usize,
-    balance: u64,
-    maybe_space: Option<u64>,
-    mint: Option<Pubkey>,
-) -> Message {
-    let space = maybe_space.unwrap_or_else(|| thread_rng().gen_range(0, 1000));
-
-    let instructions: Vec<_> = (0..num_instructions)
-        .into_iter()
-        .map(|_| {
-            let program_id = if mint.is_some() {
-                inline_spl_token_v2_0::id()
-            } else {
-                system_program::id()
-            };
-            let seed = max_created_seed.fetch_add(1, Ordering::Relaxed).to_string();
-            let to_pubkey =
-                Pubkey::create_with_seed(&base_keypair.pubkey(), &seed, &program_id).unwrap();
-            let mut instructions = vec![system_instruction::create_account_with_seed(
-                &keypair.pubkey(),
-                &to_pubkey,
-                &base_keypair.pubkey(),
-                &seed,
-                balance,
-                space,
-                &program_id,
-            )];
-            if let Some(mint_address) = mint {
-                instructions.push(spl_token_v2_0_instruction(
-                    spl_token_v2_0::instruction::initialize_account(
-                        &spl_token_v2_0::id(),
-                        &spl_token_v2_0_pubkey(&to_pubkey),
-                        &spl_token_v2_0_pubkey(&mint_address),
-                        &spl_token_v2_0_pubkey(&base_keypair.pubkey()),
-                    )
-                    .unwrap(),
-                ));
-            }
-
-            instructions
-        })
-        .collect();
-    let instructions: Vec<_> = instructions.into_iter().flatten().collect();
-
-    Message::new(&instructions, Some(&keypair.pubkey()))
-}
-
-fn make_close_message(
-    keypair: &Keypair,
-    base_keypair: &Keypair,
-    max_closed_seed: Arc<AtomicU64>,
-    num_instructions: usize,
-    balance: u64,
-    spl_token: bool,
-) -> Message {
-    let instructions: Vec<_> = (0..num_instructions)
-        .into_iter()
-        .map(|_| {
-            let program_id = if spl_token {
-                inline_spl_token_v2_0::id()
-            } else {
-                system_program::id()
-            };
-            let seed = max_closed_seed.fetch_add(1, Ordering::Relaxed).to_string();
-            let address =
-                Pubkey::create_with_seed(&base_keypair.pubkey(), &seed, &program_id).unwrap();
-            if spl_token {
-                spl_token_v2_0_instruction(
-                    spl_token_v2_0::instruction::close_account(
-                        &spl_token_v2_0::id(),
-                        &spl_token_v2_0_pubkey(&address),
-                        &spl_token_v2_0_pubkey(&keypair.pubkey()),
-                        &spl_token_v2_0_pubkey(&base_keypair.pubkey()),
-                        &[],
-                    )
-                    .unwrap(),
-                )
-            } else {
-                system_instruction::transfer_with_seed(
-                    &address,
-                    &base_keypair.pubkey(),
-                    seed,
-                    &program_id,
-                    &keypair.pubkey(),
-                    balance,
-                )
-            }
-        })
-        .collect();
-
-    Message::new(&instructions, Some(&keypair.pubkey()))
-}
-
-#[allow(clippy::too_many_arguments)]
-fn run_accounts_bench(
-    entrypoint_addr: SocketAddr,
-    faucet_addr: SocketAddr,
-    payer_keypairs: &[&Keypair],
-    iterations: usize,
-    maybe_space: Option<u64>,
-    batch_size: usize,
-    close_nth: u64,
-    maybe_lamports: Option<u64>,
-    num_instructions: usize,
-    mint: Option<Pubkey>,
-) {
-    assert!(num_instructions > 0);
-    let client =
-        RpcClient::new_socket_with_commitment(entrypoint_addr, CommitmentConfig::confirmed());
-
-    info!("Targeting {}", entrypoint_addr);
-
-    let mut last_blockhash = Instant::now();
-    let mut last_log = Instant::now();
-    let mut count = 0;
-    let mut recent_blockhash = client.get_recent_blockhash().expect("blockhash");
-    let mut tx_sent_count = 0;
-    let mut total_accounts_created = 0;
-    let mut total_accounts_closed = 0;
-    let mut balances: Vec<_> = payer_keypairs
-        .iter()
-        .map(|keypair| client.get_balance(&keypair.pubkey()).unwrap_or(0))
-        .collect();
-    let mut last_balance = Instant::now();
-
-    let default_max_lamports = 1000;
-    let min_balance = maybe_lamports.unwrap_or_else(|| {
-        let space = maybe_space.unwrap_or(default_max_lamports);
-        client
-            .get_minimum_balance_for_rent_exemption(space as usize)
-            .expect("min balance")
-    });
-
-    let base_keypair = Keypair::new();
-    let seed_tracker = SeedTracker {
-        max_created: Arc::new(AtomicU64::default()),
-        max_closed: Arc::new(AtomicU64::default()),
-    };
-
-    info!("Starting balance(s): {:?}", balances);
-
-    let executor = TransactionExecutor::new(entrypoint_addr);
-
-    loop {
-        if last_blockhash.elapsed().as_millis() > 10_000 {
-            recent_blockhash = client.get_recent_blockhash().expect("blockhash");
-            last_blockhash = Instant::now();
-        }
-
-        let fee = recent_blockhash
-            .1
-            .lamports_per_signature
-            .saturating_mul(NUM_SIGNATURES);
-        let lamports = min_balance + fee;
-
-        for (i, balance) in balances.iter_mut().enumerate() {
-            if *balance < lamports || last_balance.elapsed().as_millis() > 2000 {
-                if let Ok(b) = client.get_balance(&payer_keypairs[i].pubkey()) {
-                    *balance = b;
-                }
-                last_balance = Instant::now();
-                if *balance < lamports * 2 {
-                    info!(
-                        "Balance {} is less than needed: {}, doing aidrop...",
-                        balance, lamports
-                    );
-                    if !airdrop_lamports(
-                        &client,
-                        &faucet_addr,
-                        &payer_keypairs[i],
-                        lamports * 100_000,
-                    ) {
-                        warn!("failed airdrop, exiting");
-                        return;
-                    }
-                }
-            }
-        }
-
-        let sigs_len = executor.num_outstanding();
-        if sigs_len < batch_size {
-            let num_to_create = batch_size - sigs_len;
-            if num_to_create >= payer_keypairs.len() {
-                info!("creating {} new", num_to_create);
-                let chunk_size = num_to_create / payer_keypairs.len();
-                if chunk_size > 0 {
-                    for (i, keypair) in payer_keypairs.iter().enumerate() {
-                        let txs: Vec<_> = (0..chunk_size)
-                            .into_par_iter()
-                            .map(|_| {
-                                let message = make_create_message(
-                                    keypair,
-                                    &base_keypair,
-                                    seed_tracker.max_created.clone(),
-                                    num_instructions,
-                                    min_balance,
-                                    maybe_space,
-                                    mint,
-                                );
-                                let signers: Vec<&Keypair> = vec![keypair, &base_keypair];
-                                Transaction::new(&signers, message, recent_blockhash.0)
-                            })
-                            .collect();
-                        balances[i] = balances[i].saturating_sub(lamports * txs.len() as u64);
-                        info!("txs: {}", txs.len());
-                        let new_ids = executor.push_transactions(txs);
-                        info!("ids: {}", new_ids.len());
-                        tx_sent_count += new_ids.len();
-                        total_accounts_created += num_instructions * new_ids.len();
-                    }
-                }
-            }
-
-            if close_nth > 0 {
-                let expected_closed = total_accounts_created as u64 / close_nth;
-                if expected_closed > total_accounts_closed {
-                    let txs: Vec<_> = (0..expected_closed - total_accounts_closed)
-                        .into_par_iter()
-                        .map(|_| {
-                            let message = make_close_message(
-                                &payer_keypairs[0],
-                                &base_keypair,
-                                seed_tracker.max_closed.clone(),
-                                1,
-                                min_balance,
-                                mint.is_some(),
-                            );
-                            let signers: Vec<&Keypair> = vec![&payer_keypairs[0], &base_keypair];
-                            Transaction::new(&signers, message, recent_blockhash.0)
-                        })
-                        .collect();
-                    balances[0] = balances[0].saturating_sub(fee * txs.len() as u64);
-                    info!("close txs: {}", txs.len());
-                    let new_ids = executor.push_transactions(txs);
-                    info!("close ids: {}", new_ids.len());
-                    tx_sent_count += new_ids.len();
-                    total_accounts_closed += new_ids.len() as u64;
-                }
-            }
-        } else {
-            let _ = executor.drain_cleared();
-        }
-
-        count += 1;
-        if last_log.elapsed().as_millis() > 3000 {
-            info!(
-                "total_accounts_created: {} total_accounts_closed: {} tx_sent_count: {} loop_count: {} balance(s): {:?}",
-                total_accounts_created, total_accounts_closed, tx_sent_count, count, balances
-            );
-            last_log = Instant::now();
-        }
-        if iterations != 0 && count >= iterations {
-            break;
-        }
-        if executor.num_outstanding() >= batch_size {
-            sleep(Duration::from_millis(500));
-        }
-    }
-    executor.close();
-}
-
-fn main() {
-    solana_logger::setup_with_default("solana=info");
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("entrypoint")
-                .long("entrypoint")
-                .takes_value(true)
-                .value_name("HOST:PORT")
-                .help("RPC entrypoint address. Usually <ip>:8899"),
-        )
-        .arg(
-            Arg::with_name("faucet_addr")
-                .long("faucet")
-                .takes_value(true)
-                .value_name("HOST:PORT")
-                .help("Faucet entrypoint address. Usually <ip>:9900"),
-        )
-        .arg(
-            Arg::with_name("space")
-                .long("space")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help("Size of accounts to create"),
-        )
-        .arg(
-            Arg::with_name("lamports")
-                .long("lamports")
-                .takes_value(true)
-                .value_name("LAMPORTS")
-                .help("How many lamports to fund each account"),
-        )
-        .arg(
-            Arg::with_name("identity")
-                .long("identity")
-                .takes_value(true)
-                .multiple(true)
-                .value_name("FILE")
-                .help("keypair file"),
-        )
-        .arg(
-            Arg::with_name("batch_size")
-                .long("batch-size")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help("Number of transactions to send per batch"),
-        )
-        .arg(
-            Arg::with_name("close_nth")
-                .long("close-frequency")
-                .takes_value(true)
-                .value_name("BYTES")
-                .help(
-                    "Send close transactions after this many accounts created. \
-                    Note: a `close-frequency` value near or below `batch-size` \
-                    may result in transaction-simulation errors, as the close \
-                    transactions will be submitted before the corresponding \
-                    create transactions have been confirmed",
-                ),
-        )
-        .arg(
-            Arg::with_name("num_instructions")
-                .long("num-instructions")
-                .takes_value(true)
-                .value_name("NUM")
-                .help("Number of accounts to create on each transaction"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .value_name("NUM")
-                .help("Number of iterations to make"),
-        )
-        .arg(
-            Arg::with_name("check_gossip")
-                .long("check-gossip")
-                .help("Just use entrypoint address directly"),
-        )
-        .arg(
-            Arg::with_name("mint")
-                .long("mint")
-                .takes_value(true)
-                .help("Mint address to initialize account"),
-        )
-        .get_matches();
-
-    let skip_gossip = !matches.is_present("check_gossip");
-
-    let port = if skip_gossip { DEFAULT_RPC_PORT } else { 8001 };
-    let mut entrypoint_addr = SocketAddr::from(([127, 0, 0, 1], port));
-    if let Some(addr) = matches.value_of("entrypoint") {
-        entrypoint_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
-            eprintln!("failed to parse entrypoint address: {}", e);
-            exit(1)
-        });
-    }
-    let mut faucet_addr = SocketAddr::from(([127, 0, 0, 1], FAUCET_PORT));
-    if let Some(addr) = matches.value_of("faucet_addr") {
-        faucet_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
-            eprintln!("failed to parse entrypoint address: {}", e);
-            exit(1)
-        });
-    }
-
-    let space = value_t!(matches, "space", u64).ok();
-    let lamports = value_t!(matches, "lamports", u64).ok();
-    let batch_size = value_t!(matches, "batch_size", usize).unwrap_or(4);
-    let close_nth = value_t!(matches, "close_nth", u64).unwrap_or(0);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(10);
-    let num_instructions = value_t!(matches, "num_instructions", usize).unwrap_or(1);
-    if num_instructions == 0 || num_instructions > 500 {
-        eprintln!("bad num_instructions: {}", num_instructions);
-        exit(1);
-    }
-
-    let mint = pubkey_of(&matches, "mint");
-
-    let payer_keypairs: Vec<_> = values_t_or_exit!(matches, "identity", String)
-        .iter()
-        .map(|keypair_string| {
-            read_keypair_file(keypair_string)
-                .unwrap_or_else(|_| panic!("bad keypair {:?}", keypair_string))
-        })
-        .collect();
-    let mut payer_keypair_refs: Vec<&Keypair> = vec![];
-    for keypair in payer_keypairs.iter() {
-        payer_keypair_refs.push(keypair);
-    }
-
-    let rpc_addr = if !skip_gossip {
-        info!("Finding cluster entry: {:?}", entrypoint_addr);
-        let (gossip_nodes, _validators) = discover(
-            None,
-            Some(&entrypoint_addr),
-            None,
-            Some(60),
-            None,
-            Some(&entrypoint_addr),
-            None,
-            0,
-        )
-        .unwrap_or_else(|err| {
-            eprintln!("Failed to discover {} node: {:?}", entrypoint_addr, err);
-            exit(1);
-        });
-
-        info!("done found {} nodes", gossip_nodes.len());
-        gossip_nodes[0].rpc
-    } else {
-        info!("Using {:?} as the RPC address", entrypoint_addr);
-        entrypoint_addr
-    };
-
-    run_accounts_bench(
-        rpc_addr,
-        faucet_addr,
-        &payer_keypair_refs,
-        iterations,
-        space,
-        batch_size,
-        close_nth,
-        lamports,
-        num_instructions,
-        mint,
-    );
-}
-
-#[cfg(test)]
-pub mod test {
-    use super::*;
-    use solana_core::validator::ValidatorConfig;
-    use solana_local_cluster::{
-        local_cluster::{ClusterConfig, LocalCluster},
-        validator_configs::make_identical_validator_configs,
-    };
-    use solana_sdk::poh_config::PohConfig;
-
-    #[test]
-    fn test_accounts_cluster_bench() {
-        solana_logger::setup();
-        let validator_config = ValidatorConfig::default();
-        let num_nodes = 1;
-        let mut config = ClusterConfig {
-            cluster_lamports: 10_000_000,
-            poh_config: PohConfig::new_sleep(Duration::from_millis(50)),
-            node_stakes: vec![100; num_nodes],
-            validator_configs: make_identical_validator_configs(&validator_config, num_nodes),
-            ..ClusterConfig::default()
-        };
-
-        let faucet_addr = SocketAddr::from(([127, 0, 0, 1], 9900));
-        let cluster = LocalCluster::new(&mut config);
-        let iterations = 10;
-        let maybe_space = None;
-        let batch_size = 100;
-        let close_nth = 100;
-        let maybe_lamports = None;
-        let num_instructions = 2;
-        let mut start = Measure::start("total accounts run");
-        run_accounts_bench(
-            cluster.entry_point_info.rpc,
-            faucet_addr,
-            &[&cluster.funding_keypair],
-            iterations,
-            maybe_space,
-            batch_size,
-            close_nth,
-            maybe_lamports,
-            num_instructions,
-            None,
-        );
-        start.stop();
-        info!("{}", start);
-    }
-}

archiver/Cargo.toml

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

archiver/src/main.rs

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

banking-bench/Cargo.toml

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

banking-bench/src/main.rs

@@ -1,39 +1,30 @@
-#![allow(clippy::integer_arithmetic)]
-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::{blocktree::Blocktree, get_tmp_ledger_path};
 use solana_measure::measure::Measure;
-use solana_perf::packet::to_packets_chunked;
-use solana_runtime::{
-    accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
-};
-use solana_sdk::{
-    hash::Hash,
-    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>>,
@@ -66,23 +57,16 @@ fn check_txs(
     no_bank
 }
 
-fn make_accounts_txs(
-    total_num_transactions: usize,
-    hash: Hash,
-    same_payer: bool,
-) -> Vec<Transaction> {
-    let to_pubkey = solana_sdk::pubkey::new_rand();
-    let payer_key = Keypair::new();
-    let dummy = system_transaction::transfer(&payer_key, &to_pubkey, 1, hash);
-    (0..total_num_transactions)
+fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> {
+    let to_pubkey = Pubkey::new_rand();
+    let dummy = system_transaction::transfer(mint_keypair, &to_pubkey, 1, hash);
+    (0..txes)
         .into_par_iter()
         .map(|_| {
             let mut new = dummy.clone();
             let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen()).collect();
-            if !same_payer {
-                new.message.account_keys[0] = solana_sdk::pubkey::new_rand();
-            }
-            new.message.account_keys[1] = solana_sdk::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
         })
@@ -105,61 +89,13 @@ fn bytes_as_usize(bytes: &[u8]) -> usize {
     bytes[0] as usize | (bytes[1] as usize) << 8
 }
 
-#[allow(clippy::cognitive_complexity)]
 fn main() {
     solana_logger::setup();
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(solana_version::version!())
-        .arg(
-            Arg::with_name("num_chunks")
-                .long("num-chunks")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Number of transaction chunks."),
-        )
-        .arg(
-            Arg::with_name("packets_per_chunk")
-                .long("packets-per-chunk")
-                .takes_value(true)
-                .value_name("SIZE")
-                .help("Packets per chunk"),
-        )
-        .arg(
-            Arg::with_name("skip_sanity")
-                .long("skip-sanity")
-                .takes_value(false)
-                .help("Skip transaction sanity execution"),
-        )
-        .arg(
-            Arg::with_name("same_payer")
-                .long("same-payer")
-                .takes_value(false)
-                .help("Use the same payer for transfers"),
-        )
-        .arg(
-            Arg::with_name("iterations")
-                .long("iterations")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .arg(
-            Arg::with_name("num_threads")
-                .long("num-threads")
-                .takes_value(true)
-                .help("Number of iterations"),
-        )
-        .get_matches();
-
-    let num_threads =
-        value_t!(matches, "num_threads", usize).unwrap_or(BankingStage::num_threads() as usize);
+    let num_threads = BankingStage::num_threads() as usize;
     //   a multiple of packet chunk duplicates to avoid races
-    let num_chunks = value_t!(matches, "num_chunks", usize).unwrap_or(16);
-    let packets_per_chunk = value_t!(matches, "packets_per_chunk", usize).unwrap_or(192);
-    let iterations = value_t!(matches, "iterations", usize).unwrap_or(1000);
-
-    let total_num_transactions = num_chunks * num_threads * packets_per_chunk;
+    const CHUNKS: usize = 8 * 2;
+    const PACKETS_PER_BATCH: usize = 192;
+    let txes = PACKETS_PER_BATCH * num_threads * CHUNKS;
     let mint_total = 1_000_000_000_000;
     let GenesisConfigInfo {
         genesis_config,
@@ -169,88 +105,76 @@ 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(
-            Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"),
+        let blocktree = Arc::new(
+            Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger"),
         );
         let (exit, poh_recorder, poh_service, signal_receiver) =
-            create_test_recorder(&bank, &blockstore, None);
+            create_test_recorder(&bank, &blocktree, 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.
         // If it is dropped before poh_service, then poh_service will error when
         // calling send() on the channel.
         let signal_receiver = Arc::new(signal_receiver);
-        let mut total_us = 0;
-        let mut tx_total_us = 0;
-        let base_tx_count = bank.transaction_count();
+        let signal_receiver2 = signal_receiver.clone();
+        let mut total = 0;
+        let mut tx_total = 0;
         let mut txs_processed = 0;
         let mut root = 1;
-        let collector = solana_sdk::pubkey::new_rand();
+        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;
 
@@ -291,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_receiver2, txes / CHUNKS, &poh_recorder) {
                 debug!(
                     "resetting bank {} tx count: {} txs_proc: {}",
                     bank.slot(),
@@ -304,7 +224,7 @@ fn main() {
                 );
                 assert!(txs_processed < bank.transaction_count());
                 txs_processed = bank.transaction_count();
-                tx_total_us += duration_as_us(&now.elapsed());
+                tx_total += duration_as_us(&now.elapsed());
 
                 let mut poh_time = Measure::start("poh_time");
                 poh_recorder.lock().unwrap().reset(
@@ -326,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, &AbsRequestSender::default(), None);
+                    bank_forks.set_root(root, &None);
                     root += 1;
                 }
                 debug!(
@@ -336,21 +256,20 @@ fn main() {
                     poh_time.as_us(),
                 );
             } else {
-                tx_total_us += duration_as_us(&now.elapsed());
+                tx_total += duration_as_us(&now.elapsed());
             }
 
             // This signature clear may not actually clear the signatures
             // in this chunk, but since we rotate between CHUNKS then
             // we should clear them by the time we come around again to re-use that chunk.
             bank.clear_signatures();
-            total_us += duration_as_us(&now.elapsed());
+            total += duration_as_us(&now.elapsed());
             debug!(
                 "time: {} us checked: {} sent: {}",
                 duration_as_us(&now.elapsed()),
-                total_num_transactions / num_chunks,
+                txes / CHUNKS,
                 sent,
             );
-            total_sent += sent;
 
             if bank.slot() > 0 && bank.slot() % 16 == 0 {
                 for tx in transactions.iter_mut() {
@@ -358,25 +277,19 @@ 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}'}}",
-            (1000.0 * 1000.0 * total_sent as f64) / (total_us as f64),
+            "{{'name': 'banking_bench_total', 'median': '{}'}}",
+            total / ITERS as u64,
         );
         eprintln!(
-            "{{'name': 'banking_bench_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * total_sent as f64) / (tx_total_us as f64),
-        );
-        eprintln!(
-            "{{'name': 'banking_bench_success_tx_total', 'median': '{:.2}'}}",
-            (1000.0 * 1000.0 * (txs_processed - base_tx_count) as f64) / (total_us as f64),
+            "{{'name': 'banking_bench_tx_total', 'median': '{}'}}",
+            tx_total / ITERS as u64,
         );
 
         drop(verified_sender);
@@ -388,5 +301,5 @@ fn main() {
         sleep(Duration::from_secs(1));
         debug!("waited for poh_service");
     }
-    let _unused = Blockstore::destroy(&ledger_path);
+    let _unused = Blocktree::destroy(&ledger_path);
 }

banks-client/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "solana-banks-client"
-version = "1.6.9"
-description = "Solana banks client"
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-banks-client"
-edition = "2018"
-
-[dependencies]
-bincode = "1.3.1"
-borsh = "0.8.1"
-borsh-derive = "0.8.1"
-futures = "0.3"
-mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.6.9" }
-solana-program = { path = "../sdk/program", version = "=1.6.9" }
-solana-sdk = { path = "../sdk", version = "=1.6.9" }
-tarpc = { version = "0.24.1", features = ["full"] }
-tokio = { version = "1", features = ["full"] }
-tokio-serde = { version = "0.8", features = ["bincode"] }
-
-[dev-dependencies]
-solana-runtime = { path = "../runtime", version = "=1.6.9" }
-solana-banks-server = { path = "../banks-server", version = "=1.6.9" }
-
-[lib]
-crate-type = ["lib"]
-name = "solana_banks_client"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

banks-client/src/lib.rs

@@ -1,406 +0,0 @@
-//! A client for the ledger state, from the perspective of an arbitrary validator.
-//!
-//! Use start_tcp_client() to create a client and then import BanksClientExt to
-//! access its methods. Additional "*_with_context" methods are also available,
-//! but they are undocumented, may change over time, and are generally more
-//! cumbersome to use.
-
-use borsh::BorshDeserialize;
-use futures::{future::join_all, Future, FutureExt};
-pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
-use solana_banks_interface::{BanksRequest, BanksResponse};
-use solana_program::{
-    clock::Slot, fee_calculator::FeeCalculator, hash::Hash, program_pack::Pack, pubkey::Pubkey,
-    rent::Rent, sysvar,
-};
-use solana_sdk::{
-    account::{from_account, Account},
-    commitment_config::CommitmentLevel,
-    signature::Signature,
-    transaction::{self, Transaction},
-    transport,
-};
-use std::io::{self, Error, ErrorKind};
-use tarpc::{
-    client::{self, channel::RequestDispatch, NewClient},
-    context::{self, Context},
-    rpc::{ClientMessage, Response},
-    serde_transport::tcp,
-    Transport,
-};
-use tokio::{net::ToSocketAddrs, time::Duration};
-use tokio_serde::formats::Bincode;
-
-// This exists only for backward compatibility
-pub trait BanksClientExt {}
-
-#[derive(Clone)]
-pub struct BanksClient {
-    inner: TarpcClient,
-}
-
-impl BanksClient {
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new<C>(
-        config: client::Config,
-        transport: C,
-    ) -> NewClient<TarpcClient, RequestDispatch<BanksRequest, BanksResponse, C>>
-    where
-        C: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>>,
-    {
-        TarpcClient::new(config, transport)
-    }
-
-    pub fn send_transaction_with_context(
-        &mut self,
-        ctx: Context,
-        transaction: Transaction,
-    ) -> impl Future<Output = io::Result<()>> + '_ {
-        self.inner.send_transaction_with_context(ctx, transaction)
-    }
-
-    pub fn get_fees_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
-        self.inner
-            .get_fees_with_commitment_and_context(ctx, commitment)
-    }
-
-    pub fn get_transaction_status_with_context(
-        &mut self,
-        ctx: Context,
-        signature: Signature,
-    ) -> impl Future<Output = io::Result<Option<TransactionStatus>>> + '_ {
-        self.inner
-            .get_transaction_status_with_context(ctx, signature)
-    }
-
-    pub fn get_slot_with_context(
-        &mut self,
-        ctx: Context,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.inner.get_slot_with_context(ctx, commitment)
-    }
-
-    pub fn process_transaction_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<transaction::Result<()>>>> + '_ {
-        self.inner
-            .process_transaction_with_commitment_and_context(ctx, transaction, commitment)
-    }
-
-    pub fn get_account_with_commitment_and_context(
-        &mut self,
-        ctx: Context,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.inner
-            .get_account_with_commitment_and_context(ctx, address, commitment)
-    }
-
-    /// Send a transaction and return immediately. The server will resend the
-    /// transaction until either it is accepted by the cluster or the transaction's
-    /// blockhash expires.
-    pub fn send_transaction(
-        &mut self,
-        transaction: Transaction,
-    ) -> impl Future<Output = io::Result<()>> + '_ {
-        self.send_transaction_with_context(context::current(), transaction)
-    }
-
-    /// Return the fee parameters associated with a recent, rooted blockhash. The cluster
-    /// will use the transaction's blockhash to look up these same fee parameters and
-    /// use them to calculate the transaction fee.
-    pub fn get_fees(
-        &mut self,
-    ) -> impl Future<Output = io::Result<(FeeCalculator, Hash, Slot)>> + '_ {
-        self.get_fees_with_commitment_and_context(context::current(), CommitmentLevel::default())
-    }
-
-    /// Return the cluster rent
-    pub fn get_rent(&mut self) -> impl Future<Output = io::Result<Rent>> + '_ {
-        self.get_account(sysvar::rent::id()).map(|result| {
-            let rent_sysvar = result?
-                .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Rent sysvar not present"))?;
-            from_account::<Rent, _>(&rent_sysvar).ok_or_else(|| {
-                io::Error::new(io::ErrorKind::Other, "Failed to deserialize Rent sysvar")
-            })
-        })
-    }
-
-    /// Return a recent, rooted blockhash from the server. The cluster will only accept
-    /// transactions with a blockhash that has not yet expired. Use the `get_fees`
-    /// method to get both a blockhash and the blockhash's last valid slot.
-    pub fn get_recent_blockhash(&mut self) -> impl Future<Output = io::Result<Hash>> + '_ {
-        self.get_fees().map(|result| Ok(result?.1))
-    }
-
-    /// Send a transaction and return after the transaction has been rejected or
-    /// reached the given level of commitment.
-    pub fn process_transaction_with_commitment(
-        &mut self,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        let mut ctx = context::current();
-        ctx.deadline += Duration::from_secs(50);
-        self.process_transaction_with_commitment_and_context(ctx, transaction, commitment)
-            .map(|result| match result? {
-                None => {
-                    Err(Error::new(ErrorKind::TimedOut, "invalid blockhash or fee-payer").into())
-                }
-                Some(transaction_result) => Ok(transaction_result?),
-            })
-    }
-
-    /// Send a transaction and return until the transaction has been finalized or rejected.
-    pub fn process_transaction(
-        &mut self,
-        transaction: Transaction,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        self.process_transaction_with_commitment(transaction, CommitmentLevel::default())
-    }
-
-    pub async fn process_transactions_with_commitment(
-        &mut self,
-        transactions: Vec<Transaction>,
-        commitment: CommitmentLevel,
-    ) -> transport::Result<()> {
-        let mut clients: Vec<_> = transactions.iter().map(|_| self.clone()).collect();
-        let futures = clients
-            .iter_mut()
-            .zip(transactions)
-            .map(|(client, transaction)| {
-                client.process_transaction_with_commitment(transaction, commitment)
-            });
-        let statuses = join_all(futures).await;
-        statuses.into_iter().collect() // Convert Vec<Result<_, _>> to Result<Vec<_>>
-    }
-
-    /// Send transactions and return until the transaction has been finalized or rejected.
-    pub fn process_transactions(
-        &mut self,
-        transactions: Vec<Transaction>,
-    ) -> impl Future<Output = transport::Result<()>> + '_ {
-        self.process_transactions_with_commitment(transactions, CommitmentLevel::default())
-    }
-
-    /// Return the most recent rooted slot height. All transactions at or below this height
-    /// are said to be finalized. The cluster will not fork to a higher slot height.
-    pub fn get_root_slot(&mut self) -> impl Future<Output = io::Result<Slot>> + '_ {
-        self.get_slot_with_context(context::current(), CommitmentLevel::default())
-    }
-
-    /// Return the account at the given address at the slot corresponding to the given
-    /// commitment level. If the account is not found, None is returned.
-    pub fn get_account_with_commitment(
-        &mut self,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.get_account_with_commitment_and_context(context::current(), address, commitment)
-    }
-
-    /// Return the account at the given address at the time of the most recent root slot.
-    /// If the account is not found, None is returned.
-    pub fn get_account(
-        &mut self,
-        address: Pubkey,
-    ) -> impl Future<Output = io::Result<Option<Account>>> + '_ {
-        self.get_account_with_commitment(address, CommitmentLevel::default())
-    }
-
-    /// Return the unpacked account data at the given address
-    /// If the account is not found, an error is returned
-    pub fn get_packed_account_data<T: Pack>(
-        &mut self,
-        address: Pubkey,
-    ) -> impl Future<Output = io::Result<T>> + '_ {
-        self.get_account(address).map(|result| {
-            let account =
-                result?.ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Account not found"))?;
-            T::unpack_from_slice(&account.data)
-                .map_err(|_| io::Error::new(io::ErrorKind::Other, "Failed to deserialize account"))
-        })
-    }
-
-    /// Return the unpacked account data at the given address
-    /// If the account is not found, an error is returned
-    pub fn get_account_data_with_borsh<T: BorshDeserialize>(
-        &mut self,
-        address: Pubkey,
-    ) -> impl Future<Output = io::Result<T>> + '_ {
-        self.get_account(address).map(|result| {
-            let account =
-                result?.ok_or_else(|| io::Error::new(io::ErrorKind::Other, "account not found"))?;
-            T::try_from_slice(&account.data)
-        })
-    }
-
-    /// Return the balance in lamports of an account at the given address at the slot
-    /// corresponding to the given commitment level.
-    pub fn get_balance_with_commitment(
-        &mut self,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> impl Future<Output = io::Result<u64>> + '_ {
-        self.get_account_with_commitment_and_context(context::current(), address, commitment)
-            .map(|result| Ok(result?.map(|x| x.lamports).unwrap_or(0)))
-    }
-
-    /// Return the balance in lamports of an account at the given address at the time
-    /// of the most recent root slot.
-    pub fn get_balance(&mut self, address: Pubkey) -> impl Future<Output = io::Result<u64>> + '_ {
-        self.get_balance_with_commitment(address, CommitmentLevel::default())
-    }
-
-    /// Return the status of a transaction with a signature matching the transaction's first
-    /// signature. Return None if the transaction is not found, which may be because the
-    /// blockhash was expired or the fee-paying account had insufficient funds to pay the
-    /// transaction fee. Note that servers rarely store the full transaction history. This
-    /// method may return None if the transaction status has been discarded.
-    pub fn get_transaction_status(
-        &mut self,
-        signature: Signature,
-    ) -> impl Future<Output = io::Result<Option<TransactionStatus>>> + '_ {
-        self.get_transaction_status_with_context(context::current(), signature)
-    }
-
-    /// Same as get_transaction_status, but for multiple transactions.
-    pub async fn get_transaction_statuses(
-        &mut self,
-        signatures: Vec<Signature>,
-    ) -> io::Result<Vec<Option<TransactionStatus>>> {
-        // tarpc futures oddly hold a mutable reference back to the client so clone the client upfront
-        let mut clients_and_signatures: Vec<_> = signatures
-            .into_iter()
-            .map(|signature| (self.clone(), signature))
-            .collect();
-
-        let futs = clients_and_signatures
-            .iter_mut()
-            .map(|(client, signature)| client.get_transaction_status(*signature));
-
-        let statuses = join_all(futs).await;
-
-        // Convert Vec<Result<_, _>> to Result<Vec<_>>
-        statuses.into_iter().collect()
-    }
-}
-
-pub async fn start_client<C>(transport: C) -> io::Result<BanksClient>
-where
-    C: Transport<ClientMessage<BanksRequest>, Response<BanksResponse>> + Send + 'static,
-{
-    Ok(BanksClient {
-        inner: TarpcClient::new(client::Config::default(), transport).spawn()?,
-    })
-}
-
-pub async fn start_tcp_client<T: ToSocketAddrs>(addr: T) -> io::Result<BanksClient> {
-    let transport = tcp::connect(addr, Bincode::default).await?;
-    Ok(BanksClient {
-        inner: TarpcClient::new(client::Config::default(), transport).spawn()?,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_banks_server::banks_server::start_local_server;
-    use solana_runtime::{
-        bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache,
-        genesis_utils::create_genesis_config,
-    };
-    use solana_sdk::{message::Message, signature::Signer, system_instruction};
-    use std::sync::{Arc, RwLock};
-    use tarpc::transport;
-    use tokio::{runtime::Runtime, time::sleep};
-
-    #[test]
-    fn test_banks_client_new() {
-        let (client_transport, _server_transport) = transport::channel::unbounded();
-        BanksClient::new(client::Config::default(), client_transport);
-    }
-
-    #[test]
-    fn test_banks_server_transfer_via_server() -> io::Result<()> {
-        // This test shows the preferred way to interact with BanksServer.
-        // It creates a runtime explicitly (no globals via tokio macros) and calls
-        // `runtime.block_on()` just once, to run all the async code.
-
-        let genesis = create_genesis_config(10);
-        let bank = Bank::new(&genesis.genesis_config);
-        let slot = bank.slot();
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
-        ));
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-
-        let bob_pubkey = solana_sdk::pubkey::new_rand();
-        let mint_pubkey = genesis.mint_keypair.pubkey();
-        let instruction = system_instruction::transfer(&mint_pubkey, &bob_pubkey, 1);
-        let message = Message::new(&[instruction], Some(&mint_pubkey));
-
-        Runtime::new()?.block_on(async {
-            let client_transport = start_local_server(bank_forks, block_commitment_cache).await;
-            let mut banks_client = start_client(client_transport).await?;
-
-            let recent_blockhash = banks_client.get_recent_blockhash().await?;
-            let transaction = Transaction::new(&[&genesis.mint_keypair], message, recent_blockhash);
-            banks_client.process_transaction(transaction).await.unwrap();
-            assert_eq!(banks_client.get_balance(bob_pubkey).await?, 1);
-            Ok(())
-        })
-    }
-
-    #[test]
-    fn test_banks_server_transfer_via_client() -> io::Result<()> {
-        // The caller may not want to hold the connection open until the transaction
-        // is processed (or blockhash expires). In this test, we verify the
-        // server-side functionality is available to the client.
-
-        let genesis = create_genesis_config(10);
-        let bank = Bank::new(&genesis.genesis_config);
-        let slot = bank.slot();
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_slots(slot, slot),
-        ));
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-
-        let mint_pubkey = &genesis.mint_keypair.pubkey();
-        let bob_pubkey = solana_sdk::pubkey::new_rand();
-        let instruction = system_instruction::transfer(&mint_pubkey, &bob_pubkey, 1);
-        let message = Message::new(&[instruction], Some(&mint_pubkey));
-
-        Runtime::new()?.block_on(async {
-            let client_transport = start_local_server(bank_forks, block_commitment_cache).await;
-            let mut banks_client = start_client(client_transport).await?;
-            let (_, recent_blockhash, last_valid_slot) = banks_client.get_fees().await?;
-            let transaction = Transaction::new(&[&genesis.mint_keypair], message, recent_blockhash);
-            let signature = transaction.signatures[0];
-            banks_client.send_transaction(transaction).await?;
-
-            let mut status = banks_client.get_transaction_status(signature).await?;
-
-            while status.is_none() {
-                let root_slot = banks_client.get_root_slot().await?;
-                if root_slot > last_valid_slot {
-                    break;
-                }
-                sleep(Duration::from_millis(100)).await;
-                status = banks_client.get_transaction_status(signature).await?;
-            }
-            assert!(status.unwrap().err.is_none());
-            assert_eq!(banks_client.get_balance(bob_pubkey).await?, 1);
-            Ok(())
-        })
-    }
-}

banks-interface/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "solana-banks-interface"
-version = "1.6.9"
-description = "Solana banks RPC interface"
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-banks-interface"
-edition = "2018"
-
-[dependencies]
-mio = "0.7.6"
-serde = { version = "1.0.122", features = ["derive"] }
-solana-sdk = { path = "../sdk", version = "=1.6.9" }
-tarpc = { version = "0.24.1", features = ["full"] }
-
-[dev-dependencies]
-tokio = { version = "1", features = ["full"] }
-
-[lib]
-crate-type = ["lib"]
-name = "solana_banks_interface"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

banks-interface/src/lib.rs

@@ -1,57 +0,0 @@
-use serde::{Deserialize, Serialize};
-use solana_sdk::{
-    account::Account,
-    clock::Slot,
-    commitment_config::CommitmentLevel,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Signature,
-    transaction::{self, Transaction, TransactionError},
-};
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TransactionConfirmationStatus {
-    Processed,
-    Confirmed,
-    Finalized,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct TransactionStatus {
-    pub slot: Slot,
-    pub confirmations: Option<usize>, // None = rooted
-    pub err: Option<TransactionError>,
-    pub confirmation_status: Option<TransactionConfirmationStatus>,
-}
-
-#[tarpc::service]
-pub trait Banks {
-    async fn send_transaction_with_context(transaction: Transaction);
-    async fn get_fees_with_commitment_and_context(
-        commitment: CommitmentLevel,
-    ) -> (FeeCalculator, Hash, Slot);
-    async fn get_transaction_status_with_context(signature: Signature)
-        -> Option<TransactionStatus>;
-    async fn get_slot_with_context(commitment: CommitmentLevel) -> Slot;
-    async fn process_transaction_with_commitment_and_context(
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> Option<transaction::Result<()>>;
-    async fn get_account_with_commitment_and_context(
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> Option<Account>;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tarpc::{client, transport};
-
-    #[test]
-    fn test_banks_client_new() {
-        let (client_transport, _server_transport) = transport::channel::unbounded();
-        BanksClient::new(client::Config::default(), client_transport);
-    }
-}

banks-server/Cargo.toml

@@ -1,31 +0,0 @@
-[package]
-name = "solana-banks-server"
-version = "1.6.9"
-description = "Solana banks server"
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
-repository = "https://github.com/solana-labs/solana"
-license = "Apache-2.0"
-homepage = "https://solana.com/"
-documentation = "https://docs.rs/solana-banks-server"
-edition = "2018"
-
-[dependencies]
-bincode = "1.3.1"
-futures = "0.3"
-log = "0.4.11"
-mio = "0.7.6"
-solana-banks-interface = { path = "../banks-interface", version = "=1.6.9" }
-solana-runtime = { path = "../runtime", version = "=1.6.9" }
-solana-sdk = { path = "../sdk", version = "=1.6.9" }
-solana-metrics = { path = "../metrics", version = "=1.6.9" }
-tarpc = { version = "0.24.1", features = ["full"] }
-tokio = { version = "1", features = ["full"] }
-tokio-serde = { version = "0.8", features = ["bincode"] }
-tokio-stream = "0.1"
-
-[lib]
-crate-type = ["lib"]
-name = "solana_banks_server"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]

banks-server/src/banks_server.rs

@@ -1,298 +0,0 @@
-use crate::send_transaction_service::{SendTransactionService, TransactionInfo};
-use bincode::{deserialize, serialize};
-use futures::{
-    future,
-    prelude::stream::{self, StreamExt},
-};
-use solana_banks_interface::{
-    Banks, BanksRequest, BanksResponse, TransactionConfirmationStatus, TransactionStatus,
-};
-use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache};
-use solana_sdk::{
-    account::Account,
-    clock::Slot,
-    commitment_config::CommitmentLevel,
-    fee_calculator::FeeCalculator,
-    hash::Hash,
-    pubkey::Pubkey,
-    signature::Signature,
-    transaction::{self, Transaction},
-};
-use std::{
-    io,
-    net::{Ipv4Addr, SocketAddr},
-    sync::{
-        mpsc::{channel, Receiver, Sender},
-        Arc, RwLock,
-    },
-    thread::Builder,
-    time::Duration,
-};
-use tarpc::{
-    context::Context,
-    rpc::{transport::channel::UnboundedChannel, ClientMessage, Response},
-    serde_transport::tcp,
-    server::{self, Channel, Handler},
-    transport,
-};
-use tokio::time::sleep;
-use tokio_serde::formats::Bincode;
-
-#[derive(Clone)]
-struct BanksServer {
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    transaction_sender: Sender<TransactionInfo>,
-}
-
-impl BanksServer {
-    /// Return a BanksServer that forwards transactions to the
-    /// given sender. If unit-testing, those transactions can go to
-    /// a bank in the given BankForks. Otherwise, the receiver should
-    /// forward them to a validator in the leader schedule.
-    fn new(
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-        transaction_sender: Sender<TransactionInfo>,
-    ) -> Self {
-        Self {
-            bank_forks,
-            block_commitment_cache,
-            transaction_sender,
-        }
-    }
-
-    fn run(bank_forks: Arc<RwLock<BankForks>>, transaction_receiver: Receiver<TransactionInfo>) {
-        while let Ok(info) = transaction_receiver.recv() {
-            let mut transaction_infos = vec![info];
-            while let Ok(info) = transaction_receiver.try_recv() {
-                transaction_infos.push(info);
-            }
-            let transactions: Vec<_> = transaction_infos
-                .into_iter()
-                .map(|info| deserialize(&info.wire_transaction).unwrap())
-                .collect();
-            let bank = bank_forks.read().unwrap().working_bank();
-            let _ = bank.process_transactions(&transactions);
-        }
-    }
-
-    /// Useful for unit-testing
-    fn new_loopback(
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    ) -> Self {
-        let (transaction_sender, transaction_receiver) = channel();
-        let bank = bank_forks.read().unwrap().working_bank();
-        let slot = bank.slot();
-        {
-            // ensure that the commitment cache and bank are synced
-            let mut w_block_commitment_cache = block_commitment_cache.write().unwrap();
-            w_block_commitment_cache.set_all_slots(slot, slot);
-        }
-        let server_bank_forks = bank_forks.clone();
-        Builder::new()
-            .name("solana-bank-forks-client".to_string())
-            .spawn(move || Self::run(server_bank_forks, transaction_receiver))
-            .unwrap();
-        Self::new(bank_forks, block_commitment_cache, transaction_sender)
-    }
-
-    fn slot(&self, commitment: CommitmentLevel) -> Slot {
-        self.block_commitment_cache
-            .read()
-            .unwrap()
-            .slot_with_commitment(commitment)
-    }
-
-    fn bank(&self, commitment: CommitmentLevel) -> Arc<Bank> {
-        self.bank_forks.read().unwrap()[self.slot(commitment)].clone()
-    }
-
-    async fn poll_signature_status(
-        self,
-        signature: &Signature,
-        blockhash: &Hash,
-        last_valid_slot: Slot,
-        commitment: CommitmentLevel,
-    ) -> Option<transaction::Result<()>> {
-        let mut status = self
-            .bank(commitment)
-            .get_signature_status_with_blockhash(signature, blockhash);
-        while status.is_none() {
-            sleep(Duration::from_millis(200)).await;
-            let bank = self.bank(commitment);
-            if bank.slot() > last_valid_slot {
-                break;
-            }
-            status = bank.get_signature_status_with_blockhash(signature, blockhash);
-        }
-        status
-    }
-}
-
-fn verify_transaction(transaction: &Transaction) -> transaction::Result<()> {
-    if let Err(err) = transaction.verify() {
-        Err(err)
-    } else if let Err(err) = transaction.verify_precompiles() {
-        Err(err)
-    } else {
-        Ok(())
-    }
-}
-
-#[tarpc::server]
-impl Banks for BanksServer {
-    async fn send_transaction_with_context(self, _: Context, transaction: Transaction) {
-        let blockhash = &transaction.message.recent_blockhash;
-        let last_valid_slot = self
-            .bank_forks
-            .read()
-            .unwrap()
-            .root_bank()
-            .get_blockhash_last_valid_slot(&blockhash)
-            .unwrap();
-        let signature = transaction.signatures.get(0).cloned().unwrap_or_default();
-        let info =
-            TransactionInfo::new(signature, serialize(&transaction).unwrap(), last_valid_slot);
-        self.transaction_sender.send(info).unwrap();
-    }
-
-    async fn get_fees_with_commitment_and_context(
-        self,
-        _: Context,
-        commitment: CommitmentLevel,
-    ) -> (FeeCalculator, Hash, Slot) {
-        let bank = self.bank(commitment);
-        let (blockhash, fee_calculator) = bank.last_blockhash_with_fee_calculator();
-        let last_valid_slot = bank.get_blockhash_last_valid_slot(&blockhash).unwrap();
-        (fee_calculator, blockhash, last_valid_slot)
-    }
-
-    async fn get_transaction_status_with_context(
-        self,
-        _: Context,
-        signature: Signature,
-    ) -> Option<TransactionStatus> {
-        let bank = self.bank(CommitmentLevel::Processed);
-        let (slot, status) = bank.get_signature_status_slot(&signature)?;
-        let r_block_commitment_cache = self.block_commitment_cache.read().unwrap();
-
-        let optimistically_confirmed_bank = self.bank(CommitmentLevel::Confirmed);
-        let optimistically_confirmed =
-            optimistically_confirmed_bank.get_signature_status_slot(&signature);
-
-        let confirmations = if r_block_commitment_cache.root() >= slot
-            && r_block_commitment_cache.highest_confirmed_root() >= slot
-        {
-            None
-        } else {
-            r_block_commitment_cache
-                .get_confirmation_count(slot)
-                .or(Some(0))
-        };
-        Some(TransactionStatus {
-            slot,
-            confirmations,
-            err: status.err(),
-            confirmation_status: if confirmations.is_none() {
-                Some(TransactionConfirmationStatus::Finalized)
-            } else if optimistically_confirmed.is_some() {
-                Some(TransactionConfirmationStatus::Confirmed)
-            } else {
-                Some(TransactionConfirmationStatus::Processed)
-            },
-        })
-    }
-
-    async fn get_slot_with_context(self, _: Context, commitment: CommitmentLevel) -> Slot {
-        self.slot(commitment)
-    }
-
-    async fn process_transaction_with_commitment_and_context(
-        self,
-        _: Context,
-        transaction: Transaction,
-        commitment: CommitmentLevel,
-    ) -> Option<transaction::Result<()>> {
-        if let Err(err) = verify_transaction(&transaction) {
-            return Some(Err(err));
-        }
-
-        let blockhash = &transaction.message.recent_blockhash;
-        let last_valid_slot = self
-            .bank_forks
-            .read()
-            .unwrap()
-            .root_bank()
-            .get_blockhash_last_valid_slot(blockhash)
-            .unwrap();
-        let signature = transaction.signatures.get(0).cloned().unwrap_or_default();
-        let info =
-            TransactionInfo::new(signature, serialize(&transaction).unwrap(), last_valid_slot);
-        self.transaction_sender.send(info).unwrap();
-        self.poll_signature_status(&signature, blockhash, last_valid_slot, commitment)
-            .await
-    }
-
-    async fn get_account_with_commitment_and_context(
-        self,
-        _: Context,
-        address: Pubkey,
-        commitment: CommitmentLevel,
-    ) -> Option<Account> {
-        let bank = self.bank(commitment);
-        bank.get_account(&address).map(Account::from)
-    }
-}
-
-pub async fn start_local_server(
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-) -> UnboundedChannel<Response<BanksResponse>, ClientMessage<BanksRequest>> {
-    let banks_server = BanksServer::new_loopback(bank_forks, block_commitment_cache);
-    let (client_transport, server_transport) = transport::channel::unbounded();
-    let server = server::new(server::Config::default())
-        .incoming(stream::once(future::ready(server_transport)))
-        .respond_with(banks_server.serve());
-    tokio::spawn(server);
-    client_transport
-}
-
-pub async fn start_tcp_server(
-    listen_addr: SocketAddr,
-    tpu_addr: SocketAddr,
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-) -> io::Result<()> {
-    // Note: These settings are copied straight from the tarpc example.
-    let server = tcp::listen(listen_addr, Bincode::default)
-        .await?
-        // Ignore accept errors.
-        .filter_map(|r| future::ready(r.ok()))
-        .map(server::BaseChannel::with_defaults)
-        // Limit channels to 1 per IP.
-        .max_channels_per_key(1, |t| {
-            t.as_ref()
-                .peer_addr()
-                .map(|x| x.ip())
-                .unwrap_or_else(|_| Ipv4Addr::new(0, 0, 0, 0).into())
-        })
-        // serve is generated by the service attribute. It takes as input any type implementing
-        // the generated Banks trait.
-        .map(move |chan| {
-            let (sender, receiver) = channel();
-
-            SendTransactionService::new(tpu_addr, &bank_forks, receiver);
-
-            let server =
-                BanksServer::new(bank_forks.clone(), block_commitment_cache.clone(), sender);
-            chan.respond_with(server.serve()).execute()
-        })
-        // Max 10 channels.
-        .buffer_unordered(10)
-        .for_each(|_| async {});
-
-    server.await;
-    Ok(())
-}

banks-server/src/lib.rs

@@ -1,7 +0,0 @@
-#![allow(clippy::integer_arithmetic)]
-pub mod banks_server;
-pub mod rpc_banks_service;
-pub mod send_transaction_service;
-
-#[macro_use]
-extern crate solana_metrics;

banks-server/src/rpc_banks_service.rs

@@ -1,117 +0,0 @@
-//! The `rpc_banks_service` module implements the Solana Banks RPC API.
-
-use crate::banks_server::start_tcp_server;
-use futures::{future::FutureExt, pin_mut, prelude::stream::StreamExt, select};
-use solana_runtime::{bank_forks::BankForks, commitment::BlockCommitmentCache};
-use std::{
-    net::SocketAddr,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, RwLock,
-    },
-    thread::{self, Builder, JoinHandle},
-};
-use tokio::{
-    runtime::Runtime,
-    time::{self, Duration},
-};
-use tokio_stream::wrappers::IntervalStream;
-
-pub struct RpcBanksService {
-    thread_hdl: JoinHandle<()>,
-}
-
-/// Run the TCP service until `exit` is set to true
-async fn start_abortable_tcp_server(
-    listen_addr: SocketAddr,
-    tpu_addr: SocketAddr,
-    bank_forks: Arc<RwLock<BankForks>>,
-    block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-    exit: Arc<AtomicBool>,
-) {
-    let server = start_tcp_server(
-        listen_addr,
-        tpu_addr,
-        bank_forks.clone(),
-        block_commitment_cache.clone(),
-    )
-    .fuse();
-    let interval = IntervalStream::new(time::interval(Duration::from_millis(100))).fuse();
-    pin_mut!(server, interval);
-    loop {
-        select! {
-            _ = server => {},
-            _ = interval.select_next_some() => {
-                if exit.load(Ordering::Relaxed) {
-                    break;
-                }
-            }
-        }
-    }
-}
-
-impl RpcBanksService {
-    fn run(
-        listen_addr: SocketAddr,
-        tpu_addr: SocketAddr,
-        bank_forks: Arc<RwLock<BankForks>>,
-        block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
-        exit: Arc<AtomicBool>,
-    ) {
-        let server = start_abortable_tcp_server(
-            listen_addr,
-            tpu_addr,
-            bank_forks,
-            block_commitment_cache,
-            exit,
-        );
-        Runtime::new().unwrap().block_on(server);
-    }
-
-    pub fn new(
-        listen_addr: SocketAddr,
-        tpu_addr: SocketAddr,
-        bank_forks: &Arc<RwLock<BankForks>>,
-        block_commitment_cache: &Arc<RwLock<BlockCommitmentCache>>,
-        exit: &Arc<AtomicBool>,
-    ) -> Self {
-        let bank_forks = bank_forks.clone();
-        let block_commitment_cache = block_commitment_cache.clone();
-        let exit = exit.clone();
-        let thread_hdl = Builder::new()
-            .name("solana-rpc-banks".to_string())
-            .spawn(move || {
-                Self::run(
-                    listen_addr,
-                    tpu_addr,
-                    bank_forks,
-                    block_commitment_cache,
-                    exit,
-                )
-            })
-            .unwrap();
-
-        Self { thread_hdl }
-    }
-
-    pub fn join(self) -> thread::Result<()> {
-        self.thread_hdl.join()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_runtime::bank::Bank;
-
-    #[test]
-    fn test_rpc_banks_server_exit() {
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(Bank::default())));
-        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-        let exit = Arc::new(AtomicBool::new(false));
-        let addr = "127.0.0.1:0".parse().unwrap();
-        let service = RpcBanksService::new(addr, addr, &bank_forks, &block_commitment_cache, &exit);
-        exit.store(true, Ordering::Relaxed);
-        service.join().unwrap();
-    }
-}

banks-server/src/send_transaction_service.rs

@@ -1,343 +0,0 @@
-// TODO: Merge this implementation with the one at `core/src/send_transaction_service.rs`
-use log::*;
-use solana_metrics::{datapoint_warn, inc_new_counter_info};
-use solana_runtime::{bank::Bank, bank_forks::BankForks};
-use solana_sdk::{clock::Slot, signature::Signature};
-use std::{
-    collections::HashMap,
-    net::{SocketAddr, UdpSocket},
-    sync::{
-        mpsc::{Receiver, RecvTimeoutError},
-        Arc, RwLock,
-    },
-    thread::{self, Builder, JoinHandle},
-    time::{Duration, Instant},
-};
-
-/// Maximum size of the transaction queue
-const MAX_TRANSACTION_QUEUE_SIZE: usize = 10_000; // This seems like a lot but maybe it needs to be bigger one day
-
-pub struct SendTransactionService {
-    thread: JoinHandle<()>,
-}
-
-pub struct TransactionInfo {
-    pub signature: Signature,
-    pub wire_transaction: Vec<u8>,
-    pub last_valid_slot: Slot,
-}
-
-impl TransactionInfo {
-    pub fn new(signature: Signature, wire_transaction: Vec<u8>, last_valid_slot: Slot) -> Self {
-        Self {
-            signature,
-            wire_transaction,
-            last_valid_slot,
-        }
-    }
-}
-
-#[derive(Default, Debug, PartialEq)]
-struct ProcessTransactionsResult {
-    rooted: u64,
-    expired: u64,
-    retried: u64,
-    failed: u64,
-    retained: u64,
-}
-
-impl SendTransactionService {
-    pub fn new(
-        tpu_address: SocketAddr,
-        bank_forks: &Arc<RwLock<BankForks>>,
-        receiver: Receiver<TransactionInfo>,
-    ) -> Self {
-        let thread = Self::retry_thread(receiver, bank_forks.clone(), tpu_address);
-        Self { thread }
-    }
-
-    fn retry_thread(
-        receiver: Receiver<TransactionInfo>,
-        bank_forks: Arc<RwLock<BankForks>>,
-        tpu_address: SocketAddr,
-    ) -> JoinHandle<()> {
-        let mut last_status_check = Instant::now();
-        let mut transactions = HashMap::new();
-        let send_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
-
-        Builder::new()
-            .name("send-tx-svc".to_string())
-            .spawn(move || loop {
-                match receiver.recv_timeout(Duration::from_secs(1)) {
-                    Err(RecvTimeoutError::Disconnected) => break,
-                    Err(RecvTimeoutError::Timeout) => {}
-                    Ok(transaction_info) => {
-                        Self::send_transaction(
-                            &send_socket,
-                            &tpu_address,
-                            &transaction_info.wire_transaction,
-                        );
-                        if transactions.len() < MAX_TRANSACTION_QUEUE_SIZE {
-                            transactions.insert(transaction_info.signature, transaction_info);
-                        } else {
-                            datapoint_warn!("send_transaction_service-queue-overflow");
-                        }
-                    }
-                }
-
-                if Instant::now().duration_since(last_status_check).as_secs() >= 5 {
-                    if !transactions.is_empty() {
-                        datapoint_info!(
-                            "send_transaction_service-queue-size",
-                            ("len", transactions.len(), i64)
-                        );
-                        let bank_forks = bank_forks.read().unwrap();
-                        let root_bank = bank_forks.root_bank();
-                        let working_bank = bank_forks.working_bank();
-
-                        let _result = Self::process_transactions(
-                            &working_bank,
-                            &root_bank,
-                            &send_socket,
-                            &tpu_address,
-                            &mut transactions,
-                        );
-                    }
-                    last_status_check = Instant::now();
-                }
-            })
-            .unwrap()
-    }
-
-    fn process_transactions(
-        working_bank: &Arc<Bank>,
-        root_bank: &Arc<Bank>,
-        send_socket: &UdpSocket,
-        tpu_address: &SocketAddr,
-        transactions: &mut HashMap<Signature, TransactionInfo>,
-    ) -> ProcessTransactionsResult {
-        let mut result = ProcessTransactionsResult::default();
-
-        transactions.retain(|signature, transaction_info| {
-            if root_bank.has_signature(signature) {
-                info!("Transaction is rooted: {}", signature);
-                result.rooted += 1;
-                inc_new_counter_info!("send_transaction_service-rooted", 1);
-                false
-            } else if transaction_info.last_valid_slot < root_bank.slot() {
-                info!("Dropping expired transaction: {}", signature);
-                result.expired += 1;
-                inc_new_counter_info!("send_transaction_service-expired", 1);
-                false
-            } else {
-                match working_bank.get_signature_status_slot(signature) {
-                    None => {
-                        // Transaction is unknown to the working bank, it might have been
-                        // dropped or landed in another fork.  Re-send it
-                        info!("Retrying transaction: {}", signature);
-                        result.retried += 1;
-                        inc_new_counter_info!("send_transaction_service-retry", 1);
-                        Self::send_transaction(
-                            &send_socket,
-                            &tpu_address,
-                            &transaction_info.wire_transaction,
-                        );
-                        true
-                    }
-                    Some((_slot, status)) => {
-                        if status.is_err() {
-                            info!("Dropping failed transaction: {}", signature);
-                            result.failed += 1;
-                            inc_new_counter_info!("send_transaction_service-failed", 1);
-                            false
-                        } else {
-                            result.retained += 1;
-                            true
-                        }
-                    }
-                }
-            }
-        });
-
-        result
-    }
-
-    fn send_transaction(
-        send_socket: &UdpSocket,
-        tpu_address: &SocketAddr,
-        wire_transaction: &[u8],
-    ) {
-        if let Err(err) = send_socket.send_to(wire_transaction, tpu_address) {
-            warn!("Failed to send transaction to {}: {:?}", tpu_address, err);
-        }
-    }
-
-    pub fn join(self) -> thread::Result<()> {
-        self.thread.join()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use solana_sdk::{
-        genesis_config::create_genesis_config, pubkey::Pubkey, signature::Signer,
-        system_transaction,
-    };
-    use std::sync::mpsc::channel;
-
-    #[test]
-    fn service_exit() {
-        let tpu_address = "127.0.0.1:0".parse().unwrap();
-        let bank = Bank::default();
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let (sender, receiver) = channel();
-
-        let send_tranaction_service =
-            SendTransactionService::new(tpu_address, &bank_forks, receiver);
-
-        drop(sender);
-        send_tranaction_service.join().unwrap();
-    }
-
-    #[test]
-    fn process_transactions() {
-        let (genesis_config, mint_keypair) = create_genesis_config(4);
-        let bank = Bank::new(&genesis_config);
-        let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let send_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
-        let tpu_address = "127.0.0.1:0".parse().unwrap();
-
-        let root_bank = Arc::new(Bank::new_from_parent(
-            &bank_forks.read().unwrap().working_bank(),
-            &Pubkey::default(),
-            1,
-        ));
-        let rooted_signature = root_bank
-            .transfer(1, &mint_keypair, &mint_keypair.pubkey())
-            .unwrap();
-
-        let working_bank = Arc::new(Bank::new_from_parent(&root_bank, &Pubkey::default(), 2));
-
-        let non_rooted_signature = working_bank
-            .transfer(2, &mint_keypair, &mint_keypair.pubkey())
-            .unwrap();
-
-        let failed_signature = {
-            let blockhash = working_bank.last_blockhash();
-            let transaction =
-                system_transaction::transfer(&mint_keypair, &Pubkey::default(), 1, blockhash);
-            let signature = transaction.signatures[0];
-            working_bank.process_transaction(&transaction).unwrap_err();
-            signature
-        };
-
-        let mut transactions = HashMap::new();
-
-        info!("Expired transactions are dropped..");
-        transactions.insert(
-            Signature::default(),
-            TransactionInfo::new(Signature::default(), vec![], root_bank.slot() - 1),
-        );
-        let result = SendTransactionService::process_transactions(
-            &working_bank,
-            &root_bank,
-            &send_socket,
-            &tpu_address,
-            &mut transactions,
-        );
-        assert!(transactions.is_empty());
-        assert_eq!(
-            result,
-            ProcessTransactionsResult {
-                expired: 1,
-                ..ProcessTransactionsResult::default()
-            }
-        );
-
-        info!("Rooted transactions are dropped...");
-        transactions.insert(
-            rooted_signature,
-            TransactionInfo::new(rooted_signature, vec![], working_bank.slot()),
-        );
-        let result = SendTransactionService::process_transactions(
-            &working_bank,
-            &root_bank,
-            &send_socket,
-            &tpu_address,
-            &mut transactions,
-        );
-        assert!(transactions.is_empty());
-        assert_eq!(
-            result,
-            ProcessTransactionsResult {
-                rooted: 1,
-                ..ProcessTransactionsResult::default()
-            }
-        );
-
-        info!("Failed transactions are dropped...");
-        transactions.insert(
-            failed_signature,
-            TransactionInfo::new(failed_signature, vec![], working_bank.slot()),
-        );
-        let result = SendTransactionService::process_transactions(
-            &working_bank,
-            &root_bank,
-            &send_socket,
-            &tpu_address,
-            &mut transactions,
-        );
-        assert!(transactions.is_empty());
-        assert_eq!(
-            result,
-            ProcessTransactionsResult {
-                failed: 1,
-                ..ProcessTransactionsResult::default()
-            }
-        );
-
-        info!("Non-rooted transactions are kept...");
-        transactions.insert(
-            non_rooted_signature,
-            TransactionInfo::new(non_rooted_signature, vec![], working_bank.slot()),
-        );
-        let result = SendTransactionService::process_transactions(
-            &working_bank,
-            &root_bank,
-            &send_socket,
-            &tpu_address,
-            &mut transactions,
-        );
-        assert_eq!(transactions.len(), 1);
-        assert_eq!(
-            result,
-            ProcessTransactionsResult {
-                retained: 1,
-                ..ProcessTransactionsResult::default()
-            }
-        );
-        transactions.clear();
-
-        info!("Unknown transactions are retried...");
-        transactions.insert(
-            Signature::default(),
-            TransactionInfo::new(Signature::default(), vec![], working_bank.slot()),
-        );
-        let result = SendTransactionService::process_transactions(
-            &working_bank,
-            &root_bank,
-            &send_socket,
-            &tpu_address,
-            &mut transactions,
-        );
-        assert_eq!(transactions.len(), 1);
-        assert_eq!(
-            result,
-            ProcessTransactionsResult {
-                retried: 1,
-                ..ProcessTransactionsResult::default()
-            }
-        );
-    }
-}

bench-exchange/Cargo.toml

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

bench-exchange/src/bench.rs

@@ -1,5 +1,4 @@
 #![allow(clippy::useless_attribute)]
-#![allow(clippy::integer_arithmetic)]
 
 use crate::order_book::*;
 use itertools::izip;
@@ -8,16 +7,15 @@ use rand::{thread_rng, Rng};
 use rayon::prelude::*;
 use solana_client::perf_utils::{sample_txs, SampleStats};
 use solana_core::gen_keys::GenKeys;
+use solana_drone::drone::request_airdrop_transaction;
 use solana_exchange_program::{exchange_instruction, exchange_state::*, id};
-use solana_faucet::faucet::request_airdrop_transaction;
 use solana_genesis::Base64Account;
 use solana_metrics::datapoint_info;
 use solana_sdk::{
     client::{Client, SyncClient},
     commitment_config::CommitmentConfig,
-    message::Message,
     pubkey::Pubkey,
-    signature::{Keypair, Signer},
+    signature::{Keypair, KeypairUtil},
     timing::{duration_as_ms, duration_as_s},
     transaction::Transaction,
     {system_instruction, system_program},
@@ -180,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())
@@ -252,7 +256,7 @@ where
     trace!("Start trader thread");
     let trader_thread = {
         let exit_signal = exit_signal.clone();
-
+        let shared_txs = shared_txs.clone();
         let client = clients[0].clone();
         Builder::new()
             .name("solana-exchange-trader".to_string())
@@ -391,7 +395,7 @@ fn swapper<T>(
             while client
                 .get_balance_with_commitment(
                     &trade_infos[trade_index].trade_account,
-                    CommitmentConfig::processed(),
+                    CommitmentConfig::recent(),
                 )
                 .unwrap_or(0)
                 == 0
@@ -445,22 +449,24 @@ fn swapper<T>(
             }
             account_group = (account_group + 1) % account_groups as usize;
 
-            let (blockhash, _fee_calculator, _last_valid_slot) = client
-                .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+            let (blockhash, _fee_calculator) = client
+                .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                 .expect("Failed to get blockhash");
             let to_swap_txs: Vec<_> = to_swap
                 .par_iter()
                 .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();
 
@@ -571,8 +577,8 @@ fn trader<T>(
         }
         account_group = (account_group + 1) % account_groups as usize;
 
-        let (blockhash, _fee_calculator, _last_valid_slot) = client
-            .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+        let (blockhash, _fee_calculator) = client
+            .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
             .expect("Failed to get blockhash");
 
         trades.chunks(chunk_size).for_each(|chunk| {
@@ -582,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();
 
@@ -659,7 +667,7 @@ where
 {
     for s in &tx.signatures {
         if let Ok(Some(r)) =
-            sync_client.get_signature_status_with_commitment(s, CommitmentConfig::processed())
+            sync_client.get_signature_status_with_commitment(s, CommitmentConfig::recent())
         {
             match r {
                 Ok(_) => {
@@ -682,7 +690,7 @@ fn verify_funding_transfer<T: SyncClient + ?Sized>(
     if verify_transaction(client, tx) {
         for a in &tx.message().account_keys[1..] {
             if client
-                .get_balance_with_commitment(a, CommitmentConfig::processed())
+                .get_balance_with_commitment(a, CommitmentConfig::recent())
                 .unwrap_or(0)
                 >= amount
             {
@@ -693,7 +701,7 @@ fn verify_funding_transfer<T: SyncClient + ?Sized>(
     false
 }
 
-pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>], lamports: u64) {
+pub fn fund_keys(client: &dyn Client, source: &Keypair, dests: &[Arc<Keypair>], lamports: u64) {
     let total = lamports * (dests.len() as u64 + 1);
     let mut funded: Vec<(&Keypair, u64)> = vec![(source, total)];
     let mut notfunded: Vec<&Arc<Keypair>> = dests.iter().collect();
@@ -739,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",
@@ -764,8 +775,8 @@ 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
-                    .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                let (blockhash, _fee_calculator) = client
+                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("blockhash");
                 to_fund_txs.par_iter_mut().for_each(|(k, tx)| {
                     tx.sign(&[*k], blockhash);
@@ -804,7 +815,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
         funded.append(&mut new_funded);
         funded.retain(|(k, b)| {
             client
-                .get_balance_with_commitment(&k.pubkey(), CommitmentConfig::processed())
+                .get_balance_with_commitment(&k.pubkey(), CommitmentConfig::recent())
                 .unwrap_or(0)
                 > lamports
                 && *b > lamports
@@ -813,11 +824,7 @@ pub fn fund_keys<T: Client>(client: &T, source: &Keypair, dests: &[Arc<Keypair>]
     }
 }
 
-pub fn create_token_accounts<T: Client>(
-    client: &T,
-    signers: &[Arc<Keypair>],
-    accounts: &[Keypair],
-) {
+pub fn create_token_accounts(client: &dyn Client, signers: &[Arc<Keypair>], accounts: &[Keypair]) {
     let mut notfunded: Vec<(&Arc<Keypair>, &Keypair)> = signers.iter().zip(accounts).collect();
 
     while !notfunded.is_empty() {
@@ -836,18 +843,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",
@@ -857,8 +862,8 @@ 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
-                    .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+                let (blockhash, _fee_calculator) = client
+                    .get_recent_blockhash_with_commitment(CommitmentConfig::recent())
                     .expect("Failed to get blockhash");
                 to_create_txs
                     .par_iter_mut()
@@ -904,7 +909,7 @@ pub fn create_token_accounts<T: Client>(
         let mut new_notfunded: Vec<(&Arc<Keypair>, &Keypair)> = vec![];
         for f in &notfunded {
             if client
-                .get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::processed())
+                .get_balance_with_commitment(&f.1.pubkey(), CommitmentConfig::recent())
                 .unwrap_or(0)
                 == 0
             {
@@ -963,13 +968,8 @@ fn generate_keypairs(num: u64) -> Vec<Keypair> {
     rnd.gen_n_keypairs(num)
 }
 
-pub fn airdrop_lamports<T: Client>(
-    client: &T,
-    faucet_addr: &SocketAddr,
-    id: &Keypair,
-    amount: u64,
-) {
-    let balance = client.get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed());
+pub fn airdrop_lamports(client: &dyn Client, drone_addr: &SocketAddr, id: &Keypair, amount: u64) {
+    let balance = client.get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent());
     let balance = balance.unwrap_or(0);
     if balance >= amount {
         return;
@@ -980,30 +980,30 @@ pub fn airdrop_lamports<T: Client>(
     info!(
         "Airdropping {:?} lamports from {} for {}",
         amount_to_drop,
-        faucet_addr,
+        drone_addr,
         id.pubkey(),
     );
 
     let mut tries = 0;
     loop {
-        let (blockhash, _fee_calculator, _last_valid_slot) = client
-            .get_recent_blockhash_with_commitment(CommitmentConfig::processed())
+        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) {
+        match request_airdrop_transaction(&drone_addr, &id.pubkey(), amount_to_drop, blockhash) {
             Ok(transaction) => {
                 let signature = client.async_send_transaction(transaction).unwrap();
 
                 for _ in 0..30 {
                     if let Ok(Some(_)) = client.get_signature_status_with_commitment(
                         &signature,
-                        CommitmentConfig::processed(),
+                        CommitmentConfig::recent(),
                     ) {
                         break;
                     }
                     sleep(Duration::from_millis(100));
                 }
                 if client
-                    .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::processed())
+                    .get_balance_with_commitment(&id.pubkey(), CommitmentConfig::recent())
                     .unwrap_or(0)
                     >= amount
                 {
@@ -1013,7 +1013,7 @@ pub fn airdrop_lamports<T: Client>(
             Err(err) => {
                 panic!(
                     "Error requesting airdrop: {:?} to addr: {:?} amount: {}",
-                    err, faucet_addr, amount
+                    err, drone_addr, amount
                 );
             }
         };

bench-exchange/src/cli.rs

@@ -1,14 +1,14 @@
 use clap::{crate_description, crate_name, value_t, App, Arg, ArgMatches};
 use solana_core::gen_keys::GenKeys;
-use solana_faucet::faucet::FAUCET_PORT;
-use solana_sdk::signature::{read_keypair_file, Keypair};
+use solana_drone::drone::DRONE_PORT;
+use solana_sdk::signature::{read_keypair_file, Keypair, KeypairUtil};
 use std::net::SocketAddr;
 use std::process::exit;
 use std::time::Duration;
 
 pub struct Config {
     pub entrypoint_addr: SocketAddr,
-    pub faucet_addr: SocketAddr,
+    pub drone_addr: SocketAddr,
     pub identity: Keypair,
     pub threads: usize,
     pub num_nodes: usize,
@@ -27,7 +27,7 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             entrypoint_addr: SocketAddr::from(([127, 0, 0, 1], 8001)),
-            faucet_addr: SocketAddr::from(([127, 0, 0, 1], FAUCET_PORT)),
+            drone_addr: SocketAddr::from(([127, 0, 0, 1], DRONE_PORT)),
             identity: Keypair::new(),
             num_nodes: 1,
             threads: 4,
@@ -59,14 +59,14 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                 .help("Cluster entry point; defaults to 127.0.0.1:8001"),
         )
         .arg(
-            Arg::with_name("faucet")
+            Arg::with_name("drone")
                 .short("d")
-                .long("faucet")
+                .long("drone")
                 .value_name("HOST:PORT")
                 .takes_value(true)
                 .required(false)
                 .default_value("127.0.0.1:9900")
-                .help("Location of the faucet; defaults to 127.0.0.1:9900"),
+                .help("Location of the drone; defaults to 127.0.0.1:9900"),
         )
         .arg(
             Arg::with_name("identity")
@@ -163,8 +163,7 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
         )
 }
 
-#[allow(clippy::field_reassign_with_default)]
-pub fn extract_args(matches: &ArgMatches) -> Config {
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
     let mut args = Config::default();
 
     args.entrypoint_addr = solana_net_utils::parse_host_port(
@@ -175,9 +174,9 @@ pub fn extract_args(matches: &ArgMatches) -> Config {
         exit(1)
     });
 
-    args.faucet_addr = solana_net_utils::parse_host_port(matches.value_of("faucet").unwrap())
+    args.drone_addr = solana_net_utils::parse_host_port(matches.value_of("drone").unwrap())
         .unwrap_or_else(|e| {
-            eprintln!("failed to parse faucet address: {}", e);
+            eprintln!("failed to parse drone address: {}", e);
             exit(1)
         });
 

bench-exchange/src/main.rs

@@ -1,4 +1,3 @@
-#![allow(clippy::integer_arithmetic)]
 pub mod bench;
 mod cli;
 pub mod order_book;
@@ -6,18 +5,18 @@ pub mod order_book;
 use crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config};
 use log::*;
 use solana_core::gossip_service::{discover_cluster, get_multi_client};
-use solana_sdk::signature::Signer;
+use solana_sdk::signature::KeypairUtil;
 
 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 {
         entrypoint_addr,
-        faucet_addr,
+        drone_addr,
         identity,
         threads,
         num_nodes,
@@ -55,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);
 
@@ -73,7 +73,7 @@ fn main() {
             const NUM_SIGNERS: u64 = 2;
             airdrop_lamports(
                 &client,
-                &faucet_addr,
+                &drone_addr,
                 &config.identity,
                 fund_amount * (accounts_in_groups + 1) as u64 * NUM_SIGNERS,
             );

bench-exchange/tests/bench_exchange.rs

@@ -1,42 +1,35 @@
 use log::*;
 use solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config};
-use solana_core::{
-    gossip_service::{discover_cluster, get_multi_client},
-    validator::ValidatorConfig,
-};
-use solana_exchange_program::{
-    exchange_processor::process_instruction, id, solana_exchange_program,
-};
-use solana_faucet::faucet::run_local_faucet_with_port;
-use solana_local_cluster::{
-    local_cluster::{ClusterConfig, LocalCluster},
-    validator_configs::make_identical_validator_configs,
-};
-use solana_runtime::{bank::Bank, bank_client::BankClient};
-use solana_sdk::{
-    genesis_config::create_genesis_config,
-    signature::{Keypair, Signer},
-};
-use std::{process::exit, sync::mpsc::channel, time::Duration};
+use solana_core::gossip_service::{discover_cluster, get_multi_client};
+use solana_core::validator::ValidatorConfig;
+use solana_drone::drone::run_local_drone;
+use solana_exchange_program::exchange_processor::process_instruction;
+use solana_exchange_program::id;
+use solana_exchange_program::solana_exchange_program;
+use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
+use solana_runtime::bank::Bank;
+use solana_runtime::bank_client::BankClient;
+use solana_sdk::genesis_config::create_genesis_config;
+use solana_sdk::signature::{Keypair, KeypairUtil};
+use std::process::exit;
+use std::sync::mpsc::channel;
+use std::time::Duration;
 
 #[test]
-#[ignore]
 fn test_exchange_local_cluster() {
     solana_logger::setup();
 
     const NUM_NODES: usize = 1;
 
-    let config = Config {
-        identity: Keypair::new(),
-        duration: Duration::from_secs(1),
-        fund_amount: 100_000,
-        threads: 1,
-        transfer_delay: 20, // 15
-        batch_size: 100,    // 1000
-        chunk_size: 10,     // 200
-        account_groups: 1,  // 10
-        ..Config::default()
-    };
+    let mut config = Config::default();
+    config.identity = Keypair::new();
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 15
+    config.batch_size = 100; // 1000;
+    config.chunk_size = 10; // 200;
+    config.account_groups = 1; // 10;
     let Config {
         fund_amount,
         batch_size,
@@ -45,30 +38,27 @@ fn test_exchange_local_cluster() {
     } = config;
     let accounts_in_groups = batch_size * account_groups;
 
-    let cluster = LocalCluster::new(&mut ClusterConfig {
+    let cluster = LocalCluster::new(&ClusterConfig {
         node_stakes: vec![100_000; NUM_NODES],
         cluster_lamports: 100_000_000_000_000,
-        validator_configs: make_identical_validator_configs(&ValidatorConfig::default(), NUM_NODES),
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
         native_instruction_processors: [solana_exchange_program!()].to_vec(),
         ..ClusterConfig::default()
     });
 
-    let faucet_keypair = Keypair::new();
+    let drone_keypair = Keypair::new();
     cluster.transfer(
         &cluster.funding_keypair,
-        &faucet_keypair.pubkey(),
+        &drone_keypair.pubkey(),
         2_000_000_000_000,
     );
 
     let (addr_sender, addr_receiver) = channel();
-    run_local_faucet_with_port(faucet_keypair, addr_sender, Some(1_000_000_000_000), 0);
-    let faucet_addr = addr_receiver
-        .recv_timeout(Duration::from_secs(2))
-        .expect("run_local_faucet")
-        .expect("faucet_addr");
+    run_local_drone(drone_keypair, addr_sender, Some(1_000_000_000_000));
+    let drone_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);
@@ -82,7 +72,7 @@ fn test_exchange_local_cluster() {
     const NUM_SIGNERS: u64 = 2;
     airdrop_lamports(
         &client,
-        &faucet_addr,
+        &drone_addr,
         &config.identity,
         fund_amount * (accounts_in_groups + 1) as u64 * NUM_SIGNERS,
     );
@@ -95,21 +85,18 @@ 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("exchange_program", id(), process_instruction);
+    bank.add_instruction_processor(id(), process_instruction);
     let clients = vec![BankClient::new(bank)];
 
-    do_bench_exchange(
-        clients,
-        Config {
-            identity,
-            duration: Duration::from_secs(1),
-            fund_amount: 100_000,
-            threads: 1,
-            transfer_delay: 20, // 0;
-            batch_size: 100,    // 1500;
-            chunk_size: 10,     // 1500;
-            account_groups: 1,  // 50;
-            ..Config::default()
-        },
-    );
+    let mut config = Config::default();
+    config.identity = identity;
+    config.duration = Duration::from_secs(1);
+    config.fund_amount = 100_000;
+    config.threads = 1;
+    config.transfer_delay = 20; // 0;
+    config.batch_size = 100; // 1500;
+    config.chunk_size = 10; // 1500;
+    config.account_groups = 1; // 50;
+
+    do_bench_exchange(clients, config);
 }

bench-streamer/Cargo.toml

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

bench-streamer/src/main.rs

@@ -1,14 +1,14 @@
-#![allow(clippy::integer_arithmetic)]
 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::result::Result;
+use solana_core::streamer::{receiver, PacketReceiver};
 use std::cmp::max;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::mpsc::channel;
 use std::sync::Arc;
 use std::thread::sleep;
-use std::thread::{spawn, JoinHandle, Result};
+use std::thread::{spawn, JoinHandle};
 use std::time::Duration;
 use std::time::SystemTime;
 
@@ -28,7 +28,7 @@ fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
         let mut num = 0;
         for p in &msgs.packets {
             let a = p.meta.addr();
-            assert!(p.meta.size <= PACKET_DATA_SIZE);
+            assert!(p.meta.size < PACKET_DATA_SIZE);
             send.send_to(&p.data[..p.meta.size], &a).unwrap();
             num += 1;
         }
@@ -53,7 +53,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")
@@ -68,16 +68,15 @@ fn main() -> Result<()> {
     }
 
     let mut port = 0;
-    let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
-    let mut addr = SocketAddr::new(ip_addr, 0);
+    let mut addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
 
     let exit = Arc::new(AtomicBool::new(false));
 
     let mut read_channels = Vec::new();
     let mut read_threads = Vec::new();
-    let recycler = PacketsRecycler::new_without_limit("bench-streamer-recycler-shrink-stats");
+    let recycler = PacketsRecycler::default();
     for _ in 0..num_sockets {
-        let read = solana_net_utils::bind_to(ip_addr, port, false).unwrap();
+        let read = solana_net_utils::bind_to(port, false).unwrap();
         read.set_read_timeout(Some(Duration::new(1, 0))).unwrap();
 
         addr = read.local_addr().unwrap();
@@ -91,7 +90,6 @@ fn main() -> Result<()> {
             s_reader,
             recycler.clone(),
             "bench-streamer-test",
-            1,
         ));
     }
 

bench-tps/Cargo.toml

@@ -1,36 +1,39 @@
 [package]
-authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+authors = ["Solana Maintainers <maintainers@solana.com>"]
 edition = "2018"
 name = "solana-bench-tps"
-version = "1.6.9"
+version = "0.21.6"
 repository = "https://github.com/solana-labs/solana"
 license = "Apache-2.0"
 homepage = "https://solana.com/"
-publish = false
 
 [dependencies]
-bincode = "1.3.1"
-clap = "2.33.1"
-log = "0.4.11"
-rayon = "1.5.0"
-serde_json = "1.0.56"
-serde_yaml = "0.8.13"
-solana-clap-utils = { path = "../clap-utils", version = "=1.6.9" }
-solana-core = { path = "../core", version = "=1.6.9" }
-solana-genesis = { path = "../genesis", version = "=1.6.9" }
-solana-client = { path = "../client", version = "=1.6.9" }
-solana-faucet = { path = "../faucet", version = "=1.6.9" }
-solana-logger = { path = "../logger", version = "=1.6.9" }
-solana-metrics = { path = "../metrics", version = "=1.6.9" }
-solana-measure = { path = "../measure", version = "=1.6.9" }
-solana-net-utils = { path = "../net-utils", version = "=1.6.9" }
-solana-runtime = { path = "../runtime", version = "=1.6.9" }
-solana-sdk = { path = "../sdk", version = "=1.6.9" }
-solana-version = { path = "../version", version = "=1.6.9" }
+bincode = "1.2.0"
+clap = "2.33.0"
+log = "0.4.8"
+rayon = "1.2.0"
+serde = "1.0.102"
+serde_derive = "1.0.102"
+serde_json = "1.0.41"
+serde_yaml = "0.8.11"
+solana-clap-utils = { path = "../clap-utils", version = "0.21.6" }
+solana-core = { path = "../core", version = "0.21.6" }
+solana-genesis = { path = "../genesis", version = "0.21.6" }
+solana-client = { path = "../client", version = "0.21.6" }
+solana-drone = { path = "../drone", version = "0.21.6" }
+solana-librapay-api = { path = "../programs/librapay_api", version = "0.21.6", optional = true }
+solana-logger = { path = "../logger", version = "0.21.6" }
+solana-metrics = { path = "../metrics", version = "0.21.6" }
+solana-measure = { path = "../measure", version = "0.21.6" }
+solana-net-utils = { path = "../net-utils", version = "0.21.6" }
+solana-runtime = { path = "../runtime", version = "0.21.6" }
+solana-sdk = { path = "../sdk", version = "0.21.6" }
+solana-move-loader-program = { path = "../programs/move_loader", version = "0.21.6", optional = true }
 
 [dev-dependencies]
-serial_test = "0.4.0"
-solana-local-cluster = { path = "../local-cluster", version = "=1.6.9" }
+serial_test = "0.2.0"
+serial_test_derive = "0.2.0"
+solana-local-cluster = { path = "../local-cluster", version = "0.21.6" }
 
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
+[features]
+move = ["solana-librapay-api", "solana-move-loader-program"]

bench-tps/src/cli.rs

@@ -1,18 +1,15 @@
 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_drone::drone::DRONE_PORT;
+use solana_sdk::fee_calculator::FeeCalculator;
+use solana_sdk::signature::{read_keypair_file, Keypair, KeypairUtil};
 use std::{net::SocketAddr, process::exit, time::Duration};
 
-const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;
+const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::SOL_LAMPORTS;
 
 /// Holds the configuration for a single run of the benchmark
 pub struct Config {
     pub entrypoint_addr: SocketAddr,
-    pub faucet_addr: SocketAddr,
+    pub drone_addr: SocketAddr,
     pub id: Keypair,
     pub threads: usize,
     pub num_nodes: usize,
@@ -26,16 +23,15 @@ 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 {
     fn default() -> Config {
         Config {
             entrypoint_addr: SocketAddr::from(([127, 0, 0, 1], 8001)),
-            faucet_addr: SocketAddr::from(([127, 0, 0, 1], FAUCET_PORT)),
+            drone_addr: SocketAddr::from(([127, 0, 0, 1], DRONE_PORT)),
             id: Keypair::new(),
             threads: 4,
             num_nodes: 1,
@@ -47,11 +43,10 @@ impl Default for Config {
             client_ids_and_stake_file: String::new(),
             write_to_client_file: false,
             read_from_client_file: false,
-            target_lamports_per_signature: FeeRateGovernor::default().target_lamports_per_signature,
+            target_lamports_per_signature: FeeCalculator::default().target_lamports_per_signature,
             multi_client: true,
+            use_move: false,
             num_lamports_per_account: NUM_LAMPORTS_PER_ACCOUNT_DEFAULT,
-            target_slots_per_epoch: 0,
-            target_node: None,
         }
     }
 }
@@ -69,12 +64,12 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
                 .help("Rendezvous with the cluster at this entry point; defaults to 127.0.0.1:8001"),
         )
         .arg(
-            Arg::with_name("faucet")
+            Arg::with_name("drone")
                 .short("d")
-                .long("faucet")
+                .long("drone")
                 .value_name("HOST:PORT")
                 .takes_value(true)
-                .help("Location of the faucet; defaults to entrypoint:FAUCET_PORT"),
+                .help("Location of the drone; defaults to entrypoint:DRONE_PORT"),
         )
         .arg(
             Arg::with_name("identity")
@@ -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`
@@ -196,7 +179,7 @@ pub fn build_args<'a, 'b>(version: &'b str) -> App<'a, 'b> {
 /// * `matches` - command line arguments parsed by clap
 /// # Panics
 /// Panics if there is trouble parsing any of the arguments
-pub fn extract_args(matches: &ArgMatches) -> Config {
+pub fn extract_args<'a>(matches: &ArgMatches<'a>) -> Config {
     let mut args = Config::default();
 
     if let Some(addr) = matches.value_of("entrypoint") {
@@ -206,9 +189,9 @@ pub fn extract_args(matches: &ArgMatches) -> Config {
         });
     }
 
-    if let Some(addr) = matches.value_of("faucet") {
-        args.faucet_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
-            eprintln!("failed to parse faucet address: {}", e);
+    if let Some(addr) = matches.value_of("drone") {
+        args.drone_addr = solana_net_utils::parse_host_port(addr).unwrap_or_else(|e| {
+            eprintln!("failed to parse drone address: {}", e);
             exit(1)
         });
     }
@@ -269,21 +252,12 @@ pub fn extract_args(matches: &ArgMatches) -> 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/lib.rs

@@ -1,3 +1,2 @@
-#![allow(clippy::integer_arithmetic)]
 pub mod bench;
 pub mod cli;

bench-tps/src/main.rs

@@ -1,27 +1,26 @@
-#![allow(clippy::integer_arithmetic)]
 use log::*;
 use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs};
 use solana_bench_tps::cli;
 use solana_core::gossip_service::{discover_cluster, get_client, get_multi_client};
 use solana_genesis::Base64Account;
-use solana_sdk::fee_calculator::FeeRateGovernor;
-use solana_sdk::signature::{Keypair, Signer};
+use solana_sdk::fee_calculator::FeeCalculator;
+use solana_sdk::signature::{Keypair, KeypairUtil};
 use solana_sdk::system_program;
-use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc};
+use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit};
 
 /// Number of signatures for all transactions in ~1 week at ~100K TPS
 pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 7;
 
 fn main() {
-    solana_logger::setup_with_default("solana=info");
+    solana_logger::setup_with_filter("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 {
         entrypoint_addr,
-        faucet_addr,
+        drone_addr,
         id,
         num_nodes,
         tx_count,
@@ -30,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;
 
@@ -42,7 +41,7 @@ fn main() {
         let (keypairs, _) = generate_keypairs(&id, keypair_count as u64);
         let num_accounts = keypairs.len() as u64;
         let max_fee =
-            FeeRateGovernor::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
+            FeeCalculator::new(*target_lamports_per_signature, 0).max_lamports_per_signature;
         let num_lamports_per_account = (num_accounts - 1 + NUM_SIGNATURES_FOR_TXS * max_fee)
             / num_accounts
             + num_lamports_per_account;
@@ -68,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,25 +82,12 @@ 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);
-        })
+        client
     } else {
-        Arc::new(get_client(&nodes))
+        get_client(&nodes)
     };
 
-    let keypairs = if *read_from_client_file {
+    let (keypairs, move_keypairs, keypair_balance) = if *read_from_client_file && !use_move {
         let path = Path::new(&client_ids_and_stake_file);
         let file = File::open(path).unwrap();
 
@@ -129,15 +116,16 @@ 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, last_balance)
     } else {
         generate_and_fund_keypairs(
-            client.clone(),
-            Some(*faucet_addr),
+            &client,
+            Some(*drone_addr),
             &id,
             keypair_count,
             *num_lamports_per_account,
+            *use_move,
         )
         .unwrap_or_else(|e| {
             eprintln!("Error could not fund keys: {:?}", e);
@@ -145,5 +133,11 @@ fn main() {
         })
     };
 
-    do_bench_tps(client, cli_config, keypairs);
+    do_bench_tps(
+        vec![client],
+        cli_config,
+        keypairs,
+        keypair_balance,
+        move_keypairs,
+    );
 }

bench-tps/tests/bench_tps.rs

@@ -1,67 +1,64 @@
-#![allow(clippy::integer_arithmetic)]
-use serial_test::serial;
-use solana_bench_tps::{
-    bench::{do_bench_tps, generate_and_fund_keypairs},
-    cli::Config,
-};
+use serial_test_derive::serial;
+use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs};
+use solana_bench_tps::cli::Config;
 use solana_client::thin_client::create_client;
-use solana_core::{cluster_info::VALIDATOR_PORT_RANGE, validator::ValidatorConfig};
-use solana_faucet::faucet::run_local_faucet_with_port;
-use solana_local_cluster::{
-    local_cluster::{ClusterConfig, LocalCluster},
-    validator_configs::make_identical_validator_configs,
-};
-use solana_sdk::signature::{Keypair, Signer};
-use std::{
-    sync::{mpsc::channel, Arc},
-    time::Duration,
-};
+use solana_core::cluster_info::VALIDATOR_PORT_RANGE;
+use solana_core::validator::ValidatorConfig;
+use solana_drone::drone::run_local_drone;
+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, KeypairUtil};
+use std::sync::mpsc::channel;
+use std::time::Duration;
 
 fn test_bench_tps_local_cluster(config: Config) {
+    #[cfg(feature = "move")]
+    let native_instruction_processors = vec![solana_move_loader_program()];
+
+    #[cfg(not(feature = "move"))]
     let native_instruction_processors = vec![];
 
     solana_logger::setup();
     const NUM_NODES: usize = 1;
-    let cluster = LocalCluster::new(&mut ClusterConfig {
+    let cluster = LocalCluster::new(&ClusterConfig {
         node_stakes: vec![999_990; NUM_NODES],
         cluster_lamports: 200_000_000,
-        validator_configs: make_identical_validator_configs(&ValidatorConfig::default(), NUM_NODES),
+        validator_configs: vec![ValidatorConfig::default(); NUM_NODES],
         native_instruction_processors,
         ..ClusterConfig::default()
     });
 
-    let faucet_keypair = Keypair::new();
+    let drone_keypair = Keypair::new();
     cluster.transfer(
         &cluster.funding_keypair,
-        &faucet_keypair.pubkey(),
+        &drone_keypair.pubkey(),
         100_000_000,
     );
 
-    let client = Arc::new(create_client(
+    let client = create_client(
         (cluster.entry_point_info.rpc, cluster.entry_point_info.tpu),
         VALIDATOR_PORT_RANGE,
-    ));
+    );
 
     let (addr_sender, addr_receiver) = channel();
-    run_local_faucet_with_port(faucet_keypair, addr_sender, None, 0);
-    let faucet_addr = addr_receiver
-        .recv_timeout(Duration::from_secs(2))
-        .expect("run_local_faucet")
-        .expect("faucet_addr");
+    run_local_drone(drone_keypair, addr_sender, None);
+    let drone_addr = addr_receiver.recv_timeout(Duration::from_secs(2)).unwrap();
 
     let lamports_per_account = 100;
 
     let keypair_count = config.tx_count * config.keypair_multiplier;
-    let keypairs = generate_and_fund_keypairs(
-        client.clone(),
-        Some(faucet_addr),
+    let (keypairs, move_keypairs, _keypair_balance) = generate_and_fund_keypairs(
+        &client,
+        Some(drone_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(vec![client], config, keypairs, 0, move_keypairs);
 
     #[cfg(not(debug_assertions))]
     assert!(_total > 100);
@@ -70,9 +67,20 @@ fn test_bench_tps_local_cluster(config: Config) {
 #[test]
 #[serial]
 fn test_bench_tps_local_cluster_solana() {
-    test_bench_tps_local_cluster(Config {
-        tx_count: 100,
-        duration: Duration::from_secs(10),
-        ..Config::default()
-    });
+    let mut config = Config::default();
+    config.tx_count = 100;
+    config.duration = Duration::from_secs(10);
+
+    test_bench_tps_local_cluster(config);
+}
+
+#[test]
+#[serial]
+fn test_bench_tps_local_cluster_move() {
+    let mut config = Config::default();
+    config.tx_count = 100;
+    config.duration = Duration::from_secs(10);
+    config.use_move = true;
+
+    test_bench_tps_local_cluster(config);
 }

book/.gitattributes

@@ -0,0 +1 @@
+theme/highlight.js binary

book/README.md

@@ -0,0 +1,26 @@
+Building the Solana book
+---
+
+Install the book's dependnecies, build, and test the book:
+
+```bash
+$ ./build.sh
+```
+
+Run any Rust tests in the markdown:
+
+```bash
+$ make test
+```
+
+Render markdown as HTML:
+
+```bash
+$ make build
+```
+
+Render and view the book:
+
+```bash
+$ make open
+```

book/art/passive-staking-callflow.msc

@@ -24,7 +24,7 @@ msc {
   ... ;
   Validator abox Validator [label="\nmax\nlockout\n"];
        |||;
-  Cluster box Cluster [label="credits redeemed (at epoch)"];
-
+  StakerX => Cluster [label="StakeState::RedeemCredits()"];
+  StakerY => Cluster [label="StakeState::RedeemCredits()"] ;
 
 }

book/art/sdk-tools.bob

@@ -0,0 +1,20 @@
+
+                            .----------------------------------------.
+                            |            Solana Runtime              |
+                            |                                        |
+                            |   .------------.   .------------.      |
+                            |   |            |   |            |      |
+                      .-------->|  Verifier  +-->|  Accounts  |      |
+                      |     |   |            |   |            |      |
+  .----------.        |     |   `------------`   `------------`      |
+  |          +--------`     |                           ^            |
+  |  Client  |              |             LoadAccounts  |            |
+  |          +--------.     |          .----------------`            |
+  `----------`        |     |          |                             |
+                      |     |   .------+-----.   .-------------.     |
+                      |     |   |            |   |             |     |
+                      `-------->|  Loader    +-->| Interpreter |     |
+                            |   |            |   |             |     |
+                            |   `------------`   `-------------`     |
+                            |                                        |
+                            `----------------------------------------`

book/art/spv-bank-merkle.bob

@@ -0,0 +1,18 @@
+                             +------------+
+                             | Bank-Merkle|
+                             +------------+
+                                ^      ^
+                               /        \
+               +-----------------+    +-------------+
+               | Bank-Diff-Merkle|    | Block-Merkle|
+               +-----------------+    +-------------+
+                     ^     ^
+                    /       \
+               +------+   +--------------------------+
+               | Hash |   | Previous Bank-Diff-Merkle|
+               +------+   +--------------------------+
+               ^      ^
+              /        \
+ +---------------+   +---------------+
+ | Hash(Account1)|   | Hash(Account2)|
+ +---------------+   +---------------+

book/art/tvu.bob

@@ -0,0 +1,22 @@
+                                                  .--------.
+                                                  | Leader |
+                                                  `--------`
+                                                       ^
+                                                       |
+                  .------------------------------------|--------------------.
+                  |  TVU                               |                    |
+                  |                                    |                    |
+                  |  .-------.   .------------.   .----+---.   .---------.  |
+ .------------.   |  | Shred |   | Retransmit |   | Replay |   | Storage |  |
+ | Upstream   +----->| Fetch +-->| Stage      +-->| Stage  +-->| Stage   |  |
+ | Validators |   |  | Stage |   |            |   |        |   |         |  |
+ `------------`   |  `-------`   `----+-------`   `----+---`   `---------`  |
+                  |        ^          |                |                    |
+                  |        |          |                |                    |
+                  `--------|----------|----------------|--------------------`
+                           |          |                |
+                           |          V                v
+                          .+-----------.            .------.
+                          | Gossip     |            | Bank |
+                          | Service    |            `------`
+                          `------------`

book/art/validator.bob

@@ -18,9 +18,9 @@
       |      | `-------`  `--------` `--+---------`  | |  |            |  |
       |      |     ^              ^     |            | |  `------------`  |
       |      |     |              |     v            | |                  |
-      |      |     |           .--+---------.        | |                  |
-      |      |     |           | Blockstore |        | |                  |
-      |      |     |           `------------`        | |  .------------.  |
+      |      |     |           .--+--------.         | |                  |
+      |      |     |           | Blocktree |         | |                  |
+      |      |     |           `-----------`         | |  .------------.  |
       |      |     |                ^                | |  |            |  |
       |      |     |                |                | |  | Downstream |  |
       |      |  .--+--.     .-------+---.            | |  | Validators |  |

book/book.toml

@@ -0,0 +1,10 @@
+[book]
+title = "Solana: Blockchain Rebuilt for Scale"
+authors = ["The Solana Team"]
+
+[build]
+build-dir = "html"
+create-missing = false
+
+[output.html]
+theme = "theme"

book/build-cli-usage.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"
+
+usage=$(cargo -q run -p solana-cli -- -C ~/.foo --help | sed 's|'"$HOME"'|~|g')
+
+out=${1:-src/api-reference/cli.md}
+
+cat src/api-reference/.cli.md > "$out"
+
+section() {
+  declare mark=${2:-"###"}
+  declare section=$1
+  read -r name rest <<<"$section"
+
+  printf '%s %s
+' "$mark" "$name"
+  printf '```text
+%s
+```
+
+' "$section"
+}
+
+section "$usage" >> "$out"
+
+in_subcommands=0
+while read -r subcommand rest; do
+  [[ $subcommand == "SUBCOMMANDS:" ]] && in_subcommands=1 && continue
+  if ((in_subcommands)); then
+      section "$(cargo -q run -p solana-cli -- help "$subcommand" | sed 's|'"$HOME"'|~|g')" "####" >> "$out"
+  fi
+done <<<"$usage">>"$out"

book/build-svg.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"
+
+make -j"$(nproc)" -B svg
+
+#TODO figure out why book wants to change, but local and CI differ
+exit 0
+if [[ -n $CI ]]; then
+  # In CI confirm that no svgs need to be built
+  git diff --exit-code
+fi

book/build.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -e
+
+cd "$(dirname "$0")"
+
+make -j"$(nproc)" test

book/makefile

@@ -0,0 +1,43 @@
+BOB_SRCS=$(wildcard art/*.bob)
+MSC_SRCS=$(wildcard art/*.msc)
+MD_SRCS=$(wildcard src/*.md)
+
+SVG_IMGS=$(BOB_SRCS:art/%.bob=src/.gitbook/assets/%.svg) $(MSC_SRCS:art/%.msc=src/.gitbook/assets/%.svg)
+
+TARGET=html/index.html
+TEST_STAMP=src/tests.ok
+
+all: $(TARGET)
+
+svg: $(SVG_IMGS)
+
+test: $(TEST_STAMP)
+
+open: $(TEST_STAMP)
+	mdbook build --open
+
+watch: $(SVG_IMGS)
+	mdbook watch
+
+src/.gitbook/assets/%.svg: art/%.bob
+	@mkdir -p $(@D)
+	svgbob < $< > $@
+
+src/.gitbook/assets/%.svg: art/%.msc
+	@mkdir -p $(@D)
+	mscgen -T svg -i $< -o $@
+
+src/%.md: %.md
+	@mkdir -p $(@D)
+	@cp $< $@
+
+$(TEST_STAMP): $(TARGET)
+	mdbook test
+	touch $@
+
+$(TARGET): $(SVG_IMGS) $(MD_SRCS)
+	mdbook build
+
+clean:
+	rm -f $(SVG_IMGS) src/tests.ok
+	rm -rf html

book/src/.gitbook/assets/data-plane (1).svg

@@ -0,0 +1,192 @@
+<svg class="bob" font-family="arial" font-size="14" height="288" width="736" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="288" width="736" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="216" y2="280"/>
+<line x1="4" x2="156" y1="216" y2="216"/>
+<line x1="4" x2="172" y1="280" y2="280"/>
+<line x1="156" x2="172" y1="216" y2="216"/>
+<line x1="172" x2="172" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="124" x2="124" y1="104" y2="168"/>
+<line x1="124" x2="204" y1="104" y2="104"/>
+<line x1="124" x2="156" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="156" x2="156" y1="168" y2="204"/>
+<line x1="156" x2="204" y1="168" y2="168"/>
+<line x1="204" x2="292" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="168" y2="204"/>
+<line x1="204" x2="292" y1="168" y2="168"/>
+<line x1="292" x2="292" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="188" x2="188" y1="216" y2="280"/>
+<line x1="188" x2="204" y1="216" y2="216"/>
+<line x1="188" x2="356" y1="280" y2="280"/>
+<line x1="204" x2="356" y1="216" y2="216"/>
+<line x1="356" x2="356" y1="216" y2="280"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="40" y2="92"/>
+<line x1="204" x2="276" y1="40" y2="40"/>
+<line x1="276" x2="276" y1="8" y2="40"/>
+<line x1="276" x2="444" y1="8" y2="8"/>
+<line x1="276" x2="276" y1="40" y2="72"/>
+<line x1="276" x2="444" y1="72" y2="72"/>
+<line x1="444" x2="444" y1="8" y2="40"/>
+<line x1="444" x2="444" y1="40" y2="72"/>
+<line x1="444" x2="532" y1="40" y2="40"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="40" y2="92"/>
+</g>
+<g>
+<line x1="380" x2="380" y1="216" y2="280"/>
+<line x1="380" x2="532" y1="216" y2="216"/>
+<line x1="380" x2="548" y1="280" y2="280"/>
+<line x1="532" x2="548" y1="216" y2="216"/>
+<line x1="548" x2="548" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="444" x2="444" y1="104" y2="168"/>
+<line x1="444" x2="532" y1="104" y2="104"/>
+<line x1="444" x2="532" y1="168" y2="168"/>
+<line x1="532" x2="612" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="168" y2="204"/>
+<line x1="532" x2="580" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="580" x2="580" y1="168" y2="204"/>
+<line x1="580" x2="612" y1="168" y2="168"/>
+<line x1="612" x2="612" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="564" x2="564" y1="216" y2="280"/>
+<line x1="564" x2="580" y1="216" y2="216"/>
+<line x1="564" x2="732" y1="280" y2="280"/>
+<line x1="580" x2="732" y1="216" y2="216"/>
+<line x1="732" x2="732" y1="216" y2="280"/>
+</g>
+<g>
+<text x="33" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="137" y="252">
+3
+</text>
+</g>
+<g>
+<text x="153" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="217" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="257" y="140">
+1
+</text>
+</g>
+<g>
+<text x="305" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="252">
+4
+</text>
+</g>
+<g>
+<text x="409" y="44">
+0
+</text>
+</g>
+<g>
+<text x="409" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="473" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="513" y="252">
+5
+</text>
+</g>
+<g>
+<text x="577" y="140">
+2
+</text>
+</g>
+<g>
+<text x="593" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="697" y="252">
+6
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane (2).svg

@@ -0,0 +1,192 @@
+<svg class="bob" font-family="arial" font-size="14" height="288" width="736" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="288" width="736" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="216" y2="280"/>
+<line x1="4" x2="156" y1="216" y2="216"/>
+<line x1="4" x2="172" y1="280" y2="280"/>
+<line x1="156" x2="172" y1="216" y2="216"/>
+<line x1="172" x2="172" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="124" x2="124" y1="104" y2="168"/>
+<line x1="124" x2="204" y1="104" y2="104"/>
+<line x1="124" x2="156" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="156" x2="156" y1="168" y2="204"/>
+<line x1="156" x2="204" y1="168" y2="168"/>
+<line x1="204" x2="292" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="168" y2="204"/>
+<line x1="204" x2="292" y1="168" y2="168"/>
+<line x1="292" x2="292" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="188" x2="188" y1="216" y2="280"/>
+<line x1="188" x2="204" y1="216" y2="216"/>
+<line x1="188" x2="356" y1="280" y2="280"/>
+<line x1="204" x2="356" y1="216" y2="216"/>
+<line x1="356" x2="356" y1="216" y2="280"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="40" y2="92"/>
+<line x1="204" x2="276" y1="40" y2="40"/>
+<line x1="276" x2="276" y1="8" y2="40"/>
+<line x1="276" x2="444" y1="8" y2="8"/>
+<line x1="276" x2="276" y1="40" y2="72"/>
+<line x1="276" x2="444" y1="72" y2="72"/>
+<line x1="444" x2="444" y1="8" y2="40"/>
+<line x1="444" x2="444" y1="40" y2="72"/>
+<line x1="444" x2="532" y1="40" y2="40"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="40" y2="92"/>
+</g>
+<g>
+<line x1="380" x2="380" y1="216" y2="280"/>
+<line x1="380" x2="532" y1="216" y2="216"/>
+<line x1="380" x2="548" y1="280" y2="280"/>
+<line x1="532" x2="548" y1="216" y2="216"/>
+<line x1="548" x2="548" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="444" x2="444" y1="104" y2="168"/>
+<line x1="444" x2="532" y1="104" y2="104"/>
+<line x1="444" x2="532" y1="168" y2="168"/>
+<line x1="532" x2="612" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="168" y2="204"/>
+<line x1="532" x2="580" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="580" x2="580" y1="168" y2="204"/>
+<line x1="580" x2="612" y1="168" y2="168"/>
+<line x1="612" x2="612" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="564" x2="564" y1="216" y2="280"/>
+<line x1="564" x2="580" y1="216" y2="216"/>
+<line x1="564" x2="732" y1="280" y2="280"/>
+<line x1="580" x2="732" y1="216" y2="216"/>
+<line x1="732" x2="732" y1="216" y2="280"/>
+</g>
+<g>
+<text x="33" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="137" y="252">
+3
+</text>
+</g>
+<g>
+<text x="153" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="217" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="257" y="140">
+1
+</text>
+</g>
+<g>
+<text x="305" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="252">
+4
+</text>
+</g>
+<g>
+<text x="409" y="44">
+0
+</text>
+</g>
+<g>
+<text x="409" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="473" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="513" y="252">
+5
+</text>
+</g>
+<g>
+<text x="577" y="140">
+2
+</text>
+</g>
+<g>
+<text x="593" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="697" y="252">
+6
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane (3).svg

@@ -0,0 +1,192 @@
+<svg class="bob" font-family="arial" font-size="14" height="288" width="736" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="288" width="736" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="216" y2="280"/>
+<line x1="4" x2="156" y1="216" y2="216"/>
+<line x1="4" x2="172" y1="280" y2="280"/>
+<line x1="156" x2="172" y1="216" y2="216"/>
+<line x1="172" x2="172" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="124" x2="124" y1="104" y2="168"/>
+<line x1="124" x2="204" y1="104" y2="104"/>
+<line x1="124" x2="156" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="156" x2="156" y1="168" y2="204"/>
+<line x1="156" x2="204" y1="168" y2="168"/>
+<line x1="204" x2="292" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="168" y2="204"/>
+<line x1="204" x2="292" y1="168" y2="168"/>
+<line x1="292" x2="292" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="188" x2="188" y1="216" y2="280"/>
+<line x1="188" x2="204" y1="216" y2="216"/>
+<line x1="188" x2="356" y1="280" y2="280"/>
+<line x1="204" x2="356" y1="216" y2="216"/>
+<line x1="356" x2="356" y1="216" y2="280"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="40" y2="92"/>
+<line x1="204" x2="276" y1="40" y2="40"/>
+<line x1="276" x2="276" y1="8" y2="40"/>
+<line x1="276" x2="444" y1="8" y2="8"/>
+<line x1="276" x2="276" y1="40" y2="72"/>
+<line x1="276" x2="444" y1="72" y2="72"/>
+<line x1="444" x2="444" y1="8" y2="40"/>
+<line x1="444" x2="444" y1="40" y2="72"/>
+<line x1="444" x2="532" y1="40" y2="40"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="40" y2="92"/>
+</g>
+<g>
+<line x1="380" x2="380" y1="216" y2="280"/>
+<line x1="380" x2="532" y1="216" y2="216"/>
+<line x1="380" x2="548" y1="280" y2="280"/>
+<line x1="532" x2="548" y1="216" y2="216"/>
+<line x1="548" x2="548" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="444" x2="444" y1="104" y2="168"/>
+<line x1="444" x2="532" y1="104" y2="104"/>
+<line x1="444" x2="532" y1="168" y2="168"/>
+<line x1="532" x2="612" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="168" y2="204"/>
+<line x1="532" x2="580" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="580" x2="580" y1="168" y2="204"/>
+<line x1="580" x2="612" y1="168" y2="168"/>
+<line x1="612" x2="612" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="564" x2="564" y1="216" y2="280"/>
+<line x1="564" x2="580" y1="216" y2="216"/>
+<line x1="564" x2="732" y1="280" y2="280"/>
+<line x1="580" x2="732" y1="216" y2="216"/>
+<line x1="732" x2="732" y1="216" y2="280"/>
+</g>
+<g>
+<text x="33" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="137" y="252">
+3
+</text>
+</g>
+<g>
+<text x="153" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="217" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="257" y="140">
+1
+</text>
+</g>
+<g>
+<text x="305" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="252">
+4
+</text>
+</g>
+<g>
+<text x="409" y="44">
+0
+</text>
+</g>
+<g>
+<text x="409" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="473" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="513" y="252">
+5
+</text>
+</g>
+<g>
+<text x="577" y="140">
+2
+</text>
+</g>
+<g>
+<text x="593" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="697" y="252">
+6
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane (4).svg

@@ -0,0 +1,192 @@
+<svg class="bob" font-family="arial" font-size="14" height="288" width="736" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="288" width="736" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="216" y2="280"/>
+<line x1="4" x2="156" y1="216" y2="216"/>
+<line x1="4" x2="172" y1="280" y2="280"/>
+<line x1="156" x2="172" y1="216" y2="216"/>
+<line x1="172" x2="172" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="124" x2="124" y1="104" y2="168"/>
+<line x1="124" x2="204" y1="104" y2="104"/>
+<line x1="124" x2="156" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="156" x2="156" y1="168" y2="204"/>
+<line x1="156" x2="204" y1="168" y2="168"/>
+<line x1="204" x2="292" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="168" y2="204"/>
+<line x1="204" x2="292" y1="168" y2="168"/>
+<line x1="292" x2="292" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="188" x2="188" y1="216" y2="280"/>
+<line x1="188" x2="204" y1="216" y2="216"/>
+<line x1="188" x2="356" y1="280" y2="280"/>
+<line x1="204" x2="356" y1="216" y2="216"/>
+<line x1="356" x2="356" y1="216" y2="280"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="40" y2="92"/>
+<line x1="204" x2="276" y1="40" y2="40"/>
+<line x1="276" x2="276" y1="8" y2="40"/>
+<line x1="276" x2="444" y1="8" y2="8"/>
+<line x1="276" x2="276" y1="40" y2="72"/>
+<line x1="276" x2="444" y1="72" y2="72"/>
+<line x1="444" x2="444" y1="8" y2="40"/>
+<line x1="444" x2="444" y1="40" y2="72"/>
+<line x1="444" x2="532" y1="40" y2="40"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="40" y2="92"/>
+</g>
+<g>
+<line x1="380" x2="380" y1="216" y2="280"/>
+<line x1="380" x2="532" y1="216" y2="216"/>
+<line x1="380" x2="548" y1="280" y2="280"/>
+<line x1="532" x2="548" y1="216" y2="216"/>
+<line x1="548" x2="548" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="444" x2="444" y1="104" y2="168"/>
+<line x1="444" x2="532" y1="104" y2="104"/>
+<line x1="444" x2="532" y1="168" y2="168"/>
+<line x1="532" x2="612" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="168" y2="204"/>
+<line x1="532" x2="580" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="580" x2="580" y1="168" y2="204"/>
+<line x1="580" x2="612" y1="168" y2="168"/>
+<line x1="612" x2="612" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="564" x2="564" y1="216" y2="280"/>
+<line x1="564" x2="580" y1="216" y2="216"/>
+<line x1="564" x2="732" y1="280" y2="280"/>
+<line x1="580" x2="732" y1="216" y2="216"/>
+<line x1="732" x2="732" y1="216" y2="280"/>
+</g>
+<g>
+<text x="33" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="137" y="252">
+3
+</text>
+</g>
+<g>
+<text x="153" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="217" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="257" y="140">
+1
+</text>
+</g>
+<g>
+<text x="305" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="252">
+4
+</text>
+</g>
+<g>
+<text x="409" y="44">
+0
+</text>
+</g>
+<g>
+<text x="409" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="473" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="513" y="252">
+5
+</text>
+</g>
+<g>
+<text x="577" y="140">
+2
+</text>
+</g>
+<g>
+<text x="593" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="697" y="252">
+6
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane (5).svg

@@ -0,0 +1,210 @@
+<svg class="bob" font-family="arial" font-size="14" height="288" width="736" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon class="fg_fill" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon class="bg_fill" points="2,2 2,12 18,7 2,2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle class="fg_fill" cx="10" cy="10" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect class="fg_fill" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle class="bg_fill" cx="10" cy="10" r="4"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle class="bg_fill" cx="20" cy="20" r="6"/>
+</marker>
+</defs>
+<style type="text/css">
+
+rect.backdrop {
+    fill: white;
+}
+text{
+    fill: black;
+}
+
+circle {
+    fill: none;
+    stroke: black;
+    stroke-width: 2;
+}
+
+line {
+    stroke: black;
+    stroke-width: 2;
+    stroke-opacity: 1;
+    fill-opacity: 1;
+    stroke-linecap: round;
+    stroke-linejoin: miter;
+}
+
+path {
+    fill: none;
+    stroke: black;
+    stroke-width: 2;
+    stroke-opacity: 1;
+    fill-opacity: 1;
+    stroke-linecap: round;
+    stroke-linejoin: miter;
+}
+
+line.dashed {
+    stroke-dasharray: 5;
+}
+
+.fg_fill {
+    fill: black;
+}
+
+
+.bg_fill {
+    fill: white;
+    stroke: black;
+    stroke-width: 2;
+}
+
+tspan.head{
+    fill: none;
+    stroke: none;
+}
+    
+</style>
+<rect class="backdrop" height="288" width="736" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="216" y2="280"/>
+<line x1="4" x2="156" y1="216" y2="216"/>
+<line x1="4" x2="172" y1="280" y2="280"/>
+<line x1="156" x2="172" y1="216" y2="216"/>
+<line x1="172" x2="172" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="124" x2="124" y1="104" y2="168"/>
+<line x1="124" x2="204" y1="104" y2="104"/>
+<line x1="124" x2="156" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="156" x2="156" y1="168" y2="204"/>
+<line x1="156" x2="204" y1="168" y2="168"/>
+<line x1="204" x2="292" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="168" y2="204"/>
+<line x1="204" x2="292" y1="168" y2="168"/>
+<line x1="292" x2="292" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="188" x2="188" y1="216" y2="280"/>
+<line x1="188" x2="204" y1="216" y2="216"/>
+<line x1="188" x2="356" y1="280" y2="280"/>
+<line x1="204" x2="356" y1="216" y2="216"/>
+<line x1="356" x2="356" y1="216" y2="280"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="40" y2="92"/>
+<line x1="204" x2="276" y1="40" y2="40"/>
+<line x1="276" x2="276" y1="8" y2="40"/>
+<line x1="276" x2="444" y1="8" y2="8"/>
+<line x1="276" x2="276" y1="40" y2="72"/>
+<line x1="276" x2="444" y1="72" y2="72"/>
+<line x1="444" x2="444" y1="8" y2="40"/>
+<line x1="444" x2="444" y1="40" y2="72"/>
+<line x1="444" x2="532" y1="40" y2="40"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="40" y2="92"/>
+</g>
+<g>
+<line x1="380" x2="380" y1="216" y2="280"/>
+<line x1="380" x2="532" y1="216" y2="216"/>
+<line x1="380" x2="548" y1="280" y2="280"/>
+<line x1="532" x2="548" y1="216" y2="216"/>
+<line x1="548" x2="548" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="444" x2="444" y1="104" y2="168"/>
+<line x1="444" x2="532" y1="104" y2="104"/>
+<line x1="444" x2="532" y1="168" y2="168"/>
+<line x1="532" x2="612" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="168" y2="204"/>
+<line x1="532" x2="580" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="580" x2="580" y1="168" y2="204"/>
+<line x1="580" x2="612" y1="168" y2="168"/>
+<line x1="612" x2="612" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="564" x2="564" y1="216" y2="280"/>
+<line x1="564" x2="580" y1="216" y2="216"/>
+<line x1="564" x2="732" y1="280" y2="280"/>
+<line x1="580" x2="732" y1="216" y2="216"/>
+<line x1="732" x2="732" y1="216" y2="280"/>
+</g>
+<g>
+<text x="33" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="137" y="252">
+3
+</text>
+</g>
+<g>
+<text x="153" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="217" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="257" y="140">
+1
+</text>
+</g>
+<g>
+<text x="305" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="252">
+4
+</text>
+</g>
+<g>
+<text x="409" y="44">
+0
+</text>
+</g>
+<g>
+<text x="409" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="473" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="513" y="252">
+5
+</text>
+</g>
+<g>
+<text x="577" y="140">
+2
+</text>
+</g>
+<g>
+<text x="593" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="697" y="252">
+6
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane-3.svg

@@ -0,0 +1,192 @@
+<svg class="bob" font-family="arial" font-size="14" height="288" width="736" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="288" width="736" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="216" y2="280"/>
+<line x1="4" x2="156" y1="216" y2="216"/>
+<line x1="4" x2="172" y1="280" y2="280"/>
+<line x1="156" x2="172" y1="216" y2="216"/>
+<line x1="172" x2="172" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="124" x2="124" y1="104" y2="168"/>
+<line x1="124" x2="204" y1="104" y2="104"/>
+<line x1="124" x2="156" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="156" x2="156" y1="168" y2="204"/>
+<line x1="156" x2="204" y1="168" y2="168"/>
+<line x1="204" x2="292" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="168" y2="204"/>
+<line x1="204" x2="292" y1="168" y2="168"/>
+<line x1="292" x2="292" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="188" x2="188" y1="216" y2="280"/>
+<line x1="188" x2="204" y1="216" y2="216"/>
+<line x1="188" x2="356" y1="280" y2="280"/>
+<line x1="204" x2="356" y1="216" y2="216"/>
+<line x1="356" x2="356" y1="216" y2="280"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="204" x2="204" y1="40" y2="92"/>
+<line x1="204" x2="276" y1="40" y2="40"/>
+<line x1="276" x2="276" y1="8" y2="40"/>
+<line x1="276" x2="444" y1="8" y2="8"/>
+<line x1="276" x2="276" y1="40" y2="72"/>
+<line x1="276" x2="444" y1="72" y2="72"/>
+<line x1="444" x2="444" y1="8" y2="40"/>
+<line x1="444" x2="444" y1="40" y2="72"/>
+<line x1="444" x2="532" y1="40" y2="40"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="40" y2="92"/>
+</g>
+<g>
+<line x1="380" x2="380" y1="216" y2="280"/>
+<line x1="380" x2="532" y1="216" y2="216"/>
+<line x1="380" x2="548" y1="280" y2="280"/>
+<line x1="532" x2="548" y1="216" y2="216"/>
+<line x1="548" x2="548" y1="216" y2="280"/>
+</g>
+<g>
+<line x1="444" x2="444" y1="104" y2="168"/>
+<line x1="444" x2="532" y1="104" y2="104"/>
+<line x1="444" x2="532" y1="168" y2="168"/>
+<line x1="532" x2="612" y1="104" y2="104"/>
+<line marker-end="url(#triangle)" x1="532" x2="532" y1="168" y2="204"/>
+<line x1="532" x2="580" y1="168" y2="168"/>
+<line marker-end="url(#triangle)" x1="580" x2="580" y1="168" y2="204"/>
+<line x1="580" x2="612" y1="168" y2="168"/>
+<line x1="612" x2="612" y1="104" y2="168"/>
+</g>
+<g>
+<line x1="564" x2="564" y1="216" y2="280"/>
+<line x1="564" x2="580" y1="216" y2="216"/>
+<line x1="564" x2="732" y1="280" y2="280"/>
+<line x1="580" x2="732" y1="216" y2="216"/>
+<line x1="732" x2="732" y1="216" y2="280"/>
+</g>
+<g>
+<text x="33" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="137" y="252">
+3
+</text>
+</g>
+<g>
+<text x="153" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="217" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="257" y="140">
+1
+</text>
+</g>
+<g>
+<text x="305" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="252">
+4
+</text>
+</g>
+<g>
+<text x="409" y="44">
+0
+</text>
+</g>
+<g>
+<text x="409" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="473" y="140">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="513" y="252">
+5
+</text>
+</g>
+<g>
+<text x="577" y="140">
+2
+</text>
+</g>
+<g>
+<text x="593" y="252">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="697" y="252">
+6
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane-fanout (1).svg

@@ -0,0 +1,183 @@
+<svg class="bob" font-family="arial" font-size="14" height="304" width="544" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="304" width="544" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="8" y2="184"/>
+<line x1="4" x2="540" y1="8" y2="8"/>
+<line x1="4" x2="540" y1="184" y2="184"/>
+<line x1="540" x2="540" y1="8" y2="184"/>
+</g>
+<g>
+<line x1="28" x2="28" y1="232" y2="296"/>
+<line x1="28" x2="108" y1="232" y2="232"/>
+<line x1="28" x2="196" y1="296" y2="296"/>
+<line x1="108" x2="164" y1="232" y2="232"/>
+<line x1="164" x2="196" y1="232" y2="232"/>
+<line x1="196" x2="196" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="36" x2="36" y1="40" y2="104"/>
+<line x1="36" x2="180" y1="40" y2="40"/>
+<line x1="36" x2="108" y1="104" y2="104"/>
+<line x1="108" x2="108" y1="104" y2="176"/>
+<line x1="108" x2="124" y1="104" y2="104"/>
+<line x1="124" x2="124" y1="104" y2="136"/>
+<line x1="124" x2="180" y1="104" y2="104"/>
+<line x1="124" x2="364" y1="136" y2="136"/>
+<line x1="180" x2="180" y1="40" y2="56"/>
+<line x1="180" x2="180" y1="56" y2="88"/>
+<line marker-end="url(#triangle)" x1="180" x2="356" y1="56" y2="56"/>
+<line x1="180" x2="180" y1="88" y2="104"/>
+<line x1="180" x2="184" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="136" y2="152"/>
+<line x1="364" x2="364" y1="152" y2="176"/>
+<line x1="364" x2="420" y1="152" y2="152"/>
+<line x1="420" x2="420" y1="104" y2="152"/>
+<line x1="420" x2="436" y1="104" y2="104"/>
+<line x1="436" x2="436" y1="104" y2="176"/>
+<line x1="436" x2="508" y1="104" y2="104"/>
+<line x1="508" x2="508" y1="40" y2="104"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="108" x2="108" y1="192" y2="220"/>
+</g>
+<g>
+<line x1="164" x2="164" y1="152" y2="176"/>
+<line x1="164" x2="364" y1="152" y2="152"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="164" x2="164" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="192" x2="188" y1="88" y2="88"/>
+<line x1="192" x2="364" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="56" y2="88"/>
+<line x1="364" x2="364" y1="88" y2="104"/>
+<line x1="364" x2="420" y1="104" y2="104"/>
+</g>
+<g>
+<line x1="348" x2="348" y1="232" y2="296"/>
+<line x1="348" x2="364" y1="232" y2="232"/>
+<line x1="348" x2="516" y1="296" y2="296"/>
+<line x1="364" x2="436" y1="232" y2="232"/>
+<line x1="436" x2="516" y1="232" y2="232"/>
+<line x1="516" x2="516" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="364" x2="364" y1="40" y2="56"/>
+<line x1="364" x2="508" y1="40" y2="40"/>
+<line x1="364" x2="360" y1="56" y2="56"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="364" x2="364" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="436" x2="436" y1="192" y2="220"/>
+</g>
+<g>
+<text x="57" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="65" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="145" y="76">
+1
+</text>
+</g>
+<g>
+<text x="161" y="268">
+1
+</text>
+</g>
+<g>
+<text x="217" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="44">
+0
+</text>
+</g>
+<g>
+<text x="377" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="393" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="473" y="76">
+2
+</text>
+</g>
+<g>
+<text x="481" y="268">
+2
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane-fanout (2).svg

@@ -0,0 +1,201 @@
+<svg class="bob" font-family="arial" font-size="14" height="304" width="544" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon class="fg_fill" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon class="bg_fill" points="2,2 2,12 18,7 2,2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle class="fg_fill" cx="10" cy="10" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect class="fg_fill" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle class="bg_fill" cx="10" cy="10" r="4"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle class="bg_fill" cx="20" cy="20" r="6"/>
+</marker>
+</defs>
+<style type="text/css">
+
+rect.backdrop {
+    fill: white;
+}
+text{
+    fill: black;
+}
+
+circle {
+    fill: none;
+    stroke: black;
+    stroke-width: 2;
+}
+
+line {
+    stroke: black;
+    stroke-width: 2;
+    stroke-opacity: 1;
+    fill-opacity: 1;
+    stroke-linecap: round;
+    stroke-linejoin: miter;
+}
+
+path {
+    fill: none;
+    stroke: black;
+    stroke-width: 2;
+    stroke-opacity: 1;
+    fill-opacity: 1;
+    stroke-linecap: round;
+    stroke-linejoin: miter;
+}
+
+line.dashed {
+    stroke-dasharray: 5;
+}
+
+.fg_fill {
+    fill: black;
+}
+
+
+.bg_fill {
+    fill: white;
+    stroke: black;
+    stroke-width: 2;
+}
+
+tspan.head{
+    fill: none;
+    stroke: none;
+}
+    
+</style>
+<rect class="backdrop" height="304" width="544" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="8" y2="184"/>
+<line x1="4" x2="540" y1="8" y2="8"/>
+<line x1="4" x2="540" y1="184" y2="184"/>
+<line x1="540" x2="540" y1="8" y2="184"/>
+</g>
+<g>
+<line x1="28" x2="28" y1="232" y2="296"/>
+<line x1="28" x2="108" y1="232" y2="232"/>
+<line x1="28" x2="196" y1="296" y2="296"/>
+<line x1="108" x2="164" y1="232" y2="232"/>
+<line x1="164" x2="196" y1="232" y2="232"/>
+<line x1="196" x2="196" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="36" x2="36" y1="40" y2="104"/>
+<line x1="36" x2="180" y1="40" y2="40"/>
+<line x1="36" x2="108" y1="104" y2="104"/>
+<line x1="108" x2="108" y1="104" y2="176"/>
+<line x1="108" x2="124" y1="104" y2="104"/>
+<line x1="124" x2="124" y1="104" y2="136"/>
+<line x1="124" x2="180" y1="104" y2="104"/>
+<line x1="124" x2="364" y1="136" y2="136"/>
+<line x1="180" x2="180" y1="40" y2="56"/>
+<line x1="180" x2="180" y1="56" y2="88"/>
+<line marker-end="url(#triangle)" x1="180" x2="356" y1="56" y2="56"/>
+<line x1="180" x2="180" y1="88" y2="104"/>
+<line x1="180" x2="184" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="136" y2="152"/>
+<line x1="364" x2="364" y1="152" y2="176"/>
+<line x1="364" x2="420" y1="152" y2="152"/>
+<line x1="420" x2="420" y1="104" y2="152"/>
+<line x1="420" x2="436" y1="104" y2="104"/>
+<line x1="436" x2="436" y1="104" y2="176"/>
+<line x1="436" x2="508" y1="104" y2="104"/>
+<line x1="508" x2="508" y1="40" y2="104"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="108" x2="108" y1="192" y2="220"/>
+</g>
+<g>
+<line x1="164" x2="164" y1="152" y2="176"/>
+<line x1="164" x2="364" y1="152" y2="152"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="164" x2="164" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="192" x2="188" y1="88" y2="88"/>
+<line x1="192" x2="364" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="56" y2="88"/>
+<line x1="364" x2="364" y1="88" y2="104"/>
+<line x1="364" x2="420" y1="104" y2="104"/>
+</g>
+<g>
+<line x1="348" x2="348" y1="232" y2="296"/>
+<line x1="348" x2="364" y1="232" y2="232"/>
+<line x1="348" x2="516" y1="296" y2="296"/>
+<line x1="364" x2="436" y1="232" y2="232"/>
+<line x1="436" x2="516" y1="232" y2="232"/>
+<line x1="516" x2="516" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="364" x2="364" y1="40" y2="56"/>
+<line x1="364" x2="508" y1="40" y2="40"/>
+<line x1="364" x2="360" y1="56" y2="56"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="364" x2="364" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="436" x2="436" y1="192" y2="220"/>
+</g>
+<g>
+<text x="57" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="65" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="145" y="76">
+1
+</text>
+</g>
+<g>
+<text x="161" y="268">
+1
+</text>
+</g>
+<g>
+<text x="217" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="44">
+0
+</text>
+</g>
+<g>
+<text x="377" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="393" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="473" y="76">
+2
+</text>
+</g>
+<g>
+<text x="481" y="268">
+2
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane-fanout (3).svg

@@ -0,0 +1,183 @@
+<svg class="bob" font-family="arial" font-size="14" height="304" width="544" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="304" width="544" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="8" y2="184"/>
+<line x1="4" x2="540" y1="8" y2="8"/>
+<line x1="4" x2="540" y1="184" y2="184"/>
+<line x1="540" x2="540" y1="8" y2="184"/>
+</g>
+<g>
+<line x1="28" x2="28" y1="232" y2="296"/>
+<line x1="28" x2="108" y1="232" y2="232"/>
+<line x1="28" x2="196" y1="296" y2="296"/>
+<line x1="108" x2="164" y1="232" y2="232"/>
+<line x1="164" x2="196" y1="232" y2="232"/>
+<line x1="196" x2="196" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="36" x2="36" y1="40" y2="104"/>
+<line x1="36" x2="180" y1="40" y2="40"/>
+<line x1="36" x2="108" y1="104" y2="104"/>
+<line x1="108" x2="108" y1="104" y2="176"/>
+<line x1="108" x2="124" y1="104" y2="104"/>
+<line x1="124" x2="124" y1="104" y2="136"/>
+<line x1="124" x2="180" y1="104" y2="104"/>
+<line x1="124" x2="364" y1="136" y2="136"/>
+<line x1="180" x2="180" y1="40" y2="56"/>
+<line x1="180" x2="180" y1="56" y2="88"/>
+<line marker-end="url(#triangle)" x1="180" x2="356" y1="56" y2="56"/>
+<line x1="180" x2="180" y1="88" y2="104"/>
+<line x1="180" x2="184" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="136" y2="152"/>
+<line x1="364" x2="364" y1="152" y2="176"/>
+<line x1="364" x2="420" y1="152" y2="152"/>
+<line x1="420" x2="420" y1="104" y2="152"/>
+<line x1="420" x2="436" y1="104" y2="104"/>
+<line x1="436" x2="436" y1="104" y2="176"/>
+<line x1="436" x2="508" y1="104" y2="104"/>
+<line x1="508" x2="508" y1="40" y2="104"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="108" x2="108" y1="192" y2="220"/>
+</g>
+<g>
+<line x1="164" x2="164" y1="152" y2="176"/>
+<line x1="164" x2="364" y1="152" y2="152"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="164" x2="164" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="192" x2="188" y1="88" y2="88"/>
+<line x1="192" x2="364" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="56" y2="88"/>
+<line x1="364" x2="364" y1="88" y2="104"/>
+<line x1="364" x2="420" y1="104" y2="104"/>
+</g>
+<g>
+<line x1="348" x2="348" y1="232" y2="296"/>
+<line x1="348" x2="364" y1="232" y2="232"/>
+<line x1="348" x2="516" y1="296" y2="296"/>
+<line x1="364" x2="436" y1="232" y2="232"/>
+<line x1="436" x2="516" y1="232" y2="232"/>
+<line x1="516" x2="516" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="364" x2="364" y1="40" y2="56"/>
+<line x1="364" x2="508" y1="40" y2="40"/>
+<line x1="364" x2="360" y1="56" y2="56"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="364" x2="364" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="436" x2="436" y1="192" y2="220"/>
+</g>
+<g>
+<text x="57" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="65" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="145" y="76">
+1
+</text>
+</g>
+<g>
+<text x="161" y="268">
+1
+</text>
+</g>
+<g>
+<text x="217" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="44">
+0
+</text>
+</g>
+<g>
+<text x="377" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="393" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="473" y="76">
+2
+</text>
+</g>
+<g>
+<text x="481" y="268">
+2
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane-fanout (4).svg

@@ -0,0 +1,183 @@
+<svg class="bob" font-family="arial" font-size="14" height="304" width="544" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="304" width="544" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="8" y2="184"/>
+<line x1="4" x2="540" y1="8" y2="8"/>
+<line x1="4" x2="540" y1="184" y2="184"/>
+<line x1="540" x2="540" y1="8" y2="184"/>
+</g>
+<g>
+<line x1="28" x2="28" y1="232" y2="296"/>
+<line x1="28" x2="108" y1="232" y2="232"/>
+<line x1="28" x2="196" y1="296" y2="296"/>
+<line x1="108" x2="164" y1="232" y2="232"/>
+<line x1="164" x2="196" y1="232" y2="232"/>
+<line x1="196" x2="196" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="36" x2="36" y1="40" y2="104"/>
+<line x1="36" x2="180" y1="40" y2="40"/>
+<line x1="36" x2="108" y1="104" y2="104"/>
+<line x1="108" x2="108" y1="104" y2="176"/>
+<line x1="108" x2="124" y1="104" y2="104"/>
+<line x1="124" x2="124" y1="104" y2="136"/>
+<line x1="124" x2="180" y1="104" y2="104"/>
+<line x1="124" x2="364" y1="136" y2="136"/>
+<line x1="180" x2="180" y1="40" y2="56"/>
+<line x1="180" x2="180" y1="56" y2="88"/>
+<line marker-end="url(#triangle)" x1="180" x2="356" y1="56" y2="56"/>
+<line x1="180" x2="180" y1="88" y2="104"/>
+<line x1="180" x2="184" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="136" y2="152"/>
+<line x1="364" x2="364" y1="152" y2="176"/>
+<line x1="364" x2="420" y1="152" y2="152"/>
+<line x1="420" x2="420" y1="104" y2="152"/>
+<line x1="420" x2="436" y1="104" y2="104"/>
+<line x1="436" x2="436" y1="104" y2="176"/>
+<line x1="436" x2="508" y1="104" y2="104"/>
+<line x1="508" x2="508" y1="40" y2="104"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="108" x2="108" y1="192" y2="220"/>
+</g>
+<g>
+<line x1="164" x2="164" y1="152" y2="176"/>
+<line x1="164" x2="364" y1="152" y2="152"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="164" x2="164" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="192" x2="188" y1="88" y2="88"/>
+<line x1="192" x2="364" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="56" y2="88"/>
+<line x1="364" x2="364" y1="88" y2="104"/>
+<line x1="364" x2="420" y1="104" y2="104"/>
+</g>
+<g>
+<line x1="348" x2="348" y1="232" y2="296"/>
+<line x1="348" x2="364" y1="232" y2="232"/>
+<line x1="348" x2="516" y1="296" y2="296"/>
+<line x1="364" x2="436" y1="232" y2="232"/>
+<line x1="436" x2="516" y1="232" y2="232"/>
+<line x1="516" x2="516" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="364" x2="364" y1="40" y2="56"/>
+<line x1="364" x2="508" y1="40" y2="40"/>
+<line x1="364" x2="360" y1="56" y2="56"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="364" x2="364" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="436" x2="436" y1="192" y2="220"/>
+</g>
+<g>
+<text x="57" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="65" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="145" y="76">
+1
+</text>
+</g>
+<g>
+<text x="161" y="268">
+1
+</text>
+</g>
+<g>
+<text x="217" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="44">
+0
+</text>
+</g>
+<g>
+<text x="377" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="393" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="473" y="76">
+2
+</text>
+</g>
+<g>
+<text x="481" y="268">
+2
+</text>
+</g>
+</svg>

book/src/.gitbook/assets/data-plane-fanout (5).svg

@@ -0,0 +1,183 @@
+<svg class="bob" font-family="arial" font-size="14" height="304" width="544" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<marker id="triangle" markerHeight="8" markerWidth="8" orient="auto" refX="4" refY="2" viewBox="0 0 8 4">
+<polygon fill="black" points="0,0 0,4 8,2 0,0"/>
+</marker>
+<marker id="clear_triangle" markerHeight="10" markerWidth="10" orient="auto" refX="1" refY="7" viewBox="0 0 20 14">
+<polygon fill="none" points="2,2 2,12 18,7 2,2" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="circle" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="black" r="8"/>
+</marker>
+<marker id="square" markerHeight="5" markerWidth="5" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<rect fill="black" height="20" width="20" x="0" y="0"/>
+</marker>
+<marker id="open_circle" markerHeight="10" markerWidth="10" orient="auto" refX="10" refY="10" viewBox="0 0 20 20">
+<circle cx="10" cy="10" fill="white" r="4" stroke="black" stroke-width="2"/>
+</marker>
+<marker id="big_open_circle" markerHeight="20" markerWidth="20" orient="auto" refX="20" refY="20" viewBox="0 0 40 40">
+<circle cx="20" cy="20" fill="white" r="6" stroke="black" stroke-width="2"/>
+</marker>
+</defs>
+<style type="text/css">
+
+    line,path {
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    line.dashed {
+        stroke-dasharray: 5;
+    }
+    circle.solid {
+      fill:black;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    circle.open {
+      fill:none;
+      stroke: black;
+      stroke-width: 2;
+      stroke-opacity: 1;
+      fill-opacity: 1;
+      stroke-linecap: round;
+      stroke-linejoin: miter;
+    }
+    tspan.head{
+        fill: none;
+        stroke: none;
+    }
+    
+</style>
+<rect fill="white" height="304" width="544" x="0" y="0"/>
+<g>
+<line x1="4" x2="4" y1="8" y2="184"/>
+<line x1="4" x2="540" y1="8" y2="8"/>
+<line x1="4" x2="540" y1="184" y2="184"/>
+<line x1="540" x2="540" y1="8" y2="184"/>
+</g>
+<g>
+<line x1="28" x2="28" y1="232" y2="296"/>
+<line x1="28" x2="108" y1="232" y2="232"/>
+<line x1="28" x2="196" y1="296" y2="296"/>
+<line x1="108" x2="164" y1="232" y2="232"/>
+<line x1="164" x2="196" y1="232" y2="232"/>
+<line x1="196" x2="196" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="36" x2="36" y1="40" y2="104"/>
+<line x1="36" x2="180" y1="40" y2="40"/>
+<line x1="36" x2="108" y1="104" y2="104"/>
+<line x1="108" x2="108" y1="104" y2="176"/>
+<line x1="108" x2="124" y1="104" y2="104"/>
+<line x1="124" x2="124" y1="104" y2="136"/>
+<line x1="124" x2="180" y1="104" y2="104"/>
+<line x1="124" x2="364" y1="136" y2="136"/>
+<line x1="180" x2="180" y1="40" y2="56"/>
+<line x1="180" x2="180" y1="56" y2="88"/>
+<line marker-end="url(#triangle)" x1="180" x2="356" y1="56" y2="56"/>
+<line x1="180" x2="180" y1="88" y2="104"/>
+<line x1="180" x2="184" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="136" y2="152"/>
+<line x1="364" x2="364" y1="152" y2="176"/>
+<line x1="364" x2="420" y1="152" y2="152"/>
+<line x1="420" x2="420" y1="104" y2="152"/>
+<line x1="420" x2="436" y1="104" y2="104"/>
+<line x1="436" x2="436" y1="104" y2="176"/>
+<line x1="436" x2="508" y1="104" y2="104"/>
+<line x1="508" x2="508" y1="40" y2="104"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="108" x2="108" y1="192" y2="220"/>
+</g>
+<g>
+<line x1="164" x2="164" y1="152" y2="176"/>
+<line x1="164" x2="364" y1="152" y2="152"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="164" x2="164" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="192" x2="188" y1="88" y2="88"/>
+<line x1="192" x2="364" y1="88" y2="88"/>
+<line x1="364" x2="364" y1="56" y2="88"/>
+<line x1="364" x2="364" y1="88" y2="104"/>
+<line x1="364" x2="420" y1="104" y2="104"/>
+</g>
+<g>
+<line x1="348" x2="348" y1="232" y2="296"/>
+<line x1="348" x2="364" y1="232" y2="232"/>
+<line x1="348" x2="516" y1="296" y2="296"/>
+<line x1="364" x2="436" y1="232" y2="232"/>
+<line x1="436" x2="516" y1="232" y2="232"/>
+<line x1="516" x2="516" y1="232" y2="296"/>
+</g>
+<g>
+<line x1="364" x2="364" y1="40" y2="56"/>
+<line x1="364" x2="508" y1="40" y2="40"/>
+<line x1="364" x2="360" y1="56" y2="56"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="364" x2="364" y1="192" y2="220"/>
+</g>
+<g>
+<line marker-end="url(#triangle)" x1="436" x2="436" y1="192" y2="220"/>
+</g>
+<g>
+<text x="57" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="65" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="145" y="76">
+1
+</text>
+</g>
+<g>
+<text x="161" y="268">
+1
+</text>
+</g>
+<g>
+<text x="217" y="44">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="321" y="44">
+0
+</text>
+</g>
+<g>
+<text x="377" y="268">
+Neighborhood
+</text>
+</g>
+<g>
+<text x="393" y="76">
+Validator
+</text>
+</g>
+<g>
+<text x="473" y="76">
+2
+</text>
+</g>
+<g>
+<text x="481" y="268">
+2
+</text>
+</g>
+</svg>